back  Return to list

GL_NV_register_combiners
homeprevnext Name
      
    NV_register_combiners  
  
homeprevnext Name Strings
  
    GL_NV_register_combiners  
  
homeprevnext Contact
  
    Mark J. Kilgard, NVIDIA Corporation (mjk 'at' nvidia.com)  
  
homeprevnext Notice
  
    Copyright NVIDIA Corporation, 1999, 2000, 2001, 2002, 2003.  
  
homeprevnext IP Status
  
    NVIDIA Proprietary.  
  
homeprevnext Status
  
    Shipping (version 1.6)  
  
homeprevnext Version
  
    NVIDIA Date: February 1, 2007 (version 1.7)  
    $Id: //sw/main/docs/OpenGL/specs/GL_NV_register_combiners.txt#56 $  
  
homeprevnext Number
  
    191  
  
homeprevnext Dependencies
  
    ARB_multitexture, assuming the value of MAX_TEXTURE_UNITS_ARB is  
    at least 2.  
  
    Written based on the wording of the OpenGL 1.2 specification with  
    the ARB_multitexture appendix E.  
  
    NV_texture_shader affects the definition of this extension.  
  
    ARB_depth_texture and ARB_shadow -or- SGIX_depth_texture and  
    SGIX_shadow affect the definition of this extension.  
  
    ARB_color_buffer_float affects the definiton of this extension.  
  
homeprevnext Overview
  
    NVIDIA's next-generation graphics processor and its derivative  
    designs support an extremely configurable mechanism know as "register  
    combiners" for computing fragment colors.  
  
    The register combiner mechanism is a significant redesign of NVIDIA's  
    original TNT combiner mechanism as introduced by NVIDIA's RIVA  
    TNT graphics processor.  Familiarity with the TNT combiners will  
    help the reader appreciate the greatly enhanced register combiners  
    functionality (see the NV_texture_env_combine4 OpenGL extension  
    specification for this background).  The register combiner mechanism  
    has the following enhanced functionality:   
  
      The numeric range of combiner computations is from [-1,1]  
      (instead of TNT's [0,1] numeric range),  
  
      The set of available combiner inputs is expanded to include the  
      secondary color, fog color, fog factor, and a second combiner  
      constant color (TNT's available combiner inputs consist of  
      only zero, a single combiner constant color, the primary color,  
      texture 0, texture 1, and, in the case of combiner 1, the result  
      of combiner 0).  
  
      Each combiner variable input can be independently scaled and  
      biased into several possible numeric ranges (TNT can only  
      complement combiner inputs).  
  
      Each combiner stage computes three distinct outputs (instead  
      TNT's single combiner output).  
  
      The output operations include support for computing dot products  
      (TNT has no support for computing dot products).  
  
      After each output operation, there is a configurable scale and bias  
      applied (TNT's combiner operations builds in a scale and/or bias  
      into some of its combiner operations).  
  
      Each input variable for each combiner stage is fetched from any  
      entry in a combiner register set.  Moreover, the outputs of each  
      combiner stage are written into the register set of the subsequent  
      combiner stage (TNT could only use the result from combiner 0 as  
      a possible input to combiner 1; TNT lacks the notion of an  
      input/output register set).  
  
      The register combiner mechanism supports at least two general  
      combiner stages and then a special final combiner stage appropriate  
      for applying a color sum and fog computation (TNT provides two  
      simpler combiner stages, and TNT's color sum and fog stages are  
      hard-wired and not subsumed by the combiner mechanism as in register  
      combiners).  
  
    The register combiners fit into the OpenGL pipeline as a rasterization  
    processing stage operating in parallel to the traditional OpenGL  
    texture environment, color sum, AND fog application.  Enabling this  
    extension bypasses OpenGL's existing texture environment, color  
    sum, and fog application processing and instead use the register  
    combiners.  The combiner and texture environment state is orthogonal  
    so modifying combiner state does not change the traditional OpenGL  
    texture environment state and the texture environment state is  
    ignored when combiners are enabled.  
  
    OpenGL application developers can use the register combiner mechanism  
    for very sophisticated shading techniques.  For example, an  
    approximation of Blinn's bump mapping technique can be achieved with  
    the combiner mechanism.  Additionally, multi-pass shading models  
    that require several passes with unextended OpenGL 1.2 functionality  
    can be implemented in several fewer passes with register combiners.  
  
homeprevnext Issues
  
    Should we expose the full register combiners mechanism?  
  
      RESOLUTION:  NO.  We ignore small bits of NV10 hardware  
      functionality.  The texture LOD input is ignored.  We also ignore  
      the inverts on input to the EF product.  
  
    Do we provide full gets for all the combiner state?  
  
      RESOLUTION:  YES.  
  
    Do we parameterize combiner input and output updates to avoid  
    enumerant explosions?  
  
      RESOLUTION:  YES.  To update a combiner stage input variable, you  
      need to specify the <stage>, <portion>, and <variable>.  To update a  
      combiner stage output operation, you need to specify the <stage> and  
      <portion>.  This does mean that we need to add special Get routines  
      that are likewise parameterized.  Hence, GetCombinerInputParameter*,  
      GetCombinerOutputParameter*, and GetFinalCombinerInputParameter*.  
  
   Is the register combiner functionality a super-set of the TNT combiner  
   functionality?  
  
      Yes, but only in the sense of being a computational super-set.  
      All computations performed with the TNT combiners can be performed  
      with the register combiners, but the sequence of operations necessary  
      to configure an identical computational result can be quite  
      different.  
  
      For example, the TNT combiners have an operation that includes  
      a final complement operation.  The register combiners can perform  
      range mappings only on inputs, but not on outputs.  The register  
      combiners can mimic the TNT operation with a post-operation  
      complement only by taking pains to complement on input any uses  
      of the output in later combiner stages.  
  
      What this does mean is that NV10's hardware functionality  
      will permit support for both the NV_register_combiners AND  
      NV_texture_env_combine4 extensions.  
  
      Note the existance of an "speclit" input complement bit supported  
      by NV10 (but not accessible through the NV_register_combiners  
      extensions).  
  
   Should we say anything about the precision of the combiner  
   computations?  
  
      RESOLUTION:  NO.  The spec is written as if the computations are  
      done on floating point values ranging from -1.0 to 1.0 (clamping is  
      specified where this range is exceeded).  The fact that NV10 does  
      the computations as 9-bit signed fixed point is not mentioned in  
      the spec.  This permits a future design to support more precision  
      or use a floating pointing representation.  
  
    What should the initial combiner state be?  
  
      RESOLUTION:  See tables NV_register_combiners.5 and  
      NV_register_combiners.6.  The default state has one general combiner  
      stage active that modulates the incoming color with texture 0.  
      The final combiner is setup initially to implement OpenGL 1.2's  
      standard color sum and fog stages.  
  
    What should happen to the TEXTURE0_ARB and TEXTUER1_ARB inputs if  
    one or both textures are disabled?  
  
      RESOLUTION:  The value of these inputs is undefined.  
  
    What do the TEXTURE0_ARB and TEXTURE1_ARB inputs correspond to?  
    Does the number correspond to the absolute texture unit number  
    or is the number based on how many textures are enabled (ie,  
    TEXTURE_ARB0 would correspond to the 2nd texture unit if the  
    2nd unit is enabled, but the 1st is disabled).  
  
      RESOLUTION:  The absolute texture unit.  
  
      This should be a lot less confusing to the programmer than having  
      the texture inputs switch textures if texture 0 is disabled.  
  
      Note that the proposed hardware actually determines the TEXTURE0  
      and TEXTURE1 input based on which texture is enabled.  This means  
      it is up to the ICD to properly update the combiner state when just  
      one texture is enabled.  Since we will already have to do this to  
      track the standard OpenGL texture environment for ARB_multitexture,  
      we can do it for this extension too.  
  
    Should the combiners state be PushAttrib/PopAttrib'ed along with  
    the texture state?  
  
      RESOLUTION:  YES.  
  
    Should we advertise the LOD fractional input to the combiners?  
  
      RESOLUTION:  NO.  
  
    There will be a performance impact when two combiner stages are  
    enabled versus just one stage.  Should we mention that somewhere?  
  
      RESOLUTION:  NO.  (But it is worth mentioning in this issues  
      section.)  
  
    Should the scale and bias for the CombinerOutputNV be indicated  
    by enumerants or specified outright as floats?  
  
      RESOLUTION:  ENUMERANTS.  While some future combiners might  
      support an arbitrary scale & bias specified as floats, NV10 just  
      does the enumerated options.  
  
    Should a dot product be computed in parralel with the sum of  
    products?  
  
      RESOLUTION:  YES (changed for version 1.6).  The hardware is  
      capable of summing the two dot products.  
  
      Versions of this specification prior to version 1.6 documented that  
      an INVALID_OPERATION should be generated if either <abDotProduct>  
      or <cdDotProduct> is true and then <sumOutput> is not GL_DISCARD.  
      However, this check was never added to the driver and some  
      applications found the mode useful.  
  
    Does the GL_E_TIMES_F_NV token for the final combiner perform any  
    mapping on E or F before the mapping?  Is the multiply signed?  
    Can the result be negative?  
  
      RESOLUTION:  Input mappings and component usage is applied to E or  
      F before their product is computed.  Yes, the product is a signed  
      multiplication.  The result can be negative, but the two allowed  
      final combiner input mapping modes (GL_UNSIGNED_IDENTITY_NV and  
      GL_UNSIGNED_INVERT_NV) both effectively clamp their results to  
      [0,1].  
  
      A negative value resulting from the "E times F" product with the  
      GL_UNSIGNED_IDENTITY_NV mapping mode would be clamped to zero.  
  
      A negative value resulting from the "E times F" product with the  
      GL_UNSIGNED_INVERT_NV mpaping mode would be clamped to zero but  
      then one minus that clamped result (zero) would generate one.  
  
homeprevnext New Procedures and Functions
  
    void CombinerParameterfvNV(GLenum pname,  
                               const GLfloat *params);  
  
    void CombinerParameterivNV(GLenum pname,  
                               const GLint *params);  
  
    void CombinerParameterfNV(GLenum pname,  
                              GLfloat param);  
  
    void CombinerParameteriNV(GLenum pname,  
                              GLint param);  
  
    void CombinerInputNV(GLenum stage,  
                         GLenum portion,  
                         GLenum variable,  
                         GLenum input,  
                         GLenum mapping,  
                         GLenum componentUsage);  
  
    void CombinerOutputNV(GLenum stage,  
                          GLenum portion,   
                          GLenum abOutput,  
                          GLenum cdOutput,  
                          GLenum sumOutput,  
                          GLenum scale,  
                          GLenum bias,  
                          GLboolean abDotProduct,  
                          GLboolean cdDotProduct,  
                          GLboolean muxSum);  
  
    void FinalCombinerInputNV(GLenum variable,  
                              GLenum input,  
                              GLenum mapping,  
                              GLenum componentUsage);  
  
    void GetCombinerInputParameterfvNV(GLenum stage,  
                                       GLenum portion,  
                                       GLenum variable,  
                                       GLenum pname,  
                                       GLfloat *params);  
  
    void GetCombinerInputParameterivNV(GLenum stage,  
                                       GLenum portion,  
                                       GLenum variable,  
                                       GLenum pname,  
                                       GLint *params);  
  
    void GetCombinerOutputParameterfvNV(GLenum stage,  
                                        GLenum portion,   
                                        GLenum pname,  
                                        GLfloat *params);  
  
    void GetCombinerOutputParameterivNV(GLenum stage,  
                                        GLenum portion,   
                                        GLenum pname,  
                                        GLint *params);  
  
    void GetFinalCombinerInputParameterfvNV(GLenum variable,  
                                            GLenum pname,  
                                            GLfloat *params);  
  
    void GetFinalCombinerInputParameterivNV(GLenum variable,  
                                            GLenum pname,  
                                            GLint *params);  
  
homeprevnext New Tokens
  
    Accepted by the <cap> parameter of Enable, Disable, and IsEnabled,  
    and by the <pname> parameter of GetBooleanv, GetIntegerv,  
    GetFloatv, and GetDoublev:  
  
        REGISTER_COMBINERS_NV              0x8522  
  
    Accepted by the <stage> parameter of CombinerInputNV,  
    CombinerOutputNV, GetCombinerInputParameterfvNV,  
    GetCombinerInputParameterivNV, GetCombinerOutputParameterfvNV,  
    and GetCombinerOutputParameterivNV:  
  
        COMBINER0_NV                       0x8550  
        COMBINER1_NV                       0x8551  
        COMBINER2_NV                       0x8552  
        COMBINER3_NV                       0x8553  
        COMBINER4_NV                       0x8554  
        COMBINER5_NV                       0x8555  
        COMBINER6_NV                       0x8556  
        COMBINER7_NV                       0x8557  
  
    Accepted by the <variable> parameter of CombinerInputNV,  
    GetCombinerInputParameterfvNV, and GetCombinerInputParameterivNV:  
  
        VARIABLE_A_NV                      0x8523  
        VARIABLE_B_NV                      0x8524  
        VARIABLE_C_NV                      0x8525  
        VARIABLE_D_NV                      0x8526  
  
    Accepted by the <variable> parameter of FinalCombinerInputNV,  
    GetFinalCombinerInputParameterfvNV, and  
    GetFinalCombinerInputParameterivNV:  
  
        VARIABLE_A_NV  
        VARIABLE_B_NV  
        VARIABLE_C_NV  
        VARIABLE_D_NV  
        VARIABLE_E_NV                      0x8527  
        VARIABLE_F_NV                      0x8528  
        VARIABLE_G_NV                      0x8529  
  
    Accepted by the <input> parameter of CombinerInputNV:  
  
        ZERO                                          (not new)  
        CONSTANT_COLOR0_NV                 0x852A  
        CONSTANT_COLOR1_NV                 0x852B  
        FOG                                           (not new)  
        PRIMARY_COLOR_NV                   0x852C  
        SECONDARY_COLOR_NV                 0x852D  
        SPARE0_NV                          0x852E  
        SPARE1_NV                          0x852F  
        TEXTURE0_ARB                                  (see ARB_multitexture)  
        TEXTURE1_ARB                                  (see ARB_multitexture)  
  
    Accepted by the <mapping> parameter of CombinerInputNV:  
  
        UNSIGNED_IDENTITY_NV               0x8536  
        UNSIGNED_INVERT_NV                 0x8537  
        EXPAND_NORMAL_NV                   0x8538  
        EXPAND_NEGATE_NV                   0x8539  
        HALF_BIAS_NORMAL_NV                0x853A  
        HALF_BIAS_NEGATE_NV                0x853B  
        SIGNED_IDENTITY_NV                 0x853C  
        SIGNED_NEGATE_NV                   0x853D  
  
    Accepted by the <input> parameter of FinalCombinerInputNV:  
  
        ZERO                                          (not new)  
        CONSTANT_COLOR0_NV  
        CONSTANT_COLOR1_NV  
        FOG                                           (not new)  
        PRIMARY_COLOR_NV  
        SECONDARY_COLOR_NV  
        SPARE0_NV  
        SPARE1_NV  
        TEXTURE0_ARB                                  (see ARB_multitexture)  
        TEXTURE1_ARB                                  (see ARB_multitexture)  
        E_TIMES_F_NV                       0x8531  
        SPARE0_PLUS_SECONDARY_COLOR_NV     0x8532  
  
    Accepted by the <mapping> parameter of FinalCombinerInputNV:  
  
        UNSIGNED_IDENTITY_NV  
        UNSIGNED_INVERT_NV  
  
    Accepted by the <scale> parameter of CombinerOutputNV:  
  
        NONE                                          (not new)  
        SCALE_BY_TWO_NV                    0x853E  
        SCALE_BY_FOUR_NV                   0x853F  
        SCALE_BY_ONE_HALF_NV               0x8540  
  
    Accepted by the <bias> parameter of CombinerOutputNV:  
  
        NONE                                          (not new)  
        BIAS_BY_NEGATIVE_ONE_HALF_NV       0x8541  
  
    Accepted by the <abOutput>, <cdOutput>, and <sumOutput> parameter  
    of CombinerOutputNV:  
  
        DISCARD_NV                         0x8530  
        PRIMARY_COLOR_NV  
        SECONDARY_COLOR_NV    
        SPARE0_NV    
        SPARE1_NV    
        TEXTURE0_ARB                                  (see ARB_multitexture)  
        TEXTURE1_ARB                                  (see ARB_multitexture)  
  
    Accepted by the <pname> parameter of GetCombinerInputParameterfvNV  
    and GetCombinerInputParameterivNV:  
  
        COMBINER_INPUT_NV                  0x8542  
        COMBINER_MAPPING_NV                0x8543  
        COMBINER_COMPONENT_USAGE_NV        0x8544  
  
    Accepted by the <pname> parameter of GetCombinerOutputParameterfvNV  
    and GetCombinerOutputParameterivNV:  
  
        COMBINER_AB_DOT_PRODUCT_NV         0x8545  
        COMBINER_CD_DOT_PRODUCT_NV         0x8546  
        COMBINER_MUX_SUM_NV                0x8547  
        COMBINER_SCALE_NV                  0x8548  
        COMBINER_BIAS_NV                   0x8549  
        COMBINER_AB_OUTPUT_NV              0x854A  
        COMBINER_CD_OUTPUT_NV              0x854B  
        COMBINER_SUM_OUTPUT_NV             0x854C  
  
    Accepted by the <pname> parameter of CombinerParameterfvNV,  
    CombinerParameterivNV, GetBooleanv, GetDoublev, GetFloatv, and  
    GetIntegerv:  
  
        CONSTANT_COLOR0_NV  
        CONSTANT_COLOR1_NV  
  
    Accepted by the <pname> parameter of CombinerParameterfvNV,  
    CombinerParameterivNV, CombinerParameterfNV, CombinerParameteriNV,  
    GetBooleanv, GetDoublev, GetFloatv, and GetIntegerv:  
  
        NUM_GENERAL_COMBINERS_NV           0x854E  
        COLOR_SUM_CLAMP_NV                 0x854F  
  
    Accepted by the <pname> parameter of GetFinalCombinerInputParameterfvNV  
    and GetFinalCombinerInputParameterivNV:  
  
        COMBINER_INPUT_NV  
        COMBINER_MAPPING_NV  
        COMBINER_COMPONENT_USAGE_NV  
  
    Accepted by the <pname> parameter of GetBooleanv, GetDoublev,  
    GetFloatv, and GetIntegerv:  
  
        MAX_GENERAL_COMBINERS_NV           0x854D  
  
homeprevnext Additions to Chapter 2 of the 1.2 Specification (OpenGL Operation)
  
     None  
  
homeprevnext Additions to Chapter 3 of the 1.2 Specification (Rasterization)
  
 --  Figure 3.1 "Rasterization" (page 58)  
  
     +  Change the "Texturing" block to say "Texture Fetching".  
  
     +  Insert a new block between "Texture Fetching" and "Color Sum".  
        Name the new block "Texture Environment Application".  
  
     +  Insert a new block after "Texture Fetching".  Name the new block  
        "Register Combiners Application".  
  
     +  The output of the "Texture Fetching" stage feeds to both "Texture  
        Environment Application" and "Register Combiners Application".  
  
     +  The input for "Color Sum" comes from "Texture Environment  
        Application".  
  
     +  The output to "Fragments" is switched (controlled by  
        Disable/Enable REGISTER_COMBINERS_NV) between the output of "Fog"  
        and "Register Combiners Application".  
  
     Essentially, when register combiners are enabled, the entire standard  
     texture environment application, color sum, and fog blocks are  
     replaced with the single register combiners block.  [Note that this  
     is different from how the NV_texture_env_combine4 extension works;  
     that extension controls the texture environment application  
     block, but still uses the standard color sum and fog blocks.]  
  
 --  NEW Section 3.8.12 "Register Combiners Application"  
  
     "In parallel to the texture application, color sum, and fog processes  
     described in sections 3.8.10, 3.9, and 3.10, register combiners  
     provide a means of computing fcoc, the final combiner output color,  
     for each fragment generated by rasterization.  
  
     The register combiners consist of two or more general combiner stages  
     arranged in a fixed sequence ordered by each combiner stage's number.  
     An implementation supports a maximum number of general combiners  
     stages, which may be queried by calling GetIntegerv with the symbolic  
     constant MAX_GENERAL_COMBINERS_NV.  Implementations must  
     support at least two general combiner stages.  The general combiner  
     stages are named COMBINER0_NV, COMBINER1_NV, and so on.  
  
     Each general combiner in the sequence receives its inputs and  
     computes its outputs in an identical manner.  At the end of the  
     sequence of general combiner stages, there is a final combiner stage  
     that operates in a different manner than the general combiner stages.  
     The general combiner operation is described first, followed by a  
     description of the final combiner operation.  
  
     Each combiner stage (the general combiner stages and the final  
     combiner stage) has an associated combiner register set.  Each  
     combiner register set contains <n> RGBA vectors with components  
     ranging from -1.0 to 1.0 where <n> is 8 plus the maximum number  
     of active textures supported (that is, the implementation's value  
     for MAX_TEXTURE_UNITS_ARB).  The combiner register set entries  
     are listed in the table NV_register_combiners.1.  
  
     [ Table NV_register_combiners.1 ]  
  
                                Initial                        Output  
        Register Name           Value       Reference          Status  
        ---------------------   ----------  ----------------   ---------  
        ZERO                    0           -                  read only  
        CONSTANT_COLOR0_NV      ccc0        Section 3.8.12.1   read only  
        CONSTANT_COLOR1_NV      ccc1        Section 3.8.12.1   read only  
        FOG                     Cf          Section 3.10       read only  
        PRIMARY_COLOR_NV        cpri        Section 2.13.1     read/write  
        SECONDARY_COLOR_NV      csec        Section 2.13.1     read/write  
        SPARE0_NV               see below   Section 3.8.12     read/write  
        SPARE1_NV               undefined   Section 3.8.12     read/write  
        TEXTURE0_ARB            CT0         Figure E.2         read/write  
        TEXTURE1_ARB            CT1         Figure E.2         read/write  
        TEXTURE<i>_ARB          CT<i>       Figure E.2         read/write  
  
     The register set of COMBINER0_NV, the first combiner stage,  
     is initialized as described in table NV_register_combiners.1.  
  
     The initial value of the alpha portion of register SECONDARY_COLOR_NV  
     is undefined.  The initial value of the alpha portion of register  
     SPARE0_NV is the alpha component of texture 0 if texturing is  
     enabled for texture 0; however, the initial value of the RGB portion  
     SPARE0_NV is undefined.  The initial value of the SPARE1_NV register  
     is undefined.  The initial of registers TEXTURE0_ARB, TEXTURE1_ARB,  
     and TEXTURE<i>_ARB are undefined if texturing is not enabled for  
     textures 0, 1, and <i>, respectively.  
  
     The mapping of texture components to components of texture registers  
     is summarized in Table NV_register_combiners.2.  In the following  
     table, At, Lt, It, Rt, Gt, Bt, and Dt, are the filtered texel  
     values.  
  
     [Table NV_register_combiners.2]: Correspondence of texture components  
     to register components for texture registers.  
  
        Base Internal Format            RGB Values      Alpha Value  
        --------------------            ----------      -----------  
        ALPHA                           0,  0,  0       At  
        LUMINANCE                       Lt, Lt, Lt      1  
        LUMINANCE_ALPHA                 Lt, Lt, Lt      At  
        INTENSITY                       It, It, It      It  
        RGB                             Rt, Gt, Bt      1  
        RGBA                            Rt, Gt, Bt      At  
  
        DEPTH_COMPONENT                 0,  0,  0,      Lt  
          (when TEXTURE_COMPARE_MODE_ARB is NONE -or-  
                TEXTURE_COMPARE_SGIX is false)  
        DEPTH_COMPONENT                 Lt, Lt, Lt,     Lt  
          (when TEXTURE_COMPARE_MODE_ARB is COMPARE_R_TO_TEXTURE -or-  
                TEXTURE_COMPARE_SGIX is true)  
  
        HILO_NV                         0,  0,  0,      0  
        DSDT_NV                         0,  0,  0,      0  
        DSDT_MAG_NV                     0,  0,  0,      0  
        DSDT_MAG_INTENSITY_NV           0,  0,  0,      It  
  
     Note that the ALPHA, DEPTH_COMPONENT, and DSDT_MAG_INTENSITY_NV  
     base internal formats are mapped to components differently than  
     one could infer from the standard texture environment operations  
     with this formats.  A texture's DEPTH_TEXTURE_MODE_ARB state (see  
     the ARB_depth_texture extension) is irrelevant for determining the  
     correspondence of texture components to register components for  
     texture registers when REGISTER_COMBINERS_NV is enabled.  
  
     3.8.12.1  Combiner Parameters  
  
     Combiner parameters are specified by  
  
         CombinerParameterfvNV(GLenum pname, const GLfloat *params);  
         CombinerParameterivNV(GLenum pname, const GLint *params);  
         CombinerParameterfNV(GLenum pname, GLfloat param);  
         CombinerParameteriNV(GLenum pname, GLint param);  
  
     <pname> is a symbolic constant indicating which parameter is to be  
     set as described in the table NV_register_combiners.3:  
  
     [ Table NV_register_combiners.3 ]  
                                               Number  
       Parameter   Name                        of values   Type  
       ---------   -------------------------   ---------   ---------------  
       ccc0        CONSTANT_COLOR0_NV          4           color  
       ccc1        CONSTANT_COLOR1_NV          4           color  
       ngc         NUM_GENERAL_COMBINERS_NV    1           positive integer  
       csc         COLOR_SUM_CLAMP_NV          1           boolean  
  
     <params> is a pointer to a group of values to which to set the  
     indicated parameter.  <param> is simply the indicated parameter.  
     The number of values pointed to depends on the parameter being  
     set as shown in the table above.  Color parameters specified with  
     CombinerParameter*NV are converted to floating-point values (if  
     specified as integers) as indicated by Table 2.6 for signed integers.  
     The floating-point color values are then clamped to the range [0,1].  
  
     The values ccc0 and ccc1 named by CONSTANT_COLOR0_NV and  
     CONSTANT_COLOR1_NV are constant colors available for inputs to the  
     combiner stages.  The value ngc named by NUM_GENERAL_COMBINERS_NV  
     is a positive integer indicating how many general combiner stages are  
     active, that is, how many general combiner stages a fragment should  
     be processed by.  Setting ngc to a value less than one or  
     greater than the value of MAX_GENERAL_COMBINERS_NV generates an  
     INVALID_VALUE error.  The value csc named by COLOR_SUM_CLAMP_NV  
     is a boolean described in section 3.8.12.3.  
  
     3.8.12.2  General Combiner Stage Operation  
  
     The command  
  
         CombinerInputNV(GLenum stage,  
                         GLenum portion,  
                         GLenum variable,  
                         GLenum input,  
                         GLenum mapping,  
                         GLenum componentUsage);  
  
     controls the assignment of all the general combiner input variables.  
     For the RGB combiner portion, these are Argb, Brgb, Crgb, and  
     Drgb; and for the combiner alpha portion, these are Aa, Ba, Ca,  
     and Da.  The <stage> parameter is a symbolic constant of the form  
     COMBINER<i>_NV, indicating that general combiner stage <i> is to  
     be updated.  The constant COMBINER<i>_NV = COMBINER0_NV + <i>  
     where <i> is in the range 0 to <k>-1 and <k> is the implementation  
     dependent value of MAX_COMBINERS_NV.  The <portion> parameter  
     may be either RGB or ALPHA and determines whether the RGB color  
     vector or alpha scalar portion of the specified combiner stage is  
     updated.  The <variable> parameter may be one of VARIABLE_A_NV,  
     VARIABLE_B_NV, VARIABLE_C_NV, or VARIABLE_D_NV and determines  
     which respective variable of the specified combiner stage and  
     combiner stage portion is updated.  
  
     The <input>, <mapping>, and <componentUsage> parameters specify  
     the assignment of a value for the input variable indicated by  
     <stage>, <portion>, and <variable>.  The <input> parameter may be  
     one of the register names from table NV_register_combiners.1.  
  
     The <componentUsage> parameter may be one of RGB, ALPHA, or BLUE.  
  
     When the <portion> parameter is RGB, a <componentUsage> parameter  
     of RGB indicates that the RGB portion of the indicated register  
     should be assigned to the RGB portion of the combiner input variable,  
     while an ALPHA <componentUsage> parameter indicates that the  
     alpha portion of the indicated register should be replicated across  
     the RGB portion of the combiner input variable.  
  
     When the <portion> parameter is ALPHA, the <componentUsage>  
     parameter of ALPHA indicates that the alpha portion of the indicated  
     register should be assigned to the alpha portion of the combiner  
     input variable, while a BLUE <componentUsage> parameter indicates  
     that the blue component of the indicated register should be assigned  
     to the alpha portion of the combiner input variable.  
  
     When the <portion> parameter is ALPHA, a <componentUsage> parameter  
     of RGB generates an INVALID_OPERATION error.  When the <portion>  
     parameter is RGB, a <componentUsage> parameter of BLUE generates  
     an INVALID_OPERATION error.  
  
     When the <componentUsage> parameter is ALPHA, an <input> parameter  
     of FOG generates an INVALID_OPERATION error.  The alpha component of  
     the fog register is only available in the final combiner.  The alpha  
     component of the fog register is the fragment's fog factor when fog  
     is enabled; otherwise, the alpha component of the fog register is  
     one.  
  
     Before the value in the register named by <input> is assigned to the  
     specified input variable, a range mapping is performed based on  
     <mapping>.  The mapping may be one of the tokens from the table  
     NV_register_combiners.4.  
  
     [ Table NV_register_combiners.4 ]  
  
       Mapping Name              Mapping Function  
       -----------------------   -------------------------------------  
       UNSIGNED_IDENTITY_NV      max(0.0, e)  
       UNSIGNED_INVERT_NV        1.0 - min(max(e, 0.0), 1.0)  
       EXPAND_NORMAL_NV          2.0 * max(0.0, e) - 1.0  
       EXPAND_NEGATE_NV          -2.0 * max(0.0, e) + 1.0  
       HALF_BIAS_NORMAL_NV       max(0.0, e) - 0.5  
       HALF_BIAS_NEGATE_NV       -max(0.0, e) + 0.5  
       SIGNED_IDENTITY_NV        e  
       SIGNED_NEGATE_NV          -e  
  
     Based on the <mapping> parameter, the mapping function in the table  
     above is evaluated for each element <e> of the input vector before  
     assigning the result to the specified input variable.  Note that  
     the mapping for the RGB and alpha portion of each input variable  
     is distinct.  
  
     Each general combiner stage computes the following ten expressions  
     based on the values assigned to the variables Argb, Brgb, Crgb,  
     Drgb, Aa, Ba, Ca, and Da as determined by the combiner state set  
     by CombinerInputNV.  
  
     ["gcc" stands for general combiner computation.]  
  
        gcc1rgb = [ Argb[r]*Brgb[r], Argb[g]*Brgb[g], Argb[b]*Brgb[b] ]  
  
        gcc2rgb = [ Argb[r]*Brgb[r] + Argb[g]*Brgb[g] + Argb[b]*Brgb[b],  
                    Argb[r]*Brgb[r] + Argb[g]*Brgb[g] + Argb[b]*Brgb[b],  
                    Argb[r]*Brgb[r] + Argb[g]*Brgb[g] + Argb[b]*Brgb[b] ]  
  
        gcc3rgb = [ Crgb[r]*Drgb[r], Crgb[g]*Drgb[g], Crgb[b]*Drgb[b] ]  
  
        gcc4rgb = [ Crgb[r]*Drgb[r] + Crgb[g]*Drgb[g] + Crgb[b]*Drgb[b],  
                    Crgb[r]*Drgb[r] + Crgb[g]*Drgb[g] + Crgb[b]*Drgb[b],  
                    Crgb[r]*Drgb[r] + Crgb[g]*Drgb[g] + Crgb[b]*Drgb[b] ]  
  
        gcc5rgb = gcc1rgb + gcc3rgb  
  
        gcc6rgb = gcc1rgb or gcc3rgb               [see below]  
  
        gcc1a   = Aa * Ba  
  
        gcc2a   = Ca * Da  
  
        gcc3a   = gcc1a + gcc2a  
  
        gcc4a   = gcc1a or gcc2a                   [see below]  
  
     The computation of gcc6rgb and gcc4a involves a special "or"  
     operation.  This operation evaluates to the left-hand operand if  
     the alpha component of the combiner's SPARE0_NV register is less than  
     0.5; otherwise, the operation evaluates to the right-hand operand.    
  
     The command   
  
         CombinerOutputNV(GLenum stage,  
                          GLenum portion,   
                          GLenum abOutput,  
                          GLenum cdOutput,  
                          GLenum sumOutput,  
                          GLenum scale,  
                          GLenum bias,  
                          GLboolean abDotProduct,  
                          GLboolean cdDotProduct,  
                          GLboolean muxSum);  
  
     controls the general combiner output operation including designating  
     the register set locations where results of the general combiner's  
     three computations are written.  The <stage> and <portion>  
     parameters take the same values as the respective parameters for  
     CombinerInputNV.  
  
     If the <portion> parameter is ALPHA, specifying a non-FALSE value  
     for either of the parameters <abDotProduct> or <cdDotProduct>,  
     generates an INVALID_VALUE error.  
  
     The <scale> parameter must be one of NONE, SCALE_BY_TWO_NV,  
     SCALE_BY_FOUR_NV, or SCALE_BY_ONE_HALF_NV and specifies the  
     value of the combiner stage's portion scale, either cscalergb or  
     cscalea depending on the <portion> parameter, to 1.0, 2.0, 4.0,  
     or 0.5, respectively.  
  
     The <bias> parameter must be either NONE or  
     BIAS_BY_NEGATIVE_ONE_HALF_NV and specifies the value of the  
     combiner stage's portion bias, either cbiasrgb or cbiasa depending  
     on the <portion> parameter, to 0.0 or -0.5, respectively.  If <scale>  
     is either SCALE_BY_ONE_HALF_NV or SCALE_BY_FOUR_NV, a <bias> of  
     BIAS_BY_NEGATIVE_ONE_HALF_NV generates an INVALID_OPERATION error.  
  
     If the <abDotProduct> parameter is FALSE, then  
          
        if <portion> is RGB,     out1rgb = max(min(gcc1rgb + cbiasrgb) * cscalergb, 1), -1)  
        if <portion> is ALPHA,   out1a   = max(min((gcc1a + cbiasa) * cscalea, 1), -1)   
  
     otherwise <portion> must be RGB and  
  
        out1rgb = max(min((gcc2rgb + cbiasrgb) * cscalergb, 1), -1)  
  
     If the <cdDotProduct> parameter is FALSE, then  
          
        if <portion> is RGB,      out2rgb = max(min((gcc3rgb + cbiasrgb) * cscalergb, 1), -1)  
        if <portion> is ALPHA,    out2a   = max(min((gcc2a + cbiasa) * cscalea, 1), -1)  
  
     otherwise <portion> must be RGB so  
  
        out2rgb = max(min((gcc4rgb + cbiasrgb) * cscalergb, 1), -1)  
  
     If the <muxSum> parameter is FALSE, then  
          
        if <portion> is RGB,      out3rgb = max(min((gcc5rgb + cbiasrgb) * cscalergb, 1), -1)  
        if <portion> is ALPHA,    out3a   = max(min((gcc3a + cbiasa) * cscalea, 1), -1)  
  
     otherwise  
  
        if <portion> is RGB,      out3rgb = max(min((gcc6rgb + cbiasrgb) * cscalergb, 1), -1)  
        if <portion> is ALPHA,    out3a   = max(min((gcc4a + cbiasa) * cscalea, 1), -1)  
  
     out1rgb, out2rgb, and out3rgb are written to the RGB portion of  
     combiner stage's registers named by <abOutput>, <cdOutput>, and  
     <sumOutput> respectively.  out1a, out2a, and out3a are written to  
     the alpha portion of combiner stage's registers named by <abOutput>,  
     <cdOutput>, and <sumOutput> respectively.  The parameters <abOutput>,  
     <cdOutput>, and <sumOutput> must be either DISCARD_NV or one of  
     the register names from table NV_register_combiners.1 that has an output  
     status of read/write.  If an output is set to DISCARD_NV, that  
     output is not written to any register.  The error INVALID_OPERATION  
     is generated if <abOutput>, <cdOutput>, and <sumOutput> do not all  
     name unique register names (though multiple outputs to DISCARD_NV  
     are legal).  
  
     When the general combiner stage's register set is written based on  
     the computed outputs, the updated register set is copied to the  
     register set of the subsequent combiner stage in the combiner  
     sequence.  Copied undefined values are likewise undefined.  
     The subsequent combiner stage following the last active general  
     combiner stage, indicated by the general combiner stage's number  
     being equal to ngc-1, in the sequence is the final combiner  
     stage.  In other words, the number of general combiner stages  
     each fragment is transformed by is determined by the value of  
     NUM_GENERAL_COMBINERS_NV.  
  
     3.8.12.3  Final Combiner Stage Operation  
  
     The final combiner stage operates differently from the general  
     combiner stages.  While a general combiner stage updates its register  
     set and passes the register set to the next combiner stage, the final  
     combiner outputs an RGBA color fcoc, the final combiner output color.  
     The final combiner stage is capable of applying the standard OpenGL  
     color sum and fog operations, but has the configurability to be  
     used for other purposes.  
       
     The command  
  
        FinalCombinerInputNV(GLenum variable,  
                             GLenum input,  
                             GLenum mapping,  
                             GLenum componentUsage);  
  
     controls the assignment of all the final combiner input variables.  
     The variables A, B, C, D, E, and F are RGB vectors.  The variable  
     G is an alpha scalar.  The <variable> parameter may be one of  
     VARIABLE_A_NV, VARIABLE_B_NV, VARIABLE_C_NV, VARIABLE_D_NV,  
     VARIABLE_E_NV, VARIABLE_F_NV, and VARIABLE_G_NV, and determines  
     which respective variable of the final combiner stage is updated.  
  
     The <input>, <mapping>, and <componentUsage> parameters specify  
     the assignment of a value for the input variable indicated by  
     <variable>.  
  
     The <input> parameter may be any one of the register names from  
     table NV_register_combiners.1 or be one of two pseudo-register  
     names, either E_TIMES_F_NV or SPARE0_PLUS_SECONDARY_COLOR_NV.  
     The value of E_TIMES_F_NV is the product of the value of  
     variable E times the value of variable F.  The value of  
     SPARE0_PLUS_SECONDARY_COLOR_NV is the value the SPARE0_NV  
     register mapped using the UNSIGNED_IDENITY_NV input mapping plus  
     the value of the SECONDARY_COLOR_NV register mapped using the  
     UNSIGNED_IDENTITY_NV input mapping.  If csc, the color sum clamp,  
     is non-FALSE, the value of SPARE0_PLUS_SECONDARY_COLOR_NV is first  
     clamped to the range [0,1].  The alpha component of E_TIMES_F_NV  
     and SPARE0_PLUS_SECONDARY_COLOR_NV is always zero.  
  
     When <variable> is one of VARIABLE_E_NV, VARIABLE_F_NV,  
     or VARIABLE_G_NV and <input> is either E_TIMES_F_NV or  
     SPARE0_PLUS_SECONDARY_COLOR_NV, generate an INVALID_OPERATION  
     error.  When <variable> is VARIABLE_A_NV and <input> is  
     SPARE0_PLUS_SECONDARY_COLOR_NV, generate an INVALID_OPERATION  
     error.  
  
     The <componentUsage> parameter may be one of RGB, BLUE, ALPHA  
     (with certain restrictions depending on the <variable> and <input>  
     as described below).  
  
     When the <variable> parameter is not VARIABLE_G_NV, a  
     <componentUsage> parameter of RGB indicates that the RGB portion of  
     the indicated register should be assigned to the RGB portion of the  
     combiner input variable, while an ALPHA <componentUsage> parameter  
     indicates that the alpha portion of the indicated register should  
     be replicated across the RGB portion of the combiner input variable.  
  
     When the <variable> parameter is VARIABLE_G_NV, a <componentUsage>  
     parameter of ALPHA indicates that the alpha component of the  
     indicated register should be assigned to the alpha portion of the  
     G input variable, while a BLUE <componentUsage> parameter indicates  
     that the blue component of the indicated register should be assigned  
     to the alpha portion of the G input variable.  
  
     The INVALID_OPERATION error is generated when <componentUsage> is  
     BLUE and <variable> is not VARIABLE_G_NV.  The INVALID_OPERATION  
     error is generated when <componentUsage> is RGB and <variable>  
     is VARIABLE_G_NV.  
  
     The INVALID_OPERATION error is generated when both the <input>  
     parameter is either E_TIMES_F_NV or SPARE0_PLUS_SECONDARY_COLOR_NV  
     and the <componentUsage> parameter is ALPHA or BLUE.  
  
     Before the value in the register named by <input> is assigned to  
     the specified input variable, a range mapping is performed based  
     on <mapping>.  The mapping may be either UNSIGNED_IDENTITY_NV  
     or UNSIGNED_INVERT_NV and operates as specified in table  
     NV_register_combiners.4.  
  
     The final combiner stage computes the following expression based  
     on the values assigned to the variables A, B, C, D, E, F, and G as  
     determined by the combiner state set by FinalCombinerInputNV  
  
       fcoc = [ min(ab[r] + iac[r] + D[r], 1.0),  
                min(ab[g] + iac[g] + D[g], 1.0),  
                min(ab[b] + iac[b] + D[b], 1.0),  
                G ]  
  
     where   
  
       ab   = [ A[r]*B[r], A[g]*B[g], A[b]*B[b] ]  
       iac  = [ (1.0 -A [r])*C[r], (1.0 - A[g])*C[g], (1.0 - A[b])*C[b] ]  
  
     3.8.12.4  Required State  
  
     The state required for the register combiners is a bit indicating  
     whether register combiners are enabled or disabled, an integer  
     indicating how many general combiners are active, a bit indicating  
     whether or not the color sum clamp to 1 should be performed, two  
     RGBA constant colors, <n> sets of general combiner stage state where  
     <n> is the value of MAX_GENERAL_COMBINERS_NV, and the final  
     combiner stage state.  The per-stage general combiner state consists  
     of the RGB input portion state and the alpha input portion state.  
     Each portion (RGB and alpha) of the per-stage general combiner  
     state consists of: four integers indicating the input register for  
     the four variables A, B, C, and D; four integers to indicate each  
     variable's range mapping; four bits to indicate whether to use the  
     alpha component of the input for each variable; a bit indicating  
     whether the AB dot product should be output; a bit indicating  
     whether the CD dot product should be output; a bit indicating  
     whether the sum or mux output should be output; two integers to  
     maintain the output scale and bias enumerants; three integers to  
     maintain the output register set names.  The final combiner stage  
     state consists of seven integers to indicate the input register  
     for the seven variables A, B, C, D, E, F, and G; seven integers to  
     indicate each variable's range mapping; and seven bits to indicate  
     whether to use the alpha component of the input for each variable.  
  
     The general combiner per-stage state is initialized as described  
     in table NV_register_combiners.5.  
  
     [ Table NV_register_combiners.5 ]  
  
                                                  Component  
        Portion   Variable   Input                Usage       Mapping  
        -------   --------   ------------------   ---------   ----------------------  
         RGB       A         PRIMARY_COLOR_NV     RGB         UNSIGNED_IDENTITY_NV  
         RGB       B         ZERO                 RGB         UNSIGNED_INVERT_NV  
         RGB       C         ZERO                 RGB         UNSIGNED_IDENTITY_NV  
         RGB       D         ZERO                 RGB         UNSIGNED_IDENTITY_NV  
         alpha     A         PRIMARY_COLOR_NV     ALPHA       UNSIGNED_IDENTITY_NV  
         alpha     B         ZERO                 ALPHA       UNSIGNED_INVERT_NV  
         alpha     C         ZERO                 ALPHA       UNSIGNED_IDENTITY_NV  
         alpha     D         ZERO                 ALPHA       UNSIGNED_IDENTITY_NV  
  
     The final combiner stage state is initialized as described in table  
     NV_register_combiners.6.  
  
     [ Table NV_register_combiners.6 ]  
  
                                                      Component  
        Variable   Input                              Usage       Mapping  
        --------   --------------------------------   ---------   ----------------------  
         A         FOG                                ALPHA       UNSIGNED_IDENTITY_NV  
         B         SPARE0_PLUS_SECONDARY_COLOR_NV     RGB         UNSIGNED_IDENTITY_NV  
         C         FOG                                RGB         UNSIGNED_IDENTITY_NV  
         D         ZERO                               RGB         UNSIGNED_IDENTITY_NV  
         E         ZERO                               RGB         UNSIGNED_IDENTITY_NV  
         F         ZERO                               RGB         UNSIGNED_IDENTITY_NV  
         G         SPARE0_NV                          ALPHA       UNSIGNED_IDENTITY_NV"  
  
 --  NEW Section 3.8.11 "Antialiasing Application"  
  
     Insert the following paragraph BEFORE the section's first paragraph:  
  
     "Register combiners are enabled or disabled using the generic Enable  
     and Disable commands, respectively, with the symbolic constant  
     REGISTER_COMBINERS_NV.  If the register combiners are enabled (and not in color  
     index mode), the fragment's color value is replaced with fcoc, the  
     final combiner output color, computed in section 3.8.12; otherwise,  
     the fragment's color value is the result of the fog application  
     in section 3.10."  
  
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 "Enumerated Queries"  
  
     Change the first two sentences (page 182) to say:  
  
     "Other commands exist to obtain state variables that are identified by  
     a category (clip plane, light, material, combiners, etc.) as well as  
     a symbolic constant.  These are"  
  
     Add to the bottom of the list of function prototypes (page 183):  
  
       void GetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable,  
                                          GLenum pname, const GLfloat *params);  
       void GetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable,  
                                          GLenum pname, const GLint *params);  
       void GetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, const GLfloat *params);  
       void GetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, GLint *params);  
       void GetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, const GLfloat *params);  
       void GetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, const GLfloat *params);  
  
     Add the following paragraph to the end of the section (page 184):  
  
     "The GetCombinerInputParameterfvNV,  
     GetCombinerInputParameterivNV, GetCombinerOutputParameterfvNV,  
     and GetCombinerOutputParameterivNV parameter <stage> may be one of  
     COMBINER0_NV, COMBINER1_NV, and so on, indicating which general  
     combiner stage to query.  The GetCombinerInputParameterfvNV,  
     GetCombinerInputParameterivNV, GetCombinerOutputParameterfvNV,  
     and GetCombinerOutputParameterivNV parameter <portion> may be  
     either RGB or ALPHA, indicating which portion of the general  
     combiner stage to query.  The GetCombinerInputParameterfvNV  
     and GetCombinerInputParameterivNV parameter <variable> may  
     be one of VARIABLE_A_NV, VARIABLE_B_NV, VARIABLE_C_NV,  
     or VARIABLE_D_NV, indicating which variable of the general  
     combiner stage to query.  The GetFinalCombinerInputParameterfvNV  
     and GetFinalCombinerInputParameterivNV parameter <variable> may be one  
     of VARIABLE_A_NV, VARIABLE_B_NV, VARIABLE_C_NV, VARIABLE_D_NV,  
     VARIABLE_E_NV, VARIABLE_F_NV, or VARIABLE_G_NV."  
  
homeprevnext Additions to the GLX Specification
  
    None.  
  
homeprevnext GLX Protocol
  
    Thirteen new GL commands are added.  
  
    The following seven rendering commands are sent to the sever as part  
    of a glXRender request:  
  
        CombinerParameterfNV  
            2           12              rendering command length  
            2           4136            rendering command opcode  
            4           ENUM            pname  
            4           FLOAT32         param  
  
        CombinerParameterfvNV  
            2           8+4*n           rendering command length  
            2           4137            rendering command opcode  
            4           ENUM            pname  
                        0x852A   n=4    GL_CONSANT_COLOR0_NV  
                        0x852B   n=4    GL_CONSANT_COLOR1_NV  
                        0x854E   n=1    GL_NUM_GENERAL_COMBINERS_NV  
                        0x854F   n=1    GL_COLOR_SUM_CLAMP_NV  
                        else     n=0  
            4*n         LISTofFLOAT32   params  
  
        CombinerParameteriNV  
            2           12              rendering command length  
            2           4138            rendering command opcode  
            4           ENUM            pname  
            4           INT32           param  
  
        CombinerParameterivNV  
            2           8+4*n           rendering command length  
            2           4139            rendering command opcode  
            4           ENUM            pname  
                        0x852A   n=4    GL_CONSANT_COLOR0_NV  
                        0x852B   n=4    GL_CONSANT_COLOR1_NV  
                        0x854E   n=1    GL_NUM_GENERAL_COMBINERS_NV  
                        0x854F   n=1    GL_COLOR_SUM_CLAMP_NV  
                        else     n=0  
            4*n         LISTofINT32     params  
  
        CombinerInputNV  
            2           28              rendering command length  
            2           4140            rendering command opcode  
            4           ENUM            stage  
            4           ENUM            portion  
            4           ENUM            variable  
            4           ENUM            input  
            4           ENUM            mapping  
            4           ENUM            componentUsage  
          
        CombinerOutputNV  
            2           36              rendering command length  
            2           4141            rendering command opcode  
            4           ENUM            stage  
            4           ENUM            portion  
            4           ENUM            abOutput  
            4           ENUM            cdOutput  
            4           ENUM            sumOutput  
            4           ENUM            scale  
            4           ENUM            bias  
            1           BOOL            abDotProduct  
            1           BOOL            cdDotProduct  
            1           BOOL            muxSum  
            1           BOOL            unused  
          
        FinalCombinerInputNV  
            2           20              rendering command length  
            2           4142            rendering command opcode  
            4           ENUM            variable  
            4           ENUM            input  
            4           ENUM            mapping  
            4           ENUM            componentUsage  
  
    The remaining six commands are non-rendering commands.  These commands  
    are sent separately (i.e., not as part of a glXRender or glXRenderLarge  
    request), using the glXVendorPrivateWithReply request:  
  
        GetCombinerInputParameterfvNV  
            1           CARD8           opcode (X assigned)  
            1           17              GLX opcode (glXVendorPrivateWithReply)  
            2           7               request length  
            4           1270            vendor specific opcode  
            4           GLX_CONTEXT_TAG context tag  
            4           ENUM            stage  
            4           ENUM            portion  
            4           ENUM            variable  
            4           ENUM            pname  
          =>  
            1           1               reply  
            1                           unused  
            2           CARD16          sequence number  
            4           m               reply length, m = (n==1 ? 0 : n)  
            4                           unused  
            4           CARD32          unused  
  
            if (n=1) this follows:  
  
            4           FLOAT32         params  
            12                          unused  
  
            otherwise this follows:  
  
            16                          unused  
            n*4         LISTofFLOAT32   params  
  
        GetCombinerInputParameterivNV  
            1           CARD8           opcode (X assigned)  
            1           17              GLX opcode (glXVendorPrivateWithReply)  
            2           7               request length  
            4           1271            vendor specific opcode  
            4           GLX_CONTEXT_TAG context tag  
            4           ENUM            stage  
            4           ENUM            portion  
            4           ENUM            variable  
            4           ENUM            pname  
          =>  
            1           1               reply  
            1                           unused  
            2           CARD16          sequence number  
            4           m               reply length, m = (n==1 ? 0 : n)  
            4                           unused  
            4           CARD32          unused  
  
            if (n=1) this follows:  
  
            4           INT32           params  
            12                          unused  
  
            otherwise this follows:  
  
            16                          unused  
            n*4         LISTofINT32     params  
  
        GetCombinerOutputParameterfvNV  
            1           CARD8           opcode (X assigned)  
            1           17              GLX opcode (glXVendorPrivateWithReply)  
            2           6               request length  
            4           1272            vendor specific opcode  
            4           GLX_CONTEXT_TAG context tag  
            4           ENUM            stage  
            4           ENUM            portion  
            4           ENUM            pname  
          =>  
            1           1               reply  
            1                           unused  
            2           CARD16          sequence number  
            4           m               reply length, m = (n==1 ? 0 : n)  
            4                           unused  
            4           CARD32          unused  
  
            if (n=1) this follows:  
  
            4           FLOAT32         params  
            12                          unused  
  
            otherwise this follows:  
  
            16                          unused  
            n*4         LISTofFLOAT32   params  
  
        GetCombinerOutputParameterivNV  
            1           CARD8           opcode (X assigned)  
            1           17              GLX opcode (glXVendorPrivateWithReply)  
            2           6               request length  
            4           1273            vendor specific opcode  
            4           GLX_CONTEXT_TAG context tag  
            4           ENUM            stage  
            4           ENUM            portion  
            4           ENUM            pname  
          =>  
            1           1               reply  
            1                           unused  
            2           CARD16          sequence number  
            4           m               reply length, m = (n==1 ? 0 : n)  
            4                           unused  
            4           CARD32          unused  
  
            if (n=1) this follows:  
  
            4           INT32           params  
            12                          unused  
  
            otherwise this follows:  
  
            16                          unused  
            n*4         LISTofINT32     params  
  
        GetFinalCombinerInputParameterfvNV  
            1           CARD8           opcode (X assigned)  
            1           17              GLX opcode (glXVendorPrivateWithReply)  
            2           5               request length  
            4           1274            vendor specific opcode  
            4           GLX_CONTEXT_TAG context tag  
            4           ENUM            variable  
            4           ENUM            pname  
          =>  
            1           1               reply  
            1                           unused  
            2           CARD16          sequence number  
            4           m               reply length, m = (n==1 ? 0 : n)  
            4                           unused  
            4           CARD32          unused  
  
            if (n=1) this follows:  
  
            4           FLOAT32         params  
            12                          unused  
  
            otherwise this follows:  
  
            16                          unused  
            n*4         LISTofFLOAT32   params  
  
        GetFinalCombinerInputParameterivNV  
            1           CARD8           opcode (X assigned)  
            1           17              GLX opcode (glXVendorPrivateWithReply)  
            2           5               request length  
            4           1275            vendor specific opcode  
            4           GLX_CONTEXT_TAG context tag  
            4           ENUM            variable  
            4           ENUM            pname  
          =>  
            1           1               reply  
            1                           unused  
            2           CARD16          sequence number  
            4           m               reply length, m = (n==1 ? 0 : n)  
            4                           unused  
            4           CARD32          unused  
  
            if (n=1) this follows:  
  
            4           INT32           params  
            12                          unused  
  
            otherwise this follows:  
  
            16                          unused  
            n*4         LISTofINT32     params  
  
homeprevnext Dependencies on NV_texture_shader
  
     If NV_texture_shader is not supported, references to HILO_NV,  
     DSDT_NV, DSDT_MAG_NV, and DSDT_MAG_INTENSITY_NV base internal  
     formats in this document are invalid and should be ignored.  
  
homeprevnext Dependencies on ARB_depth_texture and ARB_shadow -or- SGIX_depth_texture and SGIX_shadow
  
     If ARB_depth_texture and ARB_shadow -or- SGIX_depth_texture and  
     SGIX_shadow are not supported, references to the DEPTH_COMPONENT base  
     internal format in this document are invalid and should be ignored.  
  
     If ARB_depth_texture and ARB_shadow are not supported, references  
     to the DEPTH_TEXTURE_MODE_ARB state in this document 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)" "min(1,x)", "min(x,1)", and "max(x,-1)" functions used  
     in Table NV_register_combiners.4 and the formulas for computing  
     out1rgb, out1a, out2rgb, out2a, out3rgb, out3a, and fcoc  when  
     CLAMP_FRAGMENT_COLOR_ARB is either FIXED_ONLY_ARB when rendering  
     to a floating-point color framebuffer or FALSE.  
  
     Also when CLAMP_FRAGMENT_COLOR_ARB is either FIXED_ONLY_ARB when  
     rendering to a floating-point color framebuffer or FALSE, the  
     COLOR COLOR_SUM_CLAMP_NV state operates as if TRUE regardless of  
     its actual state.  
  
     The intent of these interactions is to eliminate the specified  
     clamping behavior of register combiners when CLAMP_FRAGMENT_COLOR_ARB  
     indicates clamping should not be performed.  
  
homeprevnext Errors
  
     INVALID_VALUE is generated when CombinerParameterfvNV  
     or CombinerParameterivNV is called with <pname> set to  
     NUM_GENERAL_COMBINERS and the value pointed to by <params>  
     is less than one or greater or equal to the value of  
     MAX_GENERAL_COMBINERS_NV.  
  
     INVALID_OPERATION is generated when CombinerInputNV is called  
     with a <componentUsage> parameter of RGB and a <portion> parameter  
     of ALPHA.  
  
     INVALID_OPERATION is generated when CombinerInputNV is called  
     with a <componentUsage> parameter of BLUE and a <portion> parameter  
     of RGB.  
  
     INVALID_OPERATION is generated When CombinerInputNV is called with a  
     <componentUsage> parameter of ALPHA and an <input> parameter of FOG.  
  
     INVALID_VALUE is generated when CombinerOutputNV is called with  
     a <portion> parameter of ALPHA, but a non-FALSE value for either  
     of the parameters <abDotProduct> or <cdDotProduct>.  
  
     INVALID_OPERATION is generated when CombinerOutputNV is called with  
     a <scale> of either SCALE_BY_ONE_HALF_NV or SCALE_BY_FOUR_NV and  
     a <bias> of BIAS_BY_NEGATIVE_ONE_HALF_NV.  
  
     INVALID_OPERATION is generated when CombinerOutputNV is called such  
     that <abOutput>, <cdOutput>, and <sumOutput> do not all name unique  
     register names (though multiple outputs to DISCARD_NV are legal).  
  
     INVALID_OPERATION is generated when FinalCombinerInputNV  
     is called where <variable> is one of VARIABLE_E_NV,  
     VARIABLE_F_NV, or VARIABLE_G_NV and <input> is E_TIMES_F_NV or  
     SPARE0_PLUS_SECONDARY_COLOR_NV.  
  
     INVALID_OPERATION is generated when FinalCombinerInputNV  
     is called where <variable> is VARIABLE_A_NV and <input> is  
     SPARE0_PLUS_SECONDARY_COLOR_NV.  
  
     INVALID_OPERATION is generated when FinalCombinerInputNV is called  
     with VARIABLE_G_NV for <variable> and RGB for <componentUsage>.  
  
     INVALID_OPERATION is generated when FinalCombinerInputNV is called  
     with a value other than VARIABLE_G_NV for <variable> and BLUE for  
     <componentUsage>.  
  
     INVALID_OPERATION is generated when FinalCombinerInputNV is  
     called where the <input> parameter is either E_TIMES_F_NV or  
     SPARE0_PLUS_SECONDARY_COLOR_NV and the <componentUsage> parameter  
     is ALPHA.  
  
homeprevnext New State
  
 --  (NEW table 6.29, after p217)   
  
Get Value                          Type      Get Command                          Initial Value           Description        Sec       Attribute  
---------                          --------  ----------------------------------   ----------------------  ----------------   --------  --------------  
REGISTER_COMBINERS_NV              B         IsEnabled                            False                   register           3.8.11    texture/enable  
                                                                                                          combiners enable  
NUM_GENERAL_COMBINERS_NV           Z+        GetIntegerv                          1                       number of active   3.8.12.1  texture  
                                                                                                          combiner stages  
COLOR_SUM_CLAMP_NV                 B         GetBooleanv                          True                    whether or not     3.8.12.1  texture  
                                                                                                          SPARE0_PLUS_  
                                                                                                          SECONDARY_  
                                                                                                          COLOR_NV clamps  
                                                                                                          combiner stages  
CONSTANT_COLOR0_NV                 C         GetFloatv                            0,0,0,0                 combiner constant  3.8.12.1  texture  
                                                                                                          color zero  
CONSTANT_COLOR1_NV                 C         GetFloatv                            0,0,0,0                 combiner constant  3.8.12.1  texture  
                                                                                                          color one  
COMBINER_INPUT_NV                  Z8x#x2x4  GetCombinerInputParameter*NV         see 3.8.12.4            combiner input     3.8.12.2  texture  
                                                                                                          variables  
COMBINER_COMPONENT_USAGE_NV        Z3x#x2x4  GetCombinerInputParameter*NV         see 3.8.12.4            use alpha for      3.8.12.2  texture  
                                                                                                          combiner input  
COMBINER_MAPPING_NV                Z8x#x2x4  GetCombinerInputParameter*NV         see 3.8.12.4            complement         3.8.12.2  texture  
                                                                                                          combiner input  
COMBINER_AB_DOT_PRODUCT_NV         Bx#x2     GetCombinerOutputParameter*NV        False                   output AB dot      3.8.12.3  texture  
                                                                                                          product  
COMBINER_CD_DOT_PRODUCT_NV         Bx#x2     GetCombinerOutputParameter*NV        False                   output CD dot      3.8.12.3  texture  
                                                                                                          product  
COMBINER_MUX_SUM_NV                Bx#x2     GetCombinerOutputParameter*NV        False                   output mux sum     3.8.12.3  texture  
COMBINER_SCALE_NV                  Z2x#x2    GetCombinerOutputParameter*NV        NONE                    output scale       3.8.12.3  texture  
COMBINER_BIAS_NV                   Z2x#x2    GetCombinerOutputParameter*NV        NONE                    output bias        3.8.12.3  texture  
COMBINER_AB_OUTPUT_NV              Z7x#x2    GetCombinerOutputParameter*NV        DISCARD_NV              AB output          3.8.12.3  texture  
                                                                                                          register  
COMBINER_CD_OUTPUT_NV              Z7x#x2    GetCombinerOutputParameter*NV        DISCARD_NV              CD output          3.8.12.3  texture  
                                                                                                          register  
COMBINER_SUM_OUTPUT_NV             Z7x#x2    GetCombinerOutputParameter*NV        SPARE0_NV               sum output         3.8.12.3  texture  
                                                                                                          register  
COMBINER_INPUT_NV                  Z10x7     GetFinalCombinerInputParameter*NV    see 3.8.12.4            final combiner     3.8.12.4  texture  
                                                                                                          input  
COMBINER_MAPPING_NV                Z2x7      GetFinalCombinerInputParameter*NV    UNSIGNED_IDENTITY_NV    final combiner     3.8.12.4  texture  
                                                                                                          input mapping  
COMBINER_COMPONENT_USAGE_NV        Z2x7      GetFinalCombinerInputParameter*NV    see 3.8.12.4            use alpha for      3.8.12.4  texture  
                                                                                                          final combiner  
                                                                                                          input mapping  
  
[ where # is the value of MAX_GENERAL_COMBINERS_NV   ]  
  
homeprevnext New Implementation Dependent State
  
(table 6.24, p214) add the following entry:  
  
    Get Value                    Type    Get Command   Minimum Value   Description         Sec     Attribute  
    --------------------------   ----    -----------   -------------   ----------------    ------  --------------  
    MAX_GENERAL_COMBINERS_NV     Z+      GetIntegerv   2               Maximum num of      3.8.12  -  
                                                                       general combiner  
  
NVIDIA Implementation Details  
  
    The effective range of the RGB portion of the final combiner should  
    be [0,4] if the color sum clamp is false.  Exercising  this range  
    requires assigning SPARE0_PLUS_SECONDARY_COLOR_NV to the D variable  
    and either B or C or both B and C.  In practice this is a very  
    unlikely configuration.  
  
    However due to a bug in the GeForce 256 and Quadro hardware, values  
    generated above 2 in the RGB portion of the final combiner will be  
    computed incorrectly.  GeForce2 GTS and subsequent NVIDIA GPUs have  
    fixed this bug.  
  
    The behavior of the SIGNED_NEGATE_NV mapping mode is undefined on  
    GeForce3 GPUs (NV20) when used to map the initial value of a texture  
    register corresponding to an enabled texture with a base internal  
    format of GL_DEPTH_COMPONENT and a GL_TEXTURE_COMPARE_MODE_ARB mode of  
    GL_COMPARE_R_TO_TEXTURE (or for SGIX_shadow, GL_TEXTURE_COMPARE_SGIX  
    mode of true) mode when multiple enabled textures have different  
    values for GL_TEXTURE_COMPARE_FUNC_ARB (or for SGIX_shadow,  
    GL_TEXTURE_COMPARE_OPERATOR_SGIX).  Values subsequently assigned  
    to such registers and then mapped with SIGNED_NEGATIE_NV operate  
    as expected.  This issue does not affect GeForce4 Ti (NV25) and  
    subsequent GPUs.  
  
homeprevnext Revision History
  
    April 4, 2000 - Document that alpha component of the FOG register  
    should be zero when fog is disabled.  The Release 4 NVIDIA drivers  
    have a bug where this is not always true (though it often still is).  
    The bug is fixed in the Release 5 NVIDIA drivers.  
  
    June 8, 2000 - The alpha component of the FOG register is not  
    available for use until the final combiner.  The specification  
    previously incorrectly stated:  
  
      "INVALID_OPERATION is generated When CombinerInputNV is called with  
      a <portion> parameter of ALPHA and an <input> parameter of FOG."  
  
    It is actually the <componentUsage> (not the <portion>) that should  
    not be allowed to be ALPHA.  The Release 4 NVIDIA drivers implemented  
    the above incorrect error check.  The Release 5 (and later) NVIDIA  
    drivers (after June 8, 2000) have fixed this bug and correctly  
    implement the error based on <componentUsage>.  
  
    The specification previously did not allow BLUE for the  
    <componentUsage> of the G variable in the final combiner.  This is  
    now allowed in the Release 5 (and later) NVIDIA drivers (after June  
    8, 2000).  The Release 4 NVIDIA drivers do not permit BLUE for the  
    <componentUsage> of the G variable and generate an INVALID_OPERATION  
    error if this is attempted.  The Release 5 NVIDIA drivers (after June  
    8, 2000) have fixed this bug and permit BLUE for the <componentUsage>  
    of the G variable.  
  
    August 11, 2000 - The "mux" operation was incorrectly documented in  
    previous versions of this specification.  The correct mux behave is  
    as follows:  
  
       spare0_alpha >= 0.5 ? C*D : A*B  
  
    or  
  
       spare0_alpha <  0.5 ? A*B : C*D  
  
    Previous versions of this specification had the mux sense reversed.  
  
    October 31, 2000 - The initial general combiner state  
    was misdocumented for the B variable.  Previously, Table  
    NV_register_combiners.5 said that the RGB and alpha inputs for B  
    were GL_TEXTURE#_ARB and the RGB and alpha input mappings for B  
    were GL_UNSIGNED_IDENTITY_NV.  The table is now updated so that the  
    RGB and alpha inputs for B are GL_ZERO and the RGB and alpha input  
    mappings for B are GL_UNSIGNED_INVERT_NV.  The implementation has  
    always behaved in the manner described by the updated specification.  
  
    December 13, 2000 - Added a new table NV_register_combiners.2  
    describing the correspondence of texture components to register  
    components for texture registers.  This table is based on the  
    table in the EXT_texture_env_combine extension.  The table includes  
    correspondences for HILO, DSDT, DSDT_MAG, DSDT_MAG_INTENSITY, and  
    DEPTH_COMPONENT formatted textures when supported in conjunction  
    with the NV_texture_shader, SGIX_depth_texture, and SGIX_shadow  
    extensions.  
  
    Because a new table 2 was inserted, all the tables beyond it are  
    renumbered.  
  
    Document the behavior of SIGNED_NEGATE_NV in conjunction with shadow  
    mapping in the "NVIDIA Implementation Details" section.  
  
    June 28, 2002 - Properly document NV_register_combiners interactions  
    with the ARB_depth_texture and ARB_shadow extensions (previously,  
    the extension just addressed the SGIX versions of these extensions).  
  
    September 30, 2003 - Remove an error (not implemented in early NVIDIA  
    drivers prior to Release 4x.xx drivers; implemented in Relase  
    4x.xx drivers; and again removed for Release 5x.xx drivers and up)  
    that was meant to restrict the API to not allow the summing of dot  
    product outputs.  NVIDIA hardware handles this case correctly however  
    so the functionality might as well be supported; some applications  
    found it useful.  The deleted error read:  
  
       If the <abDotProduct> or <cdDotProduct> parameter is non-FALSE,  
       the value of the <sumOutput> parameter must be GL_DISCARD_NV;  
       otherwise, generate an INVALID_OPERATION error.  
  
    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.  
    or FALSE.  
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.