xref: /third_party/openGLES/extensions/NV/NV_register_combiners.txt (revision 5bd8dead)

Name
    
    NV_register_combiners

Name Strings

    GL_NV_register_combiners

Contact

    Mark J. Kilgard, NVIDIA Corporation (mjk 'at' nvidia.com)

Notice

    Copyright NVIDIA Corporation, 1999, 2000, 2001, 2002, 2003.

IP Status

    NVIDIA Proprietary.

Status

    Shipping (version 1.6)

Version

    NVIDIA Date: February 1, 2007 (version 1.7)

Number

    191

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.

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.

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.

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);

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

Additions to Chapter 2 of the 1.2 Specification (OpenGL Operation)

     None

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."

Additions to Chapter 4 of the 1.2 Specification (Per-Fragment Operations
and the Frame Buffer)

     None

Additions to Chapter 5 of the 1.2 Specification (Special Functions)

     None

Additions to Chapter 6 of the 1.2 Specification (State and State Requests)

 --  Section 6.1.3 "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."

Additions to the GLX Specification

    None.

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

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.

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.

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.

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.

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   ]

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.

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.