I came across this thread from 4.5 years ago: http://www.gamedev.net/topic/461399-const--uniform-question-in-glsl/

However, I wonder whether things have changed. This does not give me any errors, though the hold thread suggests it should:

layout(location = VIEW_SZ) uniform vec2 viewSz;
const vec2 scale = 1.0f / viewSz;

But it's still not clear to me whether scale is computed at each invocation of the shader for every fragment (and whether it makes a difference that scale is global vs making it local, in terms of evaluation time--I've read already that making it local may help the compiler with register allocation).

If it's computed, then of course it makes sense to precalculate the inverse and pass it in as a uniform.

I would go with precomputing it, and then putting both values in one uniform:

vec4 viewSzScale;//xy = size, zw = scale

But it's still not clear to me whether scale is computed at each invocation of the shader for every fragment

It is; all you have told the compiler is that the value will not change after initialization.


The correct solution is to precompute it as suggested by Hodgman.

That aside, never use const in a declaration whose right side is not a const expression; it fails to compile on some hardware/drivers, especially for example in OpenGL ES 2.0 and above or those that adhere to the standard strictly (your code should error).

https://www.opengl.org/wiki/Type_Qualifier_(GLSL)


L. Spiro

So the following should be a const expr because all arguments are literals:

const vec3 light = normalize(vec3(1.0f, 1.0f, 1.0f));

But why wouldn't this apply to user functions passed const expressions as arguments? Is there a technical reason for that?

What about textureSize()? It's a built-in function, and it takes no arguments (which _is_ a const expr); on the other hand, it depends on the bound texture. So is it const expr or not?