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 , , and . To update a combiner stage output operation, you need to specify the and . 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 or is true and then 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 parameter of Enable, Disable, and IsEnabled, and by the parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev: REGISTER_COMBINERS_NV 0x8522 Accepted by the 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 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 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 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 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 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 parameter of FinalCombinerInputNV: UNSIGNED_IDENTITY_NV UNSIGNED_INVERT_NV Accepted by the 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 parameter of CombinerOutputNV: NONE (not new) BIAS_BY_NEGATIVE_ONE_HALF_NV 0x8541 Accepted by the , , and 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 parameter of GetCombinerInputParameterfvNV and GetCombinerInputParameterivNV: COMBINER_INPUT_NV 0x8542 COMBINER_MAPPING_NV 0x8543 COMBINER_COMPONENT_USAGE_NV 0x8544 Accepted by the 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 parameter of CombinerParameterfvNV, CombinerParameterivNV, GetBooleanv, GetDoublev, GetFloatv, and GetIntegerv: CONSTANT_COLOR0_NV CONSTANT_COLOR1_NV Accepted by the parameter of CombinerParameterfvNV, CombinerParameterivNV, CombinerParameterfNV, CombinerParameteriNV, GetBooleanv, GetDoublev, GetFloatv, and GetIntegerv: NUM_GENERAL_COMBINERS_NV 0x854E COLOR_SUM_CLAMP_NV 0x854F Accepted by the parameter of GetFinalCombinerInputParameterfvNV and GetFinalCombinerInputParameterivNV: COMBINER_INPUT_NV COMBINER_MAPPING_NV COMBINER_COMPONENT_USAGE_NV Accepted by the 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 RGBA vectors with components ranging from -1.0 to 1.0 where 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_ARB CT 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_ARB are undefined if texturing is not enabled for textures 0, 1, and , 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); 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 is a pointer to a group of values to which to set the indicated parameter. 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 parameter is a symbolic constant of the form COMBINER_NV, indicating that general combiner stage is to be updated. The constant COMBINER_NV = COMBINER0_NV + where is in the range 0 to -1 and is the implementation dependent value of MAX_COMBINERS_NV. The 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 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 , , and parameters specify the assignment of a value for the input variable indicated by , , and . The parameter may be one of the register names from table NV_register_combiners.1. The parameter may be one of RGB, ALPHA, or BLUE. When the parameter is RGB, a 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 parameter indicates that the alpha portion of the indicated register should be replicated across the RGB portion of the combiner input variable. When the parameter is ALPHA, the 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 parameter indicates that the blue component of the indicated register should be assigned to the alpha portion of the combiner input variable. When the parameter is ALPHA, a parameter of RGB generates an INVALID_OPERATION error. When the parameter is RGB, a parameter of BLUE generates an INVALID_OPERATION error. When the parameter is ALPHA, an 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 is assigned to the specified input variable, a range mapping is performed based on . 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 parameter, the mapping function in the table above is evaluated for each element 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 and parameters take the same values as the respective parameters for CombinerInputNV. If the parameter is ALPHA, specifying a non-FALSE value for either of the parameters or , generates an INVALID_VALUE error. The 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 parameter, to 1.0, 2.0, 4.0, or 0.5, respectively. The 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 parameter, to 0.0 or -0.5, respectively. If is either SCALE_BY_ONE_HALF_NV or SCALE_BY_FOUR_NV, a of BIAS_BY_NEGATIVE_ONE_HALF_NV generates an INVALID_OPERATION error. If the parameter is FALSE, then if is RGB, out1rgb = max(min(gcc1rgb + cbiasrgb) * cscalergb, 1), -1) if is ALPHA, out1a = max(min((gcc1a + cbiasa) * cscalea, 1), -1) otherwise must be RGB and out1rgb = max(min((gcc2rgb + cbiasrgb) * cscalergb, 1), -1) If the parameter is FALSE, then if is RGB, out2rgb = max(min((gcc3rgb + cbiasrgb) * cscalergb, 1), -1) if is ALPHA, out2a = max(min((gcc2a + cbiasa) * cscalea, 1), -1) otherwise must be RGB so out2rgb = max(min((gcc4rgb + cbiasrgb) * cscalergb, 1), -1) If the parameter is FALSE, then if is RGB, out3rgb = max(min((gcc5rgb + cbiasrgb) * cscalergb, 1), -1) if is ALPHA, out3a = max(min((gcc3a + cbiasa) * cscalea, 1), -1) otherwise if is RGB, out3rgb = max(min((gcc6rgb + cbiasrgb) * cscalergb, 1), -1) if 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 , , and respectively. out1a, out2a, and out3a are written to the alpha portion of combiner stage's registers named by , , and respectively. The parameters , , and 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 , , and 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 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 , , and parameters specify the assignment of a value for the input variable indicated by . The 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 is one of VARIABLE_E_NV, VARIABLE_F_NV, or VARIABLE_G_NV and is either E_TIMES_F_NV or SPARE0_PLUS_SECONDARY_COLOR_NV, generate an INVALID_OPERATION error. When is VARIABLE_A_NV and is SPARE0_PLUS_SECONDARY_COLOR_NV, generate an INVALID_OPERATION error. The parameter may be one of RGB, BLUE, ALPHA (with certain restrictions depending on the and as described below). When the parameter is not VARIABLE_G_NV, a 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 parameter indicates that the alpha portion of the indicated register should be replicated across the RGB portion of the combiner input variable. When the parameter is VARIABLE_G_NV, a 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 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 is BLUE and is not VARIABLE_G_NV. The INVALID_OPERATION error is generated when is RGB and is VARIABLE_G_NV. The INVALID_OPERATION error is generated when both the parameter is either E_TIMES_F_NV or SPARE0_PLUS_SECONDARY_COLOR_NV and the parameter is ALPHA or BLUE. Before the value in the register named by is assigned to the specified input variable, a range mapping is performed based on . 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, sets of general combiner stage state where 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 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 may be either RGB or ALPHA, indicating which portion of the general combiner stage to query. The GetCombinerInputParameterfvNV and GetCombinerInputParameterivNV parameter 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 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 set to NUM_GENERAL_COMBINERS and the value pointed to by 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 parameter of RGB and a parameter of ALPHA. INVALID_OPERATION is generated when CombinerInputNV is called with a parameter of BLUE and a parameter of RGB. INVALID_OPERATION is generated When CombinerInputNV is called with a parameter of ALPHA and an parameter of FOG. INVALID_VALUE is generated when CombinerOutputNV is called with a parameter of ALPHA, but a non-FALSE value for either of the parameters or . INVALID_OPERATION is generated when CombinerOutputNV is called with a of either SCALE_BY_ONE_HALF_NV or SCALE_BY_FOUR_NV and a of BIAS_BY_NEGATIVE_ONE_HALF_NV. INVALID_OPERATION is generated when CombinerOutputNV is called such that , , and do not all name unique register names (though multiple outputs to DISCARD_NV are legal). INVALID_OPERATION is generated when FinalCombinerInputNV is called where is one of VARIABLE_E_NV, VARIABLE_F_NV, or VARIABLE_G_NV and is E_TIMES_F_NV or SPARE0_PLUS_SECONDARY_COLOR_NV. INVALID_OPERATION is generated when FinalCombinerInputNV is called where is VARIABLE_A_NV and is SPARE0_PLUS_SECONDARY_COLOR_NV. INVALID_OPERATION is generated when FinalCombinerInputNV is called with VARIABLE_G_NV for and RGB for . INVALID_OPERATION is generated when FinalCombinerInputNV is called with a value other than VARIABLE_G_NV for and BLUE for . INVALID_OPERATION is generated when FinalCombinerInputNV is called where the parameter is either E_TIMES_F_NV or SPARE0_PLUS_SECONDARY_COLOR_NV and the 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 parameter of ALPHA and an parameter of FOG." It is actually the (not the ) 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 . The specification previously did not allow BLUE for the 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 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 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 or parameter is non-FALSE, the value of the 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.