Explicit vs Automatic attribute location binding for OpenGL shaders

by

I know one good reason to prefer explicit location definition.

Consider that you hold your geometry data in Vertex Array Objects. For a given object, you create a VAO in such way that the indices correspond to, for example:

  • index 0: positions,
  • index 1: normals,
  • index 2: texcoords

Now consider that you want to draw one object with two different shaders. One shader requires position and normal data as input, the other – positions and texture coords.

If you compile those shaders, you will notice that the first shader will expect the positions at attribute index 0 and normals at 1. The other would expect positions at 0 but texture coords at 1.

Quoting https://www.opengl.org/wiki/Vertex_Shader:

Automatic assignment

If neither of the prior two methods assign an input to an attribute index, then the index is automatically assigned by OpenGL when the program is linked. The index assigned is completely arbitrary and may be different for different programs that are linked, even if they use the exact same vertex shader code.

This means that you wouldn’t be able to use your VAO with both shaders. Instead of having one VAO per, say, object, you’d need – in the worst case – a separate VAO per object per shader.

Forcing the shaders to use your own attribute numbering convention via glBindAttribLocation can solve this problem easily – all you need to do is to keep a consistent relation between attributes and their estabilished IDs, and force the shaders to use that convention when linking.

(That’s not really a big issue if you don’t use separate VAOs, but still might make your code clearer.)

BTW:

When setting up attribute locations for an OpenGL shader program, you are faced with two options

There’s a third option in OpenGL/GLSL 3.3: Specify the location directly in shader code. It looks like this:

layout(location=0) in vec4 position;

But this is not present in GLSL ES shader language.

More Related Contents:

  1. Drawing a sphere in OpenGL ES
  2. Is discard bad for program performance in OpenGL?
  3. Perspective correct texturing of trapezoid in OpenGL ES 2.0
  4. Drawing a border on a 2d polygon with a fragment shader
  5. OpenGL – vertex normals in OBJ
  6. Faster alternative to glReadPixels in iPhone OpenGL ES 2.0
  7. Appropriate multiplication of matrices for rotation/translation
  8. Modifying camera output using SurfaceTexture and OpenGL
  9. How to render Android’s YUV-NV21 camera image on the background in libgdx with OpenGLES 2.0 in real-time?
  10. Replicating MeshLambertMaterial Using ShaderMaterial ignores textures
  11. How can I do these image processing tasks using OpenGL ES 2.0 shaders?
  12. YUV to RGB conversion by fragment shader
  13. Gaussian filter with OpenGL Shaders
  14. How do I convert a vec4 rgba value to a float?
  15. Frequency of shader invocations in rendering commands
  16. Rendering meshes with multiple indices
  17. Should I ever use a `vec3` inside of a uniform buffer or shader storage buffer object?
  18. CADisplayLink OpenGL rendering breaks UIScrollView behaviour
  19. glVertexAttribPointer and glVertexAttribFormat: What’s the difference?
  20. Why is glReadPixels() failing in this code in iOS 6.0?
  21. OpenGL extensions available on different Android devices [closed]
  22. How to get UIImage from EAGLView?
  23. libgdx SpriteBatch render to texture
  24. Looping AVPlayer seamlessly
  25. Android OpenGL ES 2.0 emulator
  26. Does the Android emulator support OpenGL ES 3.0?
  27. What is the precision of highp floats in GLSL ES 2.0 (for iPhone/iPod touch/iPad)?
  28. Is it possible to rotate an object around its own axis and not around the base coordinate’s axis?
  29. Convert an UIImage in a texture
  30. What are shaders in OpenGL and what do we need them for? [closed]

Leave a Comment