| Name |
| |
| NV_texture_shader |
| |
| Name Strings |
| |
| GL_NV_texture_shader |
| |
| Contact |
| |
| Mark J. Kilgard, NVIDIA Corporation (mjk 'at' nvidia.com) |
| |
| Notice |
| |
| Copyright NVIDIA Corporation, 1999, 2000, 2001, 2002, 2004. |
| |
| IP Status |
| |
| NVIDIA Proprietary. |
| |
| Status |
| |
| Shipping (since GeForce3) |
| |
| Version |
| |
| NVIDIA Date: March 13, 2007 |
| Version: 30 |
| |
| Number |
| |
| 230 |
| |
| Dependencies |
| |
| Written based on the wording of the OpenGL 1.2.1 specification. |
| |
| Requires support for the ARB_multitexture extension. |
| |
| Requires support for the ARB_texture_cube_map extension. |
| |
| NV_register_combiners affects the definition of this extension. |
| |
| EXT_texture_lod_bias trivially affects the definition of this |
| extension. |
| |
| ARB_texture_env_combine and/or EXT_texture_env_combine affect the |
| definition of this extension. |
| |
| NV_texture_env_combine4 affects the definition of this extension. |
| |
| ARB_texture_env_add and/or EXT_texture_env_add affect the definition |
| of this extension. |
| |
| NV_texture_rectangle affects the definition of this extension. |
| |
| NV_texture_shader2 depends on the definition of this extension. |
| |
| ARB_color_buffer_float affects the definiton of this extension. |
| |
| Overview |
| |
| Standard OpenGL and the ARB_multitexture extension define a |
| straightforward direct mechanism for mapping sets of texture |
| coordinates to filtered colors. This extension provides a more |
| functional mechanism. |
| |
| OpenGL's standard texturing mechanism defines a set of texture |
| targets. Each texture target defines how the texture image |
| is specified and accessed via a set of texture coordinates. |
| OpenGL 1.0 defines the 1D and 2D texture targets. OpenGL 1.2 |
| (and/or the EXT_texture3D extension) defines the 3D texture target. |
| The ARB_texture_cube_map extension defines the cube map texture |
| target. Each texture unit's texture coordinate set is mapped to a |
| color using the unit's highest priority enabled texture target. |
| |
| This extension introduces texture shader stages. A sequence of |
| texture shader stages provides a more flexible mechanism for mapping |
| sets of texture coordinates to texture unit RGBA results than standard |
| OpenGL. |
| |
| When the texture shader enable is on, the extension replaces the |
| conventional OpenGL mechanism for mapping sets of texture coordinates |
| to filtered colors with this extension's sequence of texture shader |
| stages. |
| |
| Each texture shader stage runs one of 21 canned texture shader |
| programs. These programs support conventional OpenGL texture |
| mapping but also support dependent texture accesses, dot product |
| texture programs, and special modes. (3D texture mapping |
| texture shader operations are NOT provided by this extension; |
| 3D texture mapping texture shader operations are added by the |
| NV_texture_shader2 extension that is layered on this extension. |
| See the NV_texture_shader2 specification.) |
| |
| To facilitate the new texture shader programs, this extension |
| introduces several new texture formats and variations on existing |
| formats. Existing color texture formats are extended by introducing |
| new signed variants. Two new types of texture formats (beyond colors) |
| are also introduced. Texture offset groups encode two signed offsets, |
| and optionally a magnitude or a magnitude and an intensity. The new |
| HILO (pronounced high-low) formats provide possibly signed, high |
| precision (16-bit) two-component textures. |
| |
| Each program takes as input the stage's interpolated texture |
| coordinate set (s,t,r,q). Each program generates two results: |
| a shader stage result that may be used as an input to subsequent |
| shader stage programs, and a texture unit RGBA result that becomes the |
| texture color used by the texture unit's texture environment function |
| or becomes the initial value for the corresponding texture register |
| for register combiners. The texture unit RGBA result is always |
| an RGBA color, but the shader stage result may be one of an RGBA |
| color, a HILO value, a texture offset group, a floating-point value, |
| or an invalid result. When both results are RGBA colors, the shader |
| stage result and the texture unit RGBA result are usually identical |
| (though not in all cases). |
| |
| Additionally, certain programs have a side-effect such as culling |
| the fragment or replacing the fragment's depth value. |
| |
| The twenty-one programs are briefly described: |
| |
| <none> |
| |
| 1. NONE - Always generates a (0,0,0,0) texture unit RGBA result. |
| Equivalent to disabling all texture targets in conventional |
| OpenGL. |
| |
| <conventional textures> |
| |
| 2. TEXTURE_1D - Accesses a 1D texture via (s/q). |
| |
| 3. TEXTURE_2D - Accesses a 2D texture via (s/q,t/q). |
| |
| 4. TEXTURE_RECTANGLE_NV - Accesses a rectangular texture via (s/q,t/q). |
| |
| 5. TEXTURE_CUBE_MAP_ARB - Accesses a cube map texture via (s,t,r). |
| |
| <special modes> |
| |
| 6. PASS_THROUGH_NV - Converts a texture coordinate (s,t,r,q) |
| directly to a [0,1] clamped (r,g,b,a) texture unit RGBA result. |
| |
| 7. CULL_FRAGMENT_NV - Culls the fragment based on the whether each |
| (s,t,r,q) is "greater than or equal to zero" or "less than zero". |
| |
| <offset textures> |
| |
| 8. OFFSET_TEXTURE_2D_NV - Transforms the signed (ds,dt) components |
| of a previous texture unit by a 2x2 floating-point matrix and |
| then uses the result to offset the stage's texture coordinates |
| for a 2D non-projective texture. |
| |
| 9. OFFSET_TEXTURE_2D_SCALE_NV - Same as above except the magnitude |
| component of the previous texture unit result scales the red, |
| green, and blue components of the unsigned RGBA texture 2D |
| access. |
| |
| 10. OFFSET_TEXTURE_RECTANGLE_NV - Similar to OFFSET_TEXTURE_2D_NV |
| except that the texture access is into a rectangular |
| non-projective texture. |
| |
| 11. OFFSET_TEXTURE_RECTANGLE_SCALE_NV - Similar to |
| OFFSET_TEXTURE_2D_SCALE_NV except that the texture access is |
| into a rectangular non-projective texture. |
| |
| <dependent textures> |
| |
| 12. DEPENDENT_AR_TEXTURE_2D_NV - Converts the alpha and red |
| components of a previous shader result into an (s,t) texture |
| coordinate set to access a 2D non-projective texture. |
| |
| 13. DEPENDENT_GB_TEXTURE_2D_NV - Converts the green and blue |
| components of a previous shader result into an (s,t) texture |
| coordinate set to access a 2D non-projective texture. |
| |
| <dot product textures> |
| |
| 14. DOT_PRODUCT_NV - Computes the dot product of the texture |
| shader's texture coordinate set (s,t,r) with some mapping of the |
| components of a previous texture shader result. The component |
| mapping depends on the type (RGBA or HILO) and signedness of |
| the stage's previous texture input. Other dot product texture |
| programs use the result of this program to compose a texture |
| coordinate set for a dependent texture access. The color result |
| is undefined. |
| |
| 15. DOT_PRODUCT_TEXTURE_2D_NV - When preceded by a DOT_PRODUCT_NV |
| program in the previous texture shader stage, computes a second |
| similar dot product and composes the two dot products into (s,t) |
| texture coordinate set to access a 2D non-projective texture. |
| |
| 16. DOT_PRODUCT_TEXTURE_RECTANGLE_NV - Similar to |
| DOT_PRODUCT_TEXTURE_2D_NV except that the texture acces is into |
| a rectangular non-projective texture. |
| |
| 17. DOT_PRODUCT_TEXTURE_CUBE_MAP_NV - When preceded by two |
| DOT_PRODUCT_NV programs in the previous two texture shader |
| stages, computes a third similar dot product and composes the |
| three dot products into (s,t,r) texture coordinate set to access |
| a cube map texture. |
| |
| 18. DOT_PRODUCT_REFLECT_CUBE_MAP_NV - When preceded by two |
| DOT_PRODUCT_NV programs in the previous two texture shader |
| stages, computes a third similar dot product and composes the |
| three dot products into a normal vector (Nx,Ny,Nz). An eye |
| vector (Ex,Ey,Ez) is composed from the q texture coordinates of |
| the three stages. A reflection vector (Rx,Ry,Rz) is computed |
| based on the normal and eye vectors. The reflection vector |
| forms an (s,t,r) texture coordinate set to access a cube map |
| texture. |
| |
| 19. DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV - Operates like |
| DOT_PRODUCT_REFLECT_CUBE_MAP_NV except that the eye vector |
| (Ex,Ey,Ez) is a user-defined constant rather than composed from |
| the q coordinates of the three stages. |
| |
| 20. DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV - When used instead of the second |
| DOT_PRODUCT_NV program preceding |
| a DOT_PRODUCT_REFLECT_CUBE_MAP_NV or |
| DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV stage, the normal |
| vector forms an (s,t,r) texture coordinate set to access a |
| cube map texture. |
| |
| <dot product depth replace> |
| |
| 21. DOT_PRODUCT_DEPTH_REPLACE_NV - When preceded by a DOT_PRODUCT_NV |
| program in the previous texture shader stage, computes a second |
| similar dot product and replaces the fragment's window-space |
| depth value with the first dot product results divided by |
| the second. The texture unit RGBA result is (0,0,0,0). |
| |
| Issues |
| |
| What should this extension be called? How does the functionality |
| compare with DirectX 8's pixel shaders? |
| |
| RESOLUTION: This extension is called NV_texture_shader. |
| |
| DirectX 8 refers to its similar functionality as "pixel shaders". |
| However, DirectX 8 lumps both the functionality described in this |
| extension and additional functionality similar to the functionality |
| in the NV_register_combiners extension together into what DirectX |
| 8 calls pixel shaders. This is confusing in two ways. |
| |
| 1) Pixels are not being shaded. In fact, the DirectX 8 pixel |
| shaders functionality is, taken as a whole, shading only |
| fragments (though Direct3D tends not to make the same |
| clear distinction between fragments and pixels that OpenGL |
| consistently makes). |
| |
| 2) There are two very distinct tasks being performed. |
| |
| First, there is the task of interpolated texture coordinate |
| mapping. This per-fragment task maps from interpolated |
| floating-point texture coordinate sets to (typically |
| fixed-point) texture unit RGBA results. In conventional OpenGL, |
| this mapping is performed by accessing the highest priority |
| enabled texture target using the fragment's corresponding |
| interpolated texture coordinate set. This NV_texture_shader |
| extension provides a significantly more powerful mechanism |
| for performing this mapping. |
| |
| Second, there is the task of fragment coloring. Fragment |
| coloring is process of combining (typically fixed-point) RGBA |
| colors to generate a final fragment color that, assuming the |
| fragment is not discarded by subsequent per-fragment tests, |
| is used to update the fragment's corresponding pixel in the |
| frame buffer. In conventional OpenGL, fragment coloring is |
| performed by the enabled texture environment functions, fog, and |
| color sum operations. NVIDIA's register combiners functionality |
| (see the NV_register_combiners and NV_register_combiners2 |
| extensions) provides a substantially more powerful alternative |
| to conventional OpenGL fragment coloring. |
| |
| DirectX 8 has two types of opcodes for pixel shaders. Texture |
| address opcodes correspond to the first task listed above. Texture |
| register opcodes correspond to the second task listed above. |
| |
| NVIDIA OpenGL extensions maintain a clear distinction between |
| these two tasks. The texture shaders functionality described in |
| this specification corresponds to the first task listed above. |
| |
| Here is the conceptual framework that NVIDIA OpenGL extensions use |
| to describe shading: Shading is the process of assigning colors |
| to pixels, fragments, or texels. The texture shaders functionality |
| assigns colors to texture unit results (essentially texture |
| shading). These texture unit RGBA results can be used by fragment |
| coloring (fragment shading). The resulting fragments are used to |
| update pixels (pixel shading) possibly via blending and/or multiple |
| rendering passes. |
| |
| The goal of these individual shading operations is per-pixel |
| shading. Per-pixel shading is accomplished by combining the |
| texture shading, fragment shading, and pixel shading operations, |
| possibly with multiple rendering passes. |
| |
| Programmable shading is a style of per-pixel shading where the |
| shading operations are expressed in a higher level of abstraction |
| than "raw" OpenGL texture, fragment, and pixel shading operations. |
| In our view, programmable shading does not necessarily require a |
| "pixel program" to be downloaded and executed per-pixel by graphics |
| hardware. Indeed, there are many disadvantages to such an approach |
| in practice. An alternative view of programmable shading (the |
| one that we are promoting) treats the OpenGL primitive shading |
| operations as a SIMD machine and decomposes per-pixel shading |
| programs into one or more OpenGL rendering passes that map to "raw" |
| OpenGL shading operations. We believe that conventional OpenGL |
| combined with NV_register_combiners and NV_texture_shader (and |
| further augmented by programmable geometry via NV_vertex_program |
| and higher-order surfaces via NV_evaluators) can become the hardware |
| basis for a powerful programmable shading system. |
| |
| The roughly equivalent functionality to DirectX 8's pixel |
| shaders in OpenGL is the combination of NV_texture_shader with |
| NV_register_combiners. |
| |
| Is anyone working on programmable shading using the NV_texture_shader |
| functionality? |
| |
| Yes. The Stanford Shading Group is actively working on |
| support for programmable shading using NV_texture_shader, |
| NV_register_combiners, and other extensions as the hardware basis |
| for such a system. |
| |
| What terms are important to this specification? |
| |
| texture shaders - A series of texture shader stages that map texture |
| coordinate sets to texture unit RGBA results. An alternative to |
| conventional OpenGL texturing. |
| |
| texture coordinate set - The interpolated (s,t,r,q) value for a |
| particular texture unit of a particular fragment. |
| |
| conventional OpenGL texturing - The conventional mechanism used by |
| OpenGL to map texture coordinate sets to texture unit RGBA results |
| whereby a given texture unit's texture coordinate set is used to |
| access the highest priority enabled texture target to generate |
| the texture unit's RGBA result. Conventional OpenGL texturing |
| supports 1D, 2D, 3D, and cube map texture targets. In conventional |
| OpenGL texturing each texture unit operates independently. |
| |
| texture target type - One of the four texture target types: 1D, 2D, |
| 3D, and cube map. (Note that NV_texture_shader does NOT provide |
| support for 3D textures; the NV_texture_shader2 extension adds |
| texture shader operations for 3D texture targets.) |
| |
| texture internal format - The internal format of a particular |
| texture object. For example, GL_RGBA8, GL_SIGNED_RGBA8, or |
| GL_SIGNED_HILO16_NV. |
| |
| texture format type - One of the three texture format types: RGBA, |
| HILO, or texture offset group. |
| |
| texture component signedness - Whether or not a given component |
| of a texture's texture internal format is signed or not. |
| Signed components are clamped to the range [-1,1] while unsigned |
| components are clamped to the range [0,1]. |
| |
| texture shader enable - The OpenGL enable that determines whether |
| the texture shader functionality (if enabled) or conventional |
| OpenGL texturing functionality (if disabled) is used to map texture |
| coordinate sets to texture unit RGBA results. The enable's initial |
| state is disabled. |
| |
| texture shader stage - Each texture unit has a corresponding texture |
| shader stage that can be loaded with one of 21 texture shader |
| operations. Depending on the stage's texture shader operation, |
| a texture shader stage uses the texture unit's corresponding |
| texture coordinate set and other state including the texture shader |
| results of previous texture shader stages to generate the stage's |
| particular texture shader result and texture unit RGBA result. |
| |
| texture unit RGBA result - A (typically fixed-point) color result |
| generated by either a texture shader or conventional OpenGL |
| texturing. This is the color that becomes the texture unit's |
| texture environment function texture input or the initial value |
| of the texture unit's corresponding texture register in the case |
| of register combiners. |
| |
| texture shader result - The result of a texture shader stage that |
| may be used as an input to a subsequent texture shader stage. |
| This result is distinct from the texture unit RGBA result. |
| The texture shader result may be one of four types: an RGBA |
| color value, a HILO value, a texture offset group value, or a |
| floating-point value. A few texture shader operations are defined |
| to always generate an invalid texture shader result. |
| |
| texture shader result type - One of the four texture shader result |
| types: RGBA color, HILO, texture offset group, or floating-point. |
| |
| texture shader operation - One of 21 fixed programs that maps a |
| texture unit's texture coordinate set to a texture shader result |
| and a texture unit RGBA result. |
| |
| texture consistency - Whether or not the texture object for a |
| given texture target is consistent. The rules for determining |
| consistency depend on the texture target and the texture object's |
| filtering state. For example, a mipmapped texture is inconsistent |
| if its texture levels do not form a consistent mipmap pyramid. |
| Also, a cube map texture is inconsistent if its (filterable) |
| matching cube map faces do not have matching dimensions. |
| |
| texture shader stage consistency - Whether or not a texture |
| shader stage is consistent or not. The rules for determining |
| texture shader stage consistency depend on the texture shader |
| stage operation and the inputs upon which the texture shader |
| operation depends. For example, texture shader operations that |
| depend on accessing a given texture target are not consistent |
| if the given texture target is not consistent. Also, a texture |
| shader operation that depends on a particular texture shader |
| result type for a previous texture shader result is not consistent |
| if the previous texture shader result type is not appropriate |
| or the previous texture shader stage itself is not consistent. |
| If a texture shader stage is not consistent, it operates as if |
| the operation is the GL_NONE operation. |
| |
| previous texture input - Some texture shader operations depend |
| on a texture shader result from a specific previous texture input |
| designated by the GL_PREVIOUS_TEXTURE_INPUT_NV state. |
| |
| What should the default state be? |
| |
| RESOLUTION: Texture shaders disabled with all stages set to GL_NONE. |
| |
| How is the mipmap lambda parameter computed for dependent texture fetches? |
| |
| RESOLUTION: Very carefully. NVIDIA's implementation details are |
| NVIDIA proprietary, but mipmapping of dependent texture fetches |
| is supported. |
| |
| Does this extension support so-called "bump environment mapping"? |
| |
| Something similar to DirectX 6 so-called bump environment mapping |
| can be emulated with the GL_OFFSET_TEXTURE_2D_NV texture shader. |
| |
| A more correct form of bump environment mapping can be implemented |
| by using the following texture shaders: |
| |
| texture unit 0: GL_TEXTURE_2D |
| texture unit 1: GL_DOT_PRODUCT_NV |
| texture unit 2: GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV |
| texture unit 3: GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV |
| |
| Texture unit 0 should use a normal map for its 2D texture. |
| A GL_SIGNED_RGB texture can encode signed tangent-space normal |
| perturbations. Or for more precision, a GL_SIGNED_HILO_NV texture |
| can encode the normal perturbations in hemisphere fashion. |
| |
| The tangent (Tx,Ty,Tz), binormal (Bx,By,Bz), and normal (Nx,Ny,Nz) |
| that together map tangent-space normals to cube map-space normals |
| should be sent as texture coordinates s1, t1, r1, s2, t2, r2, s3, |
| t3, and r3 respectively. Typically, cube map space is aligned to |
| match world space. |
| |
| The (unnormalized) cube map-space eye vector (Ex,Ey,Ez) should be |
| sent as texture coordinates q1, q2, and q3 respectively. |
| |
| A vertex programs (using the NV_vertex_program extension) can |
| compute and assign the required tangent, binormal, normal, and |
| eye vectors to the appropriate texture coordinates. Conventional |
| OpenGL evaluators (or the NV_evaluators extension) can be used to |
| evaluate the tangent and normal automatically for Bezier patches. |
| The binormal is the cross product of the normal and tangent. |
| |
| Texture units 1, 2, and 3, should also all specify GL_TEXTURE0_ARB |
| (the texture unit accessing the normal map) for their |
| GL_PREVIOUS_TEXTURE_INPUT_NV parameter. |
| |
| The three dot product texture shader operations performed by the |
| texture shaders for texture units 1, 2, and 3 form a 3x3 matrix |
| that transforms the tangent-space normal (the result of the texture |
| shader for texture unit 0). This rotates the tangent-space normal |
| into a cube map-space. |
| |
| Texture unit 2's cube map texture should encode a pre-computed |
| diffuse lighting solution. Texture unit 3's cube map texture should |
| encode a pre-computed specular lighting solution. The specular |
| lighting solution can be an environment map. |
| |
| Texture unit 2 is accessed using the cube map-space normal |
| vector resulting from the three dot product results |
| of the texture shaders for texture units 1, 2, and 3. |
| (While normally texture shader operations are executed |
| in order, preceding GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV by |
| GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV is a special case where a dot |
| product result from texture unit 3 influences the cube map access |
| of texture unit 2.) |
| |
| Texture unit 3 is accessed using the cube map-space reflection |
| vector computed using the cube map-space normal vector from the |
| three dot product results of the texture shaders for texture units |
| 1, 2, and 3 and the cube-map space eye-vector (q1,q2,q3). |
| |
| Note that using cube maps to access the diffuse and specular |
| illumination obviates the need for an explicit normalization of |
| the typically unnormalized cube map-space normal and reflection |
| vectors. |
| |
| The register combiners (using the NV_register_combiners extension) |
| can combine the diffuse and specular contribution available in |
| the GL_TEXTURE2_ARB and GL_TEXTURE3_ARB registers respectively. |
| A constant ambient contribution can be stored in a register combiner |
| constant. The ambient contribution could also be folded into the |
| diffuse cube map. |
| |
| If desired, the diffuse and ambient contribution can be modulated |
| by a diffuse material parameter encoded in the RGB components of |
| the primary color. |
| |
| If desired, the specular contribution can be modulated by a specular |
| material parameter encoded in the RGB components of the secondary |
| color. |
| |
| Yes, this is all quite complicated, but the result is a true |
| bump environment mapping technique with excellent accounting for |
| normalization and per-vertex interpolated diffuse and specular |
| materials. An environment and/or an arbitrary number of distant |
| or infinite lights can be encoded into the diffuse and specular |
| cube maps. |
| |
| Why must GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV be used only in |
| conjunction with GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV? Why does the |
| GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV stage rely on a result computed |
| in the following stage? |
| |
| Think of the GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV and |
| GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV operations as forming a compound |
| operation. The idea is to generate two cube map accesses based |
| on a perturbed normal and reflection vector where the reflection |
| vector is a function of the perturbed normal vector. To minimize |
| the number of stages (three stages only) and reuse the internal |
| computations involved, this is treated as a compound operation. |
| |
| Note that the GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV |
| vector can be preceded by two GL_DOT_PRODUCT_NV |
| operations instead of a GL_DOT_PRODUCT_NV operation then a |
| GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV operation. This may be more |
| efficient when only the cube map access using the reflection vector |
| is required (a shiny object without any diffuse reflectance). |
| |
| Also note that if only the diffuse reflectance cube map |
| access is required, this can be accomplished by simply using |
| the GL_DOT_PRODUCT_CUBE_MAP_NV operation preceded by two |
| GL_DOT_PRODUCT_NV operations. |
| |
| How do texture shader stages map to register combiner texture registers? |
| |
| RESOLUTION: If GL_TEXTURE_SHADER_NV is enabled, the texture unit |
| RGBA result for a each texture stage is used to initialize the |
| respective texture register in the register combiners. |
| |
| So if a texture shader generates a texture unit RGBA result for |
| texture unit 2, use GL_TEXTURE2_ARB for the name of the register |
| value in register combiners. |
| |
| Should the number of shader stages be settable? |
| |
| RESOLUTION: No, unused stages can be set to GL_NONE. |
| |
| How do signed RGBA texture components show up in the register |
| combiners texture registers? |
| |
| RESOLUTION: As signed values. You can use GL_SIGNED_IDENTITY_NV |
| and get to the signed value directly. |
| |
| How does the texture unit RGBA result of a |
| GL_NONE, GL_CULL_FRAGMENT_NV, DOT_PRODUCT_NV, or |
| GL_DOT_PRODUCT_DEPTH_REPLACE_NV texture shader operation show up in |
| the register combiners texture registers? |
| |
| RESOLUTION: Always as the value (0,0,0,0). |
| |
| How the texture RGBA result of the GL_NONE, GL_CULL_FRAGMENT_NV, |
| GL_DOT_PRODUCT_NV, and GL_DOT_PRODUCT_DEPTH_REPLACE_NV texture |
| shader operations shows up in the texture environment is not |
| an issue, because the texture environment operation is always |
| assumed to be GL_NONE when the corresponding texture shader |
| is one of GL_NONE, GL_CULL_FRAGMENT_NV, GL_DOT_PRODUCT_NV, or |
| GL_DOT_PRODUCT_DEPTH_REPLACE_NV when GL_TEXTURE_SHADER_NV is |
| enabled. |
| |
| Why introduce new pixel groups (the HILO and texture offset groups)? |
| |
| RESOLUTION: In core OpenGL, texture image data is transferred and |
| stored as sets of color components. Such color data can always |
| be promoted to RGBA data. |
| |
| In addition to color components, there are other types of image |
| data in OpenGL including depth components, stencil components, |
| and color indices. Depth and stencil components can be used by |
| glReadPixels, glDrawPixels, and glCopyPixels, but are not useful |
| for storing texture data in core OpenGL. The EXT_paletted_texture |
| and EXT_index_texture extensions extend the contents of textures to |
| include indices (even though in the case of EXT_paletted_texture, |
| texel fetches are always eventually expanded into color components |
| by the texture palette). |
| |
| However this these existing pixel groups are not sufficient for |
| all the texture shader operations introduced by this extension. |
| Certain texture shader operations require texture data that |
| is not merely a set of color components. The dot product |
| (GL_DOT_PRODUCT_NV, etc) operations both can |
| utilize high-precision hi and lo components. The |
| offset texture operations (GL_OFFSET_TEXTURE_2D_NV, |
| GL_OFFSET_TEXTURE_2D_SCALE_NV, GL_OFFSET_TEXTURE_RECTANGLE_NV, |
| and GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV) require |
| textures containing signed offsets used to displace |
| texture coordinates. The GL_OFFSET_TEXTURE_2D_SCALE_NV and |
| GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV also require an unsigned |
| magnitude for the scaling operation. |
| |
| To facilitate these new texture representations, this extension |
| introduces several new (external) formats, pixel groups, and |
| internal texture formats. An (external) format is the external |
| representation used by an application to specify pixel data |
| for use by OpenGL. A pixel group is a grouping of components |
| that are transformed by OpenGL's pixel transfer mechanism is a |
| particular manner. For example, RGBA components for colors are |
| transformed differently than stencil components when passed through |
| OpenGL's pixel transfer mechanism. An internal texture format is |
| the representation of texture data within OpenGL. Note that the |
| (external) format used to specify the data by the application may |
| be different than the internal texture format used to store the |
| texture data internally to OpenGL. For example, core OpenGL permits |
| an application to specify data for a texture as GL_LUMINANCE_ALPHA |
| data stored in GLfloats even though the data is to be store in |
| a GL_RGBA8 texture. OpenGL's pixel unpacking and pixel transfer |
| operations perform an appropriate transformation of the data when |
| such a texture download is performed. Also note that data from |
| one pixel group (say stencil components) cannot be supplied as |
| data for a different pixel group (say RGBA components). |
| |
| This extension introduces four new (external) formats for |
| texture data: GL_HILO_NV, GL_DSDT_NV, GL_DSDT_MAG_NV, and |
| GL_DSDT_MAG_VIB_NV. |
| |
| GL_HILO_NV is for specifying high-precision hi and lo components. |
| The other three formats are used to specify texture offset groups. |
| These new formats can only be used for specifying textures (not |
| copying, reading, or writing pixels). |
| |
| Each of these four pixel formats belong to one of two pixel groups. |
| Pixels specified with the GL_HILO_NV format are transformed as HILO |
| components. Pixels specified with the DSDT_NV, DSDT_MAG_NV, and |
| DSDT_MAG_VIB_NV formats are transformed as texture offset groups. |
| |
| The HILO component and texture offset group pixel groups have |
| independent scale and bias operations for each component type. |
| Various pixel transfer operations that are performed on the RGBA |
| components pixel group are NOT performed on these two new pixel |
| groups. OpenGL's pixel map, color table, convolution, color matrix, |
| histogram, and min/max are NOT performed on the HILO components |
| or texture offset group pixel groups. |
| |
| There are four internal texture formats for texture data specified |
| as HILO components: GL_HILO_NV, GL_HILO16_NV, GL_SIGNED_HILO_NV, |
| and GL_SIGNED_HILO16_NV. The HILO data can be stored as either |
| unsigned [0,1] value or [-1,1] signed values. There are also |
| enumerants for both explicitly sized component precision (16-bit |
| components) and unsized component precision. OpenGL implementations |
| are expected to keep HILO components are high precision even if |
| an unsized internal texture format is used. |
| |
| The expectation with HILO textures is that applications will |
| specify HILO data using a type of GL_UNSIGNED_SHORT or GL_SHORT or |
| larger data types. Specifying HILO data with GL_UNSIGNED_BYTE or |
| GL_BYTE works but does not exploit the full available precision |
| of the HILO internal texture formats. |
| |
| There are six internal texture formats for texture data |
| specified as texture offset groups: GL_DSDT_NV, GL_DSDT8_NV, |
| GL_DSDT_MAG_NV, GL_DSDT8_MAG8_NV, GL_DSDT_MAG_INTENSITY_NV and |
| GL_DSDT8_MAG8_INTENSITY8_NV. The GL_DSDT_NV formats specify two |
| signed [-1,1] components, ds and dt, used to offset s and t texture |
| coordinates. The GL_DSDT_MAG_NV formats specify an additional |
| third unsigned [0,1] component that is a magnitude to scale an |
| unsigned RGBA texture fetch by. The GL_DSDT_MAG_INTENSITY_NV |
| formats specify an additional fourth [0,1] unsigned component, |
| intensity, that becomes the intensity of the fetched texture for |
| use in the texture environment or register combiners. There are |
| also enumerants for both explicitly sized (8-bit components) |
| and unsized component precision. |
| |
| Note that the vibrance (VIB) component of the |
| GL_DSDT_MAG_VIB_NV format becomes the intensity component of |
| the GL_DSDT_MAG_INTENSITY_NV internal texture format. Vibrance |
| becomes intensity in the GL_DSDT_MAG_INTENSITY_NV texture format. |
| The introduction of vibrance is because core OpenGL has no notion |
| of an intensity component in the pixel transfer mechanism or as |
| an external format (instead the red component of an RGBA value |
| becomes the intensity component of intensity textures). |
| |
| How does the texture unit RGBA result of a texture shader that fetches |
| a texture with a base internal format of GL_HILO_NV, GL_DSDT_NV, or |
| GL_DSDT_MAG_NV show up in the register combiners texture registers? |
| |
| RESOLUTION: Always as the value (0,0,0,0). |
| |
| How the texture RGBA result of a texture shader that fetches a |
| texture with a base internal format of GL_HILO_NV, GL_DSDT_NV, |
| or GL_DSDT_MAG_NV the GL_DOT_PRODUCT_NV texture shader shows up |
| in the texture environment is not an issue, because the texture |
| environment operation is always assumed to be GL_NONE in this case |
| when GL_TEXTURE_SHADER_NV is enabled. |
| |
| Does the GL_DOT_PRODUCT_DEPTH_REPLACE_NV program replace the |
| eye-distance Z or window-space depth? |
| |
| RESOLUTION: Window-space depth. And if the window-space depth |
| value is outside of the near and far depth range values, the |
| fragment is rejected. |
| |
| The GL_CULL_FRAGMENT_NV operation always compares against all four |
| texture coordinates. What if I want only one, two, or three |
| comparisons? |
| |
| RESOLUTION: To compare against a single value, replicate that value |
| in all the coordinates and set the comparison for all components to |
| be identical. Or you can set uninteresting coordinates to zero and |
| use the GL_GEQUAL comparison which will never cull for the value zero. |
| |
| What is GL_CULL_FRAGMENT_NV good for? |
| |
| The GL_CULL_FRAGMENT_NV operation provides a mechanism to implement |
| per-fragment clip planes. If a texture coordinate is assigned a |
| signed distance to a plane, the cull fragment test can discard |
| fragments on the wrong side of the plane. Each texture shader |
| stage provides up to four such clip planes. An eye-space clip |
| plane can be established using the GL_EYE_LINEAR texture coordinate |
| generation mode where the clip plane equation is specified via |
| the GL_EYE_PLANE state. |
| |
| Clip planes are one application for GL_CULL_FRAGMENT_NV, but |
| other clipping approaches are possible too. For example, by |
| computing and assigning appropriate texture coordinates (perhaps |
| with NV_vertex_program), fragments beyond a certain distance from |
| a point can be culled (assuming that it is acceptable to linearly |
| interpolate a distance between vertices). |
| |
| The texture border color is supposed to be an RGBA value clamped to |
| the range [0,1]. How does the texture border color work in conjunction |
| with signed RGBA color components, HILO components, and texture offset |
| component groups? |
| |
| RESOLUTION: The per-texture object GL_TEXTURE_BORDER_COLOR |
| is superceded by a GL_TEXTURE_BORDER_VALUES symbolic token. |
| The texture border values are four floats (not clamped to |
| [0,1] when specified). When a texture border is required for |
| a texture, the components for the border texel are determined |
| by the GL_TEXTURE_BORDER_VALUES state. For color components, |
| the GL_TEXTURE_BORDER_VALUES state is treated as a set of RGBA |
| color components. For HILO components, the first value is treated |
| as hi and the second value is treated as lo. For texture offset |
| components, the ds, dt, mag, and vib values correspond to the first, |
| second, third, and fourth texture border values respectively. |
| The particular texture border components are clamped to the range |
| of the component determined by the texture's internal format. So a |
| signed component is clamped to the [-1,1] range and an unsigned |
| component is clamped to the [0,1] range. |
| |
| For backward compatibility, the GL_TEXTURE_BORDER_COLOR can |
| still be specified and queried. When specified, the values are |
| clamped to [0,1] and used to update the texture border values. |
| When GL_TEXTURE_BORDER_COLOR is queried, there is no clamping of |
| the returned values. |
| |
| With signed texture components, does the texture environment function |
| discussion need to be amended? |
| |
| RESOLUTION: Yes. We do not want texture environment results to |
| exceed the range [-1,1]. |
| |
| The GL_DECAL and GL_BLEND operations perform linear interpolations |
| of various components of the form |
| |
| A * B + (1-A) * C |
| |
| The value of A should not be allowed to be negative otherwise, |
| the value of (1-A) may exceed 1.0. These linear interpolations |
| should be written in the form |
| |
| max(0,A) * B + (1-max(0,A)) * C |
| |
| The GL_ADD operation clamps its result to 1.0, but if negative |
| components are permitted, the result should be clamped to the range |
| [-1,1]. |
| |
| The GL_COMBINE_ARB (and GL_COMBINE_EXT) and GL_COMBINE4_NV |
| operations do explicit clamping of all result to [0,1]. |
| In addition, NV_texture_shader adds requirements to clamp |
| inputs to [0,1] too. This is because the GL_ONE_MINUS_SRC_COLOR |
| and GL_ONE_MINUS_SRC_ALPHA operands should really be computing |
| 1-max(0,C). For completeness, GL_SRC_COLOR and GL_SRC_ALPHA should |
| be computing max(0,C). |
| |
| With signed texture components, does the color sum discussion need |
| to be amended? |
| |
| RESOLUTION: Yes. The primary and secondary color should both be |
| clamped to the range [0,1] before they are summed. |
| |
| The unextended OpenGL 1.2 description of color sum does not |
| require a clamp of the primary and secondary colors to the [0,1] |
| range before they are summed. Before signed texture components, |
| the standard texture environment modes either could not generate |
| results outside the [0,1] range or explicitly clamped their |
| results to this range (as in the case of GL_ADD, GL_COMBINE_EXT, |
| and GL_COMBINE4_NV). Now with signed texture components, negative |
| values can be generated by texture environment functions. |
| |
| We do not want to clamp the intermediate results of texture |
| environment stages since negative results may be useful in |
| subsequent stages, but clamping should be applied to the primary |
| color immediately before the color sum. For symmetry, clamping of |
| the secondary color is specified as well (though there is currently |
| no way to generate a negative secondary color). |
| |
| Why vibrance? |
| |
| Vibrance is the fourth component of the external representation of a |
| texture offset group. During pixel transfer, vibrance is scaled and |
| biased based on the GL_VIBRANCE_SCALE and GL_VIBRANCE_BIAS state. |
| Once transformed, the vibrance component becomes the intensity |
| component for textures with a DSDT_MAG_INTENSITY base internal |
| format. Vibrance is meaningful only when specifying texture images |
| with the DS_DT_MAG_VIB_NV external format (and is not supported |
| when reading, drawing, or copying pixels). |
| |
| There are lots of reasons that a texture shader stage is inconsistent, |
| and in which case, the stage operates as if the operation is NONE. |
| For debugging sanity, is there a way to determine whether a particular |
| texture shader stage is consistent? |
| |
| RESOLUTION: Yes. Query the shader consistency of a particular |
| texture unit with: |
| |
| GLint consistent; |
| |
| glActiveTextureARB(stage_to_check); |
| glGetTexEnviv(GL_TEXTURE_SHADER_NV, GL_SHADER_CONSISTENT_NV, |
| &consistent); |
| |
| consistent is one or zero depending on whether the shader stage |
| is consistent or not. |
| |
| Should there be signed components with sub 8-bit precision? |
| |
| RESOLUTION: No. |
| |
| Should packed pixel formats for texture offset groups be supported? |
| |
| RESOLUTION: Yes, but they are limited to UNSIGNED_INT_S8_S8_8_8_NV |
| and UNSIGNED_INT_8_8_S8_S8_REV_NV for use with the DSDT_MAG_VIB_NV |
| format. |
| |
| Note that these two new packed pixel formats are only for the |
| DSDT_MAG_VIB_NV and cannot be used with RGBA or BGRA formats. |
| Likewise, the RGBA and BGRA formats cannot be used with the new |
| UNSIGNED_INT_S8_S8_8_8_NV and UNSIGNED_INT_8_8_S8_S8_REV_NV types. |
| |
| What should be said about signed fixed-point precision and range of |
| actual implementations? |
| |
| RESOLUTION: The core OpenGL specification typically specifies |
| fixed-point numerical computations without regard to the specific |
| precision of the computations. This practice is intentional because |
| it permits implementations to vary in the degree of precision used |
| for internal OpenGL computations. When mapping unsigned fixed-point |
| values to a [0,1] range, the mapping is straightforward. |
| |
| However, this extension supports signed texture components in |
| the range [-1,1]. This presents some awkward choices for how to |
| map [-1,1] to a fixed-point representation. Assuming a binary |
| fixed-point representation with an even distribution of precision, |
| there is no way to exactly represent -1, 0, and 1 and avoid |
| representing values outside the [-1,1] range. |
| |
| This is not a unique issue for this extension. In core OpenGL, |
| table 2.6 describes mappings from unsigned integer types (GLbyte, |
| GLshort, and GLint) that preclude the exact specification of 0.0. |
| NV_register_combiners supports signed fixed-point values that have |
| similar representation issues. |
| |
| NVIDIA's solution to this representation problem is to use 8-, 9-, |
| and 16-bit fixed-point representations for signed values in the |
| [-1,1] range such that |
| |
| floating-point 8-bit fixed-point 9-bit fixed-point 16 bit fixed-point |
| -------------- ----------------- ----------------- ------------------ |
| 1.0 n/a 255 n/a |
| 0.99996... n/a n/a 32767 |
| 0.99218... 127 n/a n/a |
| 0.0 0 0 0 |
| -1.0 -128 -255 -32768 |
| -1.00392... n/a -256 n/a |
| |
| The 8-bit and 16-bit signed fixed-point types are used for signed |
| internal texture formats, while the 9-bit signed fixed-point type |
| is used for register combiners computations. |
| |
| The 9-bit signed fixed-point type has the disadvantage that a |
| number slightly more negative than -1 can be represented and this |
| particular value is different dependent on the number of bits of |
| fixed-point precision. The advantage of this approach is that 1, |
| 0, and -1 can all be represented exactly. |
| |
| The 8-bit and 16-bit signed fixed-point types have the disadvantage |
| that 1.0 cannot be exactly represented (though -1.0 and zero can |
| be exactly represented). |
| |
| The specification however is written using the conventional |
| OpenGL practice (table 2.6) of mapping signed values evenly over |
| the range [-1,1] so that zero cannot be precisely represented. |
| This is done to keep this specification consistent with OpenGL's |
| existing conventions and to avoid the ugliness of specifying |
| a precision-dependent range. We expect leeway in how signed |
| fixed-point values are represented. |
| |
| The spirit of this extension is that an implicit allowance is |
| made for signed fixed-point representations that cannot exactly |
| represent 1.0. |
| |
| How should NV_texture_rectangle interact with NV_texture_shader? |
| |
| NV_texture_rectangle introduces a new texture target similar |
| to GL_TEXTURE_2D but that supports non-power-of-two texture |
| dimensions and several usage restrictions (no mipmapping, etc). |
| Also the imaged texture coordinate range for rectangular textures |
| is [0,width]x[0,height] rather than [0,1]x[0,1]. |
| |
| Four texture shader operations will operate like their 2D texture |
| counter-parts, but will access the rectangular texture |
| target rather than the 2D texture target. These are: |
| |
| GL_TEXTURE_RECTANGLE_NV |
| GL_OFFSET_TEXTURE_RECTANGLE_NV |
| GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV |
| GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV |
| |
| A few 2D texture shader operations, namely |
| GL_DEPENDENT_AR_TEXTURE_2D_NV and GL_DEPENDENT_GB_TEXTURE_2D_NV, |
| do not support rectangular textures because turning colors in the |
| [0,1] range into texture coordinates would only access a single |
| corner texel in a rectangular texture. The offset and dot product |
| rectangular texture shader operations support scaling of the |
| dependent texture coordinates so these operations can access the |
| entire image of a rectangular texture. Note however that it is the |
| responsibility of the application to perform the proper scaling. |
| |
| Note that the 2D and rectangular "offset texture" shaders both |
| use the same matrix, scale, and bias state. |
| |
| Does the GL_DOT_PRODUCT_DEPTH_REPLACE_NV operation happen before or |
| after polygon offset? |
| |
| RESOLUTION: After. The window Z (w_z) is computed during |
| rasterization and polygon offset occurs at this point. The depth |
| replace operation occurs after rasterization (at the point that |
| conventional OpenGL calls "texturing") so when the depth value |
| is replaced, the effect of polygon offset (and normal depth |
| interpolation) is lost when using the depth replace operation. |
| |
| How does the GL_DOT_PRODUCT_DEPTH_REPLACE_NV operation interact with |
| ARB_multisample? |
| |
| RESOLUTION: The depth value for all covered samples of a |
| multisampled fragment are replaced with the _same_ single depth |
| value computed by the depth replace operation. Without depth |
| replace, the depth values of each sample of a fragment may have |
| slightly different depth values because of the polygon's depth |
| gradient. |
| |
| How should the clamping work for GL_OFFSET_TEXTURE_2D_SCALE? |
| |
| RESOLUTION: The scale factor should be clamped to [0,1] prior |
| to scaling red, green, and blue. |
| |
| Red, green, and blue are guaranteed to be unsigned RGB values |
| so the [0,1] scale factor times the [0,1] RGB values results in |
| [0,1] values so no output clamping need be specified. |
| |
| New Procedures and Functions |
| |
| None. |
| |
| New Tokens |
| |
| Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, |
| and by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, |
| and GetDoublev, and by the <target> parameter of TexEnvf, TexEnvfv, |
| TexEnvi, TexEnviv, GetTexEnvfv, and GetTexEnviv: |
| |
| TEXTURE_SHADER_NV 0x86DE |
| |
| When the <target> parameter of TexEnvf, TexEnvfv, TexEnvi, TexEnviv, |
| GetTexEnvfv, and GetTexEnviv is TEXTURE_SHADER_NV, then the value |
| of <pname> may be: |
| |
| RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV 0x86D9 |
| SHADER_OPERATION_NV 0x86DF |
| OFFSET_TEXTURE_SCALE_NV 0x86E2 |
| OFFSET_TEXTURE_BIAS_NV 0x86E3 |
| OFFSET_TEXTURE_2D_SCALE_NV alias for OFFSET_TEXTURE_SCALE_NV |
| OFFSET_TEXTURE_2D_BIAS_NV deprecated alias for OFFSET_TEXTURE_BIAS_NV |
| PREVIOUS_TEXTURE_INPUT_NV 0x86E4 |
| |
| When the <target> parameter of TexEnvfv, TexEnviv, GetTexEnvfv, and |
| GetTexEnviv is TEXTURE_SHADER_NV, then the value of <pname> may be: |
| |
| CULL_MODES_NV 0x86E0 |
| OFFSET_TEXTURE_MATRIX_NV 0x86E1 |
| OFFSET_TEXTURE_2D_MATRIX_NV deprecated alias for OFFSET_TEXTURE_MATRIX_NV |
| CONST_EYE_NV 0x86E5 |
| |
| When the <target> parameter GetTexEnvfv and GetTexEnviv is |
| TEXTURE_SHADER_NV, then the value of <pname> may be: |
| |
| SHADER_CONSISTENT_NV 0x86DD |
| |
| When the <target> and <pname> parameters of TexEnvf, TexEnvfv, |
| TexEnvi, and TexEnviv are TEXTURE_ENV and TEXTURE_ENV_MODE |
| respectively, then the value of <param> or the value pointed to by |
| <params> may be: |
| |
| NONE |
| |
| When the <target> and <pname> parameters of TexEnvf, TexEnvfv, |
| TexEnvi, and TexEnviv are TEXTURE_SHADER_NV and SHADER_OPERATION_NV |
| respectively, then the value of <param> or the value pointed to by |
| <params> may be: |
| |
| NONE |
| |
| TEXTURE_1D |
| TEXTURE_2D |
| TEXTURE_RECTANGLE_NV (see NV_texture_rectangle) |
| TEXTURE_CUBE_MAP_ARB (see ARB_texture_cube_map) |
| |
| PASS_THROUGH_NV 0x86E6 |
| CULL_FRAGMENT_NV 0x86E7 |
| |
| OFFSET_TEXTURE_2D_NV 0x86E8 |
| OFFSET_TEXTURE_2D_SCALE_NV see above, note aliasing |
| OFFSET_TEXTURE_RECTANGLE_NV 0x864C |
| OFFSET_TEXTURE_RECTANGLE_SCALE_NV 0x864D |
| DEPENDENT_AR_TEXTURE_2D_NV 0x86E9 |
| DEPENDENT_GB_TEXTURE_2D_NV 0x86EA |
| |
| DOT_PRODUCT_NV 0x86EC |
| DOT_PRODUCT_DEPTH_REPLACE_NV 0x86ED |
| DOT_PRODUCT_TEXTURE_2D_NV 0x86EE |
| DOT_PRODUCT_TEXTURE_RECTANGLE_NV 0x864E |
| DOT_PRODUCT_TEXTURE_CUBE_MAP_NV 0x86F0 |
| DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV 0x86F1 |
| DOT_PRODUCT_REFLECT_CUBE_MAP_NV 0x86F2 |
| DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV 0x86F3 |
| |
| When the <target> and <pname> parameters of TexEnvfv and TexEnviv |
| are TEXTURE_SHADER_NV and CULL_MODES_NV respectively, then the value |
| of <param> or the value pointed to by <params> may be: |
| |
| LESS |
| GEQUAL |
| |
| When the <target> and <pname> parameters of TexEnvf, |
| TexEnvfv, TexEnvi, and TexEnviv are TEXTURE_SHADER_NV and |
| RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV respectively, then the value |
| of <param> or the value pointed to by <params> may be: |
| |
| UNSIGNED_IDENTITY_NV (see NV_register_combiners) |
| EXPAND_NORMAL_NV (see NV_register_combiners) |
| |
| When the <target> and <pname> parameters of TexEnvf, |
| TexEnvfv, TexEnvi, and TexEnviv are TEXTURE_SHADER_NV and |
| PREVIOUS_TEXTURE_INPUT_NV respectively, then the value of <param> |
| or the value pointed to by <params> may be: |
| |
| TEXTURE0_ARB |
| TEXTURE1_ARB |
| TEXTURE2_ARB |
| TEXTURE3_ARB |
| TEXTURE4_ARB |
| TEXTURE5_ARB |
| TEXTURE6_ARB |
| TEXTURE7_ARB |
| |
| Accepted by the <format> parameter of GetTexImage, TexImage1D, |
| TexImage2D, TexSubImage1D, and TexSubImage2D: |
| |
| HILO_NV 0x86F4 |
| DSDT_NV 0x86F5 |
| DSDT_MAG_NV 0x86F6 |
| DSDT_MAG_VIB_NV 0x86F7 |
| |
| Accepted by the <type> parameter of GetTexImage, TexImage1D, |
| TexImage2D, TexSubImage1D, and TexSubImage2D: |
| |
| UNSIGNED_INT_S8_S8_8_8_NV 0x86DA |
| UNSIGNED_INT_8_8_S8_S8_REV_NV 0x86DB |
| |
| Accepted by the <internalformat> parameter of CopyTexImage1D, |
| CopyTexImage2D, TexImage1D, and TexImage2D: |
| |
| SIGNED_RGBA_NV 0x86FB |
| SIGNED_RGBA8_NV 0x86FC |
| SIGNED_RGB_NV 0x86FE |
| SIGNED_RGB8_NV 0x86FF |
| SIGNED_LUMINANCE_NV 0x8701 |
| SIGNED_LUMINANCE8_NV 0x8702 |
| SIGNED_LUMINANCE_ALPHA_NV 0x8703 |
| SIGNED_LUMINANCE8_ALPHA8_NV 0x8704 |
| SIGNED_ALPHA_NV 0x8705 |
| SIGNED_ALPHA8_NV 0x8706 |
| SIGNED_INTENSITY_NV 0x8707 |
| SIGNED_INTENSITY8_NV 0x8708 |
| SIGNED_RGB_UNSIGNED_ALPHA_NV 0x870C |
| SIGNED_RGB8_UNSIGNED_ALPHA8_NV 0x870D |
| |
| Accepted by the <internalformat> parameter of TexImage1D and |
| TexImage2D: |
| |
| HILO_NV |
| HILO16_NV 0x86F8 |
| SIGNED_HILO_NV 0x86F9 |
| SIGNED_HILO16_NV 0x86FA |
| DSDT_NV |
| DSDT8_NV 0x8709 |
| DSDT_MAG_NV |
| DSDT8_MAG8_NV 0x870A |
| DSDT_MAG_INTENSITY_NV 0x86DC |
| DSDT8_MAG8_INTENSITY8_NV 0x870B |
| |
| Accepted by the <pname> parameter of GetBooleanv, GetIntegerv, |
| GetFloatv, GetDoublev, PixelTransferf, and PixelTransferi: |
| |
| HI_SCALE_NV 0x870E |
| LO_SCALE_NV 0x870F |
| DS_SCALE_NV 0x8710 |
| DT_SCALE_NV 0x8711 |
| MAGNITUDE_SCALE_NV 0x8712 |
| VIBRANCE_SCALE_NV 0x8713 |
| HI_BIAS_NV 0x8714 |
| LO_BIAS_NV 0x8715 |
| DS_BIAS_NV 0x8716 |
| DT_BIAS_NV 0x8717 |
| MAGNITUDE_BIAS_NV 0x8718 |
| VIBRANCE_BIAS_NV 0x8719 |
| |
| Accepted by the <pname> parameter of TexParameteriv, TexParameterfv, |
| GetTexParameterfv and GetTexParameteriv: |
| |
| TEXTURE_BORDER_VALUES_NV 0x871A |
| |
| Accepted by the <pname> parameter of GetTexLevelParameterfv and |
| GetTexLevelParameteriv: |
| |
| TEXTURE_HI_SIZE_NV 0x871B |
| TEXTURE_LO_SIZE_NV 0x871C |
| TEXTURE_DS_SIZE_NV 0x871D |
| TEXTURE_DT_SIZE_NV 0x871E |
| TEXTURE_MAG_SIZE_NV 0x871F |
| |
| Additions to Chapter 2 of the 1.2 Specification (OpenGL Operation) |
| |
| None |
| |
| Additions to Chapter 3 of the 1.2 Specification (Rasterization) |
| |
| -- Section 3.6 "Pixel Rectangles" |
| |
| Add four new rows to table 3.2: |
| |
| Parameter Name Type Initial Value Valid Range |
| ------------------ ----- ------------- ----------- |
| HI_SCALE_NV float 1.0 (-Inf,+Inf) |
| LO_SCALE_NV float 1.0 (-Inf,+Inf) |
| DS_SCALE_NV float 1.0 (-Inf,+Inf) |
| DT_SCALE_NV float 1.0 (-Inf,+Inf) |
| MAGNITUDE_SCALE_NV float 1.0 (-Inf,+Inf) |
| VIBRANCE_SCALE_NV float 1.0 (-Inf,+Inf) |
| |
| HI_BIAS_NV float 0.0 (-Inf,+Inf) |
| LO_BIAS_NV float 0.0 (-Inf,+Inf) |
| DS_BIAS_NV float 0.0 (-Inf,+Inf) |
| DT_BIAS_NV float 0.0 (-Inf,+Inf) |
| MAGNITUDE_BIAS_NV float 0.0 (-Inf,+Inf) |
| VIBRANCE_BIAS_NV float 0.0 (-Inf,+Inf) |
| |
| -- Section 3.6.4 "Rasterization of Pixel Rectangles" |
| |
| Add before the subsection titled "Unpacking": |
| |
| "The HILO_NV, DSDT_NV, DSDT_MAG_NV, and DSDT_MAG_VIB_NV formats |
| are described in this section and section 3.6.5 even though these |
| formats are supported only for texture images. Textures with |
| the HILO_NV format are intended for use with certain dot product |
| texture and dependent texture shader operations (see section 3.8.13). |
| Textures with the DSDT_NV, DSDT_MAG_NV, and DSDT_MAG_VIB_NV format |
| are intended for use with certain offset texture 2D texture shader |
| operations (see section 3.8.13). |
| |
| The error INVALID_ENUM occurs if HILO_NV, DSDT_NV, DSDT_MAG_NV, or |
| DSDT_MAG_VIB_NV is used as the format for DrawPixels, ReadPixels, |
| or other commands that specify or query an image with a format and |
| type parameter though the image is not a texture image. The HILO_NV, |
| DSDT_NV, DSDT_MAG_NV, or DSDT_MAG_VIB_NV formats are intended for |
| use with the TexImage and TexSubImage commands. |
| |
| The HILO_NV format consists of two components, hi and lo, in the hi |
| then lo order. The hi and lo components maintain at least 16 bits |
| of storage per component (at least 16 bits of magnitude for unsigned |
| components and at least 15 bits of magnitude for signed components). |
| |
| The DSDT_NV format consists of two signed components ds and dt, |
| in the ds then dt order. The DSDT_MAG_NV format consists of |
| three components: the signed ds and dt components and an unsigned |
| magnitude component (mag for short), in the ds, then dt, then mag |
| order. The DSDT_MAG_VIB_NV format consists of four components: |
| the signed ds and dt components, an unsigned magnitude component |
| (mag for short), and an unsigned vibrance component (vib for short), |
| in the ds, then dt, then mag, then vib order." |
| |
| Add a new row to table 3.8: |
| |
| type Parameter GL Data Number of Matching |
| Token Name Type Components Pixel Formats |
| ----------------------------- ------- ---------- ---------------- |
| UNSIGNED_INT_S8_S8_8_8_NV uint 4 DSDT_MAG_VIB_NV |
| UNSIGNED_INT_8_8_S8_S8_REV_NV uint 4 DSDT_MAG_VIB_NV |
| |
| Add to table 3.11: |
| |
| UNSIGNED_INT_S8_S8_8_8_NV: |
| |
| 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 |
| +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ |
| | 1st component | 2nd | 3rd | 4th | |
| +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ |
| |
| UNSIGNED_INT_8_8_S8_S8_REV_NV: |
| |
| 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 |
| +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ |
| | 4th | 3rd | 2nd | 1st component | |
| +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ |
| |
| Replace the fifth paragraph in the subsection titled "Unpacking" |
| with the following: |
| |
| "Calling DrawPixels with a type of UNSIGNED_BYTE_3_3_2, |
| UNSIGNED_BYTE_2_3_3_REV, UNSIGNED_SHORT_5_6_5, |
| UNSIGNED_SHORT_5_6_5_REV, UNSIGNED_SHORT_4_4_4_4, |
| UNSIGNED_SHORT_4_4_4_4_REV, UNSIGNED_SHORT_5_5_5_1, |
| UNSIGNED_SHORT_1_5_5_5_REV, UNSIGNED_INT_8_8_8_8, |
| UNSIGNED_INT_8_8_8_8_REV, UNSIGNED_INT_10_10_10_2, or |
| UNSIGNED_INT_2_10_10_10_REV is a special case in which all |
| the components of each group are packed into a single unsigned |
| byte, unsigned short, or unsigned int, depending on the type. |
| When packing or unpacking texture images (for example, using |
| TexImage2D or GetTexImage), the type parameter may also be either |
| UNSIGNED_INT_S8_S8_8_8_NV or UNSIGNED_INT_8_8_S8_S8_REV though |
| neither symbolic token is permitted for DrawPixels, ReadPixels, |
| or other commands that specify or query an image with a format |
| and type parameter though the image is not a texture image. |
| The error INVALID_ENUM occurs when UNSIGNED_INT_S8_S8_8_8_NV is |
| used when it is not permitted. When UNSIGNED_INT_S8_S8_8_8_NV |
| or UNSIGNED_INT_8_8_S8_S8_REV_NV is used, the first and second |
| components are treated as signed components. The number of |
| components per packed pixel is fixed by the type, and must match the |
| number of components per group indicated by the format parameter, |
| as listed in table 3.8. The format must also be one of the formats |
| listed in the Matching Pixel Formats column of table 3.8 for the |
| specified packed type. The error INVALID_OPERATION is generated |
| if a mismatch occurs. This constraint also holds for all other |
| functions that accept or return pixel data using type and format |
| parameters to define the type and format of the data." |
| |
| Amend the second sentence in the sixth paragraph in the subsection |
| titled "Unpacking" to read: |
| |
| "Each bitfield is interpreted as an unsigned integer value unless |
| it has been explicitly been stated that the bitfield contains a |
| signed component. Signed bitfields are treated as two's complement |
| numbers." |
| |
| Add a new row to table 3.12: |
| |
| First Second Third Fourth |
| Format Component Component Component Component |
| --------------- --------- --------- ---------- --------- |
| DSDT_MAG_VIB_NV ds dt magnitude vibrance |
| |
| Change the last sentence in the first paragraph in the subsection |
| titled "Conversion to floating-point" to read: |
| |
| "For packed pixel types, each unsigned element in the group is |
| converted by computing c / (2^N-1), where c is the unsigned integer |
| value of the bitfield containing the element and N is the number of |
| bits in the bitfield. In the case of signed elements of a packed |
| pixel type, the signed element is converted by computing 2*c+1 / |
| (2^N-1), where c is the signed integer value of the bitfield |
| containing the element and N is the number of bits in the bitfield." |
| |
| Change the first sentence in the subsection "Final Expansion to RGBA" |
| to read: |
| |
| "This step is performed only for groups other than HILO component, |
| depth component, and texture offset groups." |
| |
| Add the following additional enumeration to the kind of pixel groups |
| in section 3.6.5: |
| |
| "5. HILO component: Each group comprises two components: hi and lo. |
| |
| 6. Texture offset group: Each group comprises four components: |
| a ds and dt pair, a magnitude, and a vibrance." |
| |
| Change the subsection "Arithmetic on Components" in section 3.6.5 |
| to read: |
| |
| "This step applies only to RGBA component, depth component, and HILO |
| component, and texture offset groups. Each component is multiplied |
| by an appropriate signed scale factor: RED_SCALE for an R component, |
| GREEN_SCALE for a G component, BLUE_SCALE for a B component, |
| ALPHA_SCALE, for an A component, HI_SCALE_NV for a HI component, |
| LO_SCALE_NV for a LO component, DS_SCALE_NV for a DS component, |
| DT_SCALE_NV for a DT component, MAGNITUDE_SCALE_NV for a MAG |
| component, VIBRANCE_SCALE_NV for a VIB component, or DEPTH_SCALE |
| for a depth component. |
| |
| Then the result is added to the appropriate signed bias: RED_BIAS, |
| GREEN_BIAS, BLUE_BIAS, ALPHA_BIAS, HI_BIAS_NV, LO_BIAS_NV, |
| DS_BIAS_NV, DT_BIAS_NV, MAGNITUDE_BIAS_NV, VIBRANCE_BIAS_NV, or |
| DEPTH_BIAS." |
| |
| -- Section 3.8 "Texturing" |
| |
| Replace the first paragraph with the following: |
| |
| "The GL provides two mechanisms for mapping sets of (s,t,r,q) |
| texture coordinates to RGBA colors: conventional texturing and |
| texture shaders. |
| |
| Conventional texturing maps a portion of a specified image onto |
| each primitive for each enabled texture unit. Conventional |
| texture mapping is accomplished by using the color of an image |
| at the location indicated by a fragment's non-homogeneous (s,t,r) |
| coordinates for a given texture unit. |
| |
| The alternative to conventional texturing is the texture shaders |
| mechanism. When texture shaders are enabled, each texture unit |
| uses one of twenty-one texture shader operations. Eighteen of the |
| twenty-one shader operations map an (s,t,r,q) texture coordinate |
| set to an RGBA color. Of these, three texture shader operations |
| directly correspond to the 1D, 2D, and cube map conventional |
| texturing operations. Depending on the texture shader operation, |
| the mapping from the (s,t,r,q) texture coordinate set to an RGBA |
| color may depend on the given texture unit's currently bound |
| texture object state and/or the results of previous texture |
| shader operations. The three remaining texture shader operations |
| respectively provide a fragment culling mechanism based on texture |
| coordinates, a means to replace the fragment depth value, and a dot |
| product operation that computes a floating-point value for use by |
| subsequent texture shaders. The specifics of each texture shader |
| operation are described in section 3.8.12. |
| |
| Texture shading is enabled or disabled using the generic Enable |
| and Disable commands, respectively, with the symbolic constant |
| TEXTURE_SHADER_NV. When texture shading is disabled, conventional |
| texturing generates an RGBA color for each enabled textures unit |
| as described in Sections 3.8.10. |
| |
| After RGBA colors are assigned to each texture unit, either by |
| conventional texturing or texture shaders, the GL proceeds with |
| fragment coloring, either using the texture environment, fog, |
| and color sum operations, or using register combiners extension if |
| supported. |
| |
| Neither conventional texturing nor texture shaders affects the |
| secondary color." |
| |
| -- Section 3.8.1 "Texture Image Specification" |
| |
| Add the following sentence to the first paragraph: |
| |
| "The formats HILO_NV, DSDT_NV, DSDT_MAG_NV, and DSDT_MAG_VIB_NV |
| are allowed for specifying texture images." |
| |
| Replace the fourth paragraph with: |
| |
| "The selected groups are processed exactly as for DrawPixels, |
| stopping just before conversion. Each R, G, B, A, HI, LO, DS, DT, |
| and MAG value so generated is clamped to [0,1] if the corresponding |
| component is unsigned, or if the corresponding component is signed, |
| is clamped to [-1,1]. The signedness of components depends on the |
| internal format (see table 3.16). The signedness of components |
| for unsized internal formats matches the signedness of components |
| for any respective sized version of the internal format." |
| |
| Replace table 3.15 with the following table: |
| |
| Base Internal Format Component Values Internal Components Format Type |
| --------------------- ------------------- ------------------- ------------------------- |
| ALPHA A A RGBA |
| LUMINANCE R L RGBA |
| LUMINANCE_ALPHA R,A L,A RGBA |
| INTENSITY R I RGBA |
| RGB R,G,B R,G,B RGBA |
| RGBA R,G,B,A R,G,B,A RGBA |
| HILO_NV HI,LO HI,LO HILO |
| DSDT_NV DS,DT DS,DT texture offset group |
| DSDT_MAG_NV DS,DT,MAG DS,DT,MAG texture offset group |
| DSDT_MAG_INTENSITY_NV DS,DT,MAG,VIB DS,DT,MAG,I RGBA/texture offset group |
| |
| Re-caption table 3.15 as: |
| |
| "Conversion from RGBA, HILO, and texture offset pixel components to |
| internal texture table, or filter components. See section 3.8.9 |
| for a description of the texture components R, G, B, A, L, and I. |
| See section 3.8.13 for an explanation of the handling of the texture |
| components HI, LO, DS, DT, MAG, and VIB." |
| |
| Add five more columns to table 3.16 labeled "HI bits", "LO bits", "DS |
| bits", "DT bits", and "MAG bits". Existing table rows should have |
| these column entries blank. Add the following rows to the table: |
| |
| Sized Base R G B A L I HI LO DS DT MAG |
| Internal Format Internal Format bits bits bits bits bits bits bits bits bits bits bits |
| ------------------------------ --------------------- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- |
| HILO16_NV HILO 16 16 |
| SIGNED_HILO16_NV HILO 16* 16* |
| SIGNED_RGBA8_NV RGBA 8* 8* 8* 8* |
| SIGNED_RGB8_UNSIGNED_ALPHA8_NV RGBA 8* 8* 8* 8 |
| SIGNED_RGB8_NV RGB 8* 8* 8* |
| SIGNED_LUMINANCE8_NV LUMINANCE 8* |
| SIGNED_LUMINANCE8_ALPHA8_NV LUMINANCE_ALPHA 8* 8* |
| SIGNED_ALPHA8_NV ALPHA 8* |
| SIGNED_INTENSITY8_NV INTENSITY 8* |
| DSDT8_NV DSDT_NV 8* 8* |
| DSDT8_MAG8_NV DSDT_MAG_NV 8* 8* 8 |
| DSDT8_MAG8_INTENSITY8_NV DSDT_MAG_INTENSITY_NV 8 8* 8* 8 |
| |
| Add to the caption for table 3.16: |
| |
| "An asterisk (*) following a component size indicates that the |
| corresponding component is signed (the sign bit is included in |
| specified component resolution size)." |
| |
| Change the first sentences of the fifth paragraph to read: |
| |
| "Components are then selected from the resulting R, G, B, A, HI, LO, |
| DS, DT, and MAG values to obtain a texture with the base internal |
| format specified by (or derived from) internalformat. Table 3.15 |
| summarizes the mapping of R, G, B, A, HI, LO, DS, DT, and MAG values |
| to texture components, as a function of the base internal format of |
| the texture image. internalformat may be specified as one of the |
| ten base internal format symbolic constants listed in table 3.15, |
| or as one of the sized internal format symbolic constants listed |
| in table 3.16." |
| |
| Add these sentences before the last sentence in the fifth paragraph: |
| |
| "The error INVALID_OPERATION is generated if the format is |
| HILO_NV and the internalformat is not one of HILO_NV, HILO16_NV, |
| SIGNED_HILO_NV, SIGNED_HILO16_NV; or if the internalformat is one |
| of HILO_NV, HILO16_NV, SIGNED_HILO_NV, or SIGNED_HILO16_NV and the |
| format is not HILO_NV. |
| |
| The error INVALID_OPERATION is generated if the format is DSDT_NV |
| and the internalformat is not either DSDT_NV or DSDT8_NV; or if |
| the internal format is either DSDT_NV or DSDT8_NV and the format |
| is not DSDT_NV. |
| |
| The error INVALID_OPERATION is generated if the format is DSDT_MAG_NV |
| and the internalformat is not either DSDT_MAG_NV or DSDT8_MAG8_NV; |
| or if the internal format is either DSDT_MAG_NV or DSDT8_MAG8_NV |
| and the format is not DSDT_MAG_NV. |
| |
| The error INVALID_OPERATION is generated if the format |
| is DSDT_MAG_VIB_NV and the internalformat is not either |
| DSDT_MAG_INTENSITY_NV or DSDT8_MAG8_INTENSITY8_NV; or if the internal |
| format is either DSDT_MAG_INTENSITY_NV or DSDT8_MAG8_INTENSITY8_NV |
| and the format is not DSDT_MAG_VIB_NV." |
| |
| Change the first sentence of the sixth paragraph to read: |
| |
| "The internal component resolution is the number of bits allocated |
| to each value in a texture image (and includes the sign bit if the |
| component is signed)." |
| |
| Change the third sentence of the sixth paragraph to read: |
| |
| "If a sized internal format is specified, the mapping of the R, |
| G, B, A, HI, LO, DS, DT, and MAG values to texture components |
| is equivalent to the mapping of the corresponding base internal |
| format's components, as specified in table 3.15, and the memory |
| allocations per texture component is assigned by the GL to match |
| the allocations listed in table 3.16 as closely as possible." |
| |
| -- Section 3.8.2 "Alternate Texture Image Specification Commands" |
| |
| In the second paragraph (describing CopyTexImage2D), change the |
| third to the last sentence to: |
| |
| "Parameters level, internalformat, and border are specified using the |
| same values, with the same meanings, as the equivalent arguments of |
| TexImage2D, except that internalformat may not be specified as 1, 2, |
| 3, 4, HILO_NV, HILO16_NV, SIGNED_HILO_NV, SIGNED_HILO16_NV, DSDT_NV, |
| DSDT8_NV, DSDT_MAG_NV, DSDT8_MAG8_NV, DSDT_MAG_INTENSITY_NV, or |
| DSDT8_MAG8_INTENSITY8_NV." |
| |
| In the third paragraph (describing CopyTexImage1D), change the |
| second to the last sentence to: |
| |
| "level, internalformat, and border are specified using the same |
| values, with the same meanings, as the equivalent arguments of |
| TexImage1D, except that internalformat may not be specified as 1, 2, |
| 3, 4, HILO_NV, HILO16_NV, SIGNED_HILO_NV, SIGNED_HILO16_NV, DSDT_NV, |
| DSDT8_NV, DSDT_MAG_NV, DSDT8_MAG8_NV, DSDT_MAG_INTENSITY_NV, or |
| DSDT8_MAG8_INTENSITY8_NV." |
| |
| Insert the following text after the six paragraph reading: |
| |
| "CopyTexSubImage2D and CopyTexSubImage1D generate the error |
| INVALID_OPERATION if the internal format of the texture array to |
| which the pixels are to be copied is one of HILO_NV, HILO16_NV, |
| SIGNED_HILO_NV, SIGNED_HILO16_NV, DSDT_NV, DSDT8_NV, DSDT_MAG_NV, |
| DSDT8_MAG8_NV, DSDT_MAG_INTENSITY_NV, or DSDT8_MAG8_INTENSITY8_NV. |
| |
| TexSubImage2D and TexSubImage1D generate the error INVALID_OPERATION |
| if the internal format of the texture array to which the texels are |
| to be copied has a different format type (according to table 3.15) |
| than the format type of the texels being specified. Specifically, if |
| the base internal format is not one of HILO_NV, DSDT_NV, DSDT_MAG_NV, |
| or DSDT_INTENSITY_NV, then the format parameter must be one of |
| COLOR_INDEX, RED, GREEN, BLUE, ALPHA, RGB, RGBA, LUMINANCE, or |
| LUMINANCE_ALPHA; if the base internal format is HILO_NV, then the |
| format parameter must be HILO_NV; if the base internal format is |
| DSDT_NV, then the format parameter must be DSDT_NV; if the base |
| internal format is DSDT_MAG_NV, then the format parameter must be |
| DSDT_MAG_NV; if the base internal format is DSDT_MAG_INTENSITY_NV, |
| the format parameter must be DSDT_MAG_VIB_NV." |
| |
| -- Section 3.8.3 "Texture Parameters" |
| |
| Change the TEXTURE_BORDER_COLOR line in table 3.17 to read: |
| |
| Name Type Legal Values |
| ------------------------ -------- ------------ |
| TEXTURE_BORDER_VALUES 4 floats any value |
| |
| Add the last two sentences to read: |
| |
| "The TEXTURE_BORDER_VALUES state can also be specified with the |
| TEXTURE_BORDER_COLOR symbolic constant. When the state is specified |
| via TEXTURE_BORDER_COLOR, each of the four values specified are |
| first clamped to lie in [0,1]. However, if the texture border |
| values state is specified using TEXTURE_BORDER_VALUES, no clamping |
| occurs. In either case, if the values are specified as integers, |
| the conversion for signed integers from table 2.6 is applied to |
| convert the values to floating-point." |
| |
| -- Section 3.8.5 "Texture Minification" |
| |
| Change the last paragraph to read: |
| |
| "If any of the selected tauijk, tauij, or taui in the above equations |
| refer to a border texel with i < -bs, j < bs, k < -bs, i >= ws-bs, j |
| >= hs-bs, or k >= ds-bs, then the border values given by the current |
| setting of TEXTURE_BORDER_VALUES is used instead of the unspecified |
| value or values. If the texture contains color components, the |
| components of the TEXTURE_BORDER_VALUES vector 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 HILO components, |
| the first and second components of the TEXTURE_BORDER_VALUES vector |
| are interpreted as the hi and lo components respectively. If the |
| texture contains texture offset group components, the first, second, |
| third, and fourth components of the TEXTURE_BORDER_VALUES vector |
| are interpreted as ds, dt, mag, and vib components respectively. |
| Additionally, the texture border values are clamped appropriately |
| depending on the signedness of each particular component. Unsigned |
| components are clamped to [0,1]; signed components are clamped to |
| [-1,1]." |
| |
| -- Section 3.8.9 "Texture Environment and Texture Functions" |
| |
| Augment the list of supported texture functions in the first |
| paragraph to read: |
| |
| "TEXTURE_ENV_MODE may be set to one of REPLACE, MODULATE, DECAL, |
| BLEND, ADD, COMBINE_ARB (or COMBINE_EXT), COMBINE4_NV, or NONE;" |
| |
| Insert this paragraph between the first and second paragraphs: |
| |
| "When texture shaders are enabled (see section 3.8.13), a given |
| texture unit's texture shader result may be intended for use as |
| an input to another texture shader stage rather than generating |
| a texture unit RGBA result for use in the given texture unit's |
| texture environment function. Additionally, several texture shader |
| operations and texture format types are intended only to generate |
| texture shader results for subsequent texture shaders or perform a |
| side effect (such as culling the fragment or replacing the fragment's |
| depth value) rather than supplying a useful texture unit RGBA result |
| for use in the texture environment function. For this reason, |
| the NONE texture environment ignores the texture unit RGBA result |
| and passes through its input fragment color unchanged." |
| |
| Change the third sentence of the second paragraph to read: |
| |
| "If the TEXTURE_SHADER_NV mode is disabled, the precise form of |
| the texture environment function depends on the base internal |
| format of the texture object bound to the given texture unit's |
| highest-precedence enabled texture target. Otherwise if the |
| TEXTURE_SHADER_NV mode is enabled, then the form of the function |
| depends on the texture unit's texture shader operation. |
| |
| If a texture shader operation requires fetching a filtered |
| texture color value (though not a HILO or texture offset value; |
| see the subsequent HILO and texture offset discussion), the texture |
| environment function depends on the base internal format of the |
| texture shader operation's respective texture target used for |
| fetching by the texture shader operation. |
| |
| The PASS_THROUGH_NV texture shader operation does not fetch from any |
| texture target, but it generates an RGBA color and therefore always |
| operates as if the base internal format is RGBA for determining |
| what texture environment function to apply. |
| |
| If the TEXTURE_SHADER_NV mode is enabled and the texture shader |
| operation for a given texture unit is one of NONE, CULL_FRAGMENT_NV, |
| DOT_PRODUCT_NV, or DOT_PRODUCT_DEPTH_REPLACE_NV, then the given |
| texture unit's texture function always operates as if the texture |
| function is NONE. |
| |
| If the base internal format of the texture is HILO_NV, DSDT_NV, |
| or DSDT_MAG_NV (independent of whether or not the TEXTURE_SHADER_NV |
| mode is enabled or disabled), then corresponding the texture function |
| always operates as if the texture function is NONE. |
| |
| If the base internal format of the texture is DSDT_MAG_INTENSITY_NV |
| (independent of whether or not the TEXTURE_SHADER_NV mode is enabled |
| or disabled), then the corresponding texture function operates |
| as if the base internal format is INTENSITY for the purposes of |
| determining the appropriate function using the vibrance component |
| as the intensity value." |
| |
| Change the phrase in the fourth sentence of the second paragraph |
| describing how Rt, Gt, Bt, At, Lt, and It are assigned to: |
| |
| "when TEXTURE_SHADER_NV is disabled, Rt, Gt, Bt, At, Lt, and It are |
| the filtered texture values; when TEXTURE_SHADER_NV is enabled, Rt, |
| Gt, Bt, and At are the respective components of the texture unit |
| RGBA result of the texture unit's texture shader stage, and Lt and |
| It are any red, green, or blue component of the texture unit RGBA |
| result (the three components should be the same);" |
| |
| Change the second to last sentence of the second paragraph to read: |
| |
| "The initial primary color and texture environment color component |
| values are in the range [0,1]. The filtered texture color and |
| texture function result color component values are in the range |
| [-1,1]. Negative filtered texture color component values are |
| generated by texture internal formats with signed components such |
| as SIGNED_RGBA." |
| |
| Also amend tables 3.18 and 3.19 based on the following updated columns: |
| |
| Base DECAL BLEND ADD |
| Internal Format Texture Function Texture Function Texture Function |
| ================= ===================================== ===================================== ========================== |
| ALPHA Rv = Rf (no longer undefined) Rv = Rf Rv = Rf |
| Gv = Gf Gv = Gf Gv = Gf |
| Bv = Bf Bv = Bf Bv = Rf |
| Av = Af Av = Af*At Av = Af*Av = At |
| ----------------- ------------------------------------- ------------------------------------- -------------------------- |
| LUMINANCE Rv = Rf (no longer undefined) Rv = Rf*(1-max(0,Lt)) + Rc*max(0,Lt) Rv = max(-1,min(1,Rf+Lt)) |
| (or 1) Gv = Gf Gv = Gf*(1-max(0,Lt)) + Gc*max(0,Lt) Gv = max(-1,min(1,Gf+Lt)) |
| Bv = Bf Bv = Bf*(1-max(0,Lt)) + Bc*max(0,Lt) Bv = max(-1,min(1,Bf+Lt)) |
| Av = Af Av = Af Av = Af |
| ----------------- ------------------------------------- ------------------------------------- -------------------------- |
| LUMINANCE_ALPHA Rv = Rf (no longer undefined) Rv = Rf*(1-max(0,Lt)) + Rc*max(0,Lt) Rv = max(-1,min(1,Rf+Lt)) |
| (or 2) Gv = Gf Gv = Gf*(1-max(0,Lt)) + Gc*max(0,Lt) Gv = max(-1,min(1,Gf+Lt)) |
| Bv = Bf Bv = Bf*(1-max(0,Lt)) + Bc*max(0,Lt) Bv = max(-1,min(1,Bf+Lt)) |
| Av = Af Av = Af*At Av = Af*At |
| ----------------- ------------------------------------- ------------------------------------- -------------------------- |
| INTENSITY Rv = Rf (no longer undefined) Rv = Rf*(1-max(0,It)) + Rc*max(0,It) Rv = max(-1,min(1,Rf+It)) |
| Gv = Gf Gv = Gf*(1-max(0,It)) + Gc*max(0,It) Gv = max(-1,min(1,Gf+It)) |
| Bv = Bf Bv = Bf*(1-max(0,It)) + Bc*max(0,It) Bv = max(-1,min(1,Bf+It)) |
| Av = Af Av = Af*(1-max(0,It)) + Ac*max(0,It) Av = max(-1,min(1,Af+It)) |
| ----------------- ------------------------------------- ------------------------------------- -------------------------- |
| RGB Rv = Rt Rv = Rf*(1-max(0,Rt)) + Rc*max(0,Rt) Rv = max(-1,min(1,Rf+Rt)) |
| (or 3) Gv = Gt Gv = Gf*(1-max(0,Gt)) + Gc*max(0,Gt) Gv = max(-1,min(1,Gf+Gt)) |
| Bv = Bt Bv = Bf*(1-max(0,Bt)) + Bc*max(0,Bt) Bv = max(-1,min(1,Bf+Bt)) |
| Av = Af Av = Af Av = Af |
| ----------------- ------------------------------------- ------------------------------------- -------------------------- |
| RGBA Rv = Rf*(1-max(0,At)) + Rt*max(0,At) Rv = Rf*(1-max(0,Rt)) + Rc*max(0,Rt) Rv = max(-1,min(1,Rf+Rt)) |
| (or 4) Gv = Gf*(1-max(0,At)) + Gt*max(0,At) Gv = Gf*(1-max(0,Gt)) + Gc*max(0,Gt) Gv = max(-1,min(1,Gf+Gt)) |
| Bv = Bf*(1-max(0,At)) + Bt*max(0,At) Bv = Bf*(1-max(0,Bt)) + Bc*max(0,Bt) Bv = max(-1,min(1,Bf+Bt)) |
| Av = Af Av = Af*At Av = Af*At |
| ----------------- ------------------------------------- ------------------------------------- -------------------------- |
| |
| Also augment table 3.18 or 3.19 with the following column: |
| |
| Base NONE |
| Internal Format Texture Function |
| ================= ================ |
| ALPHA Rv = Rf |
| Gv = Gf |
| Bv = Bf |
| Av = Af |
| ----------------- ---------------- |
| LUMINANCE Rv = Rf |
| (or 1) Gv = Gf |
| Bv = Bf |
| Av = Af |
| ----------------- ---------------- |
| LUMINANCE_ALPHA Rv = Rf |
| (or 2) Gv = Gf |
| Bv = Bf |
| Av = Af |
| ----------------- ---------------- |
| INTENSITY Rv = Rf |
| Gv = Gf |
| Bv = Bf |
| Av = Af |
| ----------------- ---------------- |
| RGB Rv = Rf |
| (or 3) Gv = Gf |
| Bv = Bf |
| Av = Af |
| ----------------- ---------------- |
| RGBA Rv = Rf |
| (or 4) Gv = Gf |
| Bv = Bf |
| Av = Af |
| ----------------- ---------------- |
| |
| Amend tables 3.21 and 3.22 in the ARB_texture_env_combine |
| specification (or EXT_texture_env_combine specification) to require |
| inputs to be clamped positive (the TEXTURE<n>_ARB entries apply |
| only if NV_texture_env_combine4 is supported): |
| |
| SOURCE<n>_RGB_EXT OPERAND<n>_RGB_EXT Argument |
| ----------------- -------------- -------- |
| TEXTURE SRC_COLOR max(0,Ct) |
| ONE_MINUS_SRC_COLOR (1-max(0,Ct)) |
| SRC_ALPHA max(0,At) |
| ONE_MINUS_SRC_ALPHA (1-max(0,At)) |
| CONSTANT_EXT SRC_COLOR max(0,Cc |
| ONE_MINUS_SRC_COLOR (1-max(0,Cc) |
| SRC_ALPHA max(0,Ac |
| ONE_MINUS_SRC_ALPHA (1-max(0,Ac) |
| PRIMARY_COLOR_EXT SRC_COLOR max(0,Cf |
| ONE_MINUS_SRC_COLOR (1-max(0,Cf) |
| SRC_ALPHA max(0,Af |
| ONE_MINUS_SRC_ALPHA (1-max(0,Af) |
| PREVIOUS_EXT SRC_COLOR max(0,Cp |
| ONE_MINUS_SRC_COLOR (1-max(0,Cp) |
| SRC_ALPHA max(0,Ap |
| ONE_MINUS_SRC_ALPHA (1-max(0,Ap) |
| TEXTURE<n>_ARB SRC_COLOR max(0,Ct<n>) |
| ONE_MINUS_SRC_COLOR (1-max(0,Ct<n>)) |
| SRC_ALPHA max(0,At<n>) |
| ONE_MINUS_SRC_ALPHA (1-max(0,At<n>)) |
| |
| Table 3.21: Arguments for COMBINE_RGB_ARB (or COMBINE_RGB_EXT) |
| functions |
| |
| SOURCE<n>_ALPHA_EXT OPERAND<n>_ALPHA_EXT Argument |
| ----------------- -------------- -------- |
| TEXTURE SRC_ALPHA max(0,At) |
| ONE_MINUS_SRC_ALPHA (1-max(0,At)) |
| CONSTANT_EXT SRC_ALPHA max(0,Ac) |
| ONE_MINUS_SRC_ALPHA (1-max(0,Ac)) |
| PRIMARY_COLOR_EXT SRC_ALPHA max(0,Af) |
| ONE_MINUS_SRC_ALPHA (1-max(0,Af)) |
| PREVIOUS_EXT SRC_ALPHA max(0,Ap) |
| ONE_MINUS_SRC_ALPHA (1-max(0,Ap)) |
| TEXTURE<n>_ARB SRC_ALPHA max(0,At<n>) |
| ONE_MINUS_SRC_ALPHA (1-max(0,At<n>)) |
| |
| Table 3.22: Arguments for COMBINE_ALPHA_ARB (or COMBINE_ALPHA_EXT) |
| functions |
| |
| -- Section 3.9 "Color Sum" |
| |
| Update the first paragraph to read: |
| |
| "At the beginning of color sum, a fragment has two RGBA colors: a |
| primary color cpri (which texturing, if enabled, may have modified) |
| and a secondary color csec. The components of these two colors are |
| clamped to [0,1] and then summed to produce a single post-texturing |
| RGBA color c. The components of c are then clamped to the range |
| [0,1]." |
| |
| -- NEW Section 3.8.13 "Texture Shaders" |
| |
| "Each texture unit is configured with one of twenty-one |
| texture shader operations. Several texture shader operations |
| require additional state. All per-texture shader stage state |
| is specified using the TexEnv commands with the target specified |
| as TEXTURE_SHADER_NV. The per-texture shader state is replicated |
| per texture unit so the texture unit selected by ActiveTextureARB |
| determines which texture unit's environment is modified by TexEnv |
| calls. |
| |
| When calling TexEnv with a target of TEXTURE_SHADER_NV, |
| pname must be one of SHADER_OPERATION_NV, CULL_MODES_NV, |
| OFFSET_TEXTURE_MATRIX_NV, OFFSET_TEXTURE_SCALE_NV, |
| OFFSET_TEXTURE_BIAS_NV, PREVIOUS_TEXTURE_INPUT_NV, or CONST_EYE_NV. |
| |
| When TexEnv is called with the target of TEXTURE_SHADER_NV, |
| SHADER_OPERATION_NV may be set to one of NONE, |
| TEXTURE_1D, TEXTURE_2D, TEXTURE_CUBE_MAP_ARB, |
| PASS_THROUGH_NV, CULL_FRAGMENT_NV, OFFSET_TEXTURE_2D_NV, |
| OFFSET_TEXTURE_2D_SCALE_NV, OFFSET_TEXTURE_RECTANGLE_NV, |
| OFFSET_TEXTURE_RECTANGLE_SCALE_NV, DEPENDENT_AR_TEXTURE_2D_NV, |
| DEPENDENT_GB_TEXTURE_2D_NV, DOT_PRODUCT_NV, |
| DOT_PRODUCT_DEPTH_REPLACE_NV, DOT_PRODUCT_TEXTURE_2D_NV, |
| DOT_PRODUCT_TEXTURE_RECTANGLE_NV, DOT_PRODUCT_TEXTURE_CUBE_MAP_NV, |
| DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV, DOT_PRODUCT_REFLECT_CUBE_MAP_NV, or |
| DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV. The semantics of each of |
| these shader operations is described in section 3.8.13.1. Not every |
| operation is supported in every texture unit. The restrictions for |
| how these shader operations can be configured in various texture |
| units are described in section 3.8.13.2. |
| |
| When TexEnv is called with the target of TEXTURE_SHADER_NV, |
| CULL_MODES_NV is set to a vector of four cull comparisons by |
| providing four symbolic tokens, each being either LESS or GEQUAL. |
| These cull modes are used by the CULL_FRAGMENT_NV operation (see |
| section 3.8.13.1.7). |
| |
| When TexEnv is called with the target of TEXTURE_SHADER_NV, |
| RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV may be set to either |
| UNSIGNED_IDENTITY_NV or EXPAND_NORMAL_NV. This RGBA unsigned dot |
| product mapping mode is used by the DOT_PRODUCT_NV operation (see |
| section 3.8.13.1.14) and other operations that compute dot products. |
| |
| When TexEnv is called with the target of TEXTURE_SHADER_NV, |
| PREVIOUS_TEXTURE_INPUT_NV may be set to TEXTUREi_ARB where i is |
| between 0 and n-1 where n is the implementation-dependent number of |
| texture units supported. The INVALID_OPERATION error is generated |
| if i is greater than or equal to the current active texture unit. |
| |
| When TexEnv is called with the target of TEXTURE_SHADER_NV, |
| OFFSET_TEXTURE_MATRIX_NV may be set to a 2x2 matrix of floating-point |
| values stored in column-major order as 4 consecutive floating-point |
| values, i.e. as: |
| |
| [ a1 a3 ] |
| [ a2 a4 ] |
| |
| This matrix is used by the OFFSET_TEXTURE_2D_NV, |
| OFFSET_TEXTURE_2D_SCALE_NV, OFFSET_TEXTURE_RECTANGLE_NV, and |
| OFFSET_TEXTURE_RECTANGLE_SCALE_NV operations (see sections 3.8.13.1.8 |
| through 3.8.13.1.11). |
| |
| When TexEnv is called with the target of TEXTURE_SHADER_NV, |
| OFFSET_TEXTURE_SCALE_NV may be set to a floating-point value. |
| When TexEnv is called with the target of TEXTURE_SHADER_NV, |
| OFFSET_TEXTURE_BIAS_NV may be set to a floating-point value. These |
| scale and bias values are used by the OFFSET_TEXTURE_2D_SCALE_NV |
| and OFFSET_TEXTURE_RECTANGLE_SCALE_NV operations (see section |
| 3.8.13.1.9 and 3.8.13.1.11). |
| |
| When TexEnv is called with the target of TEXTURE_SHADER_NV, |
| CONST_EYE_NV is set to a vector of three floating-point |
| values used as the constant eye vector in the |
| DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV texture shader (see |
| section 3.8.13.1.19). |
| |
| 3.8.13.1 Texture Shader Operations |
| |
| The texture enables described in section 3.8.10 only affect |
| conventional texturing mode; these enables are ignored when |
| TEXTURE_SHADER_NV is enabled. Instead, the texture shader operation |
| determines how texture coordinates are mapped to filtered texture |
| values. |
| |
| Tables 3.A, 3.B, 3.C, and 3.D specify inter-stage dependencies, |
| texture target dependencies, relevant inputs, and result types and |
| values respectively for each texture shader operation. Table 3.E |
| specifies how the components of an accessed texture are mapped to |
| the components of the texture unit RGBA result based on the base |
| internal format of the accessed texture. The following discussion |
| describes each possible texture shader operation in detail. |
| |
| texture shader |
| texture shader operation i previous texture input texture shader operation i-1 operation i-2 texture shader operation i+1 |
| ================================= ========================= =============================== ================ ================================ |
| NONE - - - - |
| --------------------------------- ------------------------- ------------------------------- ---------------- -------------------------------- |
| TEXTURE_1D - - - - |
| TEXTURE_2D - - - - |
| TEXTURE_RECTANGLE_NV - - - - |
| TEXTURE_CUBE_MAP_ARB - - - - |
| --------------------------------- ------------------------- ------------------------------- ---------------- -------------------------------- |
| PASS_THROUGH_NV - - - - |
| CULL_FRAGMENT_NV - - - - |
| --------------------------------- ------------------------- ------------------------------- ---------------- -------------------------------- |
| OFFSET_TEXTURE_2D_NV base internal texture - - - |
| format must be one of |
| DSDT_NV, DSDT_MAG_NV, or |
| DSDT_MAG_INTENSITY_NV |
| OFFSET_TEXTURE_2D_SCALE_NV base internal texture - - - |
| format must be either |
| DSDT_MAG_NV or |
| DSDT_MAG_INTENSITY_NV |
| OFFSET_TEXTURE_RECTANGLE_NV base internal texture - - - |
| format must be one of |
| DSDT_NV, DSDT_MAG_NV, or |
| DSDT_MAG_INTENSITY_NV |
| OFFSET_TEXTURE_RECTANGLE_SCALE_NV base internal texture - - - |
| format must be either |
| DSDT_MAG_NV or |
| DSDT_MAG_INTENSITY_NV |
| --------------------------------- ------------------------- ------------------------------- ---------------- -------------------------------- |
| DEPENDENT_AR_TEXTURE_2D_NV shader result type must - - - |
| all be unsigned RGBA |
| DEPENDENT_GB_TEXTURE_2D_NV shader result type must - - - |
| all be unsigned RGBA |
| --------------------------------- ------------------------- ------------------------------- ---------------- -------------------------------- |
| DOT_PRODUCT_NV shader result type must - - - |
| be one of signed HILO, |
| unsigned HILO, all |
| signed RGBA, or all |
| unsigned RGBA |
| DOT_PRODUCT_TEXTURE_2D_NV shader result type must shader operation must be - - |
| be one of signed HILO, DOT_PRODUCT_NV |
| unsigned HILO, all |
| signed RGBA, or all |
| unsigned RGBA |
| DOT_PRODUCT_TEXTURE_RECTANGLE_NV shader result type must shader operation must be - - |
| be one of signed HILO, DOT_PRODUCT_NV |
| unsigned HILO, all |
| signed RGBA, all |
| unsigned RGBA |
| DOT_PRODUCT_TEXTURE_CUBE_MAP_NV shader result type must shader operation shader operation - |
| be one of signed HILO, must be must be |
| unsigned HILO, all DOT_PRODUCT_NV DOT_PRODUCT_NV |
| signed RGBA, or all |
| unsigned RGBA |
| DOT_PRODUCT_REFLECT_CUBE_MAP_NV shader result type must shader operation must be shader operation - |
| be one of signed HILO, DOT_PRODUCT_NV or must be |
| unsigned HILO, all DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV DOT_PRODUCT_NV |
| signed RGBA, or all |
| unsigned RGBA; previous |
| texture input must not |
| be unit i-1 |
| DOT_PRODUCT_CONST_EYE_- shader result type must shader operation shader operation - |
| REFLECT_CUBE_MAP_NV be one of signed HILO, must be must be |
| unsigned HILO, all DOT_PRODUCT_NV or DOT_PRODUCT_NV |
| signed RGBA, or all DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV |
| unsigned RGBA |
| DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV shader result type must shader operation must be - shader operation must be |
| be one of signed HILO, DOT_PRODUCT_NV DOT_PRODUCT_REFLECT_CUBE_MAP_NV |
| unsigned HILO, all or DOT_PRODUCT_CONST_EYE_- |
| signed RGBA, or all REFLECT_CUBE_MAP_NV |
| unsigned RGBA |
| --------------------------------- ------------------------- ------------------------------- ---------------- -------------------------------- |
| DOT_PRODUCT_DEPTH_REPLACE_NV shader result type must shader operation - - |
| be one of signed HILO, must be |
| unsigned HILO, all DOT_PRODUCT_NV |
| signed RGBA, or all |
| unsigned RGBA |
| --------------------------------- ------------------------- ------------------------------- ---------------- -------------------------------- |
| |
| Table 3.A: Texture shader inter-stage dependencies for each operation. |
| If any one of the dependencies listed above is not met, the texture |
| shader stage is considered inconsistent. Further texture shader target |
| dependencies are listed in table X.Y. Additionally, if any one of the |
| texture shader stages that a particular texture shader stage depends on is |
| inconsistent, then the dependent texture shader stage is also considered |
| inconsistent. When a texture shader stage is considered inconsistent, |
| the inconsistent stage operates as if the stage's operation is NONE. |
| |
| texture shader operation i texture unit i |
| ================================= ======================================= |
| NONE - |
| --------------------------------- --------------------------------------- |
| TEXTURE_1D 1D target must be consistent |
| TEXTURE_2D 2D target must be consistent |
| TEXTURE_RECTANGLE_NV rectangle target must be consistent |
| TEXTURE_CUBE_MAP_ARB cube map target must be consistent |
| --------------------------------- --------------------------------------- |
| PASS_THROUGH_NV - |
| CULL_FRAGMENT_NV - |
| --------------------------------- --------------------------------------- |
| OFFSET_TEXTURE_2D_NV 2D target must be consistent |
| OFFSET_TEXTURE_2D_SCALE_NV 2D target must be consistent |
| and 2D texture target type must |
| be unsigned RGBA |
| OFFSET_TEXTURE_RECTANGLE_NV rectangle target must be consistent |
| OFFSET_TEXTURE_RECTANGLE_SCALE_NV rectangle target must be consistent |
| and rectangle texture target type must |
| be unsigned RGBA |
| --------------------------------- --------------------------------------- |
| DEPENDENT_AR_TEXTURE_2D_NV 2D target must be consistent |
| DEPENDENT_GB_TEXTURE_2D_NV 2D target must be consistent |
| --------------------------------- --------------------------------------- |
| DOT_PRODUCT_NV - |
| DOT_PRODUCT_TEXTURE_2D_NV 2D target must be consistent |
| DOT_PRODUCT_TEXTURE_RECTANGLE_NV rectangle target must be consistent |
| DOT_PRODUCT_TEXTURE_CUBE_MAP_NV cube map target must be consistent |
| DOT_PRODUCT_REFLECT_CUBE_MAP_NV cube map target must be consistent |
| DOT_PRODUCT_CONST_EYE_- cube map target must be consistent |
| REFLECT_CUBE_MAP_NV |
| DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV cube map target must be consistent |
| --------------------------------- --------------------------------------- |
| DOT_PRODUCT_DEPTH_REPLACE_NV - |
| --------------------------------- --------------------------------------- |
| |
| Table 3.B: Texture shader target dependencies for each operation. |
| If the dependency listed above is not met, the texture shader stage is |
| considered inconsistent. |
| |
| uses uses uses uses uses offset uses |
| texture stage stage stage previous uses offset texture const |
| coordinate texture result result result texture cull texture 2D scale eye |
| texture shader operation i set usage target i-1 i-2 i+1 input modes 2D matrix and bias vector |
| ================================= ========== ========= ====== ====== ====== ======== ===== ========= ======== ====== |
| NONE - - - - - - - - - - |
| --------------------------------- ---------- --------- ------ ------ ------ -------- ----- --------- -------- ------ |
| TEXTURE_1D s,q 1D - - - - - - - - |
| TEXTURE_2D s,t,q 2D - - - - - - - - |
| TEXTURE_RECTANGLE_NV s,t,q rectangle - - - - - - - - |
| TEXTURE_CUBE_MAP_ARB s,t,r cube map - - - - - - - - |
| --------------------------------- ---------- --------- ------ ------ ------ -------- ----- --------- -------- ------ |
| PASS_THROUGH_NV s,t,r,q - - - - - - - - - |
| CULL_FRAGMENT_NV s,t,r,q - - - - - y - - - |
| --------------------------------- ---------- --------- ------ ------ ------ -------- ----- --------- -------- ------ |
| OFFSET_TEXTURE_2D_NV s,t 2D - - - y - y - - |
| OFFSET_TEXTURE_2D_SCALE_NV s,t 2D - - - y - y y - |
| OFFSET_TEXTURE_RECTANGLE_NV s,t rectangle - - - y - y - - |
| OFFSET_TEXTURE_RECTANGLE_SCALE_NV s,t rectangle - - - y - y y - |
| --------------------------------- ---------- --------- ------ ------ ------ -------- ----- --------- -------- ------ |
| DEPENDENT_AR_TEXTURE_2D_NV - 2D - - - y - - - - |
| DEPENDENT_GB_TEXTURE_2D_NV - 2D - - - y - - - - |
| --------------------------------- ---------- --------- ------ ------ ------ -------- ----- --------- -------- ------ |
| DOT_PRODUCT_NV s,t,r (q*) - - - - y - - - - |
| DOT_PRODUCT_TEXTURE_2D_NV s,t,r 2D y - - y - - - - |
| DOT_PRODUCT_TEXTURE_RECTANGLE_NV s,t,r rectangle y - - y - - - - |
| DOT_PRODUCT_TEXTURE_CUBE_MAP_NV s,t,r cube map y y - y - - - - |
| DOT_PRODUCT_REFLECT_CUBE_MAP_NV s,t,r,q cube map y y - y - - - - |
| DOT_PRODUCT_CONST_EYE_- s,t,r cube map y y - y - - - y |
| REFLECT_CUBE_MAP_NV |
| DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV s,t,r (q*) cube map y y y y - - - - |
| --------------------------------- ---------- --------- ------ ------ ------ -------- ----- --------- -------- ------ |
| DOT_PRODUCT_DEPTH_REPLACE_NV s,t,r - y - - y - - - - |
| --------------------------------- ---------- --------- ------ ------ ------ -------- ----- --------- -------- ------ |
| |
| Table 3.C: Relevant texture shader computation inputs for each |
| operation. The (q*) for the texture coordinate set usage indicates |
| that the q texture coordinate is used only when the DOT_PRODUCT_NV and |
| DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV operations are used in conjunction with |
| DOT_PRODUCT_REFLECT_CUBE_MAP_NV. |
| |
| texture shader operation i shader stage result type shader stage result texture unit RGBA color result |
| ================================= ============================= =================================== ====================================== |
| NONE unsigned RGBA invalid (0,0,0,0) |
| --------------------------------- ----------------------------- ----------------------------------- -------------------------------------- |
| TEXTURE_1D matches 1D target type filtered 1D target texel if 1D target texture type is RGBA, |
| filtered 1D target texel, |
| else (0,0,0,0) |
| TEXTURE_2D matches 2D target type filtered 2D target texel if 2D target texture type is RGBA, |
| filtered 2D target texel, |
| else (0,0,0,0) |
| TEXTURE_RECTANGLE_NV matches rectangle target type filtered rectangle target texel if rectangle target texture type is |
| RGBA, filtered rectangle target |
| texel, else (0,0,0,0) |
| TEXTURE_CUBE_MAP_ARB matches cube map target type filtered cube map target texel if cube map target texture type is |
| RGBA, filtered cube map target |
| texel, else (0,0,0,0) |
| --------------------------------- ----------------------------- ----------------------------------- -------------------------------------- |
| PASS_THROUGH_NV unsigned RGBA (max(0,min(1,s)), max(0,min(1,t)), (max(0,min(1,s)), max(0,min(1,t)), |
| max(0,min(1,r)), max(0,min(1,q))) max(0,min(1,r)), max(0,min(1,q))) |
| CULL_FRAGMENT_NV unsigned RGBA invalid (0,0,0,0) |
| --------------------------------- ----------------------------- ----------------------------------- -------------------------------------- |
| OFFSET_TEXTURE_2D_NV matches 2D target type filtered 2D target texel if 2D target texture type is RGBA, |
| filtered 2D target texel, |
| else (0,0,0,0) |
| OFFSET_TEXTURE_2D_SCALE_NV unsigned RGBA filtered 2D target texel scaled filtered 2D target texel |
| OFFSET_TEXTURE_RECTANGLE_NV matches rectangle target type filtered rectangle target texel if rectangle target texture type is |
| RGBA, filtered rectangle target |
| texel, else (0,0,0,0) |
| OFFSET_TEXTURE_RECTANGLE_SCALE_NV unsigned RGBA filtered rectangle target texel scaled filtered rectangle target texel |
| --------------------------------- ----------------------------- ----------------------------------- -------------------------------------- |
| DEPENDENT_AR_TEXTURE_2D_NV matches 2D target type filtered 2D target texel if 2D target texture type is RGBA, |
| filtered 2D target texel, |
| else (0,0,0,0) |
| DEPENDENT_GB_TEXTURE_2D_NV matches 2D target type filtered 2D target texel if 2D target texture type is RGBA, |
| filtered 2D target texel, |
| else (0,0,0,0) |
| --------------------------------- ----------------------------- ----------------------------------- -------------------------------------- |
| DOT_PRODUCT_NV float dot product (0,0,0,0) |
| DOT_PRODUCT_TEXTURE_2D_NV matches 2D target type filtered 2D target texel if 2D target texture type is RGBA, |
| filtered 2D target texel, |
| else (0,0,0,0) |
| DOT_PRODUCT_TEXTURE_RECTANGLE_NV matches rectangle target type filtered rectangle target texel if rectangle target texture type is |
| RGBA, filtered rectangle target |
| texel, else (0,0,0,0) |
| DOT_PRODUCT_TEXTURE_CUBE_MAP_NV matches cube map target type filtered cube map target texel if cube map target texture type is |
| RGBA, filtered cube map target |
| texel, else (0,0,0,0) |
| DOT_PRODUCT_REFLECT_CUBE_MAP_NV matches cube map target type filtered cube map target texel if cube map target texture type is |
| RGBA, filtered cube map target |
| texel, else (0,0,0,0) |
| DOT_PRODUCT_CONST_EYE_- matches cube map target type filtered cube map target texel if cube map target texture type is |
| REFLECT_CUBE_MAP_NV RGBA, filtered cube map target |
| texel, else (0,0,0,0) |
| DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV matches cube map target type filtered cube map target texel if cube map target texture type is |
| RGBA, filtered cube map target |
| texel, else (0,0,0,0) |
| ------------------------------- ----------------------------- ----------------------------------- -------------------------------------- |
| DOT_PRODUCT_DEPTH_REPLACE_NV unsigned RGBA invalid (0,0,0,0) |
| ------------------------------- ----------------------------- ----------------------------------- -------------------------------------- |
| |
| Table 3.D: Texture shader stage results for each operation. |
| |
| Base internal format Red Green Blue Alpha |
| -------------------- --- ----- ---- ----- |
| ALPHA 1 1 1 At |
| LUMINANCE Lt Lt Lt 1 |
| INTENSITY It It It It |
| LUMINANCE_ALPHA Lt Lt Lt At |
| RGB Rt Gt Bt 1 |
| RGBA Rt Gt Bt At |
| |
| Table 3.E: How base internal formats components are mapped to RGBA values |
| for texture shaders (note that the mapping for ALPHA is different from |
| the mapping in Table 3.23 in the EXT_texture_env_combine extension). |
| |
| 3.8.13.1.1 None |
| |
| The NONE texture shader operation ignores the texture unit's texture |
| coordinate set and always generates the texture unit RGBA result |
| (0,0,0,0) for its filtered texel value. The texture shader result |
| is invalid. This texture shader stage is always consistent. |
| |
| When a texture unit is not needed while texture shaders are enabled, |
| it is most efficient to set the texture unit's texture shader |
| operation to NONE. |
| |
| 3.8.13.1.2 1D Projective Texturing |
| |
| The TEXTURE_1D texture shader operation accesses the texture unit's |
| 1D texture object (as described in sections 3.8.4, 3.8.5, and 3.8.6) |
| using (s/q) for the 1D texture coordinate where s and q are the |
| homogeneous texture coordinates for the texture unit. The result |
| of the texture access becomes both the shader result and texture |
| unit RGBA result (see table 3.E). The type of the shader result |
| depends on the format type of the accessed texture. This mode is |
| equivalent to conventional texturing's 1D texture target. |
| |
| If the texture unit's 1D texture object is not consistent, then |
| this texture shader stage is not consistent. |
| |
| If this texture shader stage is not consistent, it operates as if |
| it is the NONE operation. |
| |
| 3.8.13.1.3 2D Projective Texturing |
| |
| The TEXTURE_2D texture shader operation accesses the texture unit's |
| 2D texture object (as described in sections 3.8.4, 3.8.5, and |
| 3.8.6) using (s/q,t/q) for the 2D texture coordinates where s, t, |
| and q are the homogeneous texture coordinates for the texture unit. |
| The result of the texture access becomes both the shader result and |
| texture unit RGBA result (see table 3.E). The type of the shader |
| result depends on the format type of the accessed texture. This mode |
| is equivalent to conventional texturing's 2D texture target. |
| |
| If the texture unit's 2D texture object is not consistent, then |
| this texture shader stage is not consistent. |
| |
| If this texture shader stage is not consistent, it operates as if |
| it is the NONE operation. |
| |
| 3.8.13.1.4 Rectangle Projective Texturing |
| |
| The TEXTURE_RECTANGLE_NV texture shader operation accesses |
| the texture unit's rectangle texture object (as described in |
| sections 3.8.4, 3.8.5, and 3.8.6) using (s/q,t/q) for the 2D texture |
| coordinates where s, t, and q are the homogeneous texture coordinates |
| for the texture unit. The result of the texture access becomes both |
| the shader result and texture unit RGBA result (see table 3.E). |
| The type of the shader result depends on the format type of the |
| accessed texture. This mode is equivalent to NV_texture_rectangle's |
| rectangle texture target. |
| |
| If the texture unit's rectangle texture object is not consistent, |
| then this texture shader stage is not consistent. |
| |
| If this texture shader stage is not consistent, it operates as if |
| it is the NONE operation. |
| |
| 3.8.13.1.5 Cube Map Texturing |
| |
| The TEXTURE_CUBE_MAP_ARB texture shader operation accesses |
| the texture unit's cube map texture object (as described in the |
| ARB_texture_cube_map specification) using (s,t,r) for the 3D texture |
| coordinate where s, t, and r are the homogeneous texture coordinates |
| for the texture unit. The result of the texture access becomes |
| both the shader result and texture unit RGBA result (see table |
| 3.E). The type of the shader result depends on the format type |
| of the accessed texture. This mode is equivalent to conventional |
| texturing's cube map texture target. |
| |
| If the texture unit's cube map texture object is not consistent, then |
| this texture shader stage is not consistent. |
| |
| If this texture shader stage is not consistent, it operates as if |
| it is the NONE operation. |
| |
| 3.8.13.1.6 Pass Through |
| |
| The PASS_THROUGH_NV texture shader operation converts an (s,t,r,q) |
| texture coordinate set into an RGBA color result (r,g,b,a). |
| Each texture coordinate is first clamped to [0,1] before being |
| mapped to its corresponding color component. The texture shader |
| result and texture unit RGBA result of this operation are both |
| assigned the clamped RGBA color result. |
| |
| This operation in no way depends on any of the texture unit's |
| texture objects. |
| |
| 3.8.13.1.7 Cull Fragment |
| |
| The CULL_FRAGMENT_NV texture shader operation compares each |
| component of the texture coordinate set (s,t,r,q) to zero based |
| on the texture shader's corresponding cull mode. For the LESS |
| cull mode to succeed, the corresponding component must be less |
| than zero; otherwise the comparison fails. For the GEQUAL cull |
| mode to succeed, the corresponding component must be greater or |
| equal to zero; otherwise the comparison fails. If any of the four |
| comparisons fails, the fragment is discarded. |
| |
| The texture unit RGBA result generated is always (0,0,0,0). |
| The texture shader result is invalid. This texture shader stage |
| is always consistent. |
| |
| This operation in no way depends on any of the texture unit's |
| texture objects. |
| |
| 3.8.13.1.8 Offset Texture 2D |
| |
| The OFFSET_TEXTURE_2D_NV texture shader operation uses the |
| transformed result of a previous texture shader stage to perturb |
| the current texture shader stage's (s,t) texture coordinates |
| (without a projective division by q). The resulting perturbed |
| texture coordinates (s',t') are used to access the texture unit's 2D |
| texture object (as described in sections 3.8.4, 3.8.5, and 3.8.6). |
| |
| The result of the texture access becomes both the shader result and |
| texture unit RGBA result (see table 3.E). The type of the shader |
| result depends on the format type of the accessed texture. |
| |
| The perturbed texture coordinates s' and t' are computed with |
| floating-point math as follows: |
| |
| s' = s + a1 * DSprev + a3 * DTprev |
| t' = t + a2 * DSprev + a4 * DTprev |
| |
| where a1, a2, a3, and a4 are the texture shader stage's |
| OFFSET_TEXTURE_MATRIX_NV values, and DSprev and DTprev are the |
| (signed) DS and DT components of a previous texture shader unit's |
| texture shader result specified by the current texture shader |
| stage's PREVIOUS_TEXTURE_INPUT_NV value. |
| |
| If the texture unit's 2D texture object is not consistent, then |
| this texture shader stage is not consistent. |
| |
| If the previous texture input texture object specified by the |
| current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| has a base internalformat that is not one of DSDT_NV, DSDT_MAG_NV |
| or DSDT_MAG_INTENSITY_NV, then this texture shader stage is not |
| consistent. |
| |
| If the previous texture input texture shader operation specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is DOT_PRODUCT_NV, then this texture shader stage is not consistent. |
| |
| If the previous texture input texture shader result specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is invalid, then this texture shader stage is not consistent. |
| |
| If the previous texture input shader stage specified by the current |
| texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value is not |
| consistent, then this texture shader stage is not consistent. |
| |
| If this texture shader stage is not consistent, it operates as if |
| it is the NONE operation. |
| |
| 3.8.13.1.9 Offset Texture 2D and Scale |
| |
| The OFFSET_TEXTURE_2D_SCALE_NV texture shader operation extends the |
| functionality of the OFFSET_TEXTURE_2D_NV texture shader operation. |
| The texture unit's 2D texture object is accessed by the same |
| perturbed s' and t' coordinates used by the OFFSET_TEXTURE_2D_NV |
| operation. The red, green, and blue components (but not alpha) |
| of the RGBA result of the texture access are further scaled by |
| the value Scale and clamped to the range [0,1]. This RGBA result |
| is this shader's texture unit RGBA result. This shader's texture |
| shader result is the RGBA result of the texture access prior to |
| scaling and clamping. |
| |
| Scale is computed with floating-point math as follows: |
| |
| Scale = max(0.0, min(1.0, textureOffsetBias + textureOffsetScale * MAGprev)) |
| |
| where textureOffsetBias is the texture shader stage's |
| OFFSET_TEXTURE_BIAS_NV value, textureOffsetScale is the texture |
| shader stage's OFFSET_TEXTURE_SCALE_NV value, and MAGprev |
| is the magnitude component of the a previous texture shader |
| unit's result specified by the current texture shader stage's |
| PREVIOUS_TEXTURE_INPUT_NV value. |
| |
| The texture unit RGBA result (red',green',blue',alpha') is computed |
| as follows: |
| |
| red' = Scale * red |
| green' = Scale * green |
| blue' = Scale * blue |
| alpha' = alpha |
| |
| where red, green, blue, and alpha are the texture access components. |
| |
| If the unit's 2D texture object has any signed components, then this |
| texture shader stage is not consistent. |
| |
| If the texture unit's 2D texture object is has a format type other |
| than RGBA (the DSDT_MAG_INTENSITY_NV base internal format does not |
| count as an RGBA format type in this context), then this texture |
| shader stage is not consistent. |
| |
| If the texture unit's 2D texture object is not consistent, then |
| this texture shader stage is not consistent. |
| |
| If the previous texture input texture object specified by the |
| current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| has a base internalformat that is not either DSDT_MAG_NV |
| or DSDT_MAG_INTENSITY_NV, then this texture shader stage is not |
| consistent. |
| |
| If the previous texture input texture shader operation specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is DOT_PRODUCT_NV, then this texture shader stage is not consistent. |
| |
| If the previous texture input texture shader result specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is invalid, then this texture shader stage is not consistent. |
| |
| If the previous texture input shader stage specified by the current |
| texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value is not |
| consistent, then this texture shader stage is not consistent. |
| |
| If this texture shader stage is not consistent, it operates as if |
| it is the NONE operation. |
| |
| 3.8.13.1.10 Offset Texture Rectangle |
| |
| The OFFSET_TEXTURE_RECTANGLE_NV shader operation operates |
| identically to the OFFSET_TEXTURE_2D_NV shader operation except |
| that the rectangle texture target is accessed rather than the 2D |
| texture target. |
| |
| If the texture unit's rectangle texture object (rather than the 2D |
| texture object) is not consistent, then this texture shader stage |
| is not consistent. |
| |
| 3.8.13.1.11 Offset Texture Rectangle Scale |
| |
| The OFFSET_TEXTURE_RECTANGLE_SCALE_NV shader operation operates |
| identically to the OFFSET_TEXTURE_2D_SCALE_NV shader operation |
| except that the rectangle texture target is accessed rather than |
| the 2D texture target. |
| |
| If the texture unit's rectangle texture object (rather than the 2D |
| texture object) is not consistent, then this texture shader stage |
| is not consistent. |
| |
| 3.8.13.1.12 Dependent Alpha-Red Texturing |
| |
| The DEPENDENT_AR_TEXTURE_2D_NV texture shader operation accesses |
| the texture unit's 2D texture object (as described in section 3.8.4, |
| 3.8.5, and 3.8.6) using (Aprev, Rprev) for the 2D texture coordinates |
| where Aprev and Rprev are the are the alpha and red components of |
| a previous texture input's RGBA texture shader result specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value. |
| The result of the texture access becomes both the shader result and |
| texture unit RGBA result (see table 3.E). The type of the shader |
| result depends on the format type of the accessed texture. |
| |
| If the texture unit's 2D texture object is not consistent, then |
| this texture shader stage is not consistent. |
| |
| If the previous texture input's texture shader result specified |
| by the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV |
| value has a texture shader result type other than RGBA (the |
| DSDT_MAG_INTENSITY_NV base internal format does not count as an |
| RGBA format type in this context), then this texture shader stage |
| is not consistent. |
| |
| If the previous texture input's texture shader result specified |
| by the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV |
| value has a texture shader result type of RGBA but any of the |
| RGBA components are signed, then this texture shader stage is not |
| consistent. |
| |
| If the previous texture input texture shader operation specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is DOT_PRODUCT_NV, then this texture shader stage is not consistent. |
| |
| If the previous texture input texture shader result specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is invalid, then this texture shader stage is not consistent. |
| |
| If the previous texture input shader stage specified by the current |
| texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value is not |
| consistent, then this texture shader stage is not consistent. |
| |
| If this texture shader stage is not consistent, it operates as if |
| it is the NONE operation. |
| |
| 3.8.13.1.13 Dependent Green-Blue Texturing |
| |
| The DEPENDENT_GB_TEXTURE_2D_NV texture shader operation accesses |
| the texture unit's 2D texture object (as described in section 3.8.4, |
| 3.8.5, and 3.8.6) using (Gprev, Bprev) for the 2D texture coordinates |
| where Gprev and Bprev are the are the green and blue components |
| of a previous texture input's RGBA texture shader result specified by the |
| current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value. |
| The result of the texture access becomes both the shader result and |
| texture unit RGBA result (see table 3.E). The type of the shader |
| result depends on the format type of the accessed texture. |
| |
| If the texture unit's 2D texture object is not consistent, then |
| this texture shader stage is not consistent. |
| |
| If the previous texture input's texture shader result specified |
| by the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV |
| value has a texture shader result type other than RGBA (the |
| DSDT_MAG_INTENSITY_NV base internal format does not count as an |
| RGBA format type in this context), then this texture shader stage |
| is not consistent. |
| |
| If the previous texture input's texture shader result specified |
| by the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV |
| value has a texture shader result type of RGBA but any of the |
| RGBA components are signed, then this texture shader stage is not |
| consistent. |
| |
| If the previous texture input texture shader operation specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is DOT_PRODUCT_NV, then this texture shader stage is not consistent. |
| |
| If the previous texture input texture shader result specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is invalid, then this texture shader stage is not consistent. |
| |
| If the previous texture input shader stage specified by the current |
| texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value is not |
| consistent, then this texture shader stage is not consistent. |
| |
| If this texture shader stage is not consistent, it operates as if |
| it is the NONE operation. |
| |
| 3.8.13.1.14 Dot Product |
| |
| The DOT_PRODUCT_NV texture shader operation computes a |
| floating-point texture shader result. The texture shader result |
| is the floating-point dot product of the texture unit's (s,t,r) |
| texture coordinates and a remapped version of the RGBA or HILO |
| texture shader result from a specified previous texture shader stage. |
| The RGBA color result of this shader is always (0,0,0,0). |
| |
| The re-mapping depends on the specified previous texture shader |
| stage's texture shader result type. Specifically, the re-mapping |
| depends on whether this texture shader result type has all signed |
| components or all unsigned components, and whether it has RGBA |
| components or HILO components, and, in the case of unsigned RGBA |
| texture shader results, the RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV |
| state. |
| |
| If the specified previous texture unit's texture shader result |
| type is HILO and all the type components are unsigned, then the |
| floating-point result is computed by |
| |
| result = s * HI + t * LO + r |
| |
| where HI and LO are the (unsigned) hi and lo components respectively |
| of the previous texture unit's HILO texture shader result. |
| |
| If the specified previous texture unit's texture shader result |
| type is HILO and all the type components are signed, then the |
| floating-point result is computed by |
| |
| result = s * HI + t * LO + r * sqrt(max(0, 1.0 - HI*HI - LO*LO)) |
| |
| where HI and LO are the (signed) hi and lo components respectively |
| of the previous texture unit's texture shader result. |
| |
| If the specified previous texture unit's texture shader result |
| contains only signed RGBA components, then the floating-point result |
| is computed by |
| |
| result = s * Rprev + t * Gprev + r * Bprev |
| |
| where Rprev, Gprev, and Bprev are the (signed) red, green, and blue |
| components respectively of the previous texture unit's RGBA texture |
| shader result. |
| |
| If the specified previous texture unit's texture shader result |
| contains only unsigned RGBA components, then the dot product |
| computation depends on the RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV |
| state. When the RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV is |
| UNSIGNED_IDENTITY_NV, then the floating-point result for unsigned |
| RGBA components is computed by |
| |
| result = s * Rprev + t * Gprev + r * Bprev |
| |
| where Rprev, Gprev, and Bprev are the (unsigned) red, green, and |
| blue components respectively of the previous texture unit's RGBA |
| texture shader result. |
| |
| When the RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV is EXPAND_NORMAL_NV, |
| then the floating-point result for unsigned RGBA components is |
| computed by |
| |
| result = s * (2.0*Rprev-1.0) + t * (2.0*Gprev-1.0) + r * (2.0*Bprev-1.0) |
| |
| where Rprev, Gprev, and Bprev are the (unsigned) red, green, and |
| blue components respectively of the previous texture unit's RGBA |
| texture shader result. |
| |
| If the previous texture input texture object specified by the |
| current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value has |
| a format type other than RGBA or HILO (the DSDT_MAG_INTENSITY_NV |
| base internal format does not count as an RGBA format type in this |
| context), then this texture shader stage is not consistent. |
| |
| If the components of the previous texture input texture |
| object specified by the current texture shader stage's |
| PREVIOUS_TEXTURE_INPUT_NV value have mixed signedness, then |
| this texture shader stage is not consistent. For example, |
| the SIGNED_RGB_UNSIGNED_ALPHA_NV base internal format has mixed |
| signedness. |
| |
| If the previous texture input texture shader operation specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is DOT_PRODUCT_NV, then this texture shader stage is not consistent. |
| |
| If the previous texture input texture shader result specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is invalid, then this texture shader stage is not consistent. |
| |
| If the previous texture input shader stage specified by the current |
| texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value is not |
| consistent, then this texture shader stage is not consistent. |
| |
| If this texture shader stage is not consistent, it operates as if |
| it is the NONE operation. |
| |
| This operation in no way depends on any of the texture unit's |
| texture objects. |
| |
| 3.8.13.1.15 Dot Product Texture 2D |
| |
| The DOT_PRODUCT_TEXTURE_2D_NV texture shader operation accesses the |
| texture unit's 2D texture object (as described in sections 3.8.4, |
| 3.8.5, and 3.8.6) using (dotP,dotC) for the 2D texture coordinates. |
| The result of the texture access becomes both the shader result and |
| texture unit RGBA result (see table 3.E). The type of the shader |
| result depends on the format type of the accessed texture. |
| |
| Assuming that i is the current texture shader stage, dotP is the |
| floating-point dot product result from the i-1 texture shader stage, |
| assuming the i-1 texture shader stage's operation is DOT_PRODUCT_NV. |
| dotC is the floating-point dot product result from the current |
| texture shader stage. dotC is computed in the identical manner |
| used to compute the floating-point result of the DOT_PRODUCT_NV |
| texture shader described in section 3.8.13.1.14. |
| |
| If the previous texture input texture object specified by the |
| current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value has |
| a format type other than RGBA or HILO (the DSDT_MAG_INTENSITY_NV |
| base internal format does not count as an RGBA format type in this |
| context), then this texture shader stage is not consistent. |
| |
| If the previous texture input texture shader operation specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is DOT_PRODUCT_NV, then this texture shader stage is not consistent. |
| |
| If the previous texture input texture shader result specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is invalid, then this texture shader stage is not consistent. |
| |
| If the previous texture input shader stage specified by the current |
| texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value is not |
| consistent, then this texture shader stage is not consistent. |
| |
| If the i-1 texture shader stage operation is not DOT_PRODUCT_NV, |
| then this texture shader stage is not consistent. |
| |
| If the i-1 texture shader stage is not consistent, then |
| this texture shader stage is not consistent. |
| |
| If the texture unit's 2D texture object is not consistent, then |
| this texture shader stage is not consistent. |
| |
| If this texture shader stage is not consistent, it operates as if |
| it is the NONE operation. |
| |
| 3.8.13.1.16 Dot Product Texture Rectangle |
| |
| The DOT_PRODUCT_TEXTURE_RECTANGLE_NV shader operation operates |
| identically to the DOT_PRODUCT_TEXTURE_2D_NV shader operation except |
| that the rectangle texture target is accessed rather than the 2D |
| texture target. |
| |
| If the texture unit's rectangle texture object (rather than the 2D |
| texture object) is not consistent, then this texture shader stage |
| is not consistent. |
| |
| 3.8.13.1.17 Dot Product Texture Cube Map |
| |
| The DOT_PRODUCT_TEXTURE_CUBE_MAP_NV texture shader operation |
| accesses the texture unit's cube map texture object (as described |
| in the ARB_texture_cube_map specification) using (dotPP,dotP,dotC) |
| for the 3D texture coordinates. The result of the texture access |
| becomes both the shader result and texture unit RGBA result (see |
| table 3.E). The type of the shader result depends on the format |
| type of the accessed texture. |
| |
| Assuming that i is the current texture shader stage, dotPP is the |
| floating-point dot product texture shader result from the i-2 |
| texture shader stage, assuming the i-2 texture shader stage's |
| operation is DOT_PRODUCT_NV. dotP is the floating-point dot |
| product texture shader result from the i-1 texture shader stage, |
| assuming the i-1 texture shader stage's operation is DOT_PRODUCT_NV. |
| dotC is the floating-point dot product result from the current |
| texture shader stage. dotC is computed in the identical manner |
| used to compute the floating-point result of the DOT_PRODUCT_NV |
| texture shader described in section 3.8.13.1.14. |
| |
| If the previous texture input texture object specified by the |
| current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value has |
| a format type other than RGBA or HILO (the DSDT_MAG_INTENSITY_NV |
| base internal format does not count as an RGBA format type in this |
| context), then this texture shader stage is not consistent. |
| |
| If the previous texture input texture shader operation specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is DOT_PRODUCT_NV, then this texture shader stage is not consistent. |
| |
| If the previous texture input texture shader result specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is invalid, then this texture shader stage is not consistent. |
| |
| If the previous texture input shader stage specified by the current |
| texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value is not |
| consistent, then this texture shader stage is not consistent. |
| |
| If either the i-1 or i-2 texture shader stage operation is not |
| DOT_PRODUCT_NV, then this texture shader stage is not consistent. |
| |
| If either the i-1 or i-2 texture shader stage is not consistent, then |
| this texture shader stage is not consistent. |
| |
| If the texture unit's cube map texture object is not consistent, |
| then this texture shader stage is not consistent. |
| |
| If this texture shader stage is not consistent, it operates as if |
| it is the NONE operation. |
| |
| 3.8.13.1.18 Dot Product Reflect Cube Map |
| |
| The DOT_PRODUCT_REFLECT_CUBE_MAP_NV and |
| DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV (described in the section |
| 3.8.13.1.20) texture shader operations are typically used together. |
| |
| The DOT_PRODUCT_REFLECT_CUBE_MAP_NV texture shader operation |
| accesses the texture unit's cube map texture object (as described |
| in the ARB_texture_cube_map specification) using (rx,ry,rz) for |
| the 3D texture coordinates. The result of the texture access becomes |
| both the shader result and texture unit RGBA result (see table 3.E). |
| The type of the shader result depends on the format type of the |
| accessed texture. |
| |
| Let R = (rx,ry,rz), N = (dotPP,dotP,dotC), and E = (qPP,qP,qC), |
| then |
| |
| R = 2 * (N dot E) / (N dot N) * N - E |
| |
| Assuming that i is the current texture shader stage, dotPP is |
| the floating-point dot product texture shader result from the |
| i-2 texture shader stage, assuming the i-2 texture shader stage's |
| operation is DOT_PRODUCT_NV. dotP is the floating-point dot product |
| texture shader result from the i-1 texture shader stage, assuming |
| the i-1 texture shader stage's operation is either DOT_PRODUCT_NV |
| or DOT_PRODUCT_DIFFUSE_NV. dotC is the floating-point dot product |
| result from the current texture shader stage. dotC is computed in |
| the identical manner used to compute the floating-point result of |
| the DOT_PRODUCT_NV texture shader described in section 3.8.13.1.14. |
| |
| qPP is the q component of the i-2 texture shader stage's texture |
| coordinate set. qP is the q component of the i-1 texture shader |
| stage's texture coordinate set. qC is the q component of the |
| current texture shader stage's texture coordinate set. |
| |
| If the previous texture input texture object specified by the |
| current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value has |
| a format type other than RGBA or HILO (the DSDT_MAG_INTENSITY_NV |
| base internal format does not count as an RGBA format type in this |
| context), then this texture shader stage is not consistent. |
| |
| If the previous texture input texture shader operation specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is DOT_PRODUCT_NV, then this texture shader stage is not consistent. |
| |
| If the previous texture input texture shader result specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is invalid, then this texture shader stage is not consistent. |
| |
| If this texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| refers to texture unit i-2 or i-1, then this texture shader stage |
| is not consistent. |
| |
| If the previous texture input shader stage specified by the current |
| texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value is not |
| consistent, then this texture shader stage is not consistent. |
| |
| If the i-2 texture shader stage operation is not |
| DOT_PRODUCT_NV, then this texture shader stage is not consistent. |
| |
| If the i-1 texture shader stage operation is not DOT_PRODUCT_NV or |
| DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV, then this texture shader stage is |
| not consistent. |
| |
| If either the i-1 or i-2 texture shader stage is not consistent, then |
| this texture shader stage is not consistent. |
| |
| If the texture unit's cube map texture object is not consistent, |
| then this texture shader stage is not consistent. |
| |
| If this texture shader stage is not consistent, it operates as if |
| it is the NONE operation. |
| |
| 3.8.13.1.19 Dot Product Constant Eye Reflect Cube Map |
| |
| The DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV texture shader |
| operation operates the same as the DOT_PRODUCT_REFLECT_CUBE_MAP_NV |
| operation except that the eye vector E is equal to the three |
| floating-point values assigned to the texture shader's eye |
| constant (rather than the three q components of the given texture |
| unit and the previous two texture units). |
| |
| The DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV operation |
| has the same texture shader consistency rules as the |
| DOT_PRODUCT_REFLECT_CUBE_MAP_NV operation. |
| |
| 3.8.13.1.20 Dot Product Diffuse Cube Map |
| |
| The DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV texture shader operation |
| accesses the texture unit's cube map texture object (as described |
| in the ARB_texture_cube_map specification) using (dotP,dotC,dotN) |
| for the 3D texture coordinates. The result of the texture access |
| becomes both the shader result and texture unit RGBA result (see |
| table 3.E). The type of the shader result depends on the format |
| type of the accessed texture. |
| |
| Assuming that i is the current texture shader stage, dotP is the |
| floating-point dot product texture shader result from the i-1 texture |
| shader stage, assuming the i-1 texture shader stage's operation |
| is DOT_PRODUCT_NV. dotC is the floating-point dot product result |
| from the current texture shader stage. dotC is computed in the |
| identical manner used to compute the floating-point result of the |
| DOT_PRODUCT_NV texture shader described in section 3.8.13.1.14. |
| dotN is the floating-point dot product texture shader result from |
| the i+1 texture shader stage, assuming the next texture shader |
| stage's operation is either DOT_PRODUCT_REFLECT_CUBE_MAP_NV or |
| DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV. |
| |
| If the texture unit's cube map texture object is not consistent, |
| then this operation operates as if it is the NONE operation. |
| If the previous texture unit's texture shader operation is |
| not DOT_PRODUCT_NV, then this operation operates as if it |
| is the NONE operation. If the next texture unit's texture |
| shader operation is neither DOT_PRODUCT_REFLECT_CUBE_MAP_NV nor |
| DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV, then this operation |
| operates as if it is the NONE operation. If the next texture unit's |
| texture shader operation is either DOT_PRODUCT_REFLECT_CUBE_MAP_NV |
| or DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV, but the next texture |
| unit operation is operating as if it is the NONE operation, then |
| this operation operates as if it is the NONE operation. If the |
| specified previous input texture unit is inconsistent or uses |
| the DOT_PRODUCT_NV texture shader operation, then this operation |
| operates as if it is the NONE operation. |
| |
| If the previous texture input texture object specified by the |
| current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value has |
| a format type other than RGBA or HILO (the DSDT_MAG_INTENSITY_NV |
| base internal format does not count as an RGBA format type in this |
| context), then this texture shader stage is not consistent. |
| |
| If the previous texture input texture shader operation specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is DOT_PRODUCT_NV, then this texture shader stage is not consistent. |
| |
| If the previous texture input texture shader result specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is invalid, then this texture shader stage is not consistent. |
| |
| If the previous texture input shader stage specified by the current |
| texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value is not |
| consistent, then this texture shader stage is not consistent. |
| |
| If the i-1 texture shader stage operation is not |
| DOT_PRODUCT_NV, then this texture shader stage is not consistent. |
| |
| If the i+1 texture shader stage operation |
| is not DOT_PRODUCT_REFLECT_CUBE_MAP_NV or |
| DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV, then this texture shader |
| stage is not consistent. |
| |
| If either the i-1 or i+1 texture shader stage is not consistent, |
| then this texture shader stage is not consistent. |
| |
| If the texture unit's cube map texture object is not consistent, |
| then this texture shader stage is not consistent. |
| |
| If this texture shader stage is not consistent, it operates as if |
| it is the NONE operation. |
| |
| 3.8.13.1.21 Dot Product Depth Replace |
| |
| The DOT_PRODUCT_DEPTH_REPLACE_NV texture shader operation replaces |
| the incoming fragments depth (in window coordinates, after polygon |
| offset and before conversion to fixed-point, i.e. in the [0,1] |
| range) with a new depth value. The new depth is computed as follows: |
| |
| depth = dotP / dotC |
| |
| Assuming that i is the current texture shader stage, dotP is the |
| floating-point dot product texture shader result from the i-1 texture |
| shader stage, assuming the i-1 texture shader stage's operation |
| is DOT_PRODUCT_NV. dotC is the floating-point dot product result |
| from the current texture shader stage. dotC is computed in the |
| identical manner used to compute the floating-point result of the |
| DOT_PRODUCT_NV texture shader described in section 3.8.13.1.14. |
| |
| If the new depth value is outside of the range of the near and far |
| depth range values, the fragment is rejected. |
| |
| The texture unit RGBA result generated is always (0,0,0,0). |
| The texture shader result is invalid. |
| |
| If the previous texture input texture object specified by the |
| current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value has |
| a format type other than RGBA or HILO (the DSDT_MAG_INTENSITY_NV |
| base internal format does not count as an RGBA format type in this |
| context), then this texture shader stage is not consistent. |
| |
| If the previous texture input texture shader operation specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is DOT_PRODUCT_NV, then this texture shader stage is not consistent. |
| |
| If the previous texture input texture shader result specified by |
| the current texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value |
| is invalid, then this texture shader stage is not consistent. |
| |
| If the previous texture input shader stage specified by the current |
| texture shader stage's PREVIOUS_TEXTURE_INPUT_NV value is not |
| consistent, then this texture shader stage is not consistent. |
| |
| If the i-1 texture shader stage operation is not DOT_PRODUCT_NV, |
| then this texture shader stage is not consistent. |
| |
| If the i-1 texture shader stage is not consistent, then |
| this texture shader stage is not consistent. |
| |
| If any previous texture shader stage operation is |
| DOT_PRODUCT_DEPTH_REPLACE_NV and that previous stage is consistent, |
| then this texture shader stage is not consistent. (This eliminates |
| the potential for two stages to each be performing a depth replace |
| operation.) |
| |
| If this texture shader stage is not consistent, it operates as if |
| it is the NONE operation. |
| |
| This operation in no way depends on any of the texture unit's |
| texture objects. |
| |
| 3.8.13.2 Texture Shader Restrictions |
| |
| There are various restrictions on possible texture shader |
| configurations. These restrictions are described in this section. |
| |
| The error INVALID_OPERATION occurs if the SHADER_OPERATION_NV |
| parameter for texture unit 0 is assigned one of OFFSET_TEXTURE_2D_NV, |
| OFFSET_TEXTURE_2D_SCALE_NV, OFFSET_TEXTURE_RECTANGLE_NV, |
| OFFSET_TEXTURE_RECTANGLE_SCALE_NV, DEPENDENT_AR_TEXTURE_2D_NV, |
| DEPENDENT_GB_TEXTURE_2D_NV, DOT_PRODUCT_NV, |
| DOT_PRODUCT_DEPTH_REPLACE_NV, DOT_PRODUCT_TEXTURE_2D_NV, |
| DOT_PRODUCT_TEXTURE_RECTANGLE_NV, DOT_PRODUCT_TEXTURE_CUBE_MAP_NV, |
| DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV, DOT_PRODUCT_REFLECT_CUBE_MAP_NV, |
| or DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV. Each of these |
| texture shaders requires a previous texture shader result that |
| is not possible for texture unit 0. Therefore these shaders are |
| disallowed for texture unit 0. |
| |
| The error INVALID_OPERATION occurs if the SHADER_OPERATION_NV |
| parameter for texture unit 1 is assigned one of |
| DOT_PRODUCT_DEPTH_REPLACE_NV, DOT_PRODUCT_TEXTURE_2D_NV, |
| DOT_PRODUCT_TEXTURE_RECTANGLE_NV, DOT_PRODUCT_TEXTURE_CUBE_MAP_NV, |
| DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV, DOT_PRODUCT_REFLECT_CUBE_MAP_NV, |
| or DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV. Each of these texture |
| shaders requires either two previous texture shader results or |
| a dot product result that cannot be generated by texture unit 0. |
| Therefore these shaders are disallowed for texture unit 1. |
| |
| The error INVALID_OPERATION occurs if the SHADER_OPERATION_NV |
| parameter for texture unit 2 is assigned one of |
| DOT_PRODUCT_TEXTURE_CUBE_MAP_NV, DOT_PRODUCT_REFLECT_CUBE_MAP_NV, |
| DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV. Each of these texture |
| shaders requires three previous texture shader results. Therefore |
| these shaders are disallowed for texture unit 2. |
| |
| The error INVALID_OPERATION occurs if the SHADER_OPERATION_NV |
| parameter for texture unit n-1 (where n is the number of |
| supported texture units) is assigned either DOT_PRODUCT_NV or |
| DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV. DOT_PRODUCT_NV is invalid for the |
| final texture shader stage because it is only useful as an input to |
| a successive texture shader stage. DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV |
| is invalid for the final texture shader stage because it must be |
| followed by the DOT_PRODUCT_REFLECT_CUBE_MAP_NV operation in the |
| immediately successive stage. Therefore these shaders are disallowed |
| for texture unit n-1. |
| |
| 3.8.13.3 Required State |
| |
| The state required for texture shaders consists of a single bit to |
| indicate whether or not texture shaders are enabled, a vector of |
| three floating-point values for the constant eye vector, and n sets |
| of per-texture unit state where n is the implementation-dependent |
| number of supported texture units. The set of per-texture unit |
| texture shader state consists of the twenty-one-valued integer |
| indicating the texture shader operation, four two-valued integers |
| indicating the cull modes, an integer indicating the previous texture |
| unit input, a two-valued integer indicating the RGBA unsigned dot |
| product mapping mode, a 2x2 floating-point matrix indicating the |
| texture offset transform, a floating-point value indicating the |
| texture offset scale, a floating-point value indicating the texture |
| offset bias, and a bit to indicate whether or not the texture shader |
| stage is consistent. |
| |
| In the initial state, the texture shaders state is set as follows: |
| the texture shaders enable is disabled; the constant eye vector |
| is (0,0,-1); all the texture shader operations are NONE; the RGBA |
| unsigned dot product mapping mode is UNSIGNED_IDENTITY_NV; all the |
| cull mode values are GEQUAL; all the previous texture units are |
| TEXTURE0_ARB; each texture offset matrix is an identity matrix; |
| all texture offset scales are 1.0; and all texture offset biases |
| are 0.0." |
| |
| Additions to Chapter 4 of the 1.2 Specification (Per-Fragment Operations |
| and the Frame Buffer) |
| |
| None |
| |
| Additions to Chapter 5 of the 1.2 Specification (Special Functions) |
| |
| None |
| |
| Additions to Chapter 6 of the 1.2 Specification (State and State Requests) |
| |
| -- Section 6.1.3 "Texture Environments and Texture Functions" |
| |
| Change the third sentence of the third paragraph to read: |
| |
| "The env argument to GetTexEnv must be one of TEXTURE_ENV, |
| TEXTURE_FILTER_CONTROL_EXT, or TEXTURE_SHADER_NV." |
| |
| Add to the end of the third paragraph: |
| |
| "For GetTexEnv, when the target is TEXTURE_SHADER_NV, the texture |
| shader stage consistency can be queried with SHADER_CONSISTENT_NV." |
| |
| Change the following sentence in the fouth paragraph to include |
| sizes for the newly introduced component: |
| |
| "Queries of TEXTURE_RED_SIZE, TEXTURE_GREEN_SIZE, TEXTURE_BLUE_SIZE, |
| TEXTURE_ALPHA_SIZE, TEXTURE_LUMINANCE_SIZE, TEXTURE_DS_SIZE_EXT, |
| TEXTURE_DT_SIZE_EXT, TEXTURE_HI_SIZE_EXT, TEXTURE_LO_SIZE_EXT, |
| TEXTURE_MAG_SIZE_EXT, and TEXTURE_INTENSITY_SIZE return the actual |
| resolutions of the stored image array components, not the resolutions |
| specified when the image array was defined." |
| |
| Add the following to the end of the fourth paragraph: |
| |
| "Queries of TEXTURE_BORDER_COLOR return the same values as the |
| TEXTURE_BORDER_VALUES query." |
| |
| -- Section 6.1.4 "Texture Queries" |
| |
| Add the following to the end of the fourth paragraph: |
| |
| "Calling GetTexImage with a color format (one of RED, GREEN, |
| BLUE, ALPHA, RGB, RGBA, BGR, BGRA, LUMINANCE, or LUMINANCE_ALPHA) |
| when the texture image is of a format type (see table 3.15) |
| other than RGBA (the DSDT_MAG_INTENSITY_NV base internal format |
| does not count as an RGBA format type in this context) causes the |
| error INVALID_OPERATION. Calling GetTexImage with a format of |
| HILO_NV when the texture image is of a format type (see table |
| 3.15) other than HILO_NV causes the error INVALID_OPERATION. |
| Calling GetTexImage with a format of DSDT_NV when the texture image |
| is of a base internal format other than DSDT_NV causes the error |
| INVALID_OPERATION. Calling GetTexImage with a format of DSDT_MAG_NV |
| when the texture image is of a base internal format other than |
| DSDT_MAG_NV causes the error INVALID_OPERATION. Calling GetTexImage |
| with a format of DSDT_MAG_VIB_NV when the texture image is of a |
| base internal format other than DSDT_MAG_INTENSITY_NV causes the |
| error INVALID_OPERATION." |
| |
| Additions to the GLX Specification |
| |
| None |
| |
| Dependencies on ARB_texture_env_add or EXT_texture_env_add |
| |
| If neither ARB_texture_env_add nor EXT_texture_env_add are |
| implemented, then the references to ADD are invalid and should be |
| ignored. |
| |
| Dependencies on ARB_texture_env_combine or EXT_texture_env_combine |
| |
| If neither ARB_texture_env_combine nor EXT_texture_env_combine are |
| implemented, then the references to COMBINE_ARB and COMBINE_EXT |
| are invalid and should be ignored. |
| |
| Dependencies on EXT_texture_lod_bias |
| |
| If EXT_texture_lod_bias is not implemented, then the references to |
| TEXTURE_FILTER_CONTROL_EXT are invalid and should be ignored. |
| |
| Dependencies on NV_texture_env_combine4 |
| |
| If NV_texture_env_combine4 is not implemented, then the references |
| to COMBINE4_NV are invalid and should be ignored. |
| |
| Dependencies on NV_texture_rectangle |
| |
| If NV_texture_rectangle is not implemented, then the references |
| to TEXTURE_RECTANGLE_NV, OFFSET_TEXTURE_RECTANGLE_NV, |
| OFFSET_TEXTURE_RECTANGLE_SCALE_NV, and |
| DOT_PRODUCT_TEXTURE_RECTANGLE_NV are invalid and should be ignored. |
| |
| Dependencies on ARB_color_buffer_float |
| |
| If ARB_color_buffer_float is also implemented, then the "max(0,x)", |
| "max(-1,x)" and "min(1,x)" functions for clamping in tables 3.18 |
| and 3.19 simply return "x" without applying the maximum or minimum |
| function when CLAMP_FRAGMENT_COLOR_ARB is either FIXED_ONLY_ARB |
| when rendering to a floating-point color framebuffer or FALSE. |
| |
| However clamping operations for texture shader operations |
| (specifically PASS_THROUGH_NV and OFFSET_TEXTURE_2D_SCALE_NV) |
| are performed independent of the CLAMP_FRAGMENT_COLOR_ARB state. |
| |
| The intent of these interactions is to eliminate the specified |
| clamping behavior of texture environment functions when |
| CLAMP_FRAGMENT_COLOR_ARB indicates clamping should not be performed. |
| |
| Errors |
| |
| INVALID_ENUM is generated if one of HILO_NV, DSDT_NV, DSDT_MAG_NV, |
| or DSDT_MAG_VIBRANCE_NV is used as the format for DrawPixels, |
| ReadPixels, ColorTable, ColorSubTable, ConvolutionFilter1D, |
| ConvolutionFilter2D, SeparableFilter2D, GetColorTable, |
| GetConvolutionFilter, GetSeparableFilter, GetHistogram, or |
| GetMinmax. |
| |
| INVALID_ENUM is generated if either UNSIGNED_INT_S8_S8_8_8_NV or |
| UNSIGNED_INT_8_8_S8_S8_REV is used as the type for DrawPixels, |
| ReadPixels, ColorTable, ColorSubTable, ConvolutionFilter1D, |
| ConvolutionFilter2D, SeparableFilter2D, GetColorTable, |
| GetConvolutionFilter, GetSeparableFilter, GetHistogram, or |
| GetMinmax. |
| |
| INVALID_OPERATION is generated if a packed pixel format type listed |
| in table 3.8 is used with DrawPixels, ReadPixels, ColorTable, |
| ColorSubTable, ConvolutionFilter1D, ConvolutionFilter2D, |
| SeparableFilter2D, GetColorTable, GetConvolutionFilter, |
| GetSeparableFilter, GetHistogram, GetMinmax, TexImage1D, TexImage2D, |
| TexSubImage1D, TexSubImage2D, TexSubImage3d, or |
| GetTexImage but the format parameter does not match on of the allowed |
| Matching Pixel Formats listed in table 3.8 for the specified packed |
| type parameter. |
| |
| INVALID_OPERATION is generated when TexImage1D or TexImage2D are |
| called and the format is HILO_NV and the internalformat is not |
| one of HILO_NV, HILO16_NV, SIGNED_HILO_NV, SIGNED_HILO16_NV; or if |
| the internalformat is one of HILO_NV, HILO16_NV, SIGNED_HILO_NV, |
| or SIGNED_HILO16_NV and the format is not HILO_NV. |
| |
| INVALID_OPERATION is generated when TexImage2D, or TexImage1D is |
| called and if the format is DSDT_NV and the internalformat is not |
| either DSDT_NV or DSDT8_NV; or if the internal format is either |
| DSDT_NV or DSDT8_NV and the format is not DSDT_NV. |
| |
| INVALID_OPERATION is generated when TexImage2D, or TexImage1D is |
| called and if the format is DSDT_MAG_NV and the internalformat |
| is not either DSDT_MAG_NV or DSDT8_MAG8_NV; or if the internal |
| format is either DSDT_MAG_NV or DSDT8_MAG8_NV and the format is |
| not DSDT_MAG_NV. |
| |
| INVALID_OPERATION is generated when TexImage2D or TexImage1D is |
| called and if the format is DSDT_MAG_VIB_NV and the internalformat |
| is not either DSDT_MAG_INTENSITY_NV or DSDT8_MAG8_INTENSITY8_NV; |
| or if the internal format is either DSDT_MAG_INTENSITY_NV or |
| DSDT8_MAG8_INTENSITY8_NV and the format is not DSDT_MAG_VIB_NV. |
| |
| INVALID_OPERATION is generated when CopyTexImage2D, CopyTexImage1D, |
| CopyTexSubImage2D, or CopyTexSubImage1D is called and the internal |
| format of the texture array to which the pixels are to be copied |
| is one of HILO_NV, HILO16_NV, SIGNED_HILO_NV, SIGNED_HILO16_NV, |
| DSDT_NV, DSDT8_NV, DSDT_MAG_NV, DSDT8_MAG8_NV, DSDT_MAG_INTENSITY_NV, |
| or DSDT8_MAG8_INTENSITY8_NV. |
| |
| INVALID_OPERATION is generated when TexSubImage2D or |
| TexSubImage1D is called and the texture array's base internal format |
| is not one of HILO_NV, DSDT_NV, DSDT_MAG_NV, or DSDT_INTENSITY_NV, |
| and the format parameter is not one of COLOR_INDEX, RED, |
| GREEN, BLUE, ALPHA, RGB, RGBA, LUMINANCE, or |
| LUMINANCE_ALPHA |
| |
| INVALID_OPERATION is generated when TexSubImage2D or |
| TexSubImage1D is called and the texture array's base internal format |
| is HILO_NV and the format parameter is not HILO_NV. |
| |
| INVALID_OPERATION is generated when TexSubImage2D or |
| TexSubImage1D is called and the texture array's base internal format |
| is DSDT_NV and the format parameter is not DSDT_NV. |
| |
| INVALID_OPERATION is generated when TexSubImage2D or |
| TexSubImage1D is called and the texture array's base internal format |
| is DSDT_MAG_NV and the format parameter is not DSDT_MAG_NV. |
| |
| INVALID_OPERATION is generated when TexSubImage2D |
| or TexSubImage1D is called and the texture array's base internal |
| format is DSDT_MAG_INTENSITY_NV and the format parameter is not |
| DSDT_MAG_VIRBANCE_NV. |
| |
| INVALID_OPERATION is generated when TexEnv is called and the |
| PREVIOUS_TEXTURE_INPUT_NV parameter for texture unit i is assigned |
| the value TEXTUREi_ARB where f i is greater than or equal to the |
| current active texture unit. |
| |
| INVALID_OPERATION is generated when TexEnv is called and the |
| SHADER_OPERATION_NV parameter for texture unit 0 is assigned |
| one of OFFSET_TEXTURE_2D_NV, OFFSET_TEXTURE_2D_SCALE_NV, |
| OFFSET_TEXTURE_RECTANGLE_NV, OFFSET_TEXTURE_RECTANGLE_SCALE_NV, |
| DEPENDENT_AR_TEXTURE_2D_NV, DEPENDENT_GB_TEXTURE_2D_NV, |
| DOT_PRODUCT_NV, DOT_PRODUCT_DEPTH_REPLACE_NV, |
| DOT_PRODUCT_TEXTURE_2D_NV, DOT_PRODUCT_TEXTURE_RECTANGLE_NV, |
| DOT_PRODUCT_TEXTURE_CUBE_MAP_NV, |
| DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV, DOT_PRODUCT_REFLECT_CUBE_MAP_NV. |
| or DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV. |
| |
| INVALID_OPERATION is generated when TexEnv is called |
| and the SHADER_OPERATION_NV parameter for texture |
| unit 1 is assigned one of DOT_PRODUCT_DEPTH_REPLACE_NV, |
| DOT_PRODUCT_TEXTURE_2D_NV, DOT_PRODUCT_TEXTURE_RECTANGLE_NV, |
| DOT_PRODUCT_TEXTURE_CUBE_MAP_NV, |
| DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV, DOT_PRODUCT_REFLECT_CUBE_MAP_NV, |
| or DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV. |
| |
| INVALID_OPERATION is generated when TexEnv is called |
| and the SHADER_OPERATION_NV parameter for texture |
| unit 2 is assigned one of |
| DOT_PRODUCT_TEXTURE_CUBE_MAP_NV, DOT_PRODUCT_REFLECT_CUBE_MAP_NV, |
| or DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV. |
| |
| INVALID_OPERATION is generated when TexEnv is called and the |
| SHADER_OPERATION_NV parameter for texture unit n-1 (where n is the |
| number of supported texture units) is assigned either DOT_PRODUCT_NV |
| or DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV. |
| |
| INVALID_OPERATION is generated when GetTexImage is called with a |
| color format (one of RED, GREEN, BLUE, ALPHA, RGB, RGBA, BGR, BGRA, |
| LUMINANCE, or LUMINANCE_ALPHA) when the texture image is of a format |
| type (see table 3.15) other than RGBA (the DSDT_MAG_INTENSITY_NV |
| base internal format does not count as an RGBA format type in this |
| context). |
| |
| INVALID_OPERATION is generated when GetTexImage is called with a |
| format of HILO_NV when the texture image is of a format type (see |
| table 3.15) other than HILO_NV. |
| |
| INVALID_OPERATION is generated when GetTexImage is called with a |
| format of DSDT_NV when the texture image is of a base internal |
| format other than DSDT_NV. |
| |
| INVALID_OPERATION is generated when GetTexImage is called with a |
| format of DSDT_MAG_NV when the texture image is of a base internal |
| format other than DSDT_MAG_NV. |
| |
| INVALID_OPERATION is generated when GetTexImage is called with a |
| format of DSDT_MAG_VIBRANCE_NV when the texture image is of a base |
| internal format other than DSDT_MAG_INTENSITY_NV causes the error |
| INVALID_OPERATION." |
| |
| New State |
| |
| Add the following entries to table 6.12: |
| |
| Get Value Type Get Command Initial Value Description Sec Attribute |
| -------------------- ------ -------------------- ------------- --------------------- --- --------- |
| TEXTURE_HI_SIZE_NV nxZ+ GetTexLevelParameter 0 xD texture image i's 3.8 texture |
| hi resolution |
| TEXTURE_LO_SIZE_NV nxZ+ GetTexLevelParameter 0 xD texture image i's 3.8 texture |
| lo resolution |
| TEXTURE_DS_SIZE_NV nxZ+ GetTexLevelParameter 0 xD texture image i's 3.8 texture |
| ds resolution |
| TEXTURE_DT_SIZE_NV nxZ+ GetTexLevelParameter 0 xD texture image i's 3.8 texture |
| dt resolution |
| TEXTURE_MAG_SIZE_NV nxZ+ GetTexLevelParameter 0 xD texture image i's 3.8 texture |
| mag resolution |
| |
| Change the TEXTURE_BORDER_COLOR line in table 6.13 to read: |
| |
| Get Value Type Get Command Initial Value Description Sec Attribute |
| ------------------------ ------ --------------- ------------- --------------------- --- --------- |
| TEXTURE_BORDER_VALUES_NV 4xR GetTexParameter (0,0,0,0) Texture border values 3.8 texture |
| (TEXTURE_BORDER_COLOR) |
| |
| Table 6.TextureShaders. Texture Shaders. |
| |
| Get Value Type Get Command Initial Value Description Sec Attribute |
| --------------------------- ------ ----------- -------------------- ------------------- ------ -------------- |
| HI_BIAS_NV R GetFloatv 0.0 Hi bias for HILO 3.6.3 pixel |
| LO_BIAS_NV R GetFloatv 0.0 Lo bias for HILO 3.6.3 pixel |
| DS_BIAS_NV R GetFloatv 0.0 Ds bias 3.6.3 pixel |
| DT_BIAS_NV R GetFloatv 0.0 Dt bias 3.6.3 pixel |
| MAGNITUDE_BIAS_NV R GetFloatv 0.0 Magnitude bias 3.6.3 pixel |
| VIBRANCE_BIAS_NV R GetFloatv 0.0 Vibrance bias 3.6.3 pixel |
| HI_SCALE_NV R GetFloatv 1.0 Hi scale 3.6.3 pixel |
| LO_SCALE_NV R GetFloatv 1.0 Lo scale 3.6.3 pixel |
| DS_SCALE_NV R GetFloatv 1.0 Ds scale 3.6.3 pixel |
| DT_SCALE_NV R GetFloatv 1.0 Dt scale 3.6.3 pixel |
| MAGNITUDE_SCALE_NV R GetFloatv 1.0 Magnitude scale 3.6.3 pixel |
| VIBRANCE_SCALE_NV R GetFloatv 1.0 Vibrance scale 3.6.3 pixel |
| |
| TEXTURE_SHADER_NV B IsEnabled False Texture shaders 3.8 texture/enable |
| enable |
| |
| SHADER_OPERATION_NV TxZ21 GetTexEnviv NONE Texture shader 3.8.13 texture |
| operation |
| CULL_MODES_NV Tx4xZ2 GetTexEnviv GEQUAL,GEQUAL, Texture shader 3.8.13 texture |
| GEQUAL,GEQUAL cull fragment modes |
| RGBA_UNSIGNED_- TxZ2 GetTexEnviv UNSIGNED_IDENTITY_NV Texture shader RGBA 3.8.13 texture |
| DOT_PRODUCT_MAPPING_NV dot product mapping |
| PREVIOUS_TEXTURE_INPUT_NV TxZn GetTexEnviv TEXTURE0_ARB Texture shader 3.8.13 texture |
| previous tex input |
| CONST_EYE_NV TxRx3 GetTexEnvfv (0,0,-1) Shader constant 3.8.13 texture |
| eye vector |
| OFFSET_TEXTURE_MATRIX_NV TxM2 GetTexEnvfv (1,0,0,1) 2x2 texture offset 3.8.13 texture |
| matrix |
| OFFSET_TEXTURE_SCALE_NV TxR GetTexEnvfv 1 Texture offset 3.8.13 texture |
| scale |
| OFFSET_TEXTURE_BIAS_NV TxR GetTexEnvfv 0 Texture offset 3.8.13 texture |
| bias |
| SHADER_CONSISTENT_NV TxB GetTexEnviv True Texture shader 3.8.13 texture |
| stage consistency |
| |
| [ The "Tx" type prefix means that the state is per-texture unit. ] |
| |
| [ The "Zn" type is an n-valued integer where n is the |
| implementation-dependent number of texture units supported.] |
| |
| New Implementation State |
| |
| None |
| |
| Revision History |
| |
| March 29, 2001 - document that using signed HILO with a dot product |
| shader forces the square root to zero if the 1.0-HI*HI-LO*LO value |
| is negative. |
| |
| November 15, 2001 - document that depth replace is after polygon |
| offset; add polygon offset issue and multisample issue. |
| |
| November 26, 2001 - Properly document the various TEXTURE_*_SIZE_NV |
| texture resolution query tokens. Add table 6.12 entries. |
| |
| June 5, 2002 - Driver implementations before this date |
| incorrectly swap the HI and LO components when specifying |
| GL_TEXTURE_BORDER_VALUES_NV when rendering via hardware. Drivers |
| after this date have fixed the problem and match the specified |
| behavior. |
| |
| July 2, 2003 - CULL_MODES_NV, OFFSET_TEXTURE_MATRIX_NV, |
| OFFSET_TEXTURE_2D_MATRIX_NV, and CONST_EYE_NV should not be specified |
| to work with glTexEnvi & glTexEnvf (they can only be used with |
| glTexEnviv & glTexEnvfv). |
| |
| October 19, 2006 - Add interaction with ARB_color_buffer_float to |
| document how ths extension behaves when ARB_color_buffer_float is |
| also supported and when its CLAMP_FRAGMENT_COLOR_ARB state is either |
| FIXED_ONLY_ARB when rendering to a floating-point color framebuffer |
| or FALSE. |
| |
| March 13, 2007 - Fix OFFSET_TEXTURE_2D_SCALE_NV operation to clamp |
| the scale factor to [0,1] before multiplying it by red, green, |
| and blue to match the hardware's actual behavior. |