OpenGL ES 3.0: Programming Guide, Second Edition (2014)

---

The vertex attribute color used in the code example is a constant value specified with glVertexAttrib4fv without enabling the vertex attribute array 0. The vertexPos attribute is specified by using a vertex array with glVertexAttribPointer and enabling the array withglEnableVertexAttribArray. The value of color will be the same for all vertices of the triangle(s) drawn, whereas the vertexPos attribute could vary for vertices of the triangle(s) drawn.

Declaring Vertex Attribute Variables in a Vertex Shader

We have looked at what a vertex attribute is, and considered how to specify vertex attributes in OpenGL ES. We now discuss how to declare vertex attribute variables in a vertex shader.

In a vertex shader, a variable is declared as a vertex attribute by using the in qualifier. Optionally, the attribute variable can also include a layout qualifier that provides the attribute index. A few example declarations of vertex attributes are given here:

layout(location = 0) in vec4 a_position;
layout(location = 1) in vec2 a_texcoord;
layout(location = 2) in vec3 a_normal;

The in qualifier can be used only with the data types float, vec2, vec3, vec4, int, ivec2, ivec3, ivec4, uint, uvec2, uvec3, uvec4, mat2, mat2x2, mat2x3, mat2x4, mat3, mat3x3, mat3x4, mat4, mat4x2, and mat4x3. Attribute variables cannot be declared as arrays or structures. The following example declarations of vertex attributes are invalid and should result in a compilation error:

in foo_t a_A; // foo_t is a structure
in vec4 a_B[10];

An OpenGL ES 3.0 implementation supports GL_MAX_VERTEX_ATTRIBS four-component vector vertex attributes. A vertex attribute that is declared as a scalar, two-component vector, or three-component vector will count as a single four-component vector attribute. Vertex attributes declared as two-dimensional, three-dimensional, or four-dimensional matrices will count as two, three, or four 4-component vector attributes, respectively. Unlike uniform and vertex shader output/fragment shader input variables, which are packed automatically by the compiler, attributes do not get packed. Please consider your choices carefully when declaring vertex attributes with sizes less than a four-component vector, as the maximum number of vertex attributes available is a limited resource. It might be better to pack them together into a single four-component attribute instead of declaring them as individual vertex attributes in the vertex shader.

Variables declared as vertex attributes in a vertex shader are read-only variables and cannot be modified. The following code should cause a compilation error:

in vec4 a_pos;
uniform vec4 u_v;

void main()
{
a_pos = u_v; <--- cannot assign to a_pos as it is read-only
}

An attribute can be declared inside a vertex shader—but if it is not used, then it is not considered active and does not count against the limit. If the number of attributes used in a vertex shader is greater than GL_MAX_VERTEX_ATTRIBS, the vertex shader will fail to link.

Once a program has been successfully linked, we may need to find out the number of active vertex attributes used by the vertex shader attached to this program. Note that this step is necessary only if you are not using input layout qualifiers for attributes. In OpenGL ES 3.0, it is recommended that you use layout qualifiers; thus you will not need to query this information after the fact. However, for completeness, the following line of code shows how to get the number of active vertex attributes:

glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &numActiveAttribs);

A detailed description of glGetProgramiv is given in Chapter 4, “Shaders and Programs.”

The list of active vertex attributes used by a program and their data types can be queried using the glGetActiveAttrib command.

The glGetActiveAttrib call provides information about the attribute selected by index. As detailed in the description of glGetActiveAttrib, index must be a value between 0 and GL_ACTIVE_ATTRIBUTES – l. The value of GL_ACTIVE_ATTRIBUTES is queried usingglGetProgramiv. An index of 0 selects the first active attributes, and an index of GL_ACTIVE_ATTRIBUTES – 1 selects the last vertex attribute.

Binding Vertex Attributes to Attribute Variables in a Vertex Shader

We discussed earlier that in a vertex shader, vertex attribute variables are specified by the in qualifier, the number of active attributes can be queried using glGetProgramiv, and the list of active attributes in a program can be queried using glGetActiveAttrib. We also described how generic attribute indices that range from 0 to (GL_MAX_VERTEX_ATTRIBS – 1) are used to enable a generic vertex attribute and specify a constant or per-vertex (i.e., vertex array) value using the glVertexAttrib* and glVertexAttribPointer commands. Now we consider how to map this generic attribute index to the appropriate attribute variable declared in the vertex shader. This mapping will allow appropriate vertex data to be read into the correct vertex attribute variable in the vertex shader.

Figure 6-4 describes how generic vertex attributes are specified and bound to attribute names in a vertex shader.

Figure 6-4 Specifying and Binding Vertex Attributes for Drawing One or More Primitives

In OpenGL ES 3.0, three approaches may be used to map a generic vertex attribute index to an attribute variable name in the vertex shader. These approaches can be categorized as follows:

• The index can be specified in the vertex shader source code using the layout(location = N) qualifier (recommended).

• OpenGL ES 3.0 will bind the generic vertex attribute index to the attribute name.

• The application can bind the vertex attribute index to an attribute name.

The easiest way to bind attributes to a location is to simply use the layout(location = N) qualifier; this approach requires the least amount of code. However, in some cases, the other two options might be more desirable. The glBindAttribLocation command can be used to bind a generic vertex attribute index to an attribute variable in a vertex shader. This binding takes effect when the program is linked the next time—it does not change the bindings used by the currently linked program.

If name was bound previously, its assigned binding is replaced with an index. glBindAttribLocation can be called even before a vertex shader is attached to a program object. As a consequence, this call can be used to bind any attribute name. Attribute names that do not exist or are not active in a vertex shader attached to the program object are ignored.

Another option is to let OpenGL ES 3.0 bind the attribute variable name to a generic vertex attribute index. This binding is performed when the program is linked. In the linking phase, the OpenGL ES 3.0 implementation performs the following operation for each attribute variable:

For each attribute variable, check whether a binding has been specified via glBindAttribLocation. If a binding is specified, the appropriate attribute index specified is used. If not, the implementation will assign a generic vertex attribute index.

This assignment is implementation specific; that is, it can vary from one OpenGL ES 3.0 implementation to another. An application can query the assigned binding by using the glGetAttribLocation command.

glGetAttribLocation returns the generic attribute index that was bound to the attribute variable name when the program object defined by program was last linked. If name is not an active attribute variable, or if program is not a valid program object or was not linked successfully, then –1 is returned, indicating an invalid attribute index.

Vertex Buffer Objects

The vertex data specified using vertex arrays are stored in client memory. This data must be copied from client memory to graphics memory when a draw call such as glDrawArrays or glDrawElements is made. These two commands are described in detail in Chapter 7, “Primitive Assembly and Rasterization.” It would, however, be much better if we did not have to copy the vertex data on every draw call, but instead could cache the data in graphics memory. This approach can significantly improve the rendering performance and also reduce the memory bandwidth and power consumption requirements, both of which are quite important for handheld devices. This is where vertex buffer objects can help. Vertex buffer objects allow OpenGL ES 3.0 applications to allocate and cache vertex data in high-performance graphics memory and render from this memory, thereby avoiding resending data every time a primitive is drawn. Not only the vertex data, but also the element indices that describe the vertex indices of the primitive and are passed as an argument to glDrawElements, can be cached.

OpenGL ES 3.0 supports two types of buffer objects that are used for specifying vertex and primitive data: array buffer objects and element array buffer objects. The array buffer objects specified by the GL_ARRAY_BUFFER token are used to create buffer objects that will store vertex data. The element array buffer objects specified by the GL_ELEMENT_ARRAY_BUFFER token are used to create buffer objects that will store indices of a primitive. Other buffer object types in OpenGL ES 3.0 are described elsewhere in this book: uniform buffers (Chapter 4), transform feedback buffers (Chapter 8), pixel unpack buffers (Chapter 9), pixel pack buffers (Chapter 11), and copy buffers (the Copying Buffer Objects section later in this chapter). For now, we will focus on the buffer objects used for specifying vertex attributes and element arrays.