Name

    AMD_interleaved_elements

Name Strings

    GL_AMD_interleaved_elements

Contact

    Graham Sellers (graham.sellers 'at' amd.com)

Contributors

    Sergey Leontyev, AMD

Status

    Shipping

Version

    Last Modified Date: 2 May 2013
    Revision: 3

Number

    431

Dependencies

    This extension is written against version 4.3 of the Core Profile OpenGL
    Specification, dated August 6, 2012.

Overview

        The glDrawElements function and its variants (instanced and indirect,
    for example) allow OpenGL to draw indexed arrays of vertices. Since its
    inception, OpenGL has supported unsigned bytes, unsigned shorts and
    unsigned integers as index types. However, all enabled vertex arrays may
    be represented by at most one shared index.

        A common scenario in graphics rendering is that several faces share
    a vertex where, for each face some properties of a vertex (position and
    texture coordinates, for example) should be common but others must be
    unique (colors, normals, and so on). Consider a mesh of a cube with
    per-face normals, for example. There are 8 vertices and 6 normals, and 12
    triangles (where each face of the cube is represented as two triangles).
    To render this cube, we must compute the 24 unique permutations of
    position and normal and build a new element list to index into it. In
    fact, any advantage of indexed draw is lost here as the number of required
    permutations is equal to the final vertex count required to draw the
    object.

        This extension allows OpenGL to process multi-component packed element
    data. The maximum size of a vertex's index data is not increased, but the
    facility to store 2 16-bit or 2 or 4 8-bit indices per vertex is introduced.
    Each vertex attribute is given a swizzle property to allow its index to
    be sourced from one of up to 4 channels of index data. This effectively
    allows an application to supply multiple interleaved streams of index data
    to OpenGL. Each vertex attribute is given a 'channel selector' to select
    one of the up to 4 channels of vertex index information presented to
    OpenGL. This enables the use-case described above and many more.
    The swizzle parameter is also applied to vertex indices passed to shaders,
    and updates to the definition of base vertex parameters and primitive
    restart are applied.

New Procedures and Functions

    void VertexAttribParameteriAMD(uint index, enum pname, int param);

New Tokens

    Accepted by the <pname> parameter of VertexAttribParameteriAMD and
    GetVertexAttrib{iv|dv|fv|Iiv|Iuiv|Ldv}:

        VERTEX_ELEMENT_SWIZZLE_AMD                          0x91A4

    Selected by the <pname> parameter of ProgramParameteri and GetProgramiv:

        VERTEX_ID_SWIZZLE_AMD                               0x91A5

    Accepted by the <param> parameter of VertexAttribParameteriAMD:

        RED                                                 0x1903
        GREEN                                               0x1904
        BLUE                                                0x1905
        ALPHA                                               0x1906

    Accepted by the <type> parameter of DrawElements, DrawElementsInstanced,
    DrawElementsInstancedBaseInstance and DrawElementsIndirect:

        RG8UI                                               0x8238
        RG16UI                                              0x823A
        RGBA8UI                                             0x8D7C

IP Status

    None.

Additions to Chapter 7 of the OpenGL Core Profile Specification, Version 4.3,
"Programs and Shaders"

    Add to the parameters accepted by ProgramParameteri, p.82:

        If <pname> is VERTEX_ID_SWIZZLE_AMD, <value> should be set to
    RED, GREEN, BLUE or ALPHA to indicate that the first, second, third
    or fourth component of the vertex element vector be propagated to the
    gl_VertexID vertex shader input as described in subsection 11.1.3.9.
    The initial value of VERTEX_ID_SWIZZLE_AMD is RED.

Additions to Chapter 10 of the OpenGL Core Profile Specification, Version 4.3,
"Vertex Specification and Drawing Commands"

    Insert Subsection 10.3.2, "Vertex Attribute Parameters", renumber
    subsequent sections:

        Each vertex attribute possesses a set of parameters that control
    its behavior. Parameters for a vertex attribute may be set by calling:

        void VertexAttribParameteriAMD(uint index,
                                       enum pname,
                                       int param);

    where <index> identifies the generic vertex attribute array whose parameter
    to modify. If <pname> is VERTEX_ELEMENT_SWIZZLE_AMD, then <param>
    specifies the component of the vertex element that is to be used to
    source the vertex indices for the selected vertex attribute. Its value
    may be RED, GREEN, BLUE or ALPHA to select the first, second, third or
    fourth component of the vertex element.

    In section 10.3.2, "Primitive Restart", modify the language describing
    how the restart index is compared to the vertex element index, p.302
    as follows:

        When one of the Draw* commands transfers a set of generic attribute
    array elements to the GL, if all present index channels in the passed
    element index are equal to the primitive restart index, then the GL
    does not process those elements as a vertex. Instead ... *include
    remainder of section verbatim.*

    In the description of DrawElementsOneInstance (p. 311), replace the
    sentence beginning "The ith element transferred by..." with:

    For each enabled vertex attribute, the ith element transferred by
    DrawElementsOneInstance will be taken from that attribute's selected
    channel of the element whose values are stored currently bound element
    array buffer at offset indices + i.

    Replace the paragraph explaining the <type> parameter to
    DrawElementsOneIntance (p. 311):

        <type> may be UNSIGNED_BYTE, UNSIGNED_SHORT or UNSIGNED_INT,
    indicating that the index values are of GL type ubyte, ushort or uint,
    respectively, RG8UI or RG16UI, indicating that the index values are pairs
    of GL type ubyte or ushort, respectively, or RGBA8UI, indicating that
    index values are quadruplets of GL type ubyte. ...

    Modify the language describing the DrawElements*BaseVertex* functions
    on p.314 as follows:

        ... are equivalent to the commands with the same base name (without
    the BaseVertex suffix), except that the ith element transferred by
    the corresponding draw call will be taken from the selected channel
    of the element vector indices[i] + <basevertex>. That is, the value of
    <basevertex> is added to the vertex index after channel selection.
    ... *include remainder of description verbatim.*

    Add to the list of accepted values for the <pname> parameter to
    GetVertexAttrib* in Section 10.6, "Vertex Array and Vertex Array Object
    Queries", p. 317:

        ... VERTEX_ELEMENT_SWIZZLE_AMD.

Additions to Chapter 11 of the OpenGL Core Profile Specification, Version 4.3,
"Programmable Vertex Processing"

    In Subsection 11.1.3.9, "Shader Inputs", p.338, modify the description
    of gl_VertexID as follows:

        gl_VertexID holds the integer index i stored in the selected component
    of the element implicitly passed by DrawArrays or one of the other drawing
    commands defined in section 10.5. The component of the element data
    stored in gl_VertexID may be specified by calling ProgramParameteri with
    <pname> set to VERTEX_ID_SWIZZLE_AMD as specified in section 7.3.

New State

    Append to Table 23.4, "Vertex Array Object State (cont.)":

    +------------------------------+----------+---------------------+----------------+---------------------------------------------+----------+
    | Get Value                    | Type     | Get Command         | Initial Value  | Description                                 | Sec      |
    +------------------------------+----------+---------------------+----------------+---------------------------------------------+----------+
    | VERTEX_ELEMENT_SWIZZLE_AMD   | 16 * x E | GetVertexAttribiv   | RED            | Channel selector for vertex attribute index | 10.3.2   |
    +------------------------------+----------+---------------------+----------------+---------------------------------------------+----------+

    Append to Table 23.39, "Program Object State (cont.)":

    +------------------------+-------+---------------+----------------+------------------------------------+----------+
    | Get Value              | Type  | Get Command   | Initial Value  | Description                        | Sec      |
    +------------------------+-------+---------------+----------------+------------------------------------+----------+
    | VERTEX_ID_SWIZZLE_AMD  | E     | GetProgramiv  | RED            | Channel selector for gl_VertexID   | 11.1.3.9 |
    +------------------------+-------+---------------+----------------+------------------------------------+----------+

New Implementation Dependent State

    None.

Errors

    INVALID_ENUM is generated by VertexAttribParameteri if <pname> is not an
    accepted token.

    INVALID_VALUE is generated by VertexAttribParameteri if <value> is not an
    acceptable value for the specified value of <pname>.

Examples

    // Basic per-face normals

    // Normal data
    static const float normals[] =
    {
        0.0f, 0.0f, 1.0f,   // Positive Z
        0.0f, 0.0f, -1.0f,  // Negative Z
        0.0f, 1.0f, 0.0f,   // Positive Y
        0.0f, -1.0f, 0.0f,  // Negative Y
        1.0f, 0.0f, 0.0f,   // Positive X
        -1.0f, 0.0f, 0.0f,  // Negative X
    };

    // Position data
    static const float positions[] =
    {
        -1.0f, -1.0f, -1.0f,
        // <More data here>
        1.0f, 1.0f, 1.0f
    };

    // Put the above data into a buffer and bind them as separate vertex
    // attributes.
    GLuint vertex_buffer;
    glGenBuffers(1, &vertex_buffer);
    glBindBuffer(GL_ARRAY_BUFFER, sizeof(positions) + sizeof(normals),
                 NULL, GL_STATIC_DRAW);
    glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(positions), positions);
    glBufferSubData(GL_ARRAY_BUFFER, sizeof(positions),
                    sizeof(normals), normals);
    // ... etc. Set up vertex attributes.

    // Index data
    static const unsigned short indices[] =
    {
        0, 0,       // vertex 0: position index, normal index
        1, 0,       // vertex 1: position index, normal index
        2, 0,       // vertex 2: position index, normal index
        1, 0,       // vertex 3: position index, normal index
        2, 0,       // ... six vertices, forming
        3, 0,       // ... two complete triangles, all using normals[0]
        0, 1,
        2, 1,
        3, 1,
        3, 1,
        4, 1,       // ... six more vertices, forming
        2, 1,       // ... two more triangles, all using normals[1]
        // etc...
    };

    GLuint index_buffer;
    glGenBuffers(1, &index_buffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices),
                 indices, GL_STATIC_DRAW);

    // Okay... here's the new code. Set up vertex attribute 0 (position) to
    // consume the RED channel of the vertex index and attribute 1 (normal)
    // to consume the GREEN (second) channel of the vertex index. Then
    // draw with GL_RG16UI (two channel, 16-bit unsigned int) as the index
    // type.
    glVertexAttribParameteriAMD(0, GL_VERTEX_ELEMENT_SWIZZLE_AMD, GL_RED);
    glVertexAttribParameteriAMD(1, GL_VERTEX_ELEMENT_SWIZZLE_AMD, GL_GREEN);

    glDrawElements(GL_TRIANGLES,
                   sizeof(indices) / (2 * sizeof(unsigned short)),
                   GL_RG16UI,
                   NULL);

Issues

    1) What is the effect of multi-channel vertex indices on gl_VertexID?

       RESOLVED: The VERTEX_ID_SWIZZLE_AMD program parameter selects the
       channel of vector element types to be passed to gl_VertexID. By
       default, this is RED, which is backwards compatible with single-channel
       types.

    2) How does this interact with primitive-restart indices?

       RESOLVED: If all present channels of the vertex index vector match the
       restart index, then the element index is considered to match.

    3) How does baseVertex affect this?

       RESOLVED: The same base vertex value is added to each each vertex
       element component after channel selection for each of the enabled
       vertex attributes. This choice is primarily motivated by the behavior
       of base vertex elements encoded in indirect draw commands.

    4) Does this feature disable potential optimizations such as vertex
       reuse?

       RESOVLED: No, vertex reuse should continue to function correctly.
       Each unique vector of indices should produce a unique set of vertex
       shader outputs (modulo side effects) and will hit a naive vertex
       reuse cache. Nothing precludes more advanced optimization strategies
       from being implemented, however.

    5) Is it possible to get at all two or four channels of the vertex index
       using a built-in input to the vertex shader?

       RESOLVED: No. A single channel selection is provided. Providing more
       data could be implemented by introducing a new built-in integer vector
       input to the shader, but we have chosen not to do at this time.

    6) What is the value of missing channels? For example, if we render with
       GL_RG16UI indices but set certain attributes to GL_BLUE or GL_ALPHA
       swizzle, what index value is used for those channels?

       RESOLVED: Zero.

    7) Are the traditional GL_RED, GL_GREEN, GL_BLUE, and GL_ALPHA terms
       appropriate for this use?

       RESOLVED: Not really, but are they appropriate for normals? g-buffers?
       Any other arbitrary data that might be in a buffer or texture?
       It's not worth introducing new enumerants just for this - we'll use
       R, G, B, A.

Revision History

    Rev.    Date      Author    Changes
    ----  --------    --------  -----------------------------------------

     3    05/02/2013  gsellers  Shipping. Finalize spec ready for posting.
     2    01/25/2013  gsellers  Resolve issues 1, 2, 3. Polish spec.
     1    01/17/2013  gsellers  Initial draft