| Name | |
| EXT_texture | |
| Name Strings | |
| GL_EXT_texture | |
| Version | |
| $Date: 1996/04/05 19:17:03 $ $Revision: 1.21 $ | |
| Number | |
| 4 | |
| Dependencies | |
| None | |
| Overview | |
| The original intention of this extension was simply to support various | |
| numeric resolutions of color components in texture images. While it | |
| accomplishes this, it also accomplishes a larger task, that of | |
| formalizing the notion of an internal format for images, corresponding | |
| to the external format that already existed for image data in host | |
| memory. This notion of an internal image format will be used | |
| extensively in later extensions, especially those concerned with pixel | |
| manipulation. | |
| The idea of an internal format is simple: rather than treating a | |
| retained image as having 1, 2, 3, or 4 components, treat it as though | |
| it has a specific format, such as LUMINANCE_ALPHA, or just ALPHA. Then | |
| define the semantics of the use of internal images with these formats in | |
| a consistent way. Because texture mapping is already defined in GL, the | |
| semantics for internal-format images were chosen to match those of the 1, | |
| 2, 3, and 4 component internal images that already existed. The new | |
| semantics are a superset of the old ones, however, so this extension | |
| adds capabilities to GL, as well as allowing internal resolutions to be | |
| specified. | |
| This extension also defines a robust method for applications to | |
| determine what combinations of texture dimensions and resolutions are | |
| supported by an implementation. It also introduces a new texture | |
| environment: REPLACE_EXT. | |
| New Procedures and Functions | |
| None | |
| New Tokens | |
| Accepted by the <components> parameter of TexImage1D and TexImage2D: | |
| ALPHA4_EXT 0x803B | |
| ALPHA8_EXT 0x803C | |
| ALPHA12_EXT 0x803D | |
| ALPHA16_EXT 0x803E | |
| LUMINANCE4_EXT 0x803F | |
| LUMINANCE8_EXT 0x8040 | |
| LUMINANCE12_EXT 0x8041 | |
| LUMINANCE16_EXT 0x8042 | |
| LUMINANCE4_ALPHA4_EXT 0x8043 | |
| LUMINANCE6_ALPHA2_EXT 0x8044 | |
| LUMINANCE8_ALPHA8_EXT 0x8045 | |
| LUMINANCE12_ALPHA4_EXT 0x8046 | |
| LUMINANCE12_ALPHA12_EXT 0x8047 | |
| LUMINANCE16_ALPHA16_EXT 0x8048 | |
| INTENSITY_EXT 0x8049 | |
| INTENSITY4_EXT 0x804A | |
| INTENSITY8_EXT 0x804B | |
| INTENSITY12_EXT 0x804C | |
| INTENSITY16_EXT 0x804D | |
| RGB2_EXT 0x804E | |
| RGB4_EXT 0x804F | |
| RGB5_EXT 0x8050 | |
| RGB8_EXT 0x8051 | |
| RGB10_EXT 0x8052 | |
| RGB12_EXT 0x8053 | |
| RGB16_EXT 0x8054 | |
| RGBA2_EXT 0x8055 | |
| RGBA4_EXT 0x8056 | |
| RGB5_A1_EXT 0x8057 | |
| RGBA8_EXT 0x8058 | |
| RGB10_A2_EXT 0x8059 | |
| RGBA12_EXT 0x805A | |
| RGBA16_EXT 0x805B | |
| Accepted by the <pname> parameters of GetTexLevelParameteriv and | |
| GetTexLevelParameterfv: | |
| TEXTURE_RED_SIZE_EXT 0x805C | |
| TEXTURE_GREEN_SIZE_EXT 0x805D | |
| TEXTURE_BLUE_SIZE_EXT 0x805E | |
| TEXTURE_ALPHA_SIZE_EXT 0x805F | |
| TEXTURE_LUMINANCE_SIZE_EXT 0x8060 | |
| TEXTURE_INTENSITY_SIZE_EXT 0x8061 | |
| Accepted by the <params> parameter of TexEnvf, TexEnvi, TexEnvfv, and | |
| TexEnvfi when the <pname> parameter value is | |
| GL_TEXTURE_ENV_MODE | |
| REPLACE_EXT 0x8062 | |
| Accepted by the <target> parameters of TexImage1D, | |
| GetTexLevelParameteriv, and GetTexLevelParameterfv: | |
| PROXY_TEXTURE_1D_EXT 0x8063 | |
| Accepted by the <target> parameters of TexImage2D, | |
| GetTexLevelParameteriv, and GetTexLevelParameterfv: | |
| PROXY_TEXTURE_2D_EXT 0x8064 | |
| Additions to Chapter 2 of the GL Specification (OpenGL Operation) | |
| A new error token value, TEXTURE_TOO_LARGE_EXT, is defined and added to | |
| table 2.3: | |
| Offending | |
| command | |
| Error Description ignored? | |
| ----- ----------- --------- | |
| INVALID_ENUM enum argument out of range Yes | |
| INVALID_VALUE Numeric argument out of range Yes | |
| INVALID_OPERATION Operation illegal in current state Yes | |
| STACK_OVERFLOW Command would cause a stack overflow Yes | |
| STACK_UNDERFLOW Command would cause a stack underflow Yes | |
| TEXTURE_TOO_LARGE_EXT The specified texture is too large Yes | |
| OUT_OF_MEMORY Not enough memory left to execute command Unknown | |
| Table 2.3: Summary of GL errors | |
| and defined as follows: | |
| TEXTURE_TOO_LARGE_EXT 0x8065 | |
| Additions to Chapter 3 of the GL Specification (Rasterization) | |
| Many additional values can be specified for the <components> parameter | |
| of TexImage1D and TexImage2D. The GL Specification indicates (in | |
| section 3.8) that only values 1, 2, 3, and 4 can be specified. This | |
| extension defines semantics for the currently existing tokens ALPHA, | |
| RGB, RGBA, LUMINANCE, and LUMINANCE_ALPHA, and also defines semantics | |
| for many new tokens. Each of the new tokens (except INTENSITY_EXT) | |
| indicates a desired storage resolution, as well as a base format. These | |
| tokens are: | |
| Red Green Blue Alpha Luminance Intensity | |
| Token name Base format Bits Bits Bits Bits Bits Bits | |
| ---------- ----------- ---- ---- ---- ---- ---- ---- | |
| ALPHA4_EXT ALPHA 4 | |
| ALPHA8_EXT ALPHA 8 | |
| ALPHA12_EXT ALPHA 12 | |
| ALPHA16_EXT ALPHA 16 | |
| LUMINANCE4_EXT LUMINANCE 4 | |
| LUMINANCE8_EXT LUMINANCE 8 | |
| LUMINANCE12_EXT LUMINANCE 12 | |
| LUMINANCE16_EXT LUMINANCE 16 | |
| LUMINANCE4_ALPHA4_EXT LUMINANCE_ALPHA 4 4 | |
| LUMINANCE6_ALPHA2_EXT LUMINANCE_ALPHA 2 6 | |
| LUMINANCE8_ALPHA8_EXT LUMINANCE_ALPHA 8 8 | |
| LUMINANCE12_ALPHA4_EXT LUMINANCE_ALPHA 4 12 | |
| LUMINANCE12_ALPHA12_EXT LUMINANCE_ALPHA 12 12 | |
| LUMINANCE16_ALPHA16_EXT LUMINANCE_ALPHA 16 16 | |
| INTENSITY_EXT INTENSITY_EXT ? | |
| INTENSITY4_EXT INTENSITY_EXT 4 | |
| INTENSITY8_EXT INTENSITY_EXT 8 | |
| INTENSITY12_EXT INTENSITY_EXT 12 | |
| INTENSITY16_EXT INTENSITY_EXT 16 | |
| RGB2_EXT RGB 2 2 2 | |
| RGB4_EXT RGB 4 4 4 | |
| RGB5_EXT RGB 5 5 5 | |
| RGB8_EXT RGB 8 8 8 | |
| RGB10_EXT RGB 10 10 10 | |
| RGB12_EXT RGB 12 12 12 | |
| RGB16_EXT RGB 16 16 16 | |
| RGBA2_EXT RGBA 2 2 2 2 | |
| RGBA4_EXT RGBA 4 4 4 4 | |
| RGB5_A1_EXT RGBA 5 5 5 1 | |
| RGBA8_EXT RGBA 8 8 8 8 | |
| RGB10_A2_EXT RGBA 10 10 10 2 | |
| RGBA12_EXT RGBA 12 12 12 12 | |
| RGBA16_EXT RGBA 16 16 16 16 | |
| All implementations of this extension support the base formats ALPHA, | |
| LUMINANCE, LUMINANCE_ALPHA, RGB, and RGBA. All implementations also | |
| accept all the tokens in the table above, but may not allocate storage | |
| exactly equal to that indicated in the table. Instead, storage is | |
| allocated to best match the resolutions in the table. The determination | |
| of best match is left to the implementation. Storage allocation for the | |
| base formats (as well as for formats "1", "2", "3", and "4") is an | |
| implementation dependent compromise of component resolution, | |
| performance, image size, and memory availability. | |
| It is acceptable for an implementation to vary its allocation of | |
| internal component resolution based on any TexImage1D or TexImage2D | |
| parameter, but the allocation must not be a function of any other | |
| factor, and cannot be changed once it is established. In particular, | |
| allocations must be invariant -- the same allocation must be made each | |
| time a texture image is specified with the same parameter values. | |
| Provision is made for an application to determine what component | |
| resolutions are available without having to fully specify the texture | |
| (see below). | |
| A set of mipmap arrays is incomplete (see the Mipmapping section of the | |
| GL Specification) if different internal formats are specified for arrays | |
| in the set, even if the resulting formats of the arrays are identical. | |
| An implementation can, however, report different component precisions | |
| for the arrays in the set, even if all were specified with the same | |
| internal format. (The set of arrays will be complete in this case.) | |
| The assignments of texture component values from color components | |
| "extracted" from the incoming image (see the discussion in section 3.8 | |
| of the GL Specification) are defined by this new version of Table 3.6: | |
| Base Internal Format red green blue alpha luminance intensity | |
| -------------------- --- ----- ---- ----- --------- --------- | |
| ALPHA A | |
| LUMINANCE R | |
| LUMINANCE_ALPHA A R | |
| INTENSITY_EXT R | |
| RGB R G B | |
| RGBA R G B A | |
| Table 3.6: Correspondence of texture components to extracted | |
| R, G, B, and A values. | |
| Texture components are assigned to Rt, Gt, Bt, and At. | |
| Table 3.8 (Texture functions) refers to these components. | |
| The assignments are defined by the following table: | |
| Texture Environment | |
| ------------------- | |
| Base Texture Format Rt Gt Bt At | |
| ------------------- -- -- -- -- | |
| LUMINANCE Lt Lt Lt x | |
| ALPHA x x x At | |
| INTENSITY_EXT It It It It | |
| LUMINANCE_ALPHA Lt Lt Lt At | |
| RGB Rt Gt Bt x | |
| RGBA Rt Gt Bt At | |
| Table ??: Mapping of Texture Components to Rt, Gt, Bt, At. | |
| Where there appears an "x", the assignment is "don't care", since | |
| that component is not used by the texture environment. | |
| This extension redefines the application of a texture to the color | |
| components of a fragment. In particular, a new texture environment, REPLACE, | |
| and two new texture formats, ALPHA and INTENSITY_EXT, are included. | |
| Table 3.8 (Texture functions) of the GL | |
| Specification is replaced by the following table: | |
| Texture Environment | |
| ------------------- | |
| Base Texture Format REPLACE MODULATE BLEND DECAL | |
| ------------------- ------- -------- ----- ----- | |
| LUMINANCE Rv = Rt Rv = Rf * Rt Rv = Rf * (1-Rt) + Rc * Rt undefined | |
| Gv = Gt Gv = Gf * Gt Gv = Gf * (1-Gt) + Gc * Gt | |
| Bv = Bt Bv = Bf * Bt Bv = Bf * (1-Bt) + Bc * Bt | |
| Av = Af Av = Af Av = Af | |
| ALPHA Rv = Rf Rv = Rf Rv = Rf undefined | |
| Gv = Gf Gv = Gf Gv = Gf | |
| Bv = Bf Bv = Bf Bv = Bf | |
| Av = At Av = Af * At Av = Af * At | |
| INTENSITY_EXT Rv = Rt Rv = Rf * Rt Rv = Rf * (1-Rt) + Rc * Rt undefined | |
| Gv = Gt Gv = Gf * Gt Gv = Gf * (1-Gt) + Gc * Gt | |
| Bv = Bt Bv = Bf * Bt Bv = Bf * (1-Bt) + Bc * Bt | |
| Av = At Av = Af * At Av = Af * (1-At) + Ac * At | |
| LUMINANCE_ALPHA Rv = Rt Rv = Rf * Rt Rv = Rf * (1-Rt) + Rc * Rt undefined | |
| Gv = Gt Gv = Gf * Gt Gv = Gf * (1-Gt) + Gc * Gt | |
| Bv = Bt Bv = Bf * Bt Bv = Bf * (1-Bt) + Bc * Bt | |
| Av = At Av = Af * At Av = Af * At | |
| RGB Rv = Rt Rv = Rf * Rt Rv = Rf * (1-Rt) + Rc * Rt Rv = Rt | |
| Gv = Gt Gv = Gf * Gt Gv = Gf * (1-Gt) + Gc * Gt Gv = Gt | |
| Bv = Bt Bv = Bf * Bt Bv = Bf * (1-Bt) + Bc * Bt Bv = Bt | |
| Av = Af Av = Af Av = Af Av = Af | |
| RGBA Rv = Rt Rv = Rf * Rt Rv = Rf * (1-Rt) + Rc * Rt Rv = Rf * (1-At) + Rt * At | |
| Gv = Gt Gv = Gf * Gt Gv = Gf * (1-Gt) + Gc * Gt Gv = Gf * (1-At) + Gt * At | |
| Bv = Bt Bv = Bf * Bt Bv = Bf * (1-Bt) + Bc * Bt Bv = Bf * (1-At) + Bt * At | |
| Av = At Av = Af * At Av = Af * At Av = Af | |
| Table 3.8: Texture functions. | |
| Finally, for backward compatibility, the semantics of <components> | |
| values 1, 2, 3, and 4 are identical to those of LUMINANCE, | |
| LUMINANCE_ALPHA, RGB, and RGBA respectively. The one exception is that | |
| the token values for 1, 2, 3, and 4 are not the same as the token values | |
| LUMINANCE, LUMINANCE_ALPHA, RGB, and RGBA. | |
| Query support | |
| ------------- | |
| Alternate sets of partial per-level texture state are defined for | |
| the proxy textures PROXY_TEXTURE_1D_EXT and PROXY_TEXTURE_2D_EXT. | |
| Specifically, TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_BORDER, | |
| TEXTURE_COMPONENTS, TEXTURE_RED_SIZE_EXT, TEXTURE_GREEN_SIZE_EXT, | |
| TEXTURE_BLUE_SIZE_EXT, TEXTURE_ALPHA_SIZE_EXT, | |
| TEXTURE_LUMINANCE_SIZE_EXT, and TEXTURE_INTENSITY_SIZE_EXT are | |
| maintained for proxy textures. When TexImage2D is called with | |
| <target> set to PROXY_TEXTURE_2D_EXT, these proxy state values are | |
| always recomputed and updated, even if the texture is too large to | |
| actually be used. If the texture is too large, all of these state | |
| variables are set to zero. If the texture could be accommodated | |
| by TexImage2D called with <target> TEXTURE_2D, these values are | |
| set as though TEXTURE_2D were being defined. All of these state | |
| value can be queried with GetTexLevelParameteriv or | |
| GetTexLevelParameterfv with <target> set to PROXY_TEXTURE_2D_EXT. | |
| Calling TexImage2D with <target> PROXY_TEXTURE_2D_EXT has no | |
| effect on the actual 2-dimensional texture or its state. | |
| To determine the maximum array size for a mipmap texture, specify and | |
| query the proxy texture at the highest level that accurately reflects the | |
| aspect ratio of the desired level zero array. | |
| There is no image associated with PROXY_TEXTURE_2D_EXT. Therefore | |
| PROXY_TEXTURE_2D_EXT cannot be used as a texture, and its image must | |
| never be queried using GetTexImage. (The error INVALID_ENUM results if | |
| this is attempted.) Likewise, there is no nonlevel-related state | |
| associated with a proxy texture, so calling GetTexParameteriv or | |
| GetTexParameterfv with <target> PROXY_TEXTURE_2D_EXT results in the | |
| error INVALID_ENUM. | |
| The proxy 1-dimensional texture behaves identically to the proxy | |
| 2-dimensional texture, except that its state does not include | |
| TEXTURE_HEIGHT. | |
| Additions to Chapter 4 of the GL Specification (Per-Fragment Operations | |
| and the Framebuffer) | |
| None | |
| Additions to Chapter 5 of the GL Specification (Special Functions) | |
| TexImage1D with a proxy target and TexImage2D with a proxy target | |
| are not included in display lists, but are instead executed | |
| immediately. | |
| Additions to Chapter 6 of the GL Specification (State and State Requests) | |
| GetTexLevelParameteriv, when called with <pname> TEXTURE_COMPONENTS, | |
| returns the value of the <components> state variable as specified by the | |
| application. This remains true even if the actual internal format | |
| matches that of another token. | |
| GetTexLevelParameteriv, when called with <pname> TEXTURE_RED_SIZE_EXT, | |
| TEXTURE_GREEN_SIZE_EXT, TEXTURE_BLUE_SIZE_EXT, TEXTURE_ALPHA_SIZE_EXT, | |
| TEXTURE_LUMINANCE_SIZE_EXT, or TEXTURE_INTENSITY_SIZE_EXT returns the | |
| actual number of bits of internal storage for red, green, blue, alpha, | |
| luminance, or intensity. This value may not match the value of the | |
| specified internal format. | |
| GetTexImage continues to operate as though ReadPixels were called with | |
| the texture image as the framebuffer. The assignments of texture | |
| component values to the initial R, G, B, and A values of the read-back | |
| texel (prior to PixelTransfer and PixelStorage operations) are: | |
| Base Internal Format R G B A | |
| -------------------- - - - - | |
| ALPHA 0.0 0.0 0.0 alpha | |
| LUMINANCE luminance 0.0 0.0 0.0 | |
| LUMINANCE_ALPHA luminance 0.0 0.0 alpha | |
| INTENSITY_EXT intensity 0.0 0.0 0.0 | |
| RGB red green blue 0.0 | |
| RGBA red green blue alpha | |
| Additions to the GLX Specification | |
| None | |
| GLX Protocol | |
| None | |
| Dependencies on EXT_abgr | |
| Token ABGR_EXT cannot be used to specify internal texture image formats. | |
| Errors | |
| The GL Specification requires that INVALID_VALUE be generated if any | |
| texture dimension is specified less than zero, greater than | |
| MAX_TEXTURE_SIZE, or with a value that cannot be represented as 2**k + | |
| 2*border, for some integer k. This extension eliminates the requirement | |
| that all dimensions be specified less than or equal to MAX_TEXTURE_SIZE, | |
| and replaces it with a new error token and error condition. | |
| INVALID_VALUE is generated if any texture dimension is specified less | |
| than zero, or with a value that cannot be represented as 2**k + 2*border. | |
| TEXTURE_TOO_LARGE_EXT is generated if the texture is too large to be | |
| accommodated, for whatever reason. An implementation must specify | |
| MAX_TEXTURE_SIZE such that TEXTURE_TOO_LARGE_EXT is never generated if | |
| all the dimensions of the texture are less than or equal to | |
| MAX_TEXTURE_SIZE. Also, TEXTURE_TOO_LARGE_EXT is never generated when | |
| the target is a proxy texture, such as PROXY_TEXTURE_1D_EXT or | |
| PROXY_TEXTURE_2D_EXT. | |
| This change to the error semantics does not require that the major | |
| revision level be incremented, because the GL Specification allows for | |
| changes to error semantics (Section 2.5). | |
| New State | |
| Initial | |
| Get Value Get Command Type Value Attrib | |
| --------- ----------- ---- ------- ------ | |
| TEXTURE_RED_SIZE_EXT GetTexLevelParameteriv 2 x 2 x levels x Z+ 0 - | |
| TEXTURE_GREEN_SIZE_EXT GetTexLevelParameteriv 2 x 2 x levels x Z+ 0 - | |
| TEXTURE_BLUE_SIZE_EXT GetTexLevelParameteriv 2 x 2 x levels x Z+ 0 - | |
| TEXTURE_ALPHA_SIZE_EXT GetTexLevelParameteriv 2 x 2 x levels x Z+ 0 - | |
| TEXTURE_LUMINANCE_SIZE_EXT GetTexLevelParameteriv 2 x 2 x levels x Z+ 0 - | |
| TEXTURE_INTENSITY_SIZE_EXT GetTexLevelParameteriv 2 x 2 x levels x Z+ 0 - | |
| TEXTURE GetTexImage 2 x 1 x levels x I null - | |
| TEXTURE_WIDTH GetTexLevelParameteriv 2 x 2 x levels x Z+ 0 - | |
| TEXTURE_HEIGHT GetTexLevelParameteriv 1 x 2 x levels x Z+ 0 - | |
| TEXTURE_BORDER GetTexLevelParameteriv 2 x 2 x levels x Z+ 0 - | |
| TEXTURE_COMPONENTS GetTexLevelParameteriv 2 x 2 x levels x Z42 1 - | |
| New Implementation Dependent State | |
| None |