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.