Light | Dark

# docs.GL

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

# glDrawElements

## Name

glDrawElements — render primitives from array data

## C Specification

`void glDrawElements(` | GLenum | mode,
| GLsizei | count,
| GLenum | type,
| const GLvoid * | indices`)`;

## Parameters

`mode`

  Specifies what kind of primitives to render. Symbolic constants `GL_POINTS`, `GL_LINE_STRIP`, `GL_LINE_LOOP`, `GL_LINES`, `GL_TRIANGLE_STRIP`, `GL_TRIANGLE_FAN`, `GL_TRIANGLES`, `GL_QUAD_STRIP`, `GL_QUADS`, and `GL_POLYGON` are accepted.

`count`

  Specifies the number of elements to be rendered.

`type`

  Specifies the type of the values in `indices`. Must be one of `GL_UNSIGNED_BYTE`, `GL_UNSIGNED_SHORT`, or `GL_UNSIGNED_INT`.

`indices`

  Specifies a pointer to the location where the indices are stored.

## Description

`glDrawElements` specifies multiple geometric primitives with very few subroutine calls. Instead of calling a GL function to pass each individual vertex, normal, texture coordinate, edge flag, or color, you can prespecify separate arrays of vertices, normals, and so on, and use them to construct a sequence of primitives with a single call to `glDrawElements`.

When `glDrawElements` is called, it uses `count` sequential elements from an enabled array, starting at `indices` to construct a sequence of geometric primitives. `mode` specifies what kind of primitives are constructed and how the array elements construct these primitives. If more than one array is enabled, each is used. If `GL_VERTEX_ARRAY` is not enabled, no geometric primitives are constructed.

Vertex attributes that are modified by `glDrawElements` have an unspecified value after `glDrawElements` returns. For example, if `GL_COLOR_ARRAY` is enabled, the value of the current color is undefined after `glDrawElements` executes. Attributes that aren't modified maintain their previous values.

## Notes

`glDrawElements` is available only if the GL version is 1.1 or greater.

`glDrawElements` is included in display lists. If `glDrawElements` is entered into a display list, the necessary array data (determined by the array pointers and enables) is also entered into the display list. Because the array pointers and enables are client-side state, their values affect display lists when the lists are created, not when the lists are executed.

## Errors

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

`GL_INVALID_VALUE` is generated if `count` is negative.

`GL_INVALID_OPERATION` is generated if a non-zero buffer object name is bound to an enabled array or the element array and the buffer object's data store is currently mapped.

`GL_INVALID_OPERATION` is generated if `glDrawElements` is executed between the execution of glBegin and the corresponding glEnd.

## 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

Songho - OpenGL Display List
Songho - OpenGL Vertex Array
Songho - OpenGL Vertex Buffer Object (VBO)
open.gl - The Graphics Pipeline

## See Also

glArrayElement, glColorPointer, glDrawArrays, glDrawRangeElements, glEdgeFlagPointer, glFogCoordPointer, glGetPointerv, glIndexPointer, glInterleavedArrays, glNormalPointer, glSecondaryColorPointer, glTexCoordPointer, glVertexPointer

## Copyright

Copyright © 1991-2006 Silicon Graphics, Inc. This document is licensed under the SGI Free Software B License. For details, see https://web.archive.org/web/20171022161616/http://oss.sgi.com/projects/FreeB/.

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