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