Passing array to uniform in glsl error

Question

Here is my attemps to pass array to uniform array:

struct Vector{ float x,y,z; }

float threshold[2] = { 0.5, 0.25 };
Vector *kernel = new Vector[_kernel_size]; // _kernel_size==16
// fill kernel

glUniform1fv(glGetUniformLocation(_program, "t"), 2, threshold);
glUniform3fv(glGetUniformLocation(_program, "kernel"), _kernel_size, (const GLfloat*)kernel); // because Vector contains only 3 float fields this kind of casting should be ok

shader:

uniform float t[2];
uniform vec3 kernel[16];

And the results are weird. Only first float or first vector are filled with proper values. For example:

t = {0.5, 7.1830559e-042} 

Even when I try change only one value (name = "t[1]") it doesn't work. I checked this on AMD CodeXL.

My graphics card is Radeon HD 5770 and I have the newest drivers. I'm using OpenGL 3.3 and GLSL 330.

What am I doing wrong?

Answer 1

Try using glUniform2fv on threshold.

Answer 2

I checked another simple project where passing array to uniform works and checked what CodeXL is showing. And again only first value was ok.

So I believe that this is some kind of bug/limited functionality. Maybe name of uniform which CodeXL shows (kernel[0]) is a hint that only first value is presented.

Answer 3

You have to send the data to the first address of the array, e.g. t[0]

glUniform1fv(glGetUniformLocation(_program, "t[0]"), 2, threshold);

Answer 4

Try switching every arrays to vec4:

uniform vec4 t[2];
uniform vec4 kernel[16];

And use t[i].x and kernel[i].xyz in the shader.

Upload them as vec4 on the CPU side as well (don't forget padding with w)

struct Vector{ float x,y,z,w; }

float threshold[2][4] = { {0.5f}, {0.25f} };
Vector *kernel = new Vector[_kernel_size]; // _kernel_size==16

// fill kernel

glUniform4fv(glGetUniformLocation(_program, "t"), 2, threshold);
glUniform4fv(glGetUniformLocation(_program, "kernel"), _kernel_size, (const GLfloat*)kernel);

It's possible the GPU and drivers only properly supports arrays of vec4 due to a hardware limitation.

Alternatively, you can use t.x and t.y as the two thresholds in the shader:

uniform vec4 t;

CPU side:

float threshold[4] = { 0.5f, 0.25f };
glUniform4fv(glGetUniformLocation(_program, "t"), 1, threshold);

If that doesn't work try uploading each uniform one by one.

glUniform4fv(glGetUniformLocation(_program, "kernel[0]"), 1, kernel+0);
glUniform4fv(glGetUniformLocation(_program, "kernel[1]"), 1, kernel+1);
...

(for-loop left out for brevity)

Mobile GPUs (ie: cell phones) tend to be scalar-based (not vector) and can access floats, vec2s and vec4s just fine. Avoid vec3 uniforms but using them as temporaries in the shader code is fine and will be faster. Use lower precisions / fixed points when possible on Mobile.

Desktop GPUs vary. Some are vector4-only internally and the driver has to put floats into vec4s. Some can access scalar uniforms at any address with a slight performance penalty.

If you have multiple arrays of floats it's a good idea to interleave them if you can

For example:

uniform vec4 table[8];

table[i].x // hue shift table
table[i].y // blur factor table
table[i].z // de-saturation factor table
// etc

If you can, invest a few bucks in getting test computers with GPUs from other manufacturers to make sure your code and shaders work on most, test regularly.

They all have quirks, some more than others.