| Name |
| |
| NV_viewport_array2 |
| |
| Name Strings |
| |
| GL_NV_viewport_array2 |
| |
| Contact |
| |
| Jeff Bolz, NVIDIA Corporation (jbolz 'at' nvidia.com) |
| Pat Brown, NVIDIA Corporation (pbrown 'at' nvidia.com) |
| |
| Contributors |
| |
| Pat Brown, NVIDIA |
| Mathias Heyer, NVIDIA |
| |
| Status |
| |
| Shipping |
| |
| Version |
| |
| Last Modified Date: March 27, 2015 |
| Revision: 2 |
| |
| Number |
| |
| OpenGL Extension #476 |
| OpenGL ES Extension #237 |
| |
| Dependencies |
| |
| This extension is written against the OpenGL 4.3 specification |
| (Compatibility Profile). |
| |
| This extension interacts with the OpenGL ES 3.1 (March 17, 2014) |
| specification. |
| |
| If implemented in OpenGL ES, NV_viewport_array, EXT_geometry_shader |
| and EXT_shader_io_blocks are required. |
| |
| This extension interacts with EXT_tessellation_shader. |
| |
| This extension interacts with NV_geometry_shader_passthrough. |
| |
| This extension interacts with NV_gpu_program4. |
| |
| Overview |
| |
| This extension provides new support allowing a single primitive to be |
| broadcast to multiple viewports and/or multiple layers. A shader output |
| gl_ViewportMask[] is provided, allowing a single primitive to be output to |
| multiple viewports simultaneously. Also, a new shader option is provided |
| to control whether the effective viewport index is added into gl_Layer. |
| These capabilities allow a single primitive to be output to multiple |
| layers simultaneously. |
| |
| The gl_ViewportMask[] output is available in vertex, tessellation |
| control, tessellation evaluation, and geometry shaders. gl_ViewportIndex |
| and gl_Layer are also made available in all these shader stages. The |
| actual viewport index or mask and render target layer values are taken |
| from the last active shader stage from this set of stages. |
| |
| This extension is a superset of the GL_AMD_vertex_shader_layer and |
| GL_AMD_vertex_shader_viewport_index extensions, and thus those extension |
| strings are expected to be exported if GL_NV_viewport_array2 is |
| supported. This extension includes the edits for those extensions, recast |
| against the reorganized OpenGL 4.3 specification. |
| |
| New Procedures and Functions |
| |
| None. |
| |
| New Tokens |
| |
| None. |
| |
| Additions to Chapter 11 of the OpenGL 4.3 (Compatibility Profile) Specification |
| (Programmable Vertex Processing) |
| |
| Add to Section 11.1.3.10 (Shader Outputs) |
| |
| The built-in output variables gl_ViewportIndex, gl_ViewportMask[], and |
| gl_Layer hold the viewport index/mask and render target layer, as described |
| in Section 11.4 (Viewport Index and Layer). |
| |
| Add to Section 11.2.1.2.3 (Tessellation Control Shader Outputs) |
| |
| The built-in output variables gl_ViewportIndex, gl_ViewportMask[], and |
| gl_Layer hold the viewport index/mask and render target layer, as described |
| in Section 11.4 (Viewport Index and Layer). |
| |
| Add to Section 11.2.3.4 (Tessellation Evaluation Shader Outputs) |
| |
| The built-in output variables gl_ViewportIndex, gl_ViewportMask[], and |
| gl_Layer hold the viewport index/mask and render target layer, as described |
| in Section 11.4 (Viewport Index and Layer). |
| |
| Modify Section 11.3.4.5 (Geometry Shader Outputs) |
| |
| Replace the paragraph about gl_ViewportIndex: |
| |
| The built-in output variables gl_ViewportIndex, gl_ViewportMask[], and |
| gl_Layer hold the viewport index/mask and render target layer, as described |
| in Section 11.4 (Viewport Index and Layer). |
| |
| Replace Section 11.3.4.6 (Layer and Viewport Selection) with new Section |
| 11.4 (Layer and Viewport Selection) |
| |
| Geometry may be rendered to one of several different layers of cube map |
| textures, three-dimensional textures, or one- or two-dimensional texture |
| arrays. This functionality allows an application to bind an entire complex |
| texture to a framebuffer object, and render primitives to arbitrary layers |
| computed at run time. For example, it can be used render a scene into |
| multiple layers of an array texture in one pass, or to select a particular |
| layer to render to in shader code. The layer to render to is specified by |
| writing to the built-in output variable gl_Layer. Layered rendering |
| requires the use of framebuffer objects (see section 9.8). |
| |
| Shaders may also direct each primitive to zero or more viewports. The |
| destination viewports for a primitive may be selected in the shader by |
| writing to the built-in output variable gl_ViewportIndex (selecting a |
| single viewport) or gl_ViewportMask[] (selecting multiple viewports). |
| This functionality allows a shader to direct its output to different |
| viewports for each primitive, or to draw multiple versions of a primitive |
| into several different viewports. |
| |
| The specific vertex of a primitive used to select the rendering layer or |
| viewport index/mask is implementation-dependent and thus portable |
| applications will assign the same layer and viewport index for all |
| vertices in a primitive. The vertex conventions followed for gl_Layer and |
| gl_ViewportIndex/gl_ViewportMask[] may be determined by calling |
| GetIntegerv with the symbolic constants LAYER_PROVOKING_VERTEX and |
| VIEWPORT_INDEX_PROVOKING_VERTEX, respectively. For either query, if the |
| value returned is PROVOKING_VERTEX, then vertex selection follows the |
| convention specified by ProvokingVertex (see section 13.4). If the value |
| returned is FIRST_VERTEX_CONVENTION, selection is always taken from the |
| first vertex of a primitive. If the value returned is |
| LAST_VERTEX_CONVENTION, the selection is always taken from the last vertex |
| of a primitive. If the value returned is UNDEFINED_VERTEX, the selection |
| is not guaranteed to be taken from any specific vertex in the |
| primitive. The vertex considered the provoking vertex for particular |
| primitive types is given in table 13.2. |
| |
| The layer selection may be made a function of the viewport index, as |
| described in Section 7.1 of the GLSL specification. |
| |
| The viewport index, viewport mask, and layer outputs are available in |
| vertex, tessellation control, tessellation evaluation, and geometry |
| shaders. Only the last active shader stage (in pipeline order) from this |
| list controls the viewport index/mask and layer; outputs in previous |
| shader stages are not used, even if the last stage fails to write one of |
| the outputs. |
| |
| |
| Additions to Chapter 13 of the OpenGL 4.3 (Compatibility Profile) Specification |
| (Fixed-Function Vertex Post-Processing) |
| |
| Modify Section 13.2 (Transform Feedback), p. 453 |
| |
| Modify the first paragraph: |
| |
| ...The vertices are fed back after vertex color clamping, but before |
| viewport mask expansion, flatshading, and clipping. ... |
| |
| |
| Modify Section 13.6.1 (Controlling the Viewport) |
| |
| Multiple viewports are available and are numbered zero through the value |
| of MAX_VIEWPORTS minus one. If last active vertex, tessellation, or |
| geometry shader writes to gl_ViewportIndex, the primitive is emitted to |
| the viewport corresponding to the value assigned to gl_ViewportIndex, as |
| taken from an implementation-dependent provoking vertex. The primitive is |
| then transformed using the state of the selected viewport. 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 last active vertex, tessellation, or geometry shader writes to |
| gl_ViewportMask[], the primitive is emitted to zero or more viewports. If |
| bit <i> is set in the mask, the primitive is emitted to viewport <i> and |
| transformed using the state of viewport <i>. However, each primitive will |
| still be captured by transform feedback and counted by primitive queries |
| only once. If bits of gl_ViewportMask[] greater than or equal to the |
| value of MAX_VIEWPORTS are set, the number of times the primitive is |
| emitted and which viewport transformations are used are undefined. |
| |
| If neither gl_ViewportIndex nor gl_ViewportMask[] are written, the |
| viewport numbered zero is used by the viewport transformation. |
| |
| |
| Modify Section 14.5.2.1 (Line Stipple) |
| |
| (add to the end of the section) |
| |
| When rasterizing line segments that could be sent to multiple viewports |
| via the gl_ViewportMask[] built-in geometry shader output (section |
| 13.6.1), the line stipple pattern is not guaranteed to be continuous if |
| segments are sent to multiple viewports. If a line segment is not an |
| independent line segment and is not the first in a series of connected |
| segments (where the stipple counter <s> is reset to 0), the initial value |
| of <s> for the segment is undefined unless that line segment and all |
| previous segments in the series were sent to the same single viewport. |
| |
| New Implementation Dependent State |
| |
| None. |
| |
| New State |
| |
| None. |
| |
| Additions to the AGL/GLX/WGL Specifications |
| |
| None. |
| |
| GLX Protocol |
| |
| None. |
| |
| Modifications to the OpenGL Shading Language Specification, Version 4.30 |
| |
| Including the following line in a shader can be used to control the |
| language features described in this extension: |
| |
| #extension GL_NV_viewport_array2 : <behavior> |
| |
| where <behavior> is as specified in section 3.3. |
| |
| New preprocessor #defines are added to the OpenGL Shading Language: |
| |
| #define GL_NV_viewport_array2 1 |
| |
| Modify Section 7.1 (Built-In Language Variables), p. 116 |
| |
| Add to the list of vertex shader built-ins: |
| |
| out gl_PerVertex { |
| highp int gl_ViewportIndex; |
| highp int gl_ViewportMask[]; |
| highp int gl_Layer; |
| }; |
| |
| Add to the list of geometry shader built-ins: |
| |
| out highp int gl_ViewportMask[]; |
| |
| Add to the list of tessellation control shader built-ins: |
| |
| out gl_PerVertex { |
| highp int gl_ViewportIndex; |
| highp int gl_ViewportMask[]; |
| highp int gl_Layer; |
| } gl_out[]; |
| |
| Add to the list of tessellation evaluation shader built-ins: |
| |
| out gl_PerVertex { |
| highp int gl_ViewportIndex; |
| highp int gl_ViewportMask[]; |
| highp int gl_Layer; |
| }; |
| |
| Modify descriptions of gl_Layer and gl_ViewportIndex as follows: |
| |
| The variable gl_Layer is available as an output variable in the vertex, |
| tessellation, and geometry (VTG) languages and an input variable in the |
| fragment language. In the VTG languages, it is used to select a specific |
| layer (or face and layer of a cube map) of a multi-layer framebuffer |
| attachment. The actual layer used will come from one of the vertices in |
| the primitive being shaded. Which vertex the layer comes from is undefined, |
| so it is best to write the same layer value for all vertices of a |
| primitive. If a shader statically assigns a value to gl_Layer, layered |
| rendering mode is enabled. See section 11.4 "Layer and Viewport Selection" |
| and section 9.4.9 "Layered Framebuffers" of the OpenGL Graphics System |
| Specification for more information. If a shader statically assigns a value |
| to gl_Layer, and there is an execution path through the shader that does |
| not set gl_Layer, then the value of gl_Layer is undefined for executions |
| of the shader that take that path. |
| |
| ... |
| |
| The input variable gl_Layer in the fragment language will have the same |
| value that was written to the output variable gl_Layer in the VTG |
| languages. If the final VTG stage does not dynamically assign a value to |
| gl_Layer, the value of gl_Layer in the fragment stage will be undefined. |
| If the final VTG stage makes no static assignment to gl_Layer, the input |
| gl_Value in the fragment stage will be zero. Otherwise, the fragment stage |
| will read the same value written by the final VTG stage, even if that value |
| is out of range. If a fragment shader contains a static access to gl_Layer, |
| it will count against the implementation defined limit for the maximum |
| number of inputs to the fragment stage. |
| |
| The variable gl_ViewportIndex is available as an output variable in the |
| VTG languages and an input variable in the fragment language. In the |
| geometry language, it provides the index of the viewport to which the next |
| primitive emitted from the geometry shader should be drawn. In the vertex |
| and tessellation languages, it provides the index of the viewport |
| associated with the vertex being shaded. Primitives 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 |
| shaded. 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 the final VTG stage does not assign a |
| value to gl_ViewportIndex or gl_ViewportMask[], viewport transform and |
| scissor rectangle zero will be used. If a 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 |
| 11.4 "Layer and Viewport Selection" of the OpenGL Graphics System |
| Specification for more information. |
| |
| The input variable gl_ViewportIndex in the fragment stage will have the |
| same value that was written to the output variable gl_ViewportIndex in the |
| final VTG stage. If the final VTG stage does not dynamically assign to |
| gl_ViewportIndex, the value of gl_ViewportIndex in the fragment shader will |
| be undefined. If the final VTG stage makes no static assignment to |
| gl_ViewportIndex, the fragment stage will read zero. Otherwise, the |
| fragment stage will read the same value written by the final VTG stage, |
| even if that value is out of range. If a fragment shader contains a static |
| access to gl_ViewportIndex, it will count against the implementation |
| defined limit for the maximum number of inputs to the fragment stage. |
| |
| The variable gl_ViewportMask[] is available as an output variable in the |
| VTG languages. The array has ceil(v/32) elements where v is the maximum |
| number of viewports supported by the implementation. When a shader writes |
| this variable, bit B of element M controls whether the primitive is |
| emitted to viewport 32*M+B. If gl_ViewportIndex is written by the final |
| VTG stage, then gl_ViewportIndex in the fragment stage will have the same |
| value. If gl_ViewportMask[] is written by the final VTG stage, then |
| gl_ViewportIndex in the fragment stage will have the index of the viewport |
| that was used in generating that fragment. |
| |
| If a shader statically assigns a value to gl_ViewportIndex, it may not |
| assign a value to any element of gl_ViewportMask[]. If a shader |
| statically writes a value to any element of gl_ViewportMask[], it may |
| not assign a value to gl_ViewportIndex. That is, a shader may assign |
| values to either gl_ViewportIndex or gl_ViewportMask[], but not |
| both. Multiple shaders linked together must also consistently write just |
| one of these variables. These incorrect usages all generate compile-time |
| or link-time errors. |
| |
| The shader output gl_Layer may be redeclared with a layout qualifer |
| <viewport_relative> as follows: |
| |
| layout (viewport_relative) out highp int gl_Layer; |
| |
| If gl_Layer is <viewport_relative>, then the viewport index is added to |
| the layer used for rendering (and available in the fragment shader). If |
| the shader writes gl_ViewportMask[], then gl_Layer has a different value |
| for each viewport the primitive is rendered to. If gl_Layer is |
| <viewport_relative> and the shader writes neither gl_ViewportIndex nor |
| gl_ViewportMask[], a link-error will result. |
| |
| Modify Section 8.15 (Geometry Shader Functions) |
| |
| The function EmitStreamVertex() specifies that a vertex is completed. A |
| vertex is added to the current output primitive in vertex stream <stream> |
| using the current values of all output variables associated with <stream>. |
| These include gl_PointSize, gl_ClipDistance, gl_Layer, gl_Position, |
| gl_PrimitiveID, gl_ViewportIndex, and gl_ViewportMask[]. The values of |
| all output variables for all output streams are undefined after a call to |
| EmitStreamVertex(). |
| |
| Errors |
| |
| None. |
| |
| Interactions with OpenGL ES 3.1 |
| |
| Unless functionality similar to ARB_provoking_vertex is supported, remove |
| references to PROVOKING_VERTEX and ProvokingVertex(). Also remove |
| reference to 'vertex color clamping'. The modifications to Line Stippling |
| don't apply. |
| |
| Interactions with EXT_tessellation_shader |
| |
| If implemented on OpenGL ES and EXT_tessellation_shader is not supported, |
| remove all language referring to the tesselation control and tessellation |
| evaluation pipeline stages. |
| |
| Interactions with NV_geometry_shader_passthrough |
| |
| If NV_geometry_shader_passthrough is supported, the NV_gpu_program4 and |
| NV_geometry_program4 language describing the PASSTHROUGH declaration |
| statement should be modified to state that "result.viewportmask" may not |
| be used in such a declaration. |
| |
| Interactions with NV_gpu_program4 |
| |
| If NV_gpu_program4 is supported and the "NV_viewport_array2" program |
| option is specified, vertex, tessellation control/evaluation, and geometry |
| program result variable "result.viewportmask" can be used to specify the |
| mask of viewports that the primitive will be emitted to, "result.viewport" |
| can be used to specify the index of the viewport that the primitive will |
| be emitted to, and "result.layer" can be used to specify the layer of a |
| layered framebuffer attachment that the primitive will be emitted to. |
| |
| (add the following rule to the NV_gpu_program4 grammar) |
| |
| <resultBasic> ::= ... |
| | <resPrefix> "viewportmask" arrayMemAbs |
| | <resPrefix> "viewport" |
| | <resPrefix> "layer" |
| |
| (add the following to the tables of Vertex, Geometry, and Tessellation |
| Control/Eval Program Result Variable Bindings) |
| |
| Binding Components Description |
| ----------------------------- ---------- ---------------------------- |
| result.viewportmask[] (v,*,*,*) viewport array mask |
| result.viewport (v,*,*,*) viewport array index |
| result.layer (l,*,*,*) layer for cube/array/3D FBOs |
| |
| (add the following to Section 2.X.2, Program Grammar) |
| |
| If a result variable binding matches "result.viewportmask", updates to the |
| "x" component of the result variable provide a single integer that serves |
| as a mask of viewport indices. The mask must be written as an integer |
| value; writing a floating-point value will produce undefined results. |
| If the value has bits greater than or equal to MAX_VIEWPORTS set, the |
| number of viewports the primitive is emitted to and which viewports are |
| used are undefined. If the "NV_viewport_array2" program option is not |
| specified, the "result.viewportmask" binding is unavailable. |
| |
| If both "result.viewport" and "result.viewportmask" are written, |
| compilation will fail. |
| |
| (add the following to Section 2.X.6.Y, Program Options) |
| |
| + Viewport Mask (NV_viewport_array2) |
| |
| If a vertex, geometry, tessellation control, or tessellation evaluation |
| program specifies the "NV_viewport_array2" option, the result binding |
| "result.viewportmask" will be available to specify the mask of viewports |
| to use for primitive viewport transformations and scissoring as described |
| in section 2.X.2. Additionally, the "result.viewport" and "result.layer" |
| result bindings will be available in these same shader stages. |
| |
| If a program specifies the "NV_layer_viewport_relative" option, the |
| result.layer will have the viewport index automatically added to it. If |
| the result.viewportmask is used, the result.layer will be different for |
| each viewport the primitive is emitted to. |
| |
| Issues |
| |
| (1) Where does the viewport mask broadcast occur? |
| |
| RESOLVED: This operation could potentially be performed before or after |
| transform feedback, but feeding back several viewports worth of primitives |
| doesn't seem particularly useful. This specification applies the viewport |
| mask after transform feedback, and makes primitive queries only count each |
| primitive once. |
| |
| Note that it is possible to capture viewport mask shader outputs when |
| transform feedback is active. |
| |
| (2) How does the gl_ViewportIndex fragment input behave? |
| |
| RESOLVED: Whether viewport mask or viewport indices are used in VTG |
| shaders, the fragment shader input gl_ViewportIndex will contain the |
| viewport number for the primitive generating each fragment. If the |
| viewport mask is used to broadcast a single primitive to multiple |
| viewports, and the same pixel is covered by the primitive in each |
| viewport, multiple fragment shader invocations for that pixel will be |
| generated, each with a different value of gl_ViewportIndex. |
| |
| This extension provides no gl_ViewportMask[] input, so a fragment shader |
| is not able to see the original viewport mask for the primitive generating |
| the fragment. If necessary, this value could be passed by a separate |
| shader variable qualified with "flat". |
| |
| (3) How does the viewport mask interact with line stipple? |
| |
| RESOLVED: With viewport mask, it's possible to broadcast line strips to |
| multiple viewports. If line stipple is enabled in the OpenGL |
| compatibility profile, implementations are required to maintain a |
| continuous stipple pattern across the strip. When primitives are |
| broadcast via viewport mask, implementations will not always be able to |
| buffer an entire strip and send it to each viewport in turn. So it will |
| often be necessary to break up a long strip, and send segments to |
| alternating viewports. An implementation could handle this by breaking up |
| the strip and keeping N independent stipple counters, but that seems like |
| overkill. |
| |
| We relax normal spec requirements and require a continuous stipple pattern |
| only if the entire strip if sent to exactly one viewport. If any segment |
| in the strip is sent to multiple viewports, no viewports, or a different |
| viewport than previous segments, the stipple counter for that segment and |
| subsequent segments in the strip is undefined. |
| |
| (4) Can a viewport index or mask written by vertex or tessellation shader |
| be read by downstream tessellation or geometry shaders? |
| |
| RESOLVED: No. The fragment shader is able to read the viewport index, but |
| this extension provides no built-in input allowing VTG shaders to see a |
| viewport index or mask written by a previous shader stage. |
| |
| (5) Can this extension be used to "kill" primitives in a passthrough |
| geometry shader (NV_geometry_shader_passthrough)? |
| |
| RESOLVED: Yes. In regular geometry shaders, input primitives can be |
| killed by returning without emitting any vertices. That's not possible |
| with passthrough geometry shaders, however it is possible to code a |
| passthrough geometry shader like: |
| |
| void main() |
| { |
| if (shouldKillPrimitive()) { |
| // Set the viewport mask to zero. A primitive will still be |
| // emitted from the geometry shader stage, however it will be sent |
| // to no viewports and thus be discarded. Any other per-primitive |
| // outputs will be undefined. |
| gl_ViewportMask[0] = 0; |
| return; |
| } |
| |
| // Since the shader writes the viewport mask in the "kill" path, it |
| // also needs to write it in the non-"kill" path; otherwise, its |
| // value would be undefined and the primitive will be sent to an |
| // undefined set of viewports. Setting the mask to 1 will always |
| // send a primitive to viewport zero. |
| gl_ViewportMask[0] = 1; |
| |
| ... |
| } |
| |
| Without the viewport mask or a similar feature, it is not possible to kill |
| primitives in a passthrough geometry shader. |
| |
| Revision History |
| |
| Revision 2, 2015/03/27 |
| - Add ES interactions |
| |
| Revision 1 |
| - Internal revisions. |
