TSL 'property', using array of float or vec, or mat etc..

[Samsy]

Description

Still porting Legacy shaders into TSL, bumped into something,

Using Legacy shaders, we could replace a string in a chunk to inject =>

shader.replace( xxx, 
 '
  vec4 META_DATA_ARRAY[10];
    META_DATA_ARRAY[0] = vec4(0.0, 0.7513855695724487, 1.0, 0.0950118750333786);
    META_DATA_ARRAY[1] = vec4(0.0, 0.9136975407600403, 1.0, 0.0482977032661438);
    META_DATA_ARRAY[2] = vec4(0.0, 0.5273159146308899, 1.0, 0.12668250501155853);
    META_DATA_ARRAY[3] = vec4(0.0, 0.9619952440261841, 1.0, 0.03246239200234413);
    META_DATA_ARRAY[4] = vec4(0.0, 0.0, 1.0, 0.241488516330719);
' + xxx ) 
  

Using 'property' in TSL to write hardcoded float, vec, mat etc.. is available

Been looking for an example in the repo that shows support on TSL 'property' for arrays of vec, float, mat etc.. but could not find it ( unless I completely missed it )

[Spiri0]

That's what the storage buffer is for. I use it for something like that

[Samsy]

I'm not familiar with the storage buffer yet, but it does not really fit the same purpose if that is a uploaded buffer.
Here in the legacy, the values are hardcoded in the shader directly, and the number of indexes in the array might be completely arbitrary

[Spiri0]

You can use it like this in a wgslFn

let META_DATA_ARRAY = array<vec4<f32>, 10>(
    vec4<f32>(0.0, 0.75138557, 1.0, 0.095011875),
    vec4<f32>(0.0, 0.91369754, 1.0, 0.048297703),
    vec4<f32>(0.0, 0.52731591, 1.0, 0.126682505),
    vec4<f32>(0.0, 0.96199524, 1.0, 0.032462392),
    vec4<f32>(0.0, 0.0, 1.0, 0.241488516),
    (xxx),
);

With the wgslFn you can work in wgsl raw code. This helps me a lot because I can use the W3C documentation directly. Only the binding management continues to be done by the node system, but I think that's good.
Please excuse me if I make the mistake of automatically assuming that you are using three.webgpu.js when you talk about TSL.

[Samsy]

Well I could, but this need to work for both WebGL backend and WebGPU backend in TSL

[Spiri0]

Then I'm sorry I can't help because I only work with webgpu

[sunag]

Wouldn't you be looking for uniformArray?

const array = uniformArray( [ new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ) ] );
const element = bloomTintColors.element( 0 )

[Samsy]

hey @sunag !

Well, not really, this won't be data passed as uniforms since those will never change but as defines, the same way we can do :

property( vec4 ), but working with array instead

[Spiri0]

I find the uniformArray an elegant solution for this case where WebGL / WebGPU compatibility is important. In the end, the data is also in the GPU. A new node that is either converted into glsl code or into wgsl code in the backend that has also be done by the cpu first, ends up in the same result as using uniformArray, where the data is only sent to the gpu once if you don't change it.
I previously closed a PR of mine that was about arrays because I realized that I could get the same result with the uniformArray. The fact that it's a different way doesn't bother me as long as it's efficient.
When it comes to things like this, I always emphasize that this is just my personal view and not a dogma for others. But I hope that I was able to make the uniformArray node a little more attractive to you. I like this node, it serves its purpose

[Samsy]

Well, it is just that we are able to write a property =>

const myproperty = property('float', 'whatever).assign( 0.5 )

This one translates into a hardcoded value in the shader and isn't a uniform or a buffer.

To write an array at the moment the way it to use a uniformArray, but the actual data is purely static and does not need to be a uniform, but a sort of define