Light | Dark

# docs.GL

OpenGL 4
OpenGL 3
OpenGL 2
OpenGL ES 3
OpenGL ES 2

# glVertexAttribPointer

## Name

glVertexAttribPointer — define an array of generic vertex attribute data

## C Specification

`void glVertexAttribPointer(` | GLuint index,
| GLint size,
| GLenum type,
| GLboolean normalized,
| GLsizei stride,
| const GLvoid * pointer`)`;

`void glVertexAttribIPointer(` | GLuint index,
| GLint size,
| GLenum type,
| GLsizei stride,
| const GLvoid * pointer`)`;

`void glVertexAttribLPointer(` | GLuint index,
| GLint size,
| GLenum type,
| GLsizei stride,
| const GLvoid * pointer`)`;

## Parameters

`index`

  Specifies the index of the generic vertex attribute to be modified.

`size`

  Specifies the number of components per generic vertex attribute. Must be 1, 2, 3, 4. Additionally, the symbolic constant `GL_BGRA` is accepted by `glVertexAttribPointer`. The initial value is 4.

`type`

  Specifies the data type of each component in the array. The symbolic constants `GL_BYTE`, `GL_UNSIGNED_BYTE`, `GL_SHORT`, `GL_UNSIGNED_SHORT`, `GL_INT`, and `GL_UNSIGNED_INT` are accepted by `glVertexAttribPointer` and `glVertexAttribIPointer`. Additionally `GL_HALF_FLOAT`, `GL_FLOAT`, `GL_DOUBLE`, `GL_FIXED`, `GL_INT_2_10_10_10_REV`, `GL_UNSIGNED_INT_2_10_10_10_REV` and `GL_UNSIGNED_INT_10F_11F_11F_REV` are accepted by `glVertexAttribPointer`. `GL_DOUBLE` is also accepted by `glVertexAttribLPointer` and is the only token accepted by the `type` parameter for that function. The initial value is `GL_FLOAT`.

`normalized`

  For `glVertexAttribPointer`, specifies whether fixed-point data values should be normalized (`GL_TRUE`) or converted directly as fixed-point values (`GL_FALSE`) when they are accessed.

`stride`

  Specifies the byte offset between consecutive generic vertex attributes. If `stride` is 0, the generic vertex attributes are understood to be tightly packed in the array. The initial value is 0.

`pointer`

  Specifies a offset of the first component of the first generic vertex attribute in the array in the data store of the buffer currently bound to the `GL_ARRAY_BUFFER` target. The initial value is 0.

## Description

`glVertexAttribPointer`, `glVertexAttribIPointer` and `glVertexAttribLPointer` specify the location and data format of the array of generic vertex attributes at index `index` to use when rendering. `size` specifies the number of components per attribute and must be 1, 2, 3, 4, or `GL_BGRA`. `type` specifies the data type of each component, and `stride` specifies the byte stride from one attribute to the next, allowing vertices and attributes to be packed into a single array or stored in separate arrays.

For `glVertexAttribPointer`, if `normalized` is set to `GL_TRUE`, it indicates that values stored in an integer format are to be mapped to the range [-1,1] (for signed values) or [0,1] (for unsigned values) when they are accessed and converted to floating point. Otherwise, values will be converted to floats directly without normalization.

For `glVertexAttribIPointer`, only the integer types `GL_BYTE`, `GL_UNSIGNED_BYTE`, `GL_SHORT`, `GL_UNSIGNED_SHORT`, `GL_INT`, `GL_UNSIGNED_INT` are accepted. Values are always left as integer values.

`glVertexAttribLPointer` specifies state for a generic vertex attribute array associated with a shader attribute variable declared with 64-bit double precision components. `type` must be `GL_DOUBLE`. `index`, `size`, and `stride` behave as described for `glVertexAttribPointer` and `glVertexAttribIPointer`.

If `pointer` is not `NULL`, a non-zero named buffer object must be bound to the `GL_ARRAY_BUFFER` target (see glBindBuffer), otherwise an error is generated. `pointer` is treated as a byte offset into the buffer object's data store. The buffer object binding (`GL_ARRAY_BUFFER_BINDING`) is saved as generic vertex attribute array state (`GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING`) for index `index`.

When a generic vertex attribute array is specified, `size`, `type`, `normalized`, `stride`, and `pointer` are saved as vertex array state, in addition to the current vertex array buffer object binding.

To enable and disable a generic vertex attribute array, call glEnableVertexAttribArray and glDisableVertexAttribArray with `index`. If enabled, the generic vertex attribute array is used when glDrawArrays, glMultiDrawArrays, glDrawElements, glMultiDrawElements, or glDrawRangeElements is called.

## Notes

Each generic vertex attribute array is initially disabled and isn't accessed when glDrawElements, glDrawRangeElements, glDrawArrays, glMultiDrawArrays, or glMultiDrawElements is called.

`GL_UNSIGNED_INT_10F_11F_11F_REV` is accepted for `type` only if the GL version is 4.4 or higher.

## Errors

`GL_INVALID_VALUE` is generated if `index` is greater than or equal to `GL_MAX_VERTEX_ATTRIBS`.

`GL_INVALID_VALUE` is generated if `size` is not 1, 2, 3, 4 or (for `glVertexAttribPointer`), `GL_BGRA`.

`GL_INVALID_ENUM` is generated if `type` is not an accepted value.

`GL_INVALID_VALUE` is generated if `stride` is negative.

`GL_INVALID_OPERATION` is generated if `size` is `GL_BGRA` and `type` is not `GL_UNSIGNED_BYTE`, `GL_INT_2_10_10_10_REV` or `GL_UNSIGNED_INT_2_10_10_10_REV`.

`GL_INVALID_OPERATION` is generated if `type` is `GL_INT_2_10_10_10_REV` or `GL_UNSIGNED_INT_2_10_10_10_REV` and `size` is not 4 or `GL_BGRA`.

`GL_INVALID_OPERATION` is generated if `type` is `GL_UNSIGNED_INT_10F_11F_11F_REV` and `size` is not 3.

`GL_INVALID_OPERATION` is generated by `glVertexAttribPointer` if `size` is `GL_BGRA` and `noramlized` is `GL_FALSE`.

`GL_INVALID_OPERATION` is generated if zero is bound to the `GL_ARRAY_BUFFER` buffer object binding point and the `pointer` argument is not `NULL`.

## Associated Gets

glGet with argument `GL_MAX_VERTEX_ATTRIBS`

glGetVertexAttrib with arguments `index` and `GL_VERTEX_ATTRIB_ARRAY_ENABLED`

glGetVertexAttrib with arguments `index` and `GL_VERTEX_ATTRIB_ARRAY_SIZE`

glGetVertexAttrib with arguments `index` and `GL_VERTEX_ATTRIB_ARRAY_TYPE`

glGetVertexAttrib with arguments `index` and `GL_VERTEX_ATTRIB_ARRAY_NORMALIZED`

glGetVertexAttrib with arguments `index` and `GL_VERTEX_ATTRIB_ARRAY_STRIDE`

glGetVertexAttrib with arguments `index` and `GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING`

glGet with argument `GL_ARRAY_BUFFER_BINDING`

glGetVertexAttribPointerv with arguments `index` and `GL_VERTEX_ATTRIB_ARRAY_POINTER`

## Examples

Render an indexed vertex array (not loaded into OpenGL) using texture UV and normal vertex attributes.

    glEnableVertexAttribArray(texcoord_attrib_index); // Attribute indexes were received from calls to glGetAttribLocation, or passed into glBindAttribLocation.
    glEnableVertexAttribArray(normal_attrib_index);
    glEnableVertexAttribArray(position_attrib_index);

    glVertexAttribPointer(texcoord_attrib_index, 2, GL_FLOAT, false, 0, texcoords_data); // texcoords_data is a float*, 2 per vertex, representing UV coordinates.
    glVertexAttribPointer(normal_attrib_index, 3, GL_FLOAT, false, 0, normals_data); // normals_data is a float*, 3 per vertex, representing normal vectors.
    glVertexAttribPointer(position_attrib_index, 3, GL_FLOAT, false, 0, vertex_data); // vertex_data is a float*, 3 per vertex, representing the position of each vertex

    // num_vertices is the number of verts in your vertex_data.
    // index_data is an array of unsigned int offsets into vertex_data.
    glDrawElements(GL_TRIANGLES, num_vertices, GL_UNSIGNED_INT, index_data);

    glDisableVertexAttribArray(position_attrib_index);
    glDisableVertexAttribArray(texcoord_attrib_index);
    glDisableVertexAttribArray(normal_attrib_index);

Render an indexed buffer object using texture UV and normal vertex attributes.

    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer); // vertex_buffer is retrieved from glGenBuffers
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer); // index_buffer is retrieved from glGenBuffers

    glEnableVertexAttribArray(texcoord_attrib_index); // Attribute indexes were received from calls to glGetAttribLocation, or passed into glBindAttribLocation.
    glEnableVertexAttribArray(normal_attrib_index);
    glEnableVertexAttribArray(position_attrib_index);

    // vertex_stride is the size of bytes of each vertex in the buffer object
    // vertex_position_offset and kin are the offset in bytes of the position data
    // in each vertex. For example if your vertex structure is
    // [ position, texcoord, normal ] then position vertex_position_offset will
    // have offset 0, vertex_texcoord_offset is 12 (position is 3 * sizeof(float)
    // bytes large, and texcoord comes just after) and vertex_normal_offset is
    // 20 = 5 * sizeof(float).
    GLintptr vertex_texcoord_offset = 3 * sizeof(float);
    GLintptr vertex_normal_offset = 5 * sizeof(float);
    GLintptr vertex_position_offset = 0 * sizeof(float);

    glVertexAttribPointer(texcoord_attrib_index, 2, GL_FLOAT, false, vertex_stride, (GLvoid*)vertex_texcoord_offset);
    glVertexAttribPointer(normal_attrib_index, 3, GL_FLOAT, false, vertex_stride, (GLvoid*)vertex_normal_offset);
    glVertexAttribPointer(position_attrib_index, 3, GL_FLOAT, false, vertex_stride, (GLvoid*)vertex_position_offset);

    // num_vertices is the number of verts in your vertex_data.
    // index_data is an array of unsigned int offsets into vertex_data.
    glDrawElements(GL_TRIANGLES, num_vertices, GL_UNSIGNED_INT, NULL);

    glDisableVertexAttribArray(position_attrib_index);
    glDisableVertexAttribArray(texcoord_attrib_index);
    glDisableVertexAttribArray(normal_attrib_index);

## Tutorials

Anton Gerdelan - "Hello Triangle" - OpenGL 4 Up and Running
Anton Gerdelan - Cube Maps: Sky Boxes and Environment Mapping
Anton Gerdelan - Vertex Buffer Objects
Learning Modern 3D Graphics Programming - Chapter 5. Objects in Depth [Vertex Array Objects, Indexed Drawing]
open.gl - Geometry Shaders
open.gl - Textures Objects and Parameters
open.gl - The Graphics Pipeline
open.gl - Transform Feedback
opengl-tutorial.org - Particles / Instancing
opengl-tutorial.org - Tutorial 13 : Normal Mapping
opengl-tutorial.org - Tutorial 2 : The first triangle
opengl-tutorial.org - Tutorial 4 : A Colored Cube
opengl-tutorial.org - Tutorial 8 : Basic shading

## Version Support

| OpenGL Version
--- | ---
Function / Feature Name | 2.0 | 2.1 | 3.0 | 3.1 | 3.2 | 3.3 | 4.0 | 4.1 | 4.2 | 4.3 | 4.4 | 4.5
`glVertexAttribIPointer` | - | - | ✔ | ✔ | ✔ | ✔ | ✔ | ✔ | ✔ | ✔ | ✔ | ✔
`glVertexAttribLPointer` | - | - | - | - | - | - | - | ✔ | ✔ | ✔ | ✔ | ✔
`glVertexAttribPointer` | ✔ | ✔ | ✔ | ✔ | ✔ | ✔ | ✔ | ✔ | ✔ | ✔ | ✔ | ✔

## See Also

glBindAttribLocation, glBindBuffer, glDisableVertexAttribArray, glDrawArrays, glDrawElements, glDrawRangeElements, glEnableVertexAttribArray, glMultiDrawArrays, glMultiDrawElements, glVertexAttrib

## Copyright

Copyright © 2003-2005 3Dlabs Inc. Ltd. Copyright © 2010-2014 Khronos Group. This material may be distributed subject to the terms and conditions set forth in the Open Publication License, v 1.0, 8 June 1999. https://opencontent.org/openpub/.

Think you can improve this page? Edit this page on GitHub.