skia / external / github.com / KhronosGroup / OpenGL-Registry / 5f3fea090d8df5638b6df385c8b431f51b284651 / . / extensions / EXT / EXT_gpu_shader4.txt

Name | |

EXT_gpu_shader4 | |

Name Strings | |

GL_EXT_gpu_shader4 | |

Contact | |

Barthold Lichtenbelt, NVIDIA (blichtenbelt 'at' nvidia.com) | |

Pat Brown, NVIDIA (pbrown 'at' nvidia.com) | |

Status | |

Multi vendor extension | |

Shipping for GeForce 8 Series (November 2006) | |

Version | |

Last Modified Date: 12/14/2009 | |

Author revision: 16 | |

Number | |

326 | |

Dependencies | |

OpenGL 2.0 is required. | |

This extension is written against the OpenGL 2.0 specification and version | |

1.10.59 of the OpenGL Shading Language specification. | |

This extension trivially interacts with ARB_texture_rectangle. | |

This extension trivially interacts with GL_EXT_texture_array. | |

This extension trivially interacts with GL_EXT_texture_integer. | |

This extension trivially interacts with GL_EXT_geometry_shader4 | |

This extension trivially interacts with GL_EXT_texture_buffer_object. | |

NV_primitive_restart trivially affects the definition of this extension. | |

ARB_color_buffer_float affects the definition of this extension. | |

EXT_draw_instanced affects the definition of this extension. | |

Overview | |

This extension provides a set of new features to the OpenGL Shading | |

Language and related APIs to support capabilities of new hardware. In | |

particular, this extension provides the following functionality: | |

* New texture lookup functions are provided that allow shaders to | |

access individual texels using integer coordinates referring to the | |

texel location and level of detail. No filtering is performed. These | |

functions allow applications to use textures as one-, two-, and | |

three-dimensional arrays. | |

* New texture lookup functions are provided that allow shaders to query | |

the dimensions of a specific level-of-detail image of a texture | |

object. | |

* New texture lookup functions variants are provided that allow shaders | |

to pass a constant integer vector used to offset the texel locations | |

used during the lookup to assist in custom texture filtering | |

operations. | |

* New texture lookup functions are provided that allow shaders to | |

access one- and two-dimensional array textures. The second, or third, | |

coordinate is used to select the layer of the array to access. | |

* New "Grad" texture lookup functions are provided that allow shaders | |

to explicitely pass in derivative values which are used by the GL to | |

compute the level-of-detail when performing a texture lookup. | |

* A new texture lookup function is provided to access a buffer texture. | |

* The existing absolute LOD texture lookup functions are no longer | |

restricted to the vertex shader only. | |

* The ability to specify and use cubemap textures with a | |

DEPTH_COMPONENT internal format. This also enables shadow mapping on | |

cubemaps. The 'q' coordinate is used as the reference value for | |

comparisons. A set of new texture lookup functions is provided to | |

lookup into shadow cubemaps. | |

* The ability to specify if varying variables are interpolated in a | |

non-perspective correct manner, if they are flat shaded or, if | |

multi-sampling, if centroid sampling should be performed. | |

* Full signed integer and unsigned integer support in the OpenGL | |

Shading Language: | |

- Integers are defined as 32 bit values using two's complement. | |

- Unsigned integers and vectors thereof are added. | |

- New texture lookup functions are provided that return integer | |

values. These functions are to be used in conjunction with new | |

texture formats whose components are actual integers, rather | |

than integers that encode a floating-point value. To support | |

these lookup functions, new integer and unsigned-integer | |

sampler types are introduced. | |

- Integer bitwise operators are now enabled. | |

- Several built-in functions and operators now operate on | |

integers or vectors of integers. | |

- New vertex attribute functions are added that load integer | |

attribute data and can be referenced in a vertex shader as | |

integer data. | |

- New uniform loading commands are added to load unsigned integer | |

data. | |

- Varying variables can now be (unsigned) integers. If declared | |

as such, they have to be flat shaded. | |

- Fragment shaders can define their own output variables, and | |

declare them to be of type floating-point, integer or unsigned | |

integer. These variables are bound to a fragment color index | |

with the new API command BindFragDataLocationEXT(), and directed | |

to buffers using the existing DrawBuffer or DrawBuffers API | |

commands. | |

* Added new built-in functions truncate() and round() to the shading | |

language. | |

* A new built-in variable accessible from within vertex shaders that | |

holds the index <i> implicitly passed to ArrayElement to specify the | |

vertex. This is called the vertex ID. | |

* A new built-in variable accessible from within fragment and geometry | |

shaders that hold the index of the currently processed | |

primitive. This is called the primitive ID. | |

This extension also briefly mentions a new shader type, called a geometry | |

shader. A geometry shader is run after vertices are transformed, but | |

before clipping. A geometry shader begins with a single primitive (point, | |

line, triangle. It can read the attributes of any of the vertices in the | |

primitive and use them to generate new primitives. A geometry shader has a | |

fixed output primitive type (point, line strip, or triangle strip) and | |

emits vertices to define a new primitive. Geometry shaders are discussed | |

in detail in the GL_EXT_geometry_shader4 specification. | |

New Procedures and Functions | |

void VertexAttribI1iEXT(uint index, int x); | |

void VertexAttribI2iEXT(uint index, int x, int y); | |

void VertexAttribI3iEXT(uint index, int x, int y, int z); | |

void VertexAttribI4iEXT(uint index, int x, int y, int z, int w); | |

void VertexAttribI1uiEXT(uint index, uint x); | |

void VertexAttribI2uiEXT(uint index, uint x, uint y); | |

void VertexAttribI3uiEXT(uint index, uint x, uint y, uint z); | |

void VertexAttribI4uiEXT(uint index, uint x, uint y, uint z, | |

uint w); | |

void VertexAttribI1ivEXT(uint index, const int *v); | |

void VertexAttribI2ivEXT(uint index, const int *v); | |

void VertexAttribI3ivEXT(uint index, const int *v); | |

void VertexAttribI4ivEXT(uint index, const int *v); | |

void VertexAttribI1uivEXT(uint index, const uint *v); | |

void VertexAttribI2uivEXT(uint index, const uint *v); | |

void VertexAttribI3uivEXT(uint index, const uint *v); | |

void VertexAttribI4uivEXT(uint index, const uint *v); | |

void VertexAttribI4bvEXT(uint index, const byte *v); | |

void VertexAttribI4svEXT(uint index, const short *v); | |

void VertexAttribI4ubvEXT(uint index, const ubyte *v); | |

void VertexAttribI4usvEXT(uint index, const ushort *v); | |

void VertexAttribIPointerEXT(uint index, int size, enum type, | |

sizei stride, const void *pointer); | |

void GetVertexAttribIivEXT(uint index, enum pname, int *params); | |

void GetVertexAttribIuivEXT(uint index, enum pname, | |

uint *params); | |

void Uniform1uiEXT(int location, uint v0); | |

void Uniform2uiEXT(int location, uint v0, uint v1); | |

void Uniform3uiEXT(int location, uint v0, uint v1, uint v2); | |

void Uniform4uiEXT(int location, uint v0, uint v1, uint v2, | |

uint v3); | |

void Uniform1uivEXT(int location, sizei count, const uint *value); | |

void Uniform2uivEXT(int location, sizei count, const uint *value); | |

void Uniform3uivEXT(int location, sizei count, const uint *value); | |

void Uniform4uivEXT(int location, sizei count, const uint *value); | |

void GetUniformuivEXT(uint program, int location, uint *params); | |

void BindFragDataLocationEXT(uint program, uint colorNumber, | |

const char *name); | |

int GetFragDataLocationEXT(uint program, const char *name); | |

New Tokens | |

Accepted by the <pname> parameters of GetVertexAttribdv, | |

GetVertexAttribfv, GetVertexAttribiv, GetVertexAttribIuivEXT and | |

GetVertexAttribIivEXT: | |

VERTEX_ATTRIB_ARRAY_INTEGER_EXT 0x88FD | |

Returned by the <type> parameter of GetActiveUniform: | |

SAMPLER_1D_ARRAY_EXT 0x8DC0 | |

SAMPLER_2D_ARRAY_EXT 0x8DC1 | |

SAMPLER_BUFFER_EXT 0x8DC2 | |

SAMPLER_1D_ARRAY_SHADOW_EXT 0x8DC3 | |

SAMPLER_2D_ARRAY_SHADOW_EXT 0x8DC4 | |

SAMPLER_CUBE_SHADOW_EXT 0x8DC5 | |

UNSIGNED_INT 0x1405 | |

UNSIGNED_INT_VEC2_EXT 0x8DC6 | |

UNSIGNED_INT_VEC3_EXT 0x8DC7 | |

UNSIGNED_INT_VEC4_EXT 0x8DC8 | |

INT_SAMPLER_1D_EXT 0x8DC9 | |

INT_SAMPLER_2D_EXT 0x8DCA | |

INT_SAMPLER_3D_EXT 0x8DCB | |

INT_SAMPLER_CUBE_EXT 0x8DCC | |

INT_SAMPLER_2D_RECT_EXT 0x8DCD | |

INT_SAMPLER_1D_ARRAY_EXT 0x8DCE | |

INT_SAMPLER_2D_ARRAY_EXT 0x8DCF | |

INT_SAMPLER_BUFFER_EXT 0x8DD0 | |

UNSIGNED_INT_SAMPLER_1D_EXT 0x8DD1 | |

UNSIGNED_INT_SAMPLER_2D_EXT 0x8DD2 | |

UNSIGNED_INT_SAMPLER_3D_EXT 0x8DD3 | |

UNSIGNED_INT_SAMPLER_CUBE_EXT 0x8DD4 | |

UNSIGNED_INT_SAMPLER_2D_RECT_EXT 0x8DD5 | |

UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT 0x8DD6 | |

UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT 0x8DD7 | |

UNSIGNED_INT_SAMPLER_BUFFER_EXT 0x8DD8 | |

Accepted by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, | |

and GetDoublev: | |

MIN_PROGRAM_TEXEL_OFFSET_EXT 0x8904 | |

MAX_PROGRAM_TEXEL_OFFSET_EXT 0x8905 | |

Additions to Chapter 2 of the OpenGL 2.0 Specification (OpenGL | |

Operation) | |

Modify Section 2.7 "Vertex Specification", p.20 | |

Insert before last paragraph, p.22: | |

The VertexAttrib* commands described so far should not be used to load | |

data for vertex attributes declared as signed or unsigned integers or | |

vectors thereof in a vertex shader. If they are used to load signed or | |

unsigned integer vertex attributes, the value in those attributes are | |

undefined. Instead use the commands | |

void VertexAttribI[1234]{i,ui}EXT(uint index, T values); | |

void VertexAttribI[1234]{i,ui}vEXT(uint index, T values); | |

void VertexAttribI4{b,s,ub,us}vEXT(uint index, T values); | |

to specify fixed-point attributes that are not converted to | |

floating-point. These attributes can be accessed in vertex shaders that | |

declare attributes as signed or unsigned integers or vectors. The | |

VertexAttribI4* commands extend the data passed in to a full signed or | |

unsigned integer. If a VertexAttribI* command is used that does not match | |

the type of the attribute declared in a vertex shader, the values in the | |

attributes are undefined. This means that the unsigned versions of the | |

VertexAttribI* commands need to be used to load data for unsigned integer | |

vertex attributes or vectors, and the signed versions of the | |

VertexAttribI* commands for signed integer vertex attributes or | |

vectors. Note that this also means that the VertexAttribI* commands should | |

not be used to load data for a vertex attribute declared as a float, float | |

vector or matrix, otherwise their values are undefined. | |

Insert at end of function list, p.24: | |

void VertexAttribIPointerEXT(uint index, int size, enum type, | |

sizei stride, const void *pointer); | |

(modify last paragraph, p.24) The <index> parameter in the | |

VertexAttribPointer and VertexAttribIPointerEXT commands identify the | |

generic vertex attribute array being described. The error INVALID_VALUE is | |

generated if <index> is greater than or equal to | |

MAX_VERTEX_ATTRIBS. Generic attribute arrays with integer <type> arguments | |

can be handled in one of three ways: converted to float by normalizing to | |

[0,1] or [-1,1] as specified in table 2.9, converted directly to float, or | |

left as integers. Data for an array specified by VertexAttribPointer will | |

be converted to floating-point by normalizing if the <normalized> | |

parameter is TRUE, and converted directly to floating-point | |

otherwise. Data for an array specified by VertexAttribIPointerEXT will | |

always be left as integer values. | |

(modify Table 2.4, p. 25) | |

Integer | |

Command Sizes Handling Types | |

---------------------- ------- --------- ----------------- | |

VertexPointer 2,3,4 cast ... | |

NormalPointer 3 normalize ... | |

ColorPointer 3,4 normalize ... | |

SecondaryColorPointer 3 normalize ... | |

IndexPointer 1 cast ... | |

FogCoordPointer 1 n/a ... | |

TexCoordPointer 1,2,3,4 cast ... | |

EdgeFlagPointer 1 integer ... | |

VertexAttribPointer 1,2,3,4 flag ... | |

VertexAttribIPointerEXT 1,2,3,4 integer byte, ubyte, | |

short, ushort, | |

int, uint | |

Table 2.4: Vertex array sizes (values per vertex) and data types. The | |

"integer handling" column indicates how fixed-point data types are | |

handled: "cast" means that they converted to floating-point directly, | |

"normalize" means that they are converted to floating-point by normalizing | |

to [0,1] (for unsigned types) or [-1,1] (for signed types), "integer" | |

means that they remain as integer values, and "flag" means that either | |

"cast" or "normalized" applies, depending on the setting of the | |

<normalized> flag in VertexAttribPointer. | |

(modify end of pseudo-code, pp. 27-28) | |

for (j = 1; j < genericAttributes; j++) { | |

if (generic vertex attribute j array enabled) { | |

if (generic vertex attribute j array is a pure integer array) | |

{ | |

VertexAttribI[size][type]vEXT(j, generic vertex attribute j | |

array element i); | |

} else if (generic vertex attribute j array normalization | |

flag is set and <type> is not FLOAT or DOUBLE) { | |

VertexAttrib[size]N[type]v(j, generic verex attribute j | |

array element i); | |

} else { | |

VertexAttrib[size][type]v(j, generic verex attribute j | |

array element i); | |

} | |

} | |

} | |

if (generic vertex attribute 0 array enabled) { | |

if (generic vertex attribute 0 array is a pure integer array) { | |

VertexAttribI[size][type]vEXT(0, generic verex attribute 0 | |

array element i); | |

} else if (generic vertex attribute 0 array normalization flag | |

is set and <type> is not FLOAT or DOUBLE) { | |

VertexAttrib[size]N[type]v(0, generic verex attribute 0 | |

array element i); | |

} else { | |

VertexAttrib[size][type]v(0, generic verex attribute 0 | |

array element i); | |

} | |

} | |

Modify section 2.14.7, "Flatshading", p. 69 | |

Add a new paragraph at the end of the section on p. 70 as follows: | |

If a vertex or geometry shader is active, the flat shading control | |

described so far applies to the built-in varying variables gl_FrontColor, | |

gl_BackColor, gl_FrontSecondaryColor and gl_BackSecondaryColor. Through | |

the OpenGL Shading Language varying qualifier flat any vertex attribute | |

can be flagged to be flat-shaded. See the OpenGL Shading Language | |

Specification section 4.3.6 for more information. | |

Modify section 2.14.8, "Color and Associated Data Clipping", p. 71 | |

Add to the end of this section: | |

For vertex shader varying variables specified to be interpolated without | |

perspective correction (using the noperspective keyword), the value of t | |

used to obtain the varying value associated with P will be adjusted to | |

produce results that vary linearly in screen space. | |

Modify section 2.15.3, "Shader Variables", page 75 | |

Add the following new return types to the description of GetActiveUniform | |

on p. 81. | |

SAMPLER_1D_ARRAY_EXT, | |

SAMPLER_2D_ARRAY_EXT, | |

SAMPLER_1D_ARRAY_SHADOW_EXT, | |

SAMPLER_2D_ARRAY_SHADOW_EXT, | |

SAMPLER_CUBE_SHADOW_EXT, | |

SAMPLER_BUFFER_EXT, | |

INT_SAMPLER_1D_EXT, | |

INT_SAMPLER_2D_EXT, | |

INT_SAMPLER_3D_EXT, | |

INT_SAMPLER_CUBE_EXT, | |

INT_SAMPLER_2D_RECT_EXT, | |

INT_SAMPLER_1D_ARRAY_EXT, | |

INT_SAMPLER_2D_ARRAY_EXT, | |

INT_SAMPLER_BUFFER_EXT, | |

UNSIGNED_INT, | |

UNSIGNED_INT_VEC2_EXT, | |

UNSIGNED_INT_VEC3_EXT, | |

UNSIGNED_INT_VEC4_EXT, | |

UNSIGNED_INT_SAMPLER_1D_EXT, | |

UNSIGNED_INT_SAMPLER_2D_EXT, | |

UNSIGNED_INT_SAMPLER_3D_EXT, | |

UNSIGNED_INT_SAMPLER_CUBE_EXT, | |

UNSIGNED_INT_SAMPLER_2D_RECT_EXT, | |

UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT, | |

UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT, | |

UNSIGNED_INT_SAMPLER_BUFFER_EXT. | |

Add the following uniform loading command prototypes on p. 81 as follows: | |

void Uniform{1234}uiEXT(int location, T value); | |

void Uniform{1234}uivEXT(int location, sizei count, T value); | |

(add the following paragraph to the description of the above | |

commands) | |

The Uniform*ui{v} commands will load count sets of one to four unsigned | |

integer values into a uniform location defined as a unsigned integer, an | |

unsigned integer vector, an array of unsigned integers or an array of | |

unsigned integer vectors. | |

(change the first sentence of the last paragraph as follows) | |

When loading values for a uniform declared as a Boolean, the Uniform*i{v}, | |

Uniform*ui{v} and Uniform*f{v} set of commands can be used to load boolean | |

values. | |

Modify section 2.15.4 Shader execution, p. 84. | |

Add a new section "2.15.4.1 Shader Only Texturing" before the sub- | |

section "Texture Access" on p. 85 | |

This section describes texture functionality that is only accessible | |

through vertex, geometry or fragment shaders. Also refer to the OpenGL | |

Shading Language Specification, section 8.7 and Section 3.8 of the OpenGL | |

2.0 specification. | |

Note: For unextended OpenGL 2.0 and the OpenGL Shading Language version | |

1.20, all supported texture internal formats store unsigned integer values | |

but return floating-point results in the range [0, 1] and are considered | |

unsigned "normalized" integers. The ARB_texture_float extension | |

introduces floating-point internal format where components are both stored | |

and returned as floating-point values, and are not clamped. The | |

EXT_texture_integer extension introduces formats that store either signed | |

or unsigned integer values. | |

This extension defines additional OpenGL Shading Language texture lookup | |

functions, see section 8.7 of the OpenGL Shading Language, that return | |

either signed or unsigned integer values if the internal format of the | |

texture is signed or unsigned, respectively. | |

Texel Fetches | |

The OpenGL Shading Language texel fetch functions provide the ability to | |

extract a single texel from a specified texture image. The integer | |

coordinates passed to the texel fetch functions are used directly as the | |

texel coordinates (i, j, k) into the texture image. This in turn means the | |

texture image is point-sampled (no filtering is performed). | |

The level of detail accessed is computed by adding the specified | |

level-of-detail parameter <lod> to the base level of the texture, | |

level_base. | |

The texel fetch functions can not perform depth comparisons or access cube | |

maps. Unlike filtered texel accesses, texel fetches do not support LOD | |

clamping or any texture wrap mode, and require a mipmapped minification | |

filter to access any level of detail other than the base level. | |

The results of the texel fetch are undefined: | |

* if the computed LOD is less than the texture's base level | |

(level_base) or greater than the maximum level (level_max), | |

* if the computed LOD is not the texture's base level and the texture's | |

minification filter is NEAREST or LINEAR, | |

* if the layer specified for array textures is negative or greater than | |

the number of layers in the array texture, | |

* if the texel at (i,j,k) coordinates refer to a border texel outside | |

the defined extents of the specified LOD, where | |

i < -b_s, j < -b_s, k < -b_s, | |

i >= w_s - b_s, j >= h_s - b_s, or k >= d_s - b_s, | |

where the size parameters (w_s, h_s, d_s, and b_s) refer to the | |

width, height, depth, and border size of the image, as in equations | |

3.15, 3.16, and 3.17, or | |

. if the texture being accessed is not complete (or cube complete for | |

cubemaps). | |

Texture Size Query | |

The OpenGL Shading Language texture size functions provide the ability to | |

query the size of a texture image. The LOD value <lod> passed in as an | |

argument to the texture size functions is added to the level_base of the | |

texture to determine a texture image level. The dimensions of that image | |

level, excluding a possible border, are then returned. If the computed | |

texture image level is outside the range [level_base, level_max], the | |

results are undefined. When querying the size of an array texture, both | |

the dimensions and the layer count are returned. Note that buffer textures | |

do not support mipmapping, therefore the previous lod discussion does not | |

apply to buffer textures | |

Make the section "Texture Access" a subsection of 2.15.4.1 | |

Modify the first paragraph on p. 86 as follows: | |

Texture lookups involving textures with depth component data can either | |

return the depth data directly or return the results of a comparison with | |

the R value (see section 3.8.14) used to perform the lookup. The | |

comparison operation is requested in the shader by using any of the shadow | |

sampler and in the texture using the TEXTURE COMPARE MODE parameter. These | |

requests must be consistent; the results of a texture lookup are undefined | |

if: | |

* The sampler used in a texture lookup function is not one of the | |

shadow sampler types, and the texture object's internal format is | |

DEPTH COMPONENT, and the TEXTURE COMPARE MODE is not NONE. | |

* The sampler used in a texture lookup function is one of the shadow | |

sampler types, and the texture object's internal format is DEPTH | |

COMPONENT, and the TEXTURE COMPARE MODE is NONE. | |

* The sampler used in a texture lookup function is one of the shadow | |

sampler types, and the texture object's internal format is not DEPTH | |

COMPONENT. | |

Add a new section "2.15.4.2 Shader Inputs" before "Position | |

Invariance" on p. 86 | |

Besides having access to vertex attributes and uniform variables, | |

vertex shaders can access the read-only built-in variables | |

gl_VertexID and gl_InstanceID. The gl_VertexID variable holds the | |

integer index <i> implicitly passed to ArrayElement() to specify | |

the vertex. The variable gl_InstanceID holds the integer index of | |

the current primitive in an instanced draw call. See also section | |

7.1 of the OpenGL Shading Language Specification. | |

Add a new section "2.15.4.3 Shader Outputs" | |

A vertex shader can write to built-in as well as user-defined varying | |

variables. These values are expected to be interpolated across the | |

primitive it outputs, unless they are specified to be flat shaded. Refer | |

to section 2.15.3 and the OpenGL Shading Language specification sections | |

4.3.6, 7.1 and 7.6 for more detail. | |

The built-in output variables gl_FrontColor, gl_BackColor, | |

gl_FrontSecondaryColor, and gl_BackSecondaryColor hold the front and back | |

colors for the primary and secondary colors for the current vertex. | |

The built-in output variable gl_TexCoord[] is an array and holds the set | |

of texture coordinates for the current vertex. | |

The built-in output variable gl_FogFragCoord is used as the "c" value, as | |

described in section 3.10 "Fog" of the OpenGL 2.0 specification. | |

The built-in special variable gl_Position is intended to hold the | |

homogeneous vertex position. Writing gl_Position is optional. | |

The built-in special variable gl_ClipVertex holds the vertex coordinate | |

used in the clipping stage, as described in section 2.12 "Clipping" of the | |

OpenGL 2.0 specification. | |

The built in special variable gl_PointSize, if written, holds the size of | |

the point to be rasterized, measured in pixels. | |

Number section "Position Invariance", "Validation" and "Undefined | |

Behavior" as sections 2.15.4.4, 2.15.4.5, and 2.15.4.6 respectively. | |

Additions to Chapter 3 of the OpenGL 2.0 Specification (Rasterization) | |

Modify Section 3.8.1, Texture Image Specification, p. 150 | |

(modify 4th paragraph, p. 151 -- add cubemaps to the list of texture | |

targets that can be used with DEPTH_COMPONENT textures) | |

Textures with a base internal format of DEPTH_COMPONENT are supported by | |

texture image specification commands only if <target> is TEXTURE_1D, | |

TEXTURE_2D, TEXTURE_CUBE_MAP, TEXTURE_RECTANGLE_ARB, PROXY_TEXTURE_1D, | |

PROXY_TEXTURE_2D, PROXY_TEXTURE_CUBE_MAP, or | |

PROXY_TEXTURE_RECTANGLE_ARB. Using this format in conjunction with any | |

other target will result in an INVALID_OPERATION error. | |

Delete Section 3.8.7, Texture Wrap Modes. (The language in this section | |

is folded into updates to the following section, and is no longer needed | |

here.) | |

Modify Section 3.8.8, Texture Minification: | |

(replace the last paragraph, p. 171): Let s(x,y) be the function that | |

associates an s texture coordinate with each set of window coordinates | |

(x,y) that lie within a primitive; define t(x,y) and r(x,y) analogously. | |

Let | |

u(x,y) = w_t * s(x,y) + offsetu_shader, | |

v(x,y) = h_t * t(x,y) + offsetv_shader, | |

w(x,y) = d_t * r(x,y) + offsetw_shader, and | |

where w_t, h_t, and d_t are as defined by equations 3.15, 3.16, and 3.17 | |

with w_s, h_s, and d_s equal to the width, height, and depth of the image | |

array whose level is level_base. (offsetu_shader, offsetv_shader, | |

offsetw_shader) is the texel offset specified in the OpenGL Shading | |

Language texture lookup functions that support offsets. If the texture | |

function used does not support offsets, or for fixed-function texture | |

accesses, all three shader offsets are taken to be zero. For | |

fixed-function texture accesses, all three shader offsets are taken to be | |

zero. For a one-dimensional texture, define v(x,y) == 0 and w(x,y) === 0; | |

for two-dimensional textures, define w(x,y) == 0. | |

After u(x,y), v(x,y), and w(x,y) are generated, they are clamped if the | |

corresponding texture wrap modes are CLAMP or MIRROR_CLAMP_EXT. Let | |

u'(x,y) = clamp(u(x,y), 0, w_t), if TEXTURE_WRAP_S is CLAMP | |

clamp(u(x,y), -w_t, w_t), if TEXTURE_WRAP_S is | |

MIRROR_CLAMP_EXT, or | |

u(x,y), otherwise | |

v'(x,y) = clamp(v(x,y), 0, w_t), if TEXTURE_WRAP_T is CLAMP | |

clamp(v(x,y), -w_t, w_t), if TEXTURE_WRAP_T is | |

MIRROR_CLAMP_EXT, or | |

v(x,y), otherwise | |

w'(x,y) = clamp(w(x,y), 0, w_t), if TEXTURE_WRAP_R is CLAMP | |

clamp(w(x,y), -w_t, w_t), if TEXTURE_WRAP_R is | |

MIRROR_CLAMP_EXT, or | |

w(x,y), otherwise, | |

where clamp(<a>,<b>,<c>) returns <b> if <a> is less than <b>, <c> if a is | |

greater than <c>, and <a> otherwise. | |

(start a new paragraph with "For a polygon, rho is given at a fragment | |

with window coordinates...", and then continue with the original spec | |

text.) | |

(replace text starting with the last paragraph on p. 172, continuing to | |

the end of p. 174) | |

When lambda indicates minification, the value assigned to | |

TEXTURE_MIN_FILTER is used to determine how the texture value for a | |

fragment is selected. | |

When TEXTURE_MIN_FILTER is NEAREST, the texel in the image array of level | |

level_base that is nearest (in Manhattan distance) to that specified by | |

(s,t,r) is obtained. Let i, j, and k be integers such that: | |

i = apply_wrap(floor(u'(x,y))), | |

j = apply_wrap(floor(v'(x,y))), and | |

k = apply_wrap(floor(w'(x,y))), | |

where the coordinate returned by apply_wrap() is as defined by Table X.19. | |

The values of i, j, and k are then modified according to the texture wrap | |

modes, as described in Table 3.19, to produce new values (i', j', and k'). | |

For a three-dimensional texture, the texel at location (i,j,k) becomes the | |

texture value. For a two-dimensional texture, k is irrelevant, and the | |

texel at location (i,j) becomes the texture value. For a one-dimensional | |

texture, j and k are irrelevant, and the texel at location i becomes the | |

texture value. | |

Wrap mode Result | |

-------------------------- ------------------------------------------ | |

CLAMP_TO_EDGE clamp(coord, 0, size-1) | |

CLAMP_TO_BORDER clamp(coord, -1, size) | |

CLAMP { clamp(coord, 0, size-1), | |

{ for NEAREST filtering | |

{ clamp(coord, -1, size), | |

{ for LINEAR filtering | |

REPEAT mod(coord, size) | |

MIRROR_CLAMP_TO_EDGE_EXT clamp(mirror(coord), 0, size-1) | |

MIRROR_CLAMP_TO_BORDER_EXT clamp(mirror(size), 0, size) | |

MIRROR_CLAMP_EXT { clamp(mirror(coord), 0, size-1), | |

{ for NEAREST filtering | |

{ clamp(mirror(size), 0, size), | |

{ for LINEAR filtering | |

MIRRORED_REPEAT (size-1) - mirror(mod(coord, 2*size)-size) | |

Table X.19: Texel location wrap mode application. mod(<a>,<b>) is | |

defined to return <a>-<b>*floor(<a>/<b>), and mirror(<a>) is defined to | |

return <a> if <a> is greater than or equal to zero or -(1+<a>) | |

otherwise. The values of "wrap mode" and size are TEXTURE_WRAP_S and | |

w_t, TEXTURE_WRAP_T and h_t, and TEXTURE_WRAP_R and d_t, for i, j, and k | |

coordinates, respectively. The coordinate clamp and MIRROR_CLAMP_EXT | |

depends on the filtering mode (NEAREST or LINEAR). | |

If the selected (i,j,k), (i,j), or i location refers to a border texel | |

that satisfies any of the following conditions: | |

i < -b_s, | |

j < -b_s, | |

k < -b_s, | |

i >= w_t + b_s, | |

j >= h_t + b_s, or | |

j >= d_t + b_s, | |

then the border values defined by TEXTURE_BORDER_COLOR are used in place | |

of the non-existent texel. If the texture contains color components, the | |

values of TEXTURE_BORDER_COLOR are interpreted as an RGBA color to match | |

the texture's internal format in a manner consistent with table 3.15. If | |

the texture contains depth components, the first component of | |

TEXTURE_BORDER_COLOR is interpreted as a depth value. | |

When TEXTURE_MIN_FILTER is LINEAR, a 2x2x2 cube of texels in the image | |

array of level level_base is selected. Let: | |

i_0 = apply_wrap(floor(u' - 0.5)), | |

j_0 = apply_wrap(floor(v' - 0.5)), | |

k_0 = apply_wrap(floor(w' - 0.5)), | |

i_1 = apply_wrap(floor(u' - 0.5) + 1), | |

j_1 = apply_wrap(floor(v' - 0.5) + 1), | |

k_1 = apply_wrap(floor(w' - 0.5) + 1), | |

alpha = frac(u' - 0.5), | |

beta = frac(v' - 0.5), | |

gamma = frac(w' - 0.5), | |

where frac(<x>) denotes the fractional part of <x>. | |

For a three-dimensional texture, the texture value tau is found as... | |

(replace last paragraph, p.174) For any texel in the equation above that | |

refers to a border texel outside the defined range of the image, the texel | |

value is taken from the texture border color as with NEAREST filtering. | |

modify the last paragraph of section 3.8.8, p. 175, as follows: | |

The rules for NEAREST or LINEAR filtering are then applied to the selected | |

array. Specifically, the coordinate (u,v,w) is computed as in equation | |

3.20a, with w_s, h_s, and d_s equal to the width, height, and depth of the | |

image array whose level is 'd'. | |

Modify the second paragraph on p. 176 | |

The rules for NEAREST or LINEAR filtering are then applied to each of the | |

selected arrays, yielding two corresponding texture valutes Tau1 and | |

Tau2. Specifically, for level d1, the coordinate (u,v,w) is computed as in | |

equation 3.20a, with w_s, h_s, and d_s equal to the width, height, and | |

depth of the image array whose level is 'd1'. For level d2 the coordinate | |

(u', v', w') is computed as in equation 3.20a, with w_s, h_s, and d_s | |

equal to the width, height, and depth of the image array whose level is | |

'd2'. | |

Modify the first paragraph of section 3.8.9 "Texture Magnification" as | |

follows: | |

When lambda indicates magnification, the value assigned to | |

TEXTURE_MAG_FILTER determines how the texture value is obtained. There are | |

two possible values for TEXTURE_MAG_FILTER: NEAREST and LINEAR. NEAREST | |

behaves exactly as NEAREST for TEXTURE_MIN_FILTER and LINEAR behaves | |

exactly as LINEAR for TEXTURE_MIN_FILTER, as described in the previous | |

section, including the wrapping calculations. The level-of-detail | |

level_base texture array is always used for magnification. | |

Modify Section 3.8.14, Texture Comparison Modes (p. 185) | |

(modify 2nd paragraph, p. 188, indicating that the Q texture coordinate is | |

used for depth comparisons on cubemap textures) | |

Let D_t be the depth texture value, in the range [0, 1]. For | |

fixed-function texture lookups, let R be the interpolated <r> texture | |

coordinate, clamped to the range [0, 1]. For texture lookups generated by | |

an OpenGL Shading Language lookup function, let R be the reference value | |

for depth comparisons provided in the lookup function, also clamped to [0, | |

1]. Then the effective texture value L_t, I_t, or A_t is computed as | |

follows: | |

Modify section 3.11, Fragment Shaders, p. 193 | |

Modify the third paragraph on p. 194 as follows: | |

Additionally, when a vertex shader is active, it may define one or more | |

varying variables (see section 2.15.3 and the OpenGL Shading Language | |

Specification). These values are, if not flat shaded, interpolated across | |

the primitive being rendered. The results of these interpolations are | |

available when varying variables of the same name are defined in the | |

fragment shader. | |

Add the following paragraph to the end of section 3.11.1, p. 194 | |

A fragment shader can also write to varying out variables. Values written | |

to these variables are used in the subsequent per-fragment operations. | |

Varying out variables can be used to write floating-point, integer or | |

unsigned integer values destined for buffers attached to a framebuffer | |

object, or destined for color buffers attached to the default | |

framebuffer. The subsection 'Shader Outputs' of the next section describes | |

API how to direct these values to buffers. | |

Add a new paragraph at the beginning of the section "Texture | |

Access", p. 194 | |

Section 2.15.4.1 describes texture lookup functionality accessible to a | |

vertex shader. The texel fetch and texture size query functionality | |

described there also applies to fragment shaders. | |

Modify the second paragraph on p. 195 as follows: | |

Texture lookups involving textures with depth component data can either | |

return the depth data directly or return the results of a comparison with | |

the R value (see section 3.8.14) used to perform the lookup. The | |

comparison operation is requested in the shader by using any of the shadow | |

sampler and in the texture using the TEXTURE COMPARE MODE parameter. These | |

requests must be consistent; the results of a texture lookup are undefined | |

if: | |

* The sampler used in a texture lookup function is not one of the | |

shadow sampler types, and the texture object's internal format is | |

DEPTH COMPONENT, and the TEXTURE COMPARE MODE is not NONE. | |

* The sampler used in a texture lookup function is one of the shadow | |

sampler types, and the texture object's internal format is DEPTH | |

COMPONENT, and the TEXTURE COMPARE MODE is NONE. | |

* The sampler used in a texture lookup function is one of the shadow | |

sampler types, and the texture object's internal format is not DEPTH | |

COMPONENT. | |

Add the following paragraph to the section Shader Inputs, p. 196 | |

If a geometry shader is active, the built-in variable gl_PrimitiveID | |

contains the ID value emitted by the geometry shader for the provoking | |

vertex. If no geometry shader is active, gl_PrimitiveID is filled with the | |

number of primitives processed by the rasterizer since the last time Begin | |

was called (directly or indirectly via vertex array functions). The first | |

primitive generated after a Begin is numbered zero, and the primitive ID | |

counter is incremented after every individual point, line, or polygon | |

primitive is processed. For polygons drawn in point or line mode, the | |

primitive ID counter is incremented only once, even though multiple points | |

or lines may be drawn. For QUADS and QUAD_STRIP primitives that are | |

decomposed into triangles, the primitive ID is incremented after each | |

complete quad is processed. For POLYGON primitives, the primitive ID | |

counter is undefined. The primitive ID is undefined for fragments | |

generated by DrawPixels or Bitmap. Restarting a primitive topology using | |

the primitive restart index has no effect on the primitive ID counter. | |

Modify the first paragraph of the section Shader Outputs, p. 196 as | |

follows | |

The OpenGL Shading Language specification describes the values that may be | |

output by a fragment shader. These outputs are split into two | |

categories. User-defined varying out variables and built-in variables. The | |

built-in variables are gl_FragColor, gl_FragData[n], and gl_FragDepth. If | |

fragment clamping is enabled, the final fragment color values or the final | |

fragment data values or the final varying out variable values written by a | |

fragment shader are clamped to the range [0,1] and then may be converted | |

to fixed-point as described in section 2.14.9. Only user-defined varying | |

out variables declared as a floating-point type are clamped and may be | |

converted. If fragment clamping is disabled, the final fragment color | |

values or the final fragment data values or the final varying output | |

variable values are not modified. The final fragment depth written... | |

Modify the second paragraph of the section Shader Outputs, p. 196 | |

as follows | |

...A fragment shader may not statically assign values to more than one of | |

gl_FragColor, gl_FragData or any user-defined varying output variable. In | |

this case, a compile or link error will result. A shader statically... | |

Add the following to the end of the section Shader Outputs, p. 197 | |

The values of user-defined varying out variables are directed to a color | |

buffer in a two step process. First the varying out variable is bound to a | |

fragment color by using its number. The GL will assign a number to each | |

varying out variable, unless overridden by the command | |

BindFragDataLocationEXT(). The number of the fragment color assigned for | |

each user-defined varying out variable can be queried with | |

GetFragDataLocationEXT(). Next, the DrawBuffer or DrawBuffers commands (see | |

section 4.2.1) direct each fragment color to a particular buffer. | |

The binding of a user-defined varying out variable to a fragment color | |

number can be specified explicitly. The command | |

void BindFragDataLocationEXT(uint program, uint colorNumber, | |

const char *name); | |

specifies that the varying out variable name in program should be bound to | |

fragment color colorNumber when the program is next linked. If name was | |

bound previously, its assigned binding is replaced with colorNumber. name | |

must be a null terminated string. The error INVALID_VALUE is generated if | |

colorNumber is equal or greater than MAX_DRAW_BUFFERS. | |

BindFragDataLocationEXT has no effect until the program is linked. In | |

particular, it doesn't modify the bindings of varying out variables in a | |

program that has already been linked. The error INVALID OPERATION is | |

generated if name starts with the reserved "gl_" prefix. | |

When a program is linked, any varying out variables without a binding | |

specified through BindFragDataLocationEXT will automatically be bound to | |

fragment colors by the GL. Such bindings can be queried using the command | |

GetFragDataLocationEXT. LinkProgram will fail if the assigned binding of a | |

varying out variable would cause the GL to reference a non-existant | |

fragment color number (one greater than or equal to MAX DRAW_BUFFERS). | |

LinkProgram will also fail if more than one varying out variable is bound | |

to the same number. This type of aliasing is not allowed. | |

BindFragDataLocationEXT may be issued before any shader objects are | |

attached to a program object. Hence it is allowed to bind any name (except | |

a name starting with "gl_") to a color number, including a name that is | |

never used as a varying out variable in any fragment shader | |

object. Assigned bindings for variables that do not exist are ignored. | |

After a program object has been linked successfully, the bindings of | |

varying out variable names to color numbers can be queried. The command | |

int GetFragDataLocationEXT(uint program, const char *name); | |

returns the number of the fragment color that the varying out variable | |

name was bound to when the program object program was last linked. name | |

must be a null terminated string. If program has not been successfully | |

linked, the error INVALID OPERATION is generated. If name is not a varying | |

out variable, or if an error occurs, -1 will be returned. | |

Additions to Chapter 4 of the OpenGL 2.0 Specification (Per-Fragment | |

Operations and the Frame Buffer) | |

Modify Section 4.2.1, Selecting a Buffer for Writing (p. 212) | |

(modify next-to-last paragraph, p. 213) If a fragment shader writes to | |

gl_FragColor, DrawBuffers specifies a set of draw buffers into which the | |

single fragment color defined by gl_FragColor is written. If a fragment | |

shader writes to gl_FragData or a user-defined varying out variable, | |

DrawBuffers specifies a set of draw buffers into which each of the | |

multiple output colors defined by these variables are separately written. | |

If a fragment shader writes to neither gl_FragColor, nor gl FragData, nor | |

any user-defined varying out variables, the values of the fragment colors | |

following shader execution are undefined, and may differ for each fragment | |

color. | |

Additions to Chapter 5 of the OpenGL 2.0 Specification (Special Functions) | |

Change section 5.4 Display Lists, p. 237 | |

Add the commands VertexAttribIPointerEXT and BindFragDataLocationEXT to | |

the list of commands that are not compiled into a display list, but | |

executed immediately, under "Program and Shader Objects", p. 241 | |

Additions to Chapter 6 of the OpenGL 2.0 Specification (State and State | |

Requests) | |

Modify section 6.1.14 "Shader and Program Queries", p. 256 | |

Modify 2nd paragraph, p.259: | |

Add the following to the list of GetVertexAttrib* commands: | |

void GetVertexAttribIivEXT(uint index, enum pname, int *params); | |

void GetVertexAttribIuivEXT(uint index, enum pname, uint *params); | |

obtain the... <pname> must be one of VERTEX_ATTRIB_ARRAY_ENABLED ,., | |

VERTEX_ATTRIB_ARRAY_NORMALIZED, VERTEX_ATTRIB_ARRAY_INTEGER_EXT, or | |

CURRENT_VERTEX_ATTRIB. ... | |

Split 3rd paragraph, p.259 | |

... The size, stride, type, normalized flag, and unconverted integer flag | |

are set by the commands VertexAttribPointer and VertexAttribIPointerEXT. | |

The normalized flag is always set to FALSE by by VertexAttribIPointerEXT. | |

The unconverted integer flag is always set to FALSE by VertexAttribPointer | |

and TRUE by VertexAttribIPointerEXT. | |

The query CURRENT_VERTEX_ATTRIB returns the current value for the generic | |

attribute <index>. GetVertexAttribdv and GetVertexAttribfv read and | |

return the current attribute values as floating-point values; | |

GetVertexAttribiv reads them as floating-point values and converts them | |

to integer values; GetVertexAttribIivEXT reads and returns them as | |

integers; GetVertexAttribIuivEXT reads and returns them as unsigned | |

integers. The results of the query are undefined if the current attribute | |

values are read using one data type but were specified using a different | |

one. The error INVALID_OPERATION is generated if <index> is zero. | |

Change the prototypes in the first paragraph on page 260 as | |

follows: | |

void GetUniformfv(uint program, int location, float *params); | |

void GetUniformiv(uint program, int location, int *params); | |

void GetUniformuivEXT(uint program, int location, uint *params); | |

Additions to Appendix A of the OpenGL 2.0 Specification (Invariance) | |

None. | |

Additions to the AGL/GLX/WGL Specifications | |

None. | |

Interactions with GL_ARB_color_buffer_float | |

If the GL_ARB_color_buffer_float extension is not supported then any | |

reference to fragment clamping in section 3.11.2 "Shader Execution" needs | |

to be deleted. | |

Interactions with GL_ARB_texture_rectangle | |

If the GL_ARB_texture_rectangle extension is not supported then all | |

references to texture lookup functions with 'Rect' in the name need to be | |

deleted. | |

Interactions with GL_EXT_texture_array | |

If the GL_EXT_texture_array extension is not supported, all references to | |

one- and two-dimensional array texture sampler types (e.g., | |

sampler1DArray, sampler2DArray) and the texture lookup functions that use | |

them need to be deleted. | |

Interactions with GL_EXT_geometry_shader4 | |

If the GL_EXT_geometry_shader4 extension is not supported, all references | |

to a geometry shader need to be deleted. | |

Interactions with GL_NV_primitive_restart | |

The spec describes the behavior that primitive restart does not affect the | |

primitive ID counter, including for POLYGON primitives (where one could | |

argue that the restart index starts a new primitive without a new Begin to | |

reset the count). If NV_primitive_restart is not supported, references to | |

that extension in the discussion of the primitive ID counter should be | |

removed. | |

If NV_primitive_restart is supported, index values causing a primitive | |

restart are not considered as specifying an End command, followed by | |

another Begin. Primitive restart is therefore not guaranteed to | |

immediately update material properties when a vertex shader is active. The | |

spec language on p.64 of the OpenGL 2.0 specification says "changes are | |

not guaranteed to update material parameters, defined in table 2.11, until | |

the following End command." | |

Interactions with EXT_texture_integer | |

If the EXT_texture_integer spec is not supported, the discussion about | |

this spec in section 2.15.4.1 needs to be removed. All texture lookup | |

functions that return integers or unsigned integers, as discussed in | |

section 8.7 of the OpenGL Shading Language specification, also need to be | |

removed. | |

Interactions with EXT_texture_buffer_object | |

If EXT_texture_buffer_object is not supported, references to buffer | |

textures, as well as the texelFetchBuffer and texelSizeBuffer lookup | |

functions and samplerBuffer types, need to be removed. | |

Interactions with EXT_draw_instanced | |

If EXT_draw_instanced is not supported, the value of gl_InstanceID | |

is always zero. | |

GLX Protocol | |

The following rendering commands are sent to the server as part of a | |

glXRender request: | |

Uniform1uiEXT | |

2 12 rendering command length | |

2 269 rendering command opcode | |

4 INT32 location | |

4 CARD32 v0 | |

Uniform2uiEXT | |

2 16 rendering command length | |

2 270 rendering command opcode | |

4 INT32 location | |

4 CARD32 v0 | |

4 CARD32 v1 | |

Uniform3uiEXT | |

2 20 rendering command length | |

2 271 rendering command opcode | |

4 INT32 location | |

4 CARD32 v0 | |

4 CARD32 v1 | |

4 CARD32 v2 | |

Uniform4uiEXT | |

2 24 rendering command length | |

2 272 rendering command opcode | |

4 INT32 location | |

4 CARD32 v0 | |

4 CARD32 v1 | |

4 CARD32 v2 | |

4 CARD32 v3 | |

BindFragDataLocationEXT | |

2 12+n+p rendering command length | |

2 273 rendering command opcode | |

4 CARD32 program | |

4 CARD32 color | |

n LISTofBYTE name, n = strlen(name) + 1 | |

p padding, p=pad(n) | |

The following rendering commands are sent sent to the server as part | |

of a glXRender request or as a glXRenderLarge request. | |

Uniform1uivEXT | |

2 12+count*4 rendering command length | |

2 274 rendering command opcode | |

4 INT32 location | |

4 CARD32 count | |

4*count LISTofCARD32 value | |

If the command is encoded in a glXRenderLarge request, the | |

command opcode and command length fields above are expanded to | |

4 bytes each: | |

4 16+count*4 rendering command length | |

4 274 rendering command opcode | |

Uniform2uivEXT | |

2 12+count*4*2 rendering command length | |

2 275 rendering command opcode | |

4 INT32 location | |

4 CARD32 count | |

2*4*count LISTofCARD32 value | |

If the command is encoded in a glXRenderLarge request, the | |

command opcode and command length fields above are expanded to | |

4 bytes each: | |

4 16+count*4*2 rendering command length | |

4 275 rendering command opcode | |

Uniform3uivEXT | |

2 12+count*4*3 rendering command length | |

2 276 rendering command opcode | |

4 INT32 location | |

4 CARD32 count | |

3*4*count LISTofCARD32 value | |

If the command is encoded in a glXRenderLarge request, the | |

command opcode and command length fields above are expanded to | |

4 bytes each: | |

4 16+count*4 rendering command length | |

4 276 rendering command opcode | |

Uniform4uivEXT | |

2 12+count*4*4 rendering command length | |

2 277 rendering command opcode | |

4 INT32 location | |

4 CARD32 count | |

4*4*count LISTofCARD32 value | |

If the command is encoded in a glXRenderLarge request, the | |

command opcode and command length fields above are expanded to | |

4 bytes each: | |

4 16+count*4*4 rendering command length | |

4 277 rendering command opcode | |

The following non-rendering commands are added. | |

GetUniformuivEXT | |

1 CARD8 opcode (X assigned) | |

1 182 GLX opcode | |

2 4 request length | |

4 GLX_CONTEXT_TAG context tag | |

4 CARD32 program | |

4 INT32 location | |

=> | |

1 1 reply | |

1 unused | |

2 CARD16 sequence number | |

4 m reply length, m = (n == 1 ? 0 : n) | |

4 CARD32 unused | |

4 CARD32 n | |

if (n = 1) this follows: | |

4 CARD32 params | |

12 unused | |

otherwise this follows: | |

16 CARD32 unused | |

4*n CARD32 params | |

Note that n may be zero, indicating that a GL error occured. | |

GetFragDataLocationEXT | |

1 CARD8 opcode (X assigned) | |

1 183 GLX opcode | |

2 3+(n+p)/4 request length | |

4 GLX_CONTEXT_TAG context tag | |

4 CARD32 program | |

n LISTofBYTE name, n = strlen(name) + 1 | |

p padding, p=pad(n) | |

=> | |

1 1 reply | |

1 unused | |

2 CARD16 sequence number | |

4 0 reply length | |

4 CARD32 retval | |

20 unused | |

GLX protocol for following commands is defined in the | |

NV_vertex_program4 extension: | |

VertexAttribI1iEXT, VertexAttribI2iEXT, VertexAttribI3iEXT, | |

VertexAttribI4iEXT, VertexAttribI1uiEXT, VertexAttribI2uiEXT, | |

VertexAttribI3uiEXT, VertexAttribI4uiEXT, VertexAttribI1ivEXT, | |

VertexAttribI2ivEXT, VertexAttribI3ivEXT, VertexAttribI4ivEXT, | |

VertexAttribI1uivEXT, VertexAttribI2uivEXT, VertexAttribI3uivEXT, | |

VertexAttribI4uivEXT, VertexAttribI4bvEXT, VertexAttribI4svEXT, | |

VertexAttribI4ubvEXT, VertexAttribI4usvEXT, GetVertexAttribIivEXT, | |

GetVertexAttribIuivEXT | |

VertexAttribIPointerEXT is an entirely client-side command. | |

Errors | |

The error INVALID_VALUE is generated by BindFragDataLocationEXT() if | |

colorNumber is equal or greater than MAX_DRAW_BUFFERS. | |

The error INVALID OPERATION is generated by BindFragDataLocationEXT() if | |

name starts with the reserved "gl_" prefix. | |

The error INVALID_OPERATION is generated by BindFragDataLocationEXT() or | |

GetFragDataLocationEXT if program is not the name of a program object. | |

The error INVALID_OPERATION is generated by GetFragDataLocationEXT() if | |

program has not been successfully linked. | |

New State | |

(add to table 6.7, p. 268) | |

Initial | |

Get Value Type Get Command Value Description Sec. Attribute | |

--------- ---- --------------- ------- -------------------- ---- --------- | |

VERTEX_ATTRIB_ARRAY 16+xB GetVertexAttrib FALSE vertex attrib array 2.8 vertex-array | |

INTEGER_EXT has unconverted ints | |

New Implementation Dependent State | |

Minimum | |

Get Value Type Get Command Value Description Sec. Attrib | |

-------------------------------- ---- --------------- ------- --------------------- ------ ------ | |

MIN_PROGRAM_TEXEL_OFFSET_EXT Z GetIntegerv -8 minimum texel offset 2.x.4.4 - | |

allowed in lookup | |

MAX_PROGRAM_TEXEL_OFFSET_EXT Z GetIntegerv +7 maximum texel offset 2.x.4.4 - | |

allowed in lookup | |

Modifications to The OpenGL Shading Language Specification, Version 1.10.59 | |

Including the following line in a shader can be used to control the | |

language features described in this extension: | |

#extension GL_EXT_gpu_shader4 : <behavior> | |

where <behavior> is as specified in section 3.3. | |

A new preprocessor #define is added to the OpenGL Shading Language: | |

#define GL_EXT_gpu_shader4 1 | |

Add to section 3.6 "Keywords" | |

Add the following keywords: | |

noperspective, flat, centroid | |

Remove the unsigned keyword from the list of keywords reserved for future | |

use, and add it to the list of keywords. | |

The following new vector types are added: | |

uvec2, uvec3, uvec4 | |

The following new sampler types are added: | |

sampler1DArray, sampler2DArray, sampler1DArrayShadow, | |

sampler2DArrayShadow, samplerCubeShadow | |

isampler1D, isampler2D, isampler3D, isamplerCube, isampler2DRect, | |

isampler1DArray, isampler2DArray | |

usampler1D, usampler2D, usampler3D, usamplerCube, usampler2DRect, | |

usampler1DArray, usampler2DArray | |

samplerBuffer, isamplerBuffer, usamplerBuffer | |

Add to section 4.1 "Basic Types" | |

Break the table in this section up in several tables. The first table | |

4.1.1 is named "scalar, vector and matrix data types". It includes the | |

first row through the 'mat4" row. | |

Add the following to the first section of this table: | |

unsigned int An unsigned integer | |

uvec2 A two-component unsigned integer vector | |

uvec3 A three-component unsigned integer vector | |

uvec4 A four-component unsigned integer vector | |

Break out the sampler types in a separate table, and name that table 4.1.2 | |

"default sampler types". Add the following sampler types to this new | |

table: | |

sampler1DArray handle for accessing a 1D array texture | |

sampler2DArray handle for accessing a 2D array texture | |

sampler1DArrayShadow handle for accessing a 1D array depth texture | |

with comparison | |

sampler2DArrayShadow handle for accessing a 2D array depth texture | |

with comparison | |

samplerBuffer handle for accessing a buffer texture | |

Add a table 4.1.3 called "integer sampler types": | |

isampler1D handle for accessing an integer 1D texture | |

isampler2D handle for accessing an integer 2D texture | |

isampler3D handle for accessing an integer 3D texture | |

isamplerCube handle for accessing an integer cube map texture | |

isampler2DRect handle for accessing an integer rectangle texture | |

isampler1DArray handle for accessing an integer 1D array texture | |

isampler2DArray handle for accessing an integer 2D array texture | |

isamplerBuffer handle for accessing an integer buffer texture | |

Add a table 4.1.4 called "unsigned integer sampler types": | |

usampler1D handle for accessing an unsigned integer | |

1D texture | |

usampler2D handle for accessing an unsigned integer | |

2D texture | |

usampler3D handle for accessing an unsigned integer | |

3D texture | |

usamplerCube handle for accessing an unsigned integer | |

cube map texture | |

usampler2DRect handle for accessing an unsigned integer | |

rectangle texture | |

usampler1DArray handle for accessing an unsigned integer 1D | |

array texture | |

usampler2DArray handle for accessing an unsigned integer 2D | |

array texture | |

usamplerBuffer handle for accessing an unsigned integer | |

buffer texture | |

Change section 4.1.3 "Integers" | |

Remove the first two paragraphs and replace with the following: | |

Signed, as well as unsigned integers, are fully supported. Integers hold | |

whole numbers. Integers have at least 32 bits of precision, including a | |

sign bit. Signed integers are stored using a two's complement | |

representation. | |

Integers are declared and optionally initialized with integer expressions | |

as in the following example: | |

int i, j = 42; | |

unsigned int k = 3u; | |

Literal integer constants can be expressed in decimal (base 10), octal | |

(base 8), or hexadecimal (base 16) as follows. | |

integer-constant: | |

decimal-constant integer-suffix_opt | |

octal-constant integer-suffix_opt | |

hexadecimal-constant integer-suffix_opt | |

integer-suffix: one of | |

u U | |

Change section 4.3 "Type Qualifiers" | |

Change the "varying" and "out" qualifier as follows: | |

varying - linkage between a vertex shader and fragment shader, or between | |

a fragment shader and the back end of the OpenGL pipeline. | |

out - for function parameters passed back out of a function, but not | |

initialized for use when passed in. Also for output varying variables | |

(fragment only). | |

In the qualifier table, add the following sub-qualifiers under the varying | |

qualifier: | |

flat varying | |

noperspective varying | |

centroid varying | |

Change section 4.3.4 "Attribute" | |

Change the sentence: | |

The attribute qualifier can be used only with the data types float, vec2, | |

vec3, vec4, mat2, mat3, and mat4. | |

To: | |

The attribute qualifier can be used only with the data types int, ivec2, | |

ivec3, ivec4, unsigned int, uvec2, uvec3, uvec4, float, vec2, vec3, vec4, | |

mat2, mat3, and mat4. | |

Change the fourth paragraph to: | |

It is expected that graphics hardware will have a small number of fixed | |

locations for passing vertex attributes. Therefore, the OpenGL Shading | |

language defines each non-matrix attribute variable as having space for up | |

to four integer or floating-point values (i.e., a vec4, ivec4 or | |

uvec4). There is an implementation dependent limit on the number of | |

attribute variables that can be used and if this is exceeded it will cause | |

a link error. (Declared attribute variables that are not used do not count | |

against this limit.) A scalar attribute counts the same amount against | |

this limit as a vector of size four, so applications may want to consider | |

packing groups of four unrelated scalar attributes together into a vector | |

to better utilize the capabilities of the underlying hardware. A mat4 | |

attribute will... | |

Change section 4.3.6 "Varying" | |

Change the first paragraph to: | |

Varying variables provide the interface between the vertex shader, the | |

fragment shader, and the fixed functionality between the vertex and | |

fragment shader, as well as the interface from the fragment shader to the | |

back-end of the OpenGL pipeline. | |

The vertex shader will compute values per vertex (such as color, texture | |

coordinates, etc.) and write them to variables declared with the varying | |

qualifier. A vertex shader may also read varying variables, getting back | |

the same values it has written. Reading a varying variable in a vertex | |

shader returns undefined values if it is read before being written. | |

The fragment shader will compute values per fragment and write them to | |

variables declared with the varying out qualifier. A fragment shader may | |

also read varying variables, getting back the same result it has | |

written. Reading a varying variable in a fragment shader returns undefined | |

values if it is read before being written. | |

Varying variables may be written more than once. If so, the last value | |

assigned is the one used. | |

Change the second paragraph to: | |

Varying variables that are set per vertex are interpolated by default in a | |

perspective-correct manner over the primitive being rendered, unless the | |

varying is further qualified with noperspective. Interpolation in a | |

perspective correct manner is specified in equations 3.6 and 3.8 in the | |

OpenGL 2.0 specification. When noperspective is specified, interpolation | |

must be linear in screen space, as described in equation 3.7 and the | |

approximation that follows equation 3.8. | |

If single-sampling, the value is interpolated to the pixel's center, and | |

the centroid qualifier, if present, is ignored. If multi-sampling, and the | |

varying is not qualified with centroid, then the value must be | |

interpolated to the pixel's center, or anywhere within the pixel, or to | |

one of the pixel's samples. If multi-sampling and the varying is qualified | |

with centroid, then the value must be interpolated to a point that lies in | |

both the pixel and in the primitive being rendered, or to one of the | |

pixel's samples that falls within the primitive. | |

[NOTE: Language for centroid sampling taken from the GLSL 1.20.4 | |

specification] | |

Varying variables, set per vertex, can be computed on a per-primitive | |

basis (flat shading), or interpolated over a line or polygon primitive | |

(smooth shading). By default, a varying variable is smooth shaded, unless | |

the varying is further qualified with flat. When smooth shading, the | |

varying is interpolated over the primitive. When flat shading, the varying | |

is constant over the primitive, and is taken from the single provoking | |

vertex of the primitive, as described in Section 2.14.7 of the OpenGL 2.0 | |

specification. | |

Change the fourth paragraph to: | |

The type and any qualifications (flat, noperspective, centroid) of varying | |

variables with the same name declared in both the vertex and fragment | |

shaders must match, otherwise the link command will fail. Note that | |

built-in varying variables, which have names starting with "gl_", can not | |

be further qualified with flat, noperspective or centroid. The flat | |

keyword cannot be used together with either the noperspective or centroid | |

keywords to further qualify a single varying variable, otherwise a compile | |

error will occur. When using the keywords centroid, flat or noperspective, | |

it must immediately precede the varying keyword. When using both centroid | |

and noperspective keywords, either one can be specified first. Only those | |

varying variables used (i.e. read) in the fragment shader must be written | |

to by the vertex shader; declaring superfluous varying variables in the | |

vertex shader is permissible. Varying out variables, set per fragment, can | |

not be further qualified with flat, noperspective or centroid. | |

Fragment shaders output values to the back-end of the OpenGL pipeline | |

using either user-defined varying out variables or built-in variables, as | |

described in section 7.2, unless the discard keyword is executed. If the | |

back-end of the OpenGL pipeline consumes a user-defined varying out | |

variable and an execution of a fragment shader does not write a value to | |

that variable, then the value consumed is undefined. If the back-end of | |

the OpenGL pipeline consumes a varying out variable and a fragment shader | |

either writes values into less components of the variable, or if the | |

variable is declared to have less components, than needed, the values of | |

the missing component(s) are undefined. The OpenGL specification, section | |

3.x.x, describes API to route varying output variables to color buffers. | |

Add the following examples: | |

noperspective varying float temperature; | |

flat varying vec3 myColor; | |

centroid varying vec2 myTexCoord; | |

centroid noperspective varying vec2 myTexCoord; | |

varying out ivec3 foo; | |

Change the third paragraph on p. 25 as follows: | |

The "varying" qualifier can be used only with the data types float, vec2, | |

vec3, vec4, mat2, mat3, and mat4, int, ivec2, ivec3, ivec4, unsigned int, | |

uvec2, uvec3, uvec4 or arrays of these. Structures cannot be varying. If | |

the varying is declared as one of the integer or unsigned integer data | |

type variants, then it has to also be qualified as being flat shaded, | |

otherwise a compile error will occur. | |

The "varying out" qualifier can be used only with the data types float, | |

vec2, vec3, vec4, int, ivec2, ivec3, ivec4, unsigned int, uvec2, uvec3 or | |

uvec4. Structures or arrays cannot be declared as varying out. | |

Change section 5.1 "Operators" | |

Remove the "reserved" qualifications from the following operator | |

precedence table entries: | |

Precedence Operator class | |

---------- ----------------------------------- | |

3 (tilde is reserved) | |

4 (modulus reserved) | |

6 bit-wise shift (reserved) | |

9 bit-wise and (reserved) | |

10 bit-wise exclusive or (reserved) | |

11 bit-wise inclusive or (reserved) | |

16 (modulus, shift, and bit-wise are reserved) | |

Change section 5.8 "Assignments" | |

Change the first bullet from: | |

* The arithmetic assignments add into (+=).. | |

To: | |

* The arithmetic assignments add into (+=), subtract from (- | |

=), multiply into (*=), and divide into (/=) as well as the | |

assignments modulus into (%=), left shift by (<<=), right | |

shift by (>>=), and into (&=), inclusive or into (|=), | |

exclusive or into (^=). The expression | |

Delete the last bullet in this paragraph. | |

Remove the second bullet in the section starting with: The assignments | |

modulus into.. | |

Change section 5.9 "Expressions" | |

Change the bullet: The operator modulus (%) is reserved for future | |

use to: | |

* The arithmetic operator % that operates on signed or unsigned integer | |

typed expressions (including vectors). The two operands must be of the | |

same type, or one can be a signed or unsigned integer scalar and the | |

other a signed or unsigned integer vector. If the second operand is | |

zero, results are undefined. If one operand is scalar and the other is a | |

vector, the scalar is applied component-wise to the vector, resulting in | |

the same type as the vector. If both operands are non-negative, then the | |

remainder is non-negative. Results are undefined if one, or both, | |

operands are negative. | |

Change the last bullet: "Operators and (&), or (|), exclusive or (^), not | |

(~), right-shift (>>), left shift (<<). These operators are reserved for | |

future use." To the following bullets: | |

* The one's complement operator ~. The operand must be of type signed or | |

unsigned integer (including vectors), and the result is the one's | |

complement of its operand. If the operand is a vector, the operator is | |

applied component-wise to the vector. If the operand is unsigned, the | |

result is computed by subtracting the value from the largest unsigned | |

integer value. If the operand is signed, the result is computed by | |

converting the operand to an unsigned integer, applying ~, and | |

converting back to a signed integer. | |

* The shift operators << and >>. For both operators, the operands must be | |

of type signed or unsigned integer (including vectors). If the first | |

operand is a scalar, the second operand has to be a scalar as well. The | |

result is undefined if the right operand is negative, or greater than or | |

equal to the number of bits in the left expression's type. The value of | |

E1 << E2 is E1 (interpreted as a bit pattern) left-shifted by E2 | |

bits. The value of E1 >> E2 is E1 right-shifted by E2 bit positions. If | |

E1 is a signed integer, the right-shift will extend the sign bit. If E1 | |

is an unsigned integer, the right-shift will zero-extend. | |

* The bitwise AND operator &. The operands must be of type signed or | |

unsigned integer (including vectors). The two operands must be of the | |

same type, or one can be a signed or unsigned integer scalar and the | |

other a signed or unsigned integer vector. If one operand is a scalar | |

and the other a vector, the scalar is applied component-wise to the | |

vector, resulting in the same type as the vector. The result is the | |

bitwise AND function of the operands. | |

* The bitwise exclusive OR operator ^. The operands must be of type signed | |

or unsigned integer (including vectors). The two operands must be of the | |

same type, or one can be a signed or unsigned integer scalar and the | |

other a signed or unsigned integer vector. If one operand is a scalar | |

and the other a vector, the scalar is applied component-wise to the | |

vector, resulting in the same type as the vector. The result is the | |

bitwise exclusive OR function of the operands. | |

* The bitwise inclusive OR operator |. The operands must be of type signed | |

or unsigned integer (including vectors). The two operands must be of the | |

same type, or one can be a signed or unsigned integer scalar and the | |

other a signed or unsigned integer vector. If one operand is a scalar | |

and the other a vector, the scalar is applied component-wise to the | |

vector, resulting in the same type as the vector. The result is the | |

bitwise inclusive OR function of the operands. | |

Change Section 7.1 "Vertex Shader Special Variables" | |

Add the following definition to the list of built-in variable definitions: | |

int gl_VertexID // read-only | |

int gl_InstanceID // read-only | |

Add the following paragraph at the end of the section: | |

The variable gl_VertexID is available as a read-only variable from within | |

vertex shaders and holds the integer index <i> implicitly passed to | |

ArrayElement() to specify the vertex. The value of gl_VertexID is defined | |

if and only if: | |

* the vertex comes from a vertex array command that specifies a complete | |

primitive (e.g. DrawArrays, DrawElements), | |

* all enabled vertex arrays have non-zero buffer object bindings, and | |

* the vertex does not come from a display list, even if the display list | |

was compiled using DrawArrays / DrawElements with data sourced from | |

buffer objects. | |

The variable gl_InstanceID is availale as a read-only variable from within | |

vertex shaders and holds holds the integer index of the current primitive | |

in an instanced draw call (DrawArraysInstancedEXT, | |

DrawElementsInstancedEXT). If the current primitive does not come from an | |

instanced draw call, the value of gl_InstanceID is zero. | |

Change Section 7.2 "Fragment Shader Special Variables" | |

Change the 8th and 9th paragraphs on p. 43 as follows: | |

If a shader statically assigns a value to gl_FragColor, it may not assign | |

a value to any element of gl_FragData nor to any user-defined varying | |

output variable (section 4.3.6). If a shader statically writes a value to | |

any element of gl_FragData, it may not assign a value to gl_FragColor nor | |

to any user-defined varying output variable. That is, a shader may assign | |

values to either gl_FragColor, gl_FragData, or any user-defined varying | |

output variable, but not to a combination of the three options. | |

If a shader executes the discard keyword, the fragment is discarded, and | |

the values of gl_FragDepth, gl_FragColor, gl_FragData and any user-defined | |

varying output variables become irrelevant. | |

Add the following paragraph to the top of p. 44: | |

The variable gl_PrimitiveID is available as a read-only variable from | |

within fragment shaders and holds the id of the currently processed | |

primitive. Section 3.11, subsection "Shader Inputs" of the OpenGL 2.0 | |

specification describes what value it holds based on the primitive type. | |

Add the following prototype to the list of built-in variables accessible | |

from a fragment shader: | |

int gl_PrimitiveID; | |

Change Chapter 8, sixth paragraph on page 50: | |

Change the sentence: | |

When the built-in functions are specified below, where the input arguments | |

(and corresponding output)can be float, vec2, vec3, or vec4, genType is | |

used as the argument. | |

To: | |

When the built-in functions are specified below, where the input arguments | |

(and corresponding output) can be float, vec2, vec3, or vec4, genType is | |

used as the argument. Where the input arguments (and corresponding output) | |

can be int, ivec2, ivec3 or ivec4, genIType is used as the argument. Where | |

the input arguments (and corresponding output) can be unsigned int, uvec2, | |

uvec3, or uvec4, genUType is used as the argument. | |

Add to section 8.3 "Common functions" | |

Add integer versions of the abs, sign, min, max and clamp functions, as | |

follows: | |

Syntax: | |

genIType abs(genIType x) | |

genIType sign(genIType x) | |

genIType min(genIType x, genIType y) | |

genIType min(genIType x, int y) | |

genUType min(genUType x, genUType y) | |

genUType min(genUType x, unsigned int y) | |

genIType max(genIType x, genIType y) | |

genIType max(genIType x, int y) | |

genUType max(genUType x, genUType y) | |

genUType max(genUType x, unsigned int y) | |

genIType clamp(genIType x, genIType minval, genIType maxval) | |

genIType clamp(genIType x, int minval, int maxval) | |

genUType clamp(genUType x, genUType minval, genUType maxval) | |

genUType clamp(genUType x, unsigned int minval, | |

unsigned int maxval) | |

Add the following new functions: | |

Syntax: | |

genType truncate(genType x) | |

Description: | |

Returns a value equal to the integer closest to x whose absolute value | |

is not larger than the absolute value of x. | |

Syntax: | |

genType round(genType x) | |

Description: | |

Returns a value equal to the closest integer to x. If the fractional | |

portion of the operand is 0.5, the nearest even integer is returned. For | |

example, round (1.0) returns 1.0. round(-1.5) returns -2.0. round(3.5) | |

and round (4.5) both return 4.0. | |

Add to section 8.6 "Vector Relational Functions" | |

Change the sentence: | |

Below, "bvec" is a placeholder for one of bvec2, bvec3, or bvec4, "ivec" | |

is a placeholder for one of ivec2, ivec3, or ivec4, and "vec" is a | |

placeholder for vec2, vec3, or vec4. | |

To: | |

Below, "bvec" is a placeholder for one of bvec2, bvec3, or bvec4, "ivec" | |

is a placeholder for one of ivec2, ivec3, or ivec4, "uvec" is a | |

placeholder for one of uvec2, uvec3 or uvec4 and "vec" is a placeholder | |

for vec2, vec3, or vec4. | |

Add uvec versions of all but the any, all and not functions to the table | |

in this section, as follows: | |

bvec lessThan(uvec x, uvec y) | |

bvec lessThanEqual(uvec x, uvec y) | |

bvec greaterThan(uvec x, uvec y) | |

bvec greaterThanEqual(uvec x, uvec y) | |

bvec equal(uvec x, uvec y) | |

bvec notEqual(uvec x, uvec y) | |

Add to section 8.7 "Texture Lookup Functions" | |

Remove the first sentence in the last paragraph: | |

"The built-ins suffixed with "Lod" are allowed only in a vertex shader.". | |

Add to this section: | |

Texture data can be stored by the GL as floating point, unsigned | |

normalized integer, unsigned integer or signed integer data. This is | |

determined by the type of the internal format of the texture. Texture | |

lookups on unsigned normalized integer and floating point data return | |

floating point values in the range [0, 1]. See also section 2.15.4.1 of | |

the OpenGL specification. | |

Texture lookup functions are provided that can return their result as | |

floating point, unsigned integer or signed integer, depending on the | |

sampler type passed to the lookup function. Care must be taken to use the | |

right sampler type for texture access. Table 8.xxx lists the supported | |

combinations of sampler types and texture internal formats. | |

texture | |

internal default (float) integer unsigned integer | |

format sampler sampler sampler | |

float vec4 n/a n/a | |

normalized vec4 n/a n/a | |

signed int n/a ivec4 n/a | |

unsigned int n/a n/a uvec4 | |

Table 8.xxx Valid combinations of the type of the internal format of a | |

texture and the type of the sampler used to access the texture. Each cell | |

in the table indicates the type of the return value of a texture | |

lookup. N/a means this combination is not supported. A texture lookup | |

using a n/a combination will return undefined values. The exceptions to | |

this table are the "textureSize" lookup functions, which will return an | |

integer or integer vector, regardless of the sampler type. | |

If a texture with a signed integer internal format is accessed, one of the | |

signed integer sampler types must be used. If a texture with an unsigned | |

integer internal format is accessed, one of the unsigned integer sampler | |

types must be used. Otherwise, one of the default (float) sampler types | |

must be used. If the types of a sampler and the corresponding texture | |

internal format do not match, the result of a texture lookup is undefined. | |

If an integer sampler type is used, the result of a texture lookup is an | |

ivec4. If an unsigned integer sampler type is used, the result of a | |

texture lookup is a uvec4. If a default sampler type is used, the result | |

of a texture lookup is a vec4, where each component is in the range [0, | |

1]. | |

Integer and unsigned integer functions of all the texture lookup functions | |

described in this section are also provided, except for the "shadow" | |

versions, using function overloading. Their prototypes, however, are not | |

listed separately. These overloaded functions use the integer or | |

unsigned-integer versions of the sampler types and will return an ivec4 or | |

an uvec4 respectively, except for the "textureSize" functions, which will | |

always return an integer, or integer vector. Refer also to table 8.xxxx | |

for valid combinations of texture internal formats and sampler types. For | |

example, for the texture1D function, the complete set of prototypes is: | |

vec4 texture1D(sampler1D sampler, float coord | |

[, float bias]) | |

ivec4 texture1D(isampler1D sampler, float coord | |

[, float bias]) | |

uvec4 texture1D(usampler1D sampler, float coord | |

[, float bias]) | |

Add the following new texture lookup functions: | |

Syntax: | |

vec4 texelFetch1D(sampler1D sampler, int coord, int lod) | |

vec4 texelFetch2D(sampler2D sampler, ivec2 coord, int lod) | |

vec4 texelFetch3D(sampler3D sampler, ivec3 coord, int lod) | |

vec4 texelFetch2DRect(sampler2DRect sampler, ivec2 coord) | |

vec4 texelFetch1DArray(sampler1DArray sampler, ivec2 coord, int lod) | |

vec4 texelFetch2DArray(sampler2DArray sampler, ivec3 coord, int lod) | |

Description: | |

Use integer texture coordinate <coord> to lookup a single texel from the | |

level-of-detail <lod> on the texture bound to <sampler> as described in | |

section 2.15.4.1 of the OpenGL specification "Texel Fetches". For the | |

"array" versions, the layer of the texture array to access is either | |

coord.t or coord.p, depending on the use of the 1D or 2D texel fetch | |

lookup, respectively. Note that texelFetch2DRect does not take a | |

level-of-detail input. | |

Syntax: | |

vec4 texelFetchBuffer(samplerBuffer sampler, int coord) | |

Description: | |

Use integer texture coordinate <coord> to lookup into the buffer texture | |

bound to <sampler>. | |

Syntax: | |

int textureSizeBuffer(samplerBuffer sampler) | |

int textureSize1D(sampler1D sampler, int lod) | |

ivec2 textureSize2D(sampler2D sampler, int lod) | |

ivec3 textureSize3D(sampler3D sampler, int lod) | |

ivec2 textureSizeCube(samplerCube sampler, int lod) | |

ivec2 textureSize2DRect(sampler2DRect sampler, int lod) | |

ivec2 textureSize1DArray(sampler1DArray sampler, int lod) | |

ivec3 textureSize2DArray(sampler2DArray sampler, int lod) | |

Description: | |

Returns the dimensions, width, height, depth, and number of layers, of | |

level <lod> for the texture bound to <sampler>, as described in section | |

2.15.4.1 of the OpenGL specification section "Texture Size Query". For the | |

textureSize1DArray function, the first (".x") component of the returned | |

vector is filled with the width of the texture image and the second | |

component with the number of layers in the texture array. For the | |

textureSize2DArray function, the first two components (".x" and ".y") of | |

the returned vector are filled with the width and height of the texture | |

image respectively. The third component (".z") is filled with the number | |

of layers in the texture array. | |

Syntax: | |

vec4 texture1DArray(sampler1DArray sampler, vec2 coord | |

[, float bias]) | |

vec4 texture1DArrayLod(sampler1DArray sampler, vec2 coord, | |

float lod) | |

Description: | |

Use the first element (coord.s) of texture coordinate coord to do a | |

texture lookup in the layer indicated by the second coordinate coord.t of | |

the 1D texture array currently bound to sampler. The layer to access is | |

computed by layer = max (0, min(d - 1, floor (coord.t + 0.5)) where 'd' is | |

the depth of the texture array. | |

Syntax: | |

vec4 texture2DArray(sampler2DArray sampler, vec3 coord | |

[, float bias]) | |

vec4 texture2DArrayLod(sampler2DArray sampler, vec3 coord, | |

float lod) | |

Description: | |

Use the first two elements (coord.s, coord.t) of texture coordinate coord | |

to do a texture lookup in the layer indicated by the third coordinate | |

coord.p of the 2D texture array currently bound to sampler. The layer to | |

access is computed by layer = max (0, min(d - 1, floor (coord.p + 0.5)) | |

where 'd' is the depth of the texture array. | |

Syntax: | |

vec4 shadow1DArray(sampler1DArrayShadow sampler, vec3 coord, | |

[float bias]) | |

vec4 shadow1DArrayLod(sampler1DArrayShadow sampler, | |

vec3 coord, float lod) | |

Description: | |

Use texture coordinate coord.s to do a depth comparison lookup on an array | |

layer of the depth texture bound to sampler, as described in section | |

3.8.14 of version 2.0 of the OpenGL specification. The layer to access is | |

indicated by the second coordinate coord.t and is computed by layer = max | |

(0, min(d - 1, floor (coord.t + 0.5)) where 'd' is the depth of the | |

texture array. The third component of coord (coord.p) is used as the R | |

value. The texture bound to sampler must be a depth texture, or results | |

are undefined. | |

Syntax: | |

vec4 shadow2DArray(sampler2DArrayShadow sampler, vec4 coord) | |

Description: | |

Use texture coordinate (coord.s, coord.t) to do a depth comparison lookup | |

on an array layer of the depth texture bound to sampler, as described in | |

section 3.8.14 of version 2.0 of the OpenGL specification. The layer to | |

access is indicated by the third coordinate coord.p and is computed by | |

layer = max (0, min(d - 1, floor (coord.p + 0.5)) where 'd' is the depth | |

of the texture array. The fourth component of coord (coord.q) is used as | |

the R value. The texture bound to sampler must be a depth texture, or | |

results are undefined. | |

Syntax: | |

vec4 shadowCube(samplerCubeShadow sampler, vec4 coord) | |

Description: | |

Use texture coordinate (coord.s, coord.t, coord.p) to do a depth | |

comparison lookup on the depth cubemap bound to sampler, as described in | |

section 3.8.14. The direction of the vector (coord.s, coord.t, coord.p) is | |

used to select which face to do a two-dimensional texture lookup in, as | |

described in section 3.8.6 of the OpenGL 2.0 specification. The fourth | |

component of coord (coord.q) is used as the R value. The texture bound to | |

sampler must be a depth cubemap, otherwise results are undefined. | |

Syntax: | |

vec4 texture1DGrad(sampler1D sampler, float coord, | |

float ddx, float ddy); | |

vec4 texture1DProjGrad(sampler1D sampler, vec2 coord, | |

float ddx, float ddy); | |

vec4 texture1DProjGrad(sampler1D sampler, vec4 coord, | |

float ddx, float ddy); | |

vec4 texture1DArrayGrad(sampler1DArray sampler, vec2 coord, | |

float ddx, float ddy); | |

vec4 texture2DGrad(sampler2D sampler, vec2 coord, | |

vec2 ddx, vec2 ddy); | |

vec4 texture2DProjGrad(sampler2D sampler, vec3 coord, | |

vec2 ddx, vec2 ddy); | |

vec4 texture2DProjGrad(sampler2D sampler, vec4 coord, | |

vec2 ddx, vec2 ddy); | |

vec4 texture2DArrayGrad(sampler2DArray sampler, vec3 coord, | |

vec2 ddx, vec2 ddy); | |

vec4 texture3DGrad(sampler3D sampler, vec3 coord, | |

vec3 ddx, vec3 ddy); | |

vec4 texture3DProjGrad(sampler3D sampler, vec4 coord, | |

vec3 ddx, vec3 ddy); | |

vec4 textureCubeGrad(samplerCube sampler, vec3 coord, | |

vec3 ddx, vec3 ddy); | |

vec4 shadow1DGrad(sampler1DShadow sampler, vec3 coord, | |

float ddx, float ddy); | |

vec4 shadow1DProjGrad(sampler1DShadow sampler, vec4 coord, | |

float ddx, float ddy); | |

vec4 shadow1DArrayGrad(sampler1DArrayShadow sampler, vec3 coord, | |

float ddx, float ddy); | |

vec4 shadow2DGrad(sampler2DShadow sampler, vec3 coord, | |

vec2 ddx, vec2 ddy); | |

vec4 shadow2DProjGrad(sampler2DShadow sampler, vec4 coord, | |

vec2 ddx, vec2 ddy); | |

vec4 shadow2DArrayGrad(sampler2DArrayShadow sampler, vec4 coord, | |

vec2 ddx, vec2 ddy); | |

vec4 texture2DRectGrad(sampler2DRect sampler, vec2 coord, | |

vec2 ddx, vec2 ddy); | |

vec4 texture2DRectProjGrad(sampler2DRect sampler, vec3 coord, | |

vec2 ddx, vec2 ddy); | |

vec4 texture2DRectProjGrad(sampler2DRect sampler, vec4 coord, | |

vec2 ddx, vec2 ddy); | |

vec4 shadow2DRectGrad(sampler2DRectShadow sampler, vec3 coord, | |

vec2 ddx, vec2 ddy); | |

vec4 shadow2DRectProjGrad(sampler2DRectShadow sampler, vec4 coord, | |

vec2 ddx, vec2 ddy); | |

vec4 shadowCubeGrad(samplerCubeShadow sampler, vec4 coord, | |

vec3 ddx, vec3 ddy); | |

Description: | |

The "Grad" functions map the partial derivatives ddx and ddy to ds/dx, | |

dt/dx, dr/dx, and ds/dy, dt/dy, dr/dy respectively and use texture | |

coordinate "coord" to do a texture lookup as described for their non | |

"Grad" counterparts. The derivatives ddx and ddy are used as the explicit | |

derivate of "coord" with respect to window x and window y respectively and | |

are used to compute lambda_base(x,y) as in equation 3.18 in the OpenGL 2.0 | |

specification. For the "Proj" versions, it is assumed that the partial | |

derivatives ddx and ddy are already projected. I.e. the GL assumes that | |

ddx and ddy represent d(s/q)/dx, d(t/q)/dx, d(r/q)/dx and d(s/q)/dy, | |

d(t/q)/dy, d(r/q)/dy respectively. For the "Cube" versions, the partial | |

derivatives ddx and ddy are assumed to be in the coordinate system used | |

before texture coordinates are projected onto the appropriate cube | |

face. The partial derivatives of the post-projection texture coordinates, | |

which are used for level-of-detail and anisotropic filtering | |

calculations, are derived from coord, ddx and ddy in an | |

implementation-dependent manner. | |

NOTE: Except for the "array" and shadowCubeGrad() functions, these | |

functions are taken from the ARB_shader_texture_lod spec and are | |

functionally equivalent. | |

Syntax: | |

vec4 texture1DOffset(sampler1D sampler, float coord, | |

int offset [,float bias]) | |

vec4 texture1DProjOffset(sampler1D sampler, vec2 coord, | |

int offset [,float bias]) | |

vec4 texture1DProjOffset(sampler1D sampler, vec4 coord, | |

int offset [,float bias]) | |

vec4 texture1DLodOffset(sampler1D sampler, float coord, | |

float lod, int offset) | |

vec4 texture1DProjLodOffset(sampler1D sampler, vec2 coord, | |

float lod, int offset) | |

vec4 texture1DProjLodOffset(sampler1D sampler, vec4 coord, | |

float lod, int offset) | |

vec4 texture2DOffset(sampler2D sampler, vec2 coord, | |

ivec2 offset [,float bias]) | |

vec4 texture2DProjOffset(sampler2D sampler, vec3 coord, | |

ivec2 offset [,float bias]) | |

vec4 texture2DProjOffset(sampler2D sampler, vec4 coord, | |

ivec2 offset [,float bias]) | |

vec4 texture2DLodOffset(sampler2D sampler, vec2 coord, | |

float lod, ivec2 offset) | |

vec4 texture2DProjLodOffset(sampler2D sampler, vec3 coord, | |

float lod, ivec2 offset) | |

vec4 texture2DProjLodOffset(sampler2D sampler, vec4 coord, | |

float lod, ivec2 offset) | |

vec4 texture3DOffset(sampler3D sampler, vec3 coord, | |

ivec3 offset [,float bias]) | |

vec4 texture3DProjOffset(sampler3D sampler, vec4 coord, | |

ivec3 offset [,float bias]) | |

vec4 texture3DLodOffset(sampler3D sampler, vec3 coord, | |

float lod, ivec3 offset) | |

vec4 texture3DProjLodOffset(sampler3D sampler, vec4 coord, | |

float lod, ivec3 offset) | |

vec4 shadow1DOffset(sampler1DShadow sampler, vec3 coord, | |

int offset [,float bias]) | |

vec4 shadow2DOffset(sampler2DShadow sampler, vec3 coord, | |

ivec2 offset [,float bias]) | |

vec4 shadow1DProjOffset(sampler1DShadow sampler, vec4 coord, | |

int offset [,float bias]) | |

vec4 shadow2DProjOffset(sampler2DShadow sampler, vec4 coord, | |

ivec2 offset [,float bias]) | |

vec4 shadow1DLodOffset(sampler1DShadow sampler, vec3 coord, | |

float lod, int offset) | |

vec4 shadow2DLodOffset(sampler2DShadow sampler, vec3 coord, | |

float lod, ivec2 offset) | |

vec4 shadow1DProjLodOffset(sampler1DShadow sampler, vec4 coord, | |

float lod, int offset) | |

vec4 shadow2DProjLodOffset(sampler2DShadow sampler, vec4 coord, | |

float lod, ivec2 offset) | |

vec4 texture2DRectOffset(sampler2DRect sampler, vec2 coord, | |

ivec2 offset) | |

vec4 texture2DRectProjOffset(sampler2DRect sampler, vec3 coord, | |

ivec2 offset) | |

vec4 texture2DRectProjOffset(sampler2DRect sampler, vec4 coord, | |

ivec2 offset) | |

vec4 shadow2DRectOffset(sampler2DRectShadow sampler, vec3 coord, | |

ivec2 offset) | |

vec4 shadow2DRectProjOffset(sampler2DRectShadow sampler, vec4 coord, | |

ivec2 offset) | |

vec4 texelFetch1DOffset(sampler1D sampler, int coord, int lod, | |

int offset) | |

vec4 texelFetch2DOffset(sampler2D sampler, ivec2 coord, int lod, | |

ivec2 offset) | |

vec4 texelFetch3DOffset(sampler3D sampler, ivec3 coord, int lod, | |

ivec3 offset) | |

vec4 texelFetch2DRectOffset(sampler2DRect sampler, ivec2 coord, | |

ivec2 offset) | |

vec4 texelFetch1DArrayOffset(sampler1DArray sampler, ivec2 coord, | |

int lod, int offset) | |

vec4 texelFetch2DArrayOffset(sampler2DArray sampler, ivec3 coord, | |

int lod, ivec2 offset) | |

vec4 texture1DArrayOffset(sampler1DArray sampler, vec2 coord, | |

int offset [, float bias]) | |

vec4 texture1DArrayLodOffset(sampler1DArray sampler, vec2 coord, | |

float lod, int offset) | |

vec4 texture2DArrayOffset(sampler2DArray sampler, vec3 coord, | |

ivec2 offset [, float bias]) | |

vec4 texture2DArrayLodOffset(sampler2DArray sampler, vec3 coord, | |

float lod, ivec2 offset) | |

vec4 shadow1DArrayOffset(sampler1DArrayShadow sampler, vec3 coord, | |

int offset, [float bias]) | |

vec4 shadow1DArrayLodOffset(sampler1DArrayShadow sampler, vec3 coord, | |

float lod, int offset) | |

vec4 shadow2DArrayOffset(sampler2DArrayShadow sampler, | |

vec4 coord, ivec2 offset) | |

vec4 texture1DGradOffset(sampler1D sampler, float coord, | |

float ddx, float ddy, int offset); | |

vec4 texture1DProjGradOffset(sampler1D sampler, vec2 coord, | |

float ddx, float ddy, int offset); | |

vec4 texture1DProjGradOffset(sampler1D sampler, vec4 coord, | |

float ddx, float ddy, int offset); | |

vec4 texture1DArrayGradOffset(sampler1DArray sampler, vec2 coord, | |

float ddx, float ddy, int offset); | |

vec4 texture2DGradOffset(sampler2D sampler, vec2 coord, | |

vec2 ddx, vec2 ddy, ivec2 offset); | |

vec4 texture2DProjGradOffset(sampler2D sampler, vec3 coord, | |

vec2 ddx, vec2 ddy, ivec2 offset); | |

vec4 texture2DProjGradOffset(sampler2D sampler, vec4 coord, | |

vec2 ddx, vec2 ddy, ivec2 offset); | |

vec4 texture2DArrayGradOffset(sampler2DArray sampler, vec3 coord, | |

vec2 ddx, vec2 ddy, ivec2 offset); | |

vec4 texture3DGradOffset(sampler3D sampler, vec3 coord, | |

vec3 ddx, vec3 ddy, ivec3 offset); | |

vec4 texture3DProjGradOffset(sampler3D sampler, vec4 coord, | |

vec3 ddx, vec3 ddy, ivec3 offset); | |

vec4 shadow1DGradOffset(sampler1DShadow sampler, vec3 coord, | |

float ddx, float ddy, int offset); | |

vec4 shadow1DProjGradOffset(sampler1DShadow sampler, | |

vec4 coord, float ddx, float ddy, | |

int offset); | |

vec4 shadow1DArrayGradOffset(sampler1DArrayShadow sampler, | |

vec3 coord, float ddx, float ddy, | |

int offset); | |

vec4 shadow2DGradOffset(sampler2DShadow sampler, vec3 coord, | |

vec2 ddx, vec2 ddy, ivec2 offset); | |

vec4 shadow2DProjGradOffset(sampler2DShadow sampler, vec4 coord, | |

vec2 ddx, vec2 ddy, ivec2 offset); | |

vec4 shadow2DArrayGradOffset(sampler2DArrayShadow sampler, | |

vec4 coord, vec2 ddx, vec2 ddy, | |

ivec2 offset); | |

vec4 texture2DRectGradOffset(sampler2DRect sampler, vec2 coord, | |

vec2 ddx, vec2 ddy, ivec2 offset); | |

vec4 texture2DRectProjGradOffset(sampler2DRect sampler, vec3 coord, | |

vec2 ddx, vec2 ddy, ivec2 offset); | |

vec4 texture2DRectProjGradOffset(sampler2DRect sampler, vec4 coord, | |

vec2 ddx, vec2 ddy, ivec2 offset); | |

vec4 shadow2DRectGradOffset(sampler2DRectShadow sampler, | |

vec3 coord, vec2 ddx, vec2 ddy, | |

ivec2 offset); | |

vec4 shadow2DRectProjGradOffset(sampler2DRectShadow sampler, | |

vec4 coord, vec2 ddx, vec2 ddy, | |

ivec2 offset); | |

Description: | |

The "offset" version of each function provides an extra parameter <offset> | |

which is added to the (u,v,w) texel coordinates before looking up each | |

texel. The offset value must be a constant expression. A limited range | |

of offset values are supported; the minimum and maximum offset values are | |

implementation-dependent and given by MIN_PROGRAM_TEXEL_OFFSET_EXT and | |

MAX_PROGRAM_TEXEL_OFFSET_EXT, respectively. Note that <offset> does not | |

apply to the layer coordinate for texture arrays. This is explained in | |

detail in section 3.8.7 of the OpenGL Specification. Note that texel | |

offsets are also not supported for cubemaps or buffer textures. | |

Add to section 9 "Grammar" | |

type_qualifer: | |

CONST | |

ATTRIBUTE // Vertex only | |

varying-modifier_opt VARYING | |

UNIFORM | |

varying-modifier: | |

FLAT | |

CENTROID | |

NOPERSPECTIVE | |

type_specifier: | |

VOID | |

FLOAT | |

INT | |

UNSIGNED_INT | |

BOOL | |

Issues | |

1. Should we support shorts in GLSL? | |

DISCUSSION: | |

RESOLUTION: UNRESOLVED | |

2. Do bitwise shifts, AND, exclusive OR and inclusive OR support all | |

combinations of scalars and vectors for each operand? | |

DISCUSSION: It seems sense to support scalar OP scalar, vector OP scalar | |

and vector OP vector. But what about scalar OP vector? Should the scalar | |

be promoted to a vector first? | |

RESOLUTION: RESOLVED. Yes, this should work essentially as the '+' | |

operator. The scalar is applied to each component of the vector. | |

3. Which built-in functions should also operate on integers? | |

DISCUSSION: There are several that don't make sense to define to operate | |

on integers at all, but the following can be debated: pow, sqrt, dot (and | |

the functions that use dot), cross. | |

RESOLUTION: RESOLVED. Integer versions of the abs, sign, min, max and | |

clamp functions are defined. Note that the modulus operator % has been | |

defined for integer operands. | |

4. Do we need to support integer matrices? | |

DISCUSSION: | |

RESOLUTION: RESOLVED No, not at the moment. | |

5. Which texture array lookup functions do we need to support? | |

DISCUSSION: We don't want to support lookup functions that need more than | |

four components passed as parameters. Components can be used for texture | |

coordinates, layer selection, 'R' depth compare and the 'q' coordinate | |

for projection. However, texture projection might be relatively easy to | |

support through code-generation, thus we might be able to support | |

functions that need five components, as long as one of them is 'q' for | |

projective texturing. Specifically, should we support: | |

vec4 texture2DArrayProjLod(sampler2DArray sampler, vec4 coord, | |

float lod) | |

vec4 shadow1DArray(sampler1DArrayShadow sampler, vec3 coord, | |

[float bias]) | |

vec4 shadow1DArrayProj(sampler1DArrayShadow sampler, vec4 coord, | |

[float bias]) | |

vec4 shadow1DArrayLod(sampler1DArrayShadow sampler, vec3 coord, | |

float lod) | |

vec4 shadow1DArrayProjLod(sampler1DArrayShadow sampler, | |

vec4 coord, float lod) | |

vec4 shadow2DArray(sampler2DArrayShadow sampler, vec4 coord) | |

vec4 shadow2DArrayProj(sampler2DArrayShadow sampler, vec4 coord, | |

float refValue) | |

RESOLUTION: RESOLVED, We'll support all but the "Proj" versions. The | |

assembly spec (NV_gpu_program4) doesn't support the equivalent | |

functionality, either. | |

6. How do we handle conversions between integer and unsigned | |

integers? | |

DISCUSSION: Do we allow automatic type conversions between signed and | |

unsigned integers? | |

RESOLUTION: RESOLVED. We will not add this until GLSL version 1.20 has | |

been defined, and the implicit conversion rules have been established | |

there. If we do this, we would likely only support implicit conversion | |

from int to unsigned int, just like C does. | |

7. Should varying modifiers (flat, noperspective) apply to built-in | |

varying variables also? | |

DISCUSSION: There is API to control flat vs smooth shading for colors | |

through glShadeModel(). There is also API to hint if colors should be | |

interpolated perspective correct, or not, through glHint(). These API | |

commands apply to the built-in color varying variables (gl_FrontColor | |

etc). If the varying modifiers in a shader also apply to the color | |

built-ins, which has precedence? | |

RESOLUTION: RESOLVED. It is simplest and cleanest to only allow the | |

varying modifiers to apply to user-defined varying variables. The | |

behavior of the built-in color varying variables can still be controlled | |

through the API. | |

8. How should perspective-incorrect interpolation (linear in screen space) | |

and clipping interact? | |

RESOLVED: Primitives with attributes specified to be perspective- | |

incorrect should be clipped so that the vertices introduced by clipping | |

should have attribute values consistent with the interpolation mode. We | |

do not want to have large color shifts introduced by clipping a | |

perspective-incorrect attribute. For example, a primitive that | |

approaches, but doesn't cross, a frustum clip plane should look pretty | |

much identical to a similar primitive that just barely crosses the clip | |

plane. | |

Clipping perspective-incorrect interpolants that cross the W==0 plane is | |

very challenging. The attribute clipping equation provided in the spec | |

effectively projects all the original vertices to screen space while | |

ignoring the X and Y frustum clip plane. As W approaches zero, the | |

projected X/Y window coordinates become extremely large. When clipping | |

an edge with one vertex inside the frustum and the other out near | |

infinity (after projection, due to W approaching zero), the interpolated | |

attribute for the entire visible portion of the edge should almost | |

exactly match the attribute value of the visible vertex. | |

If an outlying vertex approaches and then goes past W==0, it can be said | |

to go "to infinity and beyond" in screen space. The correct answer for | |

screen-linear interpolation is no longer obvious, at least to the author | |

of this specification. Rather than trying to figure out what the | |

"right" answer is or if one even exists, the results of clipping such | |

edges is specified as undefined. | |

9. Do we need to support a non-MRT fragment shader writing to (unsigned) | |

integer outputs? | |

DISCUSSION: Fragment shaders with only one fragment output are | |

considered non-MRT shaders. This means that the output of the shader | |

gets smeared across all color buffers attached to the | |

framebuffer. Fragment shaders with multiple fragment outputs are MRT | |

shaders. Each output is directed to a color buffer using the DrawBuffers | |

API (for gl_FragData) and a combination of the BindFragDataLocationEXT | |

and DrawBuffers API (for varying out variables). Before this extension, | |

a non-MRT shader would write to gl_Color only. A shader writing to | |

gl_FragData[] is a MRT shader. With the addition of varying out | |

variables in this extension, any shader writing to a variable out | |

variable is a MRT shader. It is not possible to construct a non-MRT | |

shader writing to varying out variables. Varying out variables can be | |

declared to be of type integer or unsigned integer. In order to support | |

a non-MRT shader that can write to (unsigned) integer outputs, we could | |

define two new built-in variables: | |

ivec4 gl_FragColorInt; | |

uvec4 gl_FragColorUInt; | |

Or we could add a special rule stating that if the program object writes | |

to exactly one varying out variable, it is considered to be non-MRT. | |

RESOLUTION: NO. We don't care enough to support this. | |

10. Is section 2.14.8, "Color and Associated Data Clipping" in the core | |

specification still correct? | |

DISCUSSION: This section is in need of some updating, now that varying | |

variables can be interpolated without perspective correction. Some (not | |

so precise) language has been added in the spec body, suggesting that | |

the interpolation needs to be performed in such a way as to produce | |

results that vary linearly in screen space. However, we could define the | |

exact interpolation method required to achieve this. A suggested updated | |

paragraph follows, but we'll leave updating section 2.14.8 to a future | |

edit of the core specification, not this extension. | |

Replace Section 2.14.8, and rename it to "Vertex Attribute Clipping" | |

After lighting, clamping or masking and possible flatshading, vertex | |

attributes, including colors, texture and fog coordinates, shader | |

varying variables, and point sizes computed on a per vertex basis, are | |

clipped. Those attributes associated with a vertex that lies within the | |

clip volume are unaffected by clipping. If a primitive is clipped, | |

however, the attributes assigned to vertices produced by clipping are | |

produced by interpolating attributes along the clipped edge. | |

Let the attributes assigned to the two vertices P_1 and P_2 of an | |

unclipped edge be a_1 and a_2. The value of t (section 2.12) for a | |

clipped point P is used to obtain the attribute associated with P as | |

a = t * a_1 + (1-t) * a_2 | |

unless the attribute is specified to be interpolated without perspective | |

correction in a shader (using the noperspective keyword). In that case, | |

the attribute associated with P is | |

a = t' * a_1 + (1-t') * a_2 | |

where | |

t' = (t * w_1) / (t * w_1 + (1-t) * w_2) | |

and w_1 and w_2 are the w clip coordinates of P_1 and P_2, | |

respectively. If w_1 or w_2 is either zero or negative, the value of the | |

associated attribute is undefined. | |

For a color index color, multiplying a color by a scalar means | |

multiplying the index by the scalar. For a vector attribute, it means | |

multiplying each vector component by the scalar. Polygon clipping may | |

create a clipped vertex along an edge of the clip volume's | |

boundary. This situation is handled by noting that polygon clipping | |

proceeds by clipping against one plane of the clip volume's boundary at | |

a time. Attribute clipping is done in the same way, so that clipped | |

points always occur at the intersection of polygon edges (possibly | |

already clipped) with the clip volume's boundary. | |

11. When and where in the texture filtering process are texel offsets | |

applied? | |

DISCUSSION: Texel offsets are applied to the (u,v,w) coordinates of the | |

base level of the texture if the texture filter mode does not indicate | |

mipmapping. Otherwise, texel offsets are applied to the (u,v,w) | |

coordinates of the mipmap level 'd', as found by equation 3.27 or to | |

mipmap levels 'd1' and 'd2' as found by equation 3.28 in the OpenGL 2.0 | |

specification. In other words, texel offsets are applied to the | |

(u,v,w) coordinate of whatever mipmap level is accessed. | |

12. Why is writing to the built-in output variable "gl_Position" in a vertex | |

shader now optional? | |

DISCUSSION: Before this specification, writing to gl_Position in a | |

vertex shader was mandatory. The GL pipeline required a vertex position | |

to be written in order to produce well-defined output. This is still the | |

case if the GL pipeline indeed needs a vertex position. However, with | |

fourth-generation programmable hardware there are now cases where the GL | |

pipeline no longer requires a vertex position in order to produce | |

well-defined results. If a geometry shader is present, the vertex shader | |

does not need to write to gl_Position anymore. Instead, the geometry | |

shader can compute a vertex position and write to its gl_Position | |

output. In case of transform-feedback, where the output of a vertex or | |

geometry shader is streamed to one or more buffer objects, perfectly | |

valid results can be obtained without either the vertex shader nor | |

geometry shader writing to gl_Position. The transform-feedback | |

specification adds a new enable to discard primitives right before | |

rasterization, making it potentially unnecessary to write to | |

gl_Position. | |

13. How does this extension interact with ARB_shader_texture_lod? | |

DISCUSSION: This extension adds "Grad" functions which are functionally | |

equivalent to those defined by ARB_shader_texture_lod, but do not have | |

an ARB suffix. | |

RESOLUTION: There is no interaction. If both extensions are supported, | |

both sets of functions are available and can be controlled independently | |

via the #extension mechanism. | |

Revision History | |

Rev. Date Author Changes | |

---- -------- -------- ----------------------------------------- | |

16 12/14/09 mgodse Added GLX protocol. | |

15 04/09/09 pbrown Fixed a typo in the texture size query spec | |

language - returns a layer count, not "index". | |

14 07/29/08 pbrown Discovered additional issues with texture wrap | |

handling, replaced with logic that applies wrap | |

modes per sample. | |

13 04/04/08 pbrown Added issue 13, concerning the (non-)interaction | |

with ARB_shader_texture_lod. | |

12 02/04/08 pbrown Fix errors in texture wrap mode handling. | |

Added a missing clamp to avoid sampling border | |

in REPEAT mode. Fixed incorrectly specified | |

weights for LINEAR filtering. | |

11 05/08/07 pbrown Add VertexAttribIPointerEXT to the list of | |

commands that can't go in display lists. | |

10 01/23/07 pbrown Fix prototypes for a variety of functions | |

that were specified with an incorrect sampler | |

type. | |

9 12/15/06 pbrown Documented that the '#extension' token | |

for this extension should begin with "GL_", | |

as apparently called for per convention. | |

8 -- Pre-release revisions. | |