• Advertisement
Sign in to follow this  

const & uniform question revisited

This topic is 1431 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

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.

Share this post


Link to post
Share on other sites
Advertisement

I did something similar, and whereas it worked on my ATI cards, the driver refused to compile it on nVidia.

 

I would avoid anyhting not specifically const in a const declaration.

Share this post


Link to post
Share on other sites

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

Share this post


Link to post
Share on other sites

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

 

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

Share this post


Link to post
Share on other sites

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

 

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

 

vec3(1.0f, 1.0f, 1.0f) is a const expression because it is a type constructor that contains only const expressions, and normalize is a built-in function that is given a const expression, so light is also a valid const expression.

Share this post


Link to post
Share on other sites

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

Share this post


Link to post
Share on other sites


But why wouldn't this apply to user functions passed const expressions as arguments?

 

Because it's not in the standard. C++11 has constexpr which allows this kind of thing. Since it is all compile time there is no technical reason why GLSL couldn't do this, it simply doesn't yet.

Share this post


Link to post
Share on other sites

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?

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement