Jump to content

  • Log In with Google      Sign In   
  • Create Account

Banner advertising on our site currently available from just $5!


1. Learn about the promo. 2. Sign up for GDNet+. 3. Set up your advert!


const & uniform question revisited


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
9 replies to this topic

#1 Prune   Members   -  Reputation: 223

Like
0Likes
Like

Posted 12 February 2014 - 08:30 PM

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.


"But who prays for Satan? Who, in eighteen centuries, has had the common humanity to pray for the one sinner that needed it most?" --Mark Twain

~~~~~~~~~~~~~~~Looking for a high-performance, easy to use, and lightweight math library? http://www.cmldev.net/ (note: I'm not associated with that project; just a user)

Sponsor:

#2 HScottH   Members   -  Reputation: 516

Like
0Likes
Like

Posted 13 February 2014 - 04:30 PM

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.



#3 Hodgman   Moderators   -  Reputation: 36580

Like
2Likes
Like

Posted 13 February 2014 - 04:42 PM

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

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



#4 L. Spiro   Crossbones+   -  Reputation: 17350

Like
1Likes
Like

Posted 16 February 2014 - 04:04 PM

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



#5 Prune   Members   -  Reputation: 223

Like
0Likes
Like

Posted 17 February 2014 - 11:28 PM

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 who prays for Satan? Who, in eighteen centuries, has had the common humanity to pray for the one sinner that needed it most?" --Mark Twain

~~~~~~~~~~~~~~~Looking for a high-performance, easy to use, and lightweight math library? http://www.cmldev.net/ (note: I'm not associated with that project; just a user)

#6 Chris_F   Members   -  Reputation: 2600

Like
0Likes
Like

Posted 18 February 2014 - 09:48 AM

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.



#7 Prune   Members   -  Reputation: 223

Like
0Likes
Like

Posted 18 February 2014 - 01:00 PM

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


"But who prays for Satan? Who, in eighteen centuries, has had the common humanity to pray for the one sinner that needed it most?" --Mark Twain

~~~~~~~~~~~~~~~Looking for a high-performance, easy to use, and lightweight math library? http://www.cmldev.net/ (note: I'm not associated with that project; just a user)

#8 Chris_F   Members   -  Reputation: 2600

Like
0Likes
Like

Posted 18 February 2014 - 03:03 PM


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.



#9 Prune   Members   -  Reputation: 223

Like
0Likes
Like

Posted 18 February 2014 - 05:53 PM

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?


"But who prays for Satan? Who, in eighteen centuries, has had the common humanity to pray for the one sinner that needed it most?" --Mark Twain

~~~~~~~~~~~~~~~Looking for a high-performance, easy to use, and lightweight math library? http://www.cmldev.net/ (note: I'm not associated with that project; just a user)

#10 Chris_F   Members   -  Reputation: 2600

Like
0Likes
Like

Posted 18 February 2014 - 05:56 PM

 

Notably exempt from this are the texture functions, because uniform variables are not compile-time constant.

 






Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS