Name

    AMD_vertex_shader_viewport_index

Name Strings

    GL_AMD_vertex_shader_viewport_index

Contact

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

Contributors

    Graham Sellers

Status

    Shipping.

Version

    Last Modified Date: March 15, 2012
    Revision: 2

Number

    416

Dependencies

    OpenGL 4.1 or ARB_viewport_array is required.

    The extension is written against the OpenGL 4.2 Specification, Core Profile,
    January 19, 2011 and the OpenGL Shading Language Specification,
    version 4.20.11.

Overview

    The gl_ViewportIndex built-in variable was introduced by the
    ARB_viewport_array extension and OpenGL 4.1. This variable is available
    in un-extended OpenGL only to the geometry shader. When written in the
    geometry shader, it causes geometry to be directed to one of an array
    of several independent viewport rectangles.

    In order to use any viewport other than zero, a geometry shader must be
    present. Geometry shaders introduce processing overhead and potential
    performance issues. This extension exposes the gl_ViewportIndex built-in
    variable to the vertex shader, allowing the functionality introduced by
    ARB_viewport_array to be accessed without requiring a geometry shader to
    be present.

New Procedures and Functions

    None.

New Tokens

    None.

Additions to Chapter 2 of the OpenGL 4.2 (Core) Specification (OpenGL Operation)

    Add the following paragraph to the "Output Variables" subsection of
    section 2.11, "Vertex Shaders" on p. 106.

        The built-in special variable gl_ViewportIndex, if written, is used to
    direct rendering to one of several viewports and is discussed further in
    the next section.

    Insert the following subsection after the "Shader Outputs" subsection on
    p.106.

    "Viewport Selection"

        Vertex shaders can be used to render to one of several different
    viewport rectangles. The destination viewport rectangle for a primitive
    may be specified by writing to the built-in output variable
    gl_ViewportIndex in the vertex shader. This functionality allows a vertex
    shader to direct rendering to one of several viewport rectangles. The
    specific vertex of a primitive from which gl_ViewportIndex is taken
    is implementation defined and may be determined by calling GetIntegerv with
    the symbolic constant VIEWPORT_INDEX_PROVOKING_VERTEX.

    If the value returned is PROVOKING_VERTEX then vertex selection follows the
    convention specified to ProvokingVertex (see Section 2.19). If the value
    returned is FIRST_VERTEX_CONVENTION, selection is always taken from the
    first vertex of the primitive. If the value returned is
    LAST_VERTEX_CONVENTION, the selection is always taken from the last vertex
    of the primitive. If the value returned is UNDEFINED_VERTEX, the selection
    is not guaranteed to be taken from any specific vertex. The vertex
    considered the provoking vertex for particular primitive types is given
    in table 2.15.

    Replace the second paragraph of the "Layer and Viewport Selection" subsection
    of section 2.13, "Geometry Shaders", p.135 (which describes
    gl_ViewportIndex) with:

        The special built-in variable gl_ViewportIndex is available to geometry
    shaders to direct rendering to a specific viewport in an array of
    viewports and has the same effect as the similarly named variable in the
    vertex shader.

    Modify section 2.14.1 "Controling the Viewport" as follows:

        Multiple viewports are available and are numbered zero through the value
    of MAX_VIEWPORTS minus one. If a vertex or geometry shader is active and
    writes to gl_ViewportIndex, the viewport transformation uses the viewport
    corresponding to the value assigned to gl_ViewportIndex taken from an
    implementation-dependent primitive vertex. If the value of the viewport
    index is outside the range zero to the value of MAX_VIEWPORTS minus one,
    the results of the viewport transformation are undefined. If the active
    vertex shaders or geometry shaders (if present) do not write to
    gl_ViewportIndex, the viewport numbered zero is used by the viewport
    transformation.

Additions to Chapter 3 of the OpenGL 4.2 (Core) Specification (Rasterization)

    None.

Additions to Chapter 4 of the OpenGL 4.2 (Core) Specification (Per-Fragment Operations
and the Framebuffer)

    None.

Additions to Chapter 5 of the OpenGL 4.2 (Core) Specification (Special
Functions)

    None.

Additions to Chapter 6 of the OpenGL 4.2 (Core) Specification (State and
State Requests)

    None.

Additions to Chapter 7 of the OpenGL Shading Language Specification, Version 4.20

    Add to the list of vertex shader built-in variables, Section 7.1, p. 97:

        out int gl_ViewportIndex;

    Modify the first paragraph on p.101, describing gl_ViewpotIndex as follows:

        The output variable gl_ViewportIndex is available only in the vertex and
    geometry languages and provides the index of the viewport to which the next
    primitive assembled from the resulting vertices or emitted from the
    geometry shader (if present) should be drawn. Primitives generated during
    primitive assembly will undergo viewport transformation and scissor testing
    using the viewport transformation and scissor rectangle selected by the
    value of gl_ViewportIndex. The viewport index used will come from one of
    the vertices in the primitive being processed. However, which vertex the
    viewport index comes from is implementation-dependent, so it is best to use
    the same viewport index for all vertices of the primitive. If a vertex or
    geometry shader (if present) does not assign a value to gl_ViewportIndex,
    viewport transform and scissor rectangle zero will be used.  If a vertex
    or geometry shader statically assigns a value to gl_ViewportIndex and there
    is a path through the shader that does not assign a value to
    gl_ViewportIndex, the value of gl_ViewportIndex is undefined for executions
    of the shader that take that path. See section 2.11.11, under "Output
    Variables" of the OpenGL Graphics System Specification (Core Profile) for
    more information.

Additions to the AGL/GLX/WGL Specifications

    None.

GLX Protocol

    None.

Errors

    None.

New State

    None.

New Implementation Dependent State

    None.

Issues

    1) What happens when there is a tessellation shader in the pipe?

    RESOVED: gl_ViewportIndex is not exposed to tessellation shaders. The
    primary motivation for this extension is to allow simple applications using
    only vertex and fragment shaders to take advantage of multiple viewports.
    To use vertex-shader specified viewport indices in a program that uses
    tessellation, the viewport index can be passed from vertex to control to
    evaluation shader and then a geometry shader can be used to initialize
    gl_ViewportIndex as would be the case in the absence of this extension.

    2) What happens if gl_ViewportIndex is written in the vertex shader and
    a geometry shader is present?

    RESOLVED: The value written in the VS is lost. If the GS writes
    gl_ViewportIndex, that value is used, otherwise the zeroth viewport
    is used.

    3) Are provoking vertex semantics honored for the purposes of writes to
    gl_ViewportIndex in the VS?

    RESOLVED: Yes, they are. Query VIEWPORT_INDEX_PROVOKING_VERTEX to determine
    the 'provokingness' of gl_ViewportIndex. In general, though, it's best
    practice to ensure that all vertices of a single primitive (including
    strips, fans and loops) have the same value for gl_ViewportIndex.

Revision History

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

     2    03/15/2012  gsellers  Finalize for posting in public repository
     1    04/05/2011  gsellers  Initial draft
