Name
EXT_texture_integer
Name Strings
GL_EXT_texture_integer
Contact
Michael Gold, NVIDIA Corporation (gold 'at' nvidia.com)
Pat Brown, NVIDIA Corporation (pbrown 'at' nvidia.com)
Status
Shipping for GeForce 8 Series (November 2006)
Version
Last Modified Date: 05/20/2010
NVIDIA Revision: 6
Number
343
Dependencies
OpenGL 2.0 is required.
NV_gpu_program4 or EXT_gpu_shader4 is required.
ARB_texture_float affects the definition of this extension.
ARB_color_buffer_float affects the definition of this extension.
EXT_framebuffer_object affects the definition of this extension.
This extension is written against the OpenGL 2.0 specification.
Overview
Fixed-point textures in unextended OpenGL have integer components,
but those values are taken to represent floating-point values in
the range [0,1]. These integer components are considered
"normalized" integers. When such a texture is accessed by a
shader or by fixed-function fragment processing, floating-point
values are returned.
This extension provides a set of new "unnormalized" integer texture
formats. Formats with both signed and unsigned integers are provided. In
these formats, the components are treated as true integers. When such
textures are accessed by a shader, actual integer values are returned.
Pixel operations that read from or write to a texture or color
buffer with unnormalized integer components follow a path similar
to that used for color index pixel operations, except that more
than one component may be provided at once. Integer values flow
through the pixel processing pipe, and no pixel transfer
operations are performed. Integer format enumerants used for such
operations indicate unnormalized integer data.
Textures or render buffers with unnormalized integer formats may also be
attached to framebuffer objects to receive fragment color values written
by a fragment shader. Per-fragment operations that require floating-point
color components, including multisample alpha operations, alpha test,
blending, and dithering, have no effect when the corresponding colors are
written to an integer color buffer. The NV_gpu_program4 and
EXT_gpu_shader4 extensions add the capability to fragment programs and
fragment shaders to write signed and unsigned integer output values.
This extension does not enforce type consistency for texture accesses or
between fragment shaders and the corresponding framebuffer attachments.
The results of a texture lookup from an integer texture are undefined:
* for fixed-function fragment processing, or
* for shader texture accesses expecting floating-point return values.
The color components used for per-fragment operations and written into a
color buffer are undefined:
* for fixed-function fragment processing with an integer color buffer,
* for fragment shaders that write floating-point color components to an
integer color buffer, or
* for fragment shaders that write integer color components to a color
buffer with floating point or normalized integer components.
New Procedures and Functions
void ClearColorIiEXT ( int r, int g, int b, int a );
void ClearColorIuiEXT ( uint r, uint g, uint b, uint a );
void TexParameterIivEXT( enum target, enum pname, int *params );
void TexParameterIuivEXT( enum target, enum pname, uint *params );
void GetTexParameterIivEXT ( enum target, enum pname, int *params);
void GetTexParameterIuivEXT ( enum target, enum pname, uint *params);
New Tokens
Accepted by the parameters of GetBooleanv, GetIntegerv,
GetFloatv, and GetDoublev:
RGBA_INTEGER_MODE_EXT 0x8D9E
Accepted by the parameter of TexImage1D,
TexImage2D, and TexImage3D:
RGBA32UI_EXT 0x8D70
RGB32UI_EXT 0x8D71
ALPHA32UI_EXT 0x8D72
INTENSITY32UI_EXT 0x8D73
LUMINANCE32UI_EXT 0x8D74
LUMINANCE_ALPHA32UI_EXT 0x8D75
RGBA16UI_EXT 0x8D76
RGB16UI_EXT 0x8D77
ALPHA16UI_EXT 0x8D78
INTENSITY16UI_EXT 0x8D79
LUMINANCE16UI_EXT 0x8D7A
LUMINANCE_ALPHA16UI_EXT 0x8D7B
RGBA8UI_EXT 0x8D7C
RGB8UI_EXT 0x8D7D
ALPHA8UI_EXT 0x8D7E
INTENSITY8UI_EXT 0x8D7F
LUMINANCE8UI_EXT 0x8D80
LUMINANCE_ALPHA8UI_EXT 0x8D81
RGBA32I_EXT 0x8D82
RGB32I_EXT 0x8D83
ALPHA32I_EXT 0x8D84
INTENSITY32I_EXT 0x8D85
LUMINANCE32I_EXT 0x8D86
LUMINANCE_ALPHA32I_EXT 0x8D87
RGBA16I_EXT 0x8D88
RGB16I_EXT 0x8D89
ALPHA16I_EXT 0x8D8A
INTENSITY16I_EXT 0x8D8B
LUMINANCE16I_EXT 0x8D8C
LUMINANCE_ALPHA16I_EXT 0x8D8D
RGBA8I_EXT 0x8D8E
RGB8I_EXT 0x8D8F
ALPHA8I_EXT 0x8D90
INTENSITY8I_EXT 0x8D91
LUMINANCE8I_EXT 0x8D92
LUMINANCE_ALPHA8I_EXT 0x8D93
Accepted by the parameter of TexImage1D, TexImage2D,
TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D,
DrawPixels and ReadPixels:
RED_INTEGER_EXT 0x8D94
GREEN_INTEGER_EXT 0x8D95
BLUE_INTEGER_EXT 0x8D96
ALPHA_INTEGER_EXT 0x8D97
RGB_INTEGER_EXT 0x8D98
RGBA_INTEGER_EXT 0x8D99
BGR_INTEGER_EXT 0x8D9A
BGRA_INTEGER_EXT 0x8D9B
LUMINANCE_INTEGER_EXT 0x8D9C
LUMINANCE_ALPHA_INTEGER_EXT 0x8D9D
Additions to Chapter 3 of the OpenGL 2.0 Specification (Rasterization)
Modify Section 3.6.4 (Rasterization of Pixel Rectangles), p. 126:
(modify the last paragraph, p. 126)
Pixels are drawn using
void DrawPixels( sizei width, sizei height, enum format,
enum type, void *data );
is a symbolic constant indicating what the values in
memory represent. and are the width and height,
respectively, of the pixel rectangle to be drawn. is a
pointer to the data to be drawn. These data are represented with
one of seven GL data types, specified by . The
correspondence between the twenty type token values and the GL
data types they indicate is given in table 3.5. If the GL is in
color index mode and is not one of COLOR_INDEX,
STENCIL_INDEX, or DEPTH_COMPONENT, then the error
INVALID_OPERATION occurs. If the GL is in RGBA mode and the color
buffer is an integer format and no fragment shader is active, the
error INVALID_OPERATION occurs. If is BITMAP and
is not COLOR_INDEX or STENCIL_INDEX then the error INVALID_ENUM
occurs. If is one of the integer component formats as
defined in table 3.6, and is FLOAT, then the error
INVALID_ENUM occurs. Some additional constraints on the
combinations of format and type values that are accepted is
discussed below.
(add the following to table 3.6, p. 129)
Format Name Element Meaning and Order Target Buffer
------ ---- ------- ------- --- ----- ------ ------
RED_INTEGER_EXT iR Color
GREEN_INTEGER_EXT iG Color
BLUE_INTEGER_EXT iB Color
ALPHA_INTEGER_EXT iA Color
RGB_INTEGER_EXT iR, iG, iB Color
RGBA_INTEGER_EXT iR, iG, iB, iA Color
BGR_INTEGER_EXT iB, iG, iR Color
BGRA_INTEGER_EXT iB, iG, iR, iA Color
LUMINANCE_INTEGER_EXT iLuminance Color
LUMINANCE_ALPHA_INTEGER_EXT iLuminance, iA Color
Table 3.6: DrawPixels and ReadPixels formats. The second column
gives a description of and the number and order of elements in a
group. Unless specified as an index, formats yield components.
Components are floating-point unless prefixed with the letter 'i'
which indicates they are integer.
(modify first paragraph, p. 129)
Data are taken from host memory as a sequence of signed or
unsigned bytes (GL data types byte and ubyte), signed or unsigned
short integers (GL data types short and ushort), signed or
unsigned integers (GL data types int and uint), or floating point
values (GL data type float). These elements are grouped into sets
of one, two, three, or four values, depending on the format, to
form a group. Table 3.6 summarizes the format of groups obtained
from memory; it also indicates those formats that yield indices
and those that yield floating-point or integer components.
(modify the last paragraph, p. 135)
Conversion to floating-point
This step applies only to groups of floating-point components. It
is not performed on indices or integer components.
(modify the third paragraph, p. 136)
Final Expansion to RGBA
This step is performed only for non-depth component groups. Each
group is converted to a group of 4 elements as follows: if a group
does not contain an A element, then A is added and set to 1 for
integer components or 1.0 for floating-point components. If any of
R, G, or B is missing from the group, each missing element is
added and assigned a value of 0 for integer components or 0.0 for
floating-point components.
(modify the last paragraph, p. 136)
Final Conversion
For a color index, final conversion consists of masking the bits
of the index to the left of the binary point by 2^n - 1, where n is
the number of bits in an index buffer. For floating-point RGBA
components, each element is clamped to [0, 1]. The resulting
values are converted to fixed-point according to the rules given
in section 2.14.9 (Final Color Processing). For integer RGBA
components, no conversion is applied. For a depth component, an
element is first clamped to [0, 1] and then converted to
fixed-point as if it were a window z value (see section 2.11.1,
Controlling the Viewport). Stencil indices are masked by 2^n - 1,
where n is the number of bits in the stencil buffer.
Modify Section 3.6.5 (Pixel Transfer Operations), p. 137
(modify last paragraph, p. 137)
The GL defines five kinds of pixel groups:
1. Floating-point RGBA component: Each group comprises four color
components in floating point format: red, green, blue, and
alpha.
2. Integer RGBA component: Each group comprises four color
components in integer format: red, green, blue, and alpha.
3. Depth component: Each group comprises a single depth component.
4. Color index: Each group comprises a single color index.
5. Stencil index: Each group comprises a single stencil index.
(modify second paragraph, p. 138)
Each operation described in this section is applied sequentially
to each pixel group in an image. Many operations are applied only
to pixel groups of certain kinds; if an operation is not
applicable to a given group, it is skipped. None of the
operations defined in this section affect integer RGBA component
pixel groups.
Modify Section 3.8 (Texturing), p. 149
(insert between the first and second paragraphs, p. 150)
The internal data type of a texture may be fixed-point,
floating-point, signed integer or unsigned integer, depending on
the internalformat of the texture. The correspondence between
internalformat and the internal data type is given in table 3.16.
Fixed-point and floating-point textures return a floating-point
value and integer textures return signed or unsigned integer
values. When a fragment shader is active, the shader is
responsible for interpreting the result of a texture lookup as the
correct data type, otherwise the result is undefined. Fixed
functionality assumes floating-point data, hence the result of
using fixed functionality with integer textures is undefined.
Modify Section 3.8.1 (Texture Image Specification), p. 150
(modify second paragraph, p. 151) The selected groups are
processed exactly as for DrawPixels, stopping just before final
conversion. If the of the texture is integer,
the components are clamped to the representable range of the
internal format: for signed formats, this is [-2^(n-1), 2^(n-1)-1]
where n is the number of bits per component; for unsigned formats,
the range is [0, 2^n-1]. For R, G, B, and A, if the
of the texture is fixed-point, the components are
clamped to [0, 1]. Otherwise, the components are not modified.
(insert between paragraphs five and six, p. 151)
Textures with integer internal formats (table 3.16) require
integer data. The error INVALID_OPERATION is generated if the
internal format is integer and is not one of the integer
formats listed in table 3.6, or if the internal format is not
integer and is an integer format, or if is an
integer format and is FLOAT.
(add the following to table 3.16, p. 154)
Sized Base R G B A L I
Internal Format Internal Format bits bits bits bits bits bits
----------------------- --------------- ---- ---- ---- ---- ---- ----
ALPHA8I_EXT ALPHA i8
ALPHA8UI_EXT ALPHA ui8
ALPHA16I_EXT ALPHA i16
ALPHA16UI_EXT ALPHA ui16
ALPHA32I_EXT ALPHA i32
ALPHA32UI_EXT ALPHA ui32
LUMINANCE8I_EXT LUMINANCE i8
LUMINANCE8UI_EXT LUMINANCE ui8
LUMINANCE16I_EXT LUMINANCE i16
LUMINANCE16UI_EXT LUMINANCE ui16
LUMINANCE32I_EXT LUMINANCE i32
LUMINANCE32UI_EXT LUMINANCE ui32
LUMINANCE_ALPHA8I_EXT LUMINANCE_ALPHA i8 i8
LUMINANCE_ALPHA8UI_EXT LUMINANCE_ALPHA ui8 ui8
LUMINANCE_ALPHA16I_EXT LUMINANCE_ALPHA i16 i16
LUMINANCE_ALPHA16UI_EXT LUMINANCE_ALPHA ui16 ui16
LUMINANCE_ALPHA32I_EXT LUMINANCE_ALPHA i32 i32
LUMINANCE_ALPHA32UI_EXT LUMINANCE_ALPHA ui32 ui32
INTENSITY8I_EXT INTENSITY i8
INTENSITY8UI_EXT INTENSITY ui8
INTENSITY16I_EXT INTENSITY i16
INTENSITY16UI_EXT INTENSITY ui16
INTENSITY32I_EXT INTENSITY i32
INTENSITY32UI_EXT INTENSITY ui32
RGB8I_EXT RGB i8 i8 i8
RGB8UI_EXT RGB ui8 ui8 ui8
RGB16I_EXT RGB i16 i16 i16
RGB16UI_EXT RGB ui16 ui16 ui16
RGB32I_EXT RGB i32 i32 i32
RGB32UI_EXT RGB ui32 ui32 ui32
RGBA8I_EXT RGBA i8 i8 i8 i8
RGBA8UI_EXT RGBA ui8 ui8 ui8 ui8
RGBA16I_EXT RGBA i16 i16 i16 i16
RGBA16UI_EXT RGBA ui16 ui16 ui16 ui16
RGBA32I_EXT RGBA i32 i32 i32 i32
RGBA32UI_EXT RGBA ui32 ui32 ui32 ui32
Table 3.16: Correspondence of sized internal formats to base
internal formats, internal data type and desired component
resolutions for each sized internal format. The component
resolution prefix indicates the internal data type: is
floating point, is signed integer, is unsigned integer,
and no prefix is fixed-point.
Modify Section 3.8.2 (Alternate Texture Image Specification
Commands), p. 159:
(modify the second paragraph, p. 159)
The error INVALID_OPERATION is generated if depth component data
is required and no depth buffer is present, or if integer RGBA
data is required and the format of the current color buffer is not
integer, or if floating-point or fixed-point RGBA data is required
and the format of the current color buffer is integer.
Modify Section 3.8.4 (Texture Parameters), p. 166:
Various parameters control how the texture array is treated when
specified or changed, and when applied to a fragment. Each
parameter is set by calling
void TexParameter{if}( enum target, enum pname, T param );
void TexParameter{if}v( enum target, enum pname, T params );
void TexParameterIivEXT( enum target, enum pname, int *params );
void TexParameterIuivEXT( enum target, enum pname, uint *params );
is the target, either TEXTURE_1D, TEXTURE_2D, TEXTURE_3D,
or TEXTURE_CUBE_MAP. is a symbolic constant indicating the
parameter to be set; the possible constants and corresponding
parameters are summarized in table 3.19. In the first form of the
command, is a value to which to set a single-valued
parameter; in the second and third forms of the command,
is an array of parameters whose type depends on the parameter
being set.
If the value for TEXTURE_PRIORITY is specified as an integer, the
conversion for signed integers from table 2.9 is applied to
convert the value to floating-point. The floating point value of
TEXTURE_PRIORITY is clamped to lie in [0, 1].
If the values for TEXTURE_BORDER_COLOR are specified with
TexParameterIivEXT or TexParameterIuivEXT, the values are
unmodified and stored with an internal data type of integer. If
specified with TexParameteriv, the conversion for signed integers
from table 2.9 is applied to convert these values to
floating-point. Otherwise the values are unmodified and stored as
floating-point.
(modify table 3.19, p. 167)
Name Type Legal Values
---- ---- ------------
TEXTURE_BORDER_COLOR 4 floats or any 4 values
4 ints or
4 uints
Table 3.19: Texture parameters and their values.
Modify Section 3.8.8 (Texture Minification), p. 170
(modify last paragraph, p. 174)
... 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.
The internal data type of the border values must be consistent
with the type returned by the texture as described in section 3.8,
or the result is undefined. The border values for texture
components stored as fixed-point values are clamped to [0, 1]
before they are used. If the texture contains depth components,
the first component of TEXTURE_BORDER_COLOR is interpreted as a
depth value
Modify Section 3.8.10 (Texture Completeness), p. 177:
(add to the requirements for one-, two-, or three-dimensional
textures)
If the internalformat is integer, TEXTURE_MAG_FILTER must be
NEAREST and TEXTURE_MIN_FILTER must be NEAREST or
NEAREST_MIPMAP_NEAREST.
Modify Section 3.11.2 (Shader Execution), p. 194
(modify Shader Outputs, first paragraph, p. 196)
... These are gl_FragColor, gl_FragData[n], and gl_FragDepth. If
fragment clamping is enabled and the color buffer has a
fixed-point or floating-point format, the final fragment color
values or the final fragment data values written by a fragment
shader are clamped to the range [0, 1]. If fragment clamping is
disabled or the color buffer has an integer format, the final
fragment color values or the final fragment data values are not
modified. The final fragment depth...
(insert between the first paragraph and second paragraphs of
"Shader Outputs", p. 196)
Colors values written by the fragment shader may be floating-
point, signed integer or unsigned integer. If the color buffer
has a fixed-point format, the color values are assumed to be
floating-point and are converted to fixed-point as described in
section 2.14.9; otherwise no type conversion is applied. If the
values written by the fragment shader do not match the format(s)
of the corresponding color buffer(s), the result is undefined.
Additions to Chapter 4 of the OpenGL 2.0 Specification (Per-Fragment
Operations and the Frame Buffer)
Modify Chapter 4 Introduction, (p. 198)
(modify third paragraph, p. 198)
Color buffers consist of unsigned integer color indices, R, G, B
and optionally A floating-point components represented as
fixed-point unsigned integer or floating-point values, or R, G, B
and optionally A integer components represented as signed or
unsigned integer values. The number of bitplanes...
Modify Section 4.1.3 (Multisample Fragment Operations), p. 200
(modify the second paragraph in this section)
... If SAMPLE_ALPHA_TO_COVERAGE is enabled and the color buffer
has a fixed-point or floating-point format, a temporary coverage
value is generated ...
Modify Section 4.1.4 (Alpha Test), p. 201
(modify the first paragraph in this section)
This step applies only in RGBA mode and only if the color buffer
has a fixed-point or floating-point format. In color index mode or
if the color buffer has an integer format, proceed to the next
operation. The alpha test discards ...
Modify Section 4.1.8 (Blending), p. 205
(modify the second paragraph, p. 206)
... Blending is dependent on the incoming fragment's alpha value
and that of the corresponding currently stored pixel. Blending
applies only in RGBA mode and only if the color buffer has a
fixed-point or floating-point format; in color index mode or if
the color buffer has an integer format, it is bypassed. ...
Modify Section 4.2.3 (Clearing the Buffers), p. 215
void ClearColor(float r, float g, float b, float a);
sets the clear value for fixed-point and floating-point color
buffers in RGBA mode. The specified components are stored as
floating-point values.
void ClearColorIiEXT(int r, int g, int b, int a);
void ClearColorIuiEXT(uint r, uint g, uint b, uint a);
set the clear value for signed integer and unsigned integer color
buffers, respectively, in RGBA mode. The specified components are
stored as integer values.
(add to the end of first partial paragraph, p. 217) ... then a
Clear directed at that buffer has no effect. When fixed-point
RGBA color buffers are cleared, the clear color values are assumed
to be floating-point and are clamped to [0,1] before being
converted to fixed-point according to the rules of section 2.14.9.
The result of clearing fixed-point or floating-point color buffers
is undefined if the clear color was specified as integer values.
The result of when clearing integer color buffers is undefined if
the clear color was specified as floating-point values.
Modify Section 4.3.2 (Reading Pixels), p. 219
(append to the last paragraph, p. 221)
The error INVALID_OPERATION occurs if is an integer
format and the color buffer is not an integer format, or if the
color buffer is an integer format and is not. The error
INVALID_ENUM occurs if is an integer format and is
FLOAT.
(modify the first paragraph, p. 222)
... For a fixed-point color buffer, each element is taken to be a
fixed-point value in [0, 1] with m bits, where m is the number of
bits in the corresponding color component of the selected buffer
(see section 2.14.9). For an integer or floating-point color
buffer, the elements are unmodified.
(modify the section labeled "Conversion to L", p. 222)
This step applies only to RGBA component groups. If the format is
either LUMINANCE or LUMINANCE_ALPHA, a value L is computed as
L = R + G + B
otherwise if the format is either LUMINANCE_INTEGER_EXT or
LUMINANCE_ALPHA_INTEGER_EXT, L is computed as
L = R
where R, G, and B are the values of the R, G, and B
components. The single computed L component replaces the R, G, and
B components in the group.
(modify the section labeled "Final Conversion", p. 222)
For a floating-point RGBA color, each component is first clamped
to [0, 1]. Then the appropriate conversion formula from table 4.7
is applied to the component. For an integer RGBA color, each
component is clamped to the representable range of .
Additions to Chapter 6 of the OpenGL 2.0 Specification (State and
State Requests)
Modify Section 6.1.3 (Enumerated Queries), p. 246
(insert in the list of query functions, p. 246)
void GetTexParameterIivEXT( enum target, enum value, int *data );
void GetTexParameterIuivEXT( enum target, enum value, uint *data );
(modify the second paragraph, p. 247)
... For GetTexParameter, value must be either TEXTURE_RESIDENT, or
one of the symbolic values in table 3.19. Querying
TEXTURE_BORDER_COLOR with GetTexParameterIivEXT or
GetTexParameterIuivEXT returns the border color values as signed
integers or unsigned integers, respectively; otherwise the values
are returned as described in section 6.1.2. If the border color
is queried with a type that does not match the original type with
which it was specified, the result is undefined. The
argument ...
(add to end of third paragraph, p. 247) Queries with a of
TEXTURE_RED_TYPE_ARB, TEXTURE_GREEN_TYPE_ARB, TEXTURE_BLUE_TYPE_ARB,
TEXTURE_ALPHA_TYPE_ARB, TEXTURE_LUMINANCE_TYPE_ARB,
TEXTURE_INTENSITY_TYPE_ARB, or TEXTURE_DEPTH_TYPE_ARB, return the data
type used to store the component. Values of NONE,
UNSIGNED_NORMALIZED_ARB, FLOAT, INT, or UNSIGNED_INT, indicate missing,
unsigned normalized integer, floating-point, signed unnormalized integer,
and unsigned unnormalized integer components, respectively.
GLX Protocol
The following rendering commands are sent to the server as part of
a glXRender request:
ClearColorIiEXT
2 20 rendering command length
2 4292 rendering command opcode
4 INT32 r
4 INT32 g
4 INT32 b
4 INT32 a
ClearColorIuiEXT
2 20 rendering command length
2 4293 rendering command opcode
4 CARD32 r
4 CARD32 g
4 CARD32 b
4 CARD32 a
TexParameterIivEXT
2 12+(4*n) rendering command length
2 346 rendering command opcode
4 ENUM target
4 ENUM pname
0x2802 n=1 GL_TEXTURE_WRAP_S
0x2803 n=1 GL_TEXTURE_WRAP_T
0x8072 n=1 GL_TEXTURE_WRAP_R
0x2801 n=1 GL_TEXTURE_MIN_FILTER
0x2800 n=1 GL_TEXTURE_MAG_FILTER
0x8066 n=1 GL_TEXTURE_PRIORITY
0x813A n=1 GL_TEXTURE_MIN_LOD
0x813B n=1 GL_TEXTURE_MAX_LOD
0x813C n=1 GL_TEXTURE_BASE_LEVEL
0x813D n=1 GL_TEXTURE_MAX_LEVEL
0x8501 n=1 GL_TEXTURE_LOD_BIAS
0x884B n=1 GL_DEPTH_TEXTURE_MODE
0x884C n=1 GL_TEXTURE_COMPARE_MODE
0x884D n=1 GL_TEXTURE_COMPARE_FUNC
0x8191 n=1 GL_GENERATE_MIPMAP
0x1004 n=4 GL_TEXTURE_BORDER_COLOR
4*n LISTofINT32 params
TexParameterIuivEXT
2 12+(4*n) rendering command length
2 347 rendering command opcode
4 ENUM target
4 ENUM pname
0x2802 n=1 GL_TEXTURE_WRAP_S
0x2803 n=1 GL_TEXTURE_WRAP_T
0x8072 n=1 GL_TEXTURE_WRAP_R
0x2801 n=1 GL_TEXTURE_MIN_FILTER
0x2800 n=1 GL_TEXTURE_MAG_FILTER
0x8066 n=1 GL_TEXTURE_PRIORITY
0x813A n=1 GL_TEXTURE_MIN_LOD
0x813B n=1 GL_TEXTURE_MAX_LOD
0x813C n=1 GL_TEXTURE_BASE_LEVEL
0x813D n=1 GL_TEXTURE_MAX_LEVEL
0x8501 n=1 GL_TEXTURE_LOD_BIAS
0x884B n=1 GL_DEPTH_TEXTURE_MODE
0x884C n=1 GL_TEXTURE_COMPARE_MODE
0x884D n=1 GL_TEXTURE_COMPARE_FUNC
0x8191 n=1 GL_GENERATE_MIPMAP
0x1004 n=4 GL_TEXTURE_BORDER_COLOR
4*n LISTofCARD32 params
The following new non-rendering commands are added:
GetTexParameterIivEXT
1 CARD8 opcode(X assigned)
1 203 GLX opcode
2 4 request length
4 GLX_CONTEXT_TAG context tag
4 ENUM target
4 ENUM pname
=>
1 1 reply
1 unused
2 CARD16 sequence number
4 m reply length, m=(n==1?0:n)
4 unused
4 CARD32 n
if (n=1) this follows:
4 INT32 params
12 unused
otherwise this follows:
16 unused
n*4 LISTofINT32 params
GetTexParameterIuivEXT
1 CARD8 opcode(X assigned)
1 204 GLX opcode
2 4 request length
4 GLX_CONTEXT_TAG context tag
4 ENUM target
4 ENUM pname
=>
1 1 reply
1 unused
2 CARD16 sequence number
4 m reply length, m=(n==1?0:n)
4 unused
4 CARD32 n
if (n=1) this follows:
4 CARD32 params
12 unused
otherwise this follows:
16 unused
n*4 LISTofCARD32 params
Dependencies on ARB_texture_float
The following changes should be made if ARB_texture_float is not
supported:
The references to floating-point data types in section 3.8, p. 150
should be deleted.
The language in section 3.8.1 should indicate that final
conversion always clamps when the internalformat is not integer.
The description of table 3.16 should not mention the
floating-point formats.
Section 3.8.4 should indicate that border color values should be
clamped to [0,1] before being stored, if not specified with one of
the TexParameterI* functions.
Section 3.8.8 should not mention clamping border color values to
[0,1] for fixed-point textures, since this occurs in 3.8.4 at
TexParameter specification.
Dependencies on ARB_color_buffer_float
The following changes should be made if ARB_color_buffer_float is
not supported:
Section 3.11.2, subsection "Shader Outputs: p. 196 should not
mention fragment clamping or color buffers with floating-point
formats.
Chapter 4, p. 198 should not mention components represented as
floating-point values.
Section 4.1.3, p. 200, section 4.1.4 p. 205, section 4.1.8 p. 206,
section 4.2.3 p. 215 and section 4.3.2 p. 222 should not mention
color buffers with a floating-point format.
Section 4.2.3 p. 217 should not mention clamping the clear color
values to [0,1].
Errors
INVALID_OPERATION is generated by Begin, DrawPixels, Bitmap,
CopyPixels, or a command that performs an explicit Begin if the
color buffer has an integer RGBA format and no fragment shader is
active.
INVALID_ENUM is generated by DrawPixels, TexImage* and
SubTexImage* if is one of the integer component formats
described in table 3.6 and is FLOAT.
INVALID_OPERATION is generated by TexImage* and SubTexImage* if
the texture internalformat is an integer format as described in
table 3.16 and is not one of the integer component
formats described in table 3.6, or if the internalformat is not an
integer format and is an integer format.
INVALID_OPERATION is generated by CopyTexImage* and
CopyTexSubImage* if the texture internalformat is an integer
format and the read color buffer is not an integer format, or if
the internalformat is not an integer format and the read color
buffer is an integer format.
INVALID_ENUM is generated by ReadPixels if is an integer
format and is FLOAT.
INVALID_OPERATON is generated by ReadPixels if is an
integer format and the color buffer is not an integer format, or
if is not an integer format and the color buffer is an
integer format.
New State
(modify table 6.33, p. 294)
Minimum
Get Value Type Get Command Value Description Sec. Attribute
------------------------ ---- ----------- ------- ---------------- ---- ----------
RGBA_INTEGER_MODE_EXT B GetBooleanv - True if RGBA 2.7 -
components are
integers
Issues
How should the integer pixel path be triggered: by the destination
type, new source types, or new source formats?
RESOLVED: New source formats, based on the precedence of
COLOR_INDEX and STENCIL_INDEX formats which invoke distinct
pixel path behavior with identical data types and independent
of the destination.
Should pixel transfer operations be defined for the integer pixel
path?
RESOLVED: No. Fragment shaders can achieve similar results
with more flexibility. There is no need to aggrandize this
legacy mechanism.
What happens if a shader reads a float texel from an integer
texture or vice-versa?
RESOLVED: The result is undefined. The shader must have
knowledge of the texture internal data type.
How do integer textures behave in fixed function fragment
processing?
RESOLVED: The fixed function texture pipeline assumes textures
return floating-point values, hence the return value from an
integer texture will not be in a meaningful format.
How does TEXTURE_BORDER_COLOR work with integer textures?
RESOLVED: The internal storage of border values effectively
becomes a union, and the returned values are interpreted as
the same type as the texture. New versions of TexParameter
allow specification of signed and unsigned integer border
values.
How does logic op behave with RGBA mode rendering into integer
color buffer?
RESOLVED: The color logic op operates when enabled when
rendering into integer color buffers.
Logic op operations make sense for integer color buffers so the
COLOR_LOGIC_OP enable is respected when rendering into integer
color buffers.
Blending does not apply to RGBA mode rendering when rendering
into integer color buffers (as section 4.1.8 is updated to say).
The color logic op (described in section 4.1.10) is not a blending
operation (though it does take priority over the blending enable).
Revision History
Rev. Date Author Changes
---- -------- -------- -----------------------------------------
6 05/20/10 srahman Add GLX protocol.
5 07/15/07 pbrown Fix typo in GetTexParameterIuivEXT function
name in "New Procedures and Functions".
4 -- Pre-release revisions.