back  Return to list

GL_NV_texture_shader
homeprevnext Name
      
    NV_texture_shader  
  
homeprevnext Name Strings
  
    GL_NV_texture_shader  
  
homeprevnext Contact
  
    Mark J. Kilgard, NVIDIA Corporation (mjk 'at' nvidia.com)  
  
homeprevnext Notice
  
    Copyright NVIDIA Corporation, 1999, 2000, 2001, 2002, 2004.  
  
homeprevnext IP Status
  
    NVIDIA Proprietary.  
  
homeprevnext Status
  
    Shipping (since GeForce3)  
  
homeprevnext Version
  
    NVIDIA Date: March 13, 2007  
    $Id: //sw/main/docs/OpenGL/specs/GL_NV_texture_shader.txt#30 $  
  
homeprevnext Number
  
    230  
  
homeprevnext 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.  
  
homeprevnext 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).  
  
homeprevnext 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.  
  
homeprevnext New Procedures and Functions
  
    None.  
  
homeprevnext 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  
  
homeprevnext Additions to Chapter 2 of the 1.2 Specification (OpenGL Operation)
  
     None  
  
homeprevnext 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."  
  
homeprevnext Additions to Chapter 4 of the 1.2 Specification (Per-Fragment Operations and the Frame Buffer)
  
     None  
  
homeprevnext Additions to Chapter 5 of the 1.2 Specification (Special Functions)
  
     None  
  
homeprevnext 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."  
  
homeprevnext Additions to the GLX Specification
  
     None  
  
homeprevnext 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.  
  
homeprevnext 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.  
  
homeprevnext 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.  
  
homeprevnext 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.  
  
homeprevnext 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.  
  
homeprevnext 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.  
  
homeprevnext 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."  
  
homeprevnext 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  
  
homeprevnext 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.  
     and blue to match the hardware's actual behavior.  
Valid XHTML 1.1! Valid CSS! Last update: November 14, 2006.
Cette page doit être lue avec un navigateur récent respectant le standard XHTML 1.1.