back  Return to list

GL_NV_fragment_program_option
homeprevnext Name
  
    NV_fragment_program_option  
  
homeprevnext Name Strings
  
    GL_NV_fragment_program_option  
  
homeprevnext Contact
  
    Pat Brown, NVIDIA Corporation (pbrown 'at' nvidia.com)  
  
homeprevnext Status
  
    Shipping.  
  
homeprevnext Version
  
    Last Modified:      05/27/2005  
    NVIDIA Revision:    4  
  
homeprevnext Number
  
    303  
  
homeprevnext Dependencies
  
    ARB_fragment_program is required.  
  
homeprevnext Overview
  
    This extension provides additional fragment program functionality  
    to extend the standard ARB_fragment_program language and execution  
    environment.  ARB programs wishing to use this added functionality  
    need only add:  
  
        OPTION NV_fragment_program;  
  
    to the beginning of their fragment programs.  
  
    The functionality provided by this extension, which is roughly  
    equivalent to that provided by the NV_fragment_program extension,  
    includes:  
  
      * increased control over precision in arithmetic computations and  
        storage,  
  
      * data-dependent conditional writemasks,  
  
      * an absolute value operator on scalar and swizzled operand loads,  
  
      * instructions to compute partial derivatives, and perform texture  
        lookups using specified partial derivatives,  
  
      * fully orthogonal "set on" instructions,  
  
      * instructions to compute reflection vector and perform a 2D  
        coordinate transform, and  
  
      * instructions to pack and unpack multiple quantities into a single  
        component.  
  
homeprevnext Issues
  
    Why is this a separate extension, rather than just an additional  
    feature of NV_fragment_program?  
  
      RESOLVED:  The NV_fragment_program specification was complete  
      (with a published implementation) prior to the completion of  
      ARB_fragment_program.  Future NVIDIA fragment program extensions  
      should contain extensions to the ARB_fragment_program execution  
      environment as a standard feature.  
  
    Should a similar option be provided to expose ARB_fragment_program  
    features not found in NV_fragment_program (e.g., state bindings,  
    certain "macro" instructions) under the NV_fragment_program  
    interface?  
  
      RESOLVED:  No.  Why not just write an ARB program?  
  
    The ARB_fragment_program spec has a minor grammar bug that requires  
    that inline scalar constants used as scalar operands include a  
    component selector.  In other words, you have to say "11.0.x" to  
    use the constant "11.0".  What should we do here?  
  
      RESOLVED:  The NV_fragment_program_option grammar will correct  
      this problem, which should be fixed in future revisions to the  
      ARB language.  
  
homeprevnext New Procedures and Functions
  
    None.  
  
homeprevnext New Tokens
  
    None.  
  
homeprevnext Additions to Chapter 2 of the OpenGL 1.2.1 Specification (OpenGL Operation)
  
    None.  
  
homeprevnext Additions to Chapter 3 of the OpenGL 1.2.1 Specification (Rasterization)
  
    Modify Section 3.11.2 of ARB_fragment_program (Fragment Program  
    Grammar and Restrictions):  
  
    (mostly add to existing grammar rules, modify a few existing grammar  
    rules -- changes marked with "***")  
      
    <optionName>            ::= "NV_fragment_program"  
  
    <TexInstruction>        ::= <TXDop_instruction>  
  
    <VECTORop>              ::= "DDX"  
                              | "DDY"  
                              | "PK2H"  
                              | "PK2US"  
                              | "PK4B"  
                              | "PK4UB"  
  
    <SCALARop>              ::= "UP2H"  
                              | "UP2US"  
                              | "UP4B"  
                              | "UP4UB"  
  
    <BINop>                 ::= "RFL"  
                              | "SEQ"  
                              | "SFL"  
                              | "SGT"  
                              | "SLE"  
                              | "SNE"  
                              | "STR"  
  
    <TRIop>                 ::= "X2D"  
  
    <TXDop_instruction>     ::= <TXDop> <instResult> "," <instOperandV> ","   
                                <instOperandV> "," <instOperandV> ","   
                                <texTarget>  
  
    <TXDop>                 ::= "TXD"  
  
    <killCond>              ::= <ccTest>  
  
    <instOperandV>          ::= <instOperandAbsV>  
  
    <instOperandAbsV>       ::= <optSign> "|" <instOperandBaseV> "|"  
  
    <instOperandS>          ::= <instOperandAbsS>  
  
    <instOperandAbsS>       ::= <optSign> "|" <instOperandBaseS> "|"  
  
    <instResult>            ::= <instResultCC>  
  
    <instResultCC>          ::= <instResultBase> <ccMask>  
  
    <TEMP_statement>        ::= <varSize> "TEMP" <varNameList>  
  
    <OUTPUT_statement>      ::= <varSize> "OUTPUT" <establishName> "="   
                                  <resultUseD>  
  
    <varSize>               ::= "SHORT"  
                              | "LONG"  
  
    <paramUseV>             ::= <constantScalar>   
                                  (*** instead of <constantScalar>  
                                       <swizzleSuffix>)  
  
    <paramUseS>             ::= <constantScalar>   
                                  (*** instead of <constantScalar>  
                                       <scalarSuffix>)  
  
    <ccMask>                ::= "(" <ccTest> ")"  
  
    <ccTest>                ::= <ccMaskRule> <swizzleSuffix>  
  
    <ccMaskRule>            ::= "EQ"  
                              | "GE"  
                              | "GT"  
                              | "LE"  
                              | "LT"  
                              | "NE"  
                              | "TR"  
                              | "FL"  
  
    (modify language describing reserved keywords) The following strings  
    are reserved keywords and may not be used as identifiers:  
  
        ALIAS, ATTRIB, END, OPTION, OUTPUT, PARAM, TEMP, fragment,  
        program, result, state, and texture.  
  
    Additionally, all the instruction names (and variants) listed in  
    Table X.5 are reserved.  
  
    Modify Section 3.11.3.3, Fragment Program Temporaries  
  
    (replace second paragraph) Fragment program temporary variables  
    can be declared explicitly using the <TEMP_statement> grammar  
    rule.  Each such statement can declare one or more temporaries.  
    Temporary declaration can optionally specify a variable size,  
    using the <varSize> grammar rule.  Variables declared as "SHORT"  
    will represented with at least 16 bits per component (5 bits of  
    exponent, 10 bits of mantissa).  Variables declared as "LONG" will be  
    represented with at least 32 bits per component (8 bits of exponent,  
    23 bits of mantissa).  Fragment program temporary variables can not  
    be declared implicitly.  
  
    Modify Section 3.11.3.4, Fragment Program Results  
  
    (replace second paragraph) Fragment program result variables  
    can be declared explicitly using the <OUTPUT_statement> grammar  
    rule, or implicitly using the <resultBinding> grammar rule in an  
    executable instruction.  Explicit result variable declaration can  
    optionally specify a variable size, using the <varSize> grammar rule.  
    Variables declared as "SHORT" will represented with at least 16  
    bits per component (5 bits of exponent, 10 bits of mantissa).  
    Variables declared as "LONG" will be represented with at least  
    32 bits per component (8 bits of exponent, 23 bits of mantissa).  
    Each fragment program result variable is bound to a fragment attribute  
    used in subsequent back-end processing.  The set of fragment program  
    result variable bindings is given in Table X.3.  
  
    (add to the end of a section) A fragment program will fail to load if  
    contains instructions writing to variables bound to the same result,  
    but declared with different sizes.  
  
    Add New Section 3.11.3.X, Condition Code Register (insert after  
    Section 3.11.3.4, Fragment Program Results)  
  
    The fragment program condition code register is a single  
    four-component vector.  Each component of this register is one of four  
    enumerated values: GT (greater than), EQ (equal), LT (less than),  
    or UN (unordered).  The condition code register can be used to mask  
    writes to registers and to evaluate conditional branches.  
  
    Most fragment program instructions can optionally update the condition  
    code register.  When a fragment program instruction updates the  
    condition code register, a condition code component is set to LT if  
    the corresponding component of the result is less than zero, EQ if it  
    is equal to zero, GT if it is greater than zero, and UN if it is NaN  
    (not a number).  
  
    The condition code register is initialized to a vector of EQ values  
    each time a fragment program executes.  
      
    Modify Section 3.11.4, Fragment Program Execution Environment  
  
    (modify instruction table) There are fifty-two fragment program  
    instructions.  Fragment program instructions may have up to sixteen  
    variants, including a suffix of "R", "H", or "X" to specify arithmetic  
    precision (section 3.11.4.X), a suffix of "C" to allow an update  
    of the condition code register (section 3.11.3.X), and a suffix of  
    "_SAT" to clamp the result vector components to the range [0,1]  
    (section 3.11.4.3).  For example, the sixteen forms of the "ADD"  
    instruction are "ADD", "ADDR", "ADDH", "ADDX", "ADDC", "ADDRC",  
    "ADDHC", "ADDXC", "ADD_SAT", "ADDR_SAT", "ADDH_SAT", "ADDX_SAT",  
    "ADDC_SAT", "ADDRC_SAT", "ADDHC_SAT", and "ADDXC_SAT".The instructions  
    and their respective input and output parameters are summarized in  
    Table X.5.  
  
               Modifiers  
      Instr.   R H X C S  Inputs  Output   Description  
      -------  - - - - -  ------  ------   --------------------------------  
      ABS      X X X X X  v       v        absolute value  
      ADD      X X X X X  v,v     v        add  
      CMP      - - - - X  v,v,v   v        compare  
      COS      X X - X X  s       ssss     cosine with reduction to [-PI,PI]  
      DDX      X X - X X  v       v        partial derivative relative to X  
      DDY      X X - X X  v       v        partial derivative relative to Y  
      DP3      X X X X X  v,v     ssss     3-component dot product  
      DP4      X X X X X  v,v     ssss     4-component dot product  
      DPH      X X X X X  v,v     ssss     homogeneous dot product  
      DST      X X - X X  v,v     v        distance vector  
      EX2      X X - X X  s       ssss     exponential base 2  
      FLR      X X X X X  v       v        floor  
      FRC      X X X X X  v       v        fraction  
      KIL      - - - - -  v or c  -        kill fragment  
      LG2      X X - X X  s       ssss     logarithm base 2  
      LIT      X X - X X  v       v        compute light coefficients  
      LRP      X X X X X  v,v,v   v        linear interpolation  
      MAD      X X X X X  v,v,v   v        multiply and add  
      MAX      X X X X X  v,v     v        maximum  
      MIN      X X X X X  v,v     v        minimum  
      MOV      X X X X X  v       v        move  
      MUL      X X X X X  v,v     v        multiply  
      PK2H     - - - - -  v       ssss     pack two 16-bit floats  
      PK2US    - - - - -  v       ssss     pack two unsigned 16-bit scalars  
      PK4B     - - - - -  v       ssss     pack four signed 8-bit scalars  
      PK4UB    - - - - -  v       ssss     pack four unsigned 8-bit scalars  
      POW      X X - X X  s,s     ssss     exponentiate  
      RCP      X X - X X  s       ssss     reciprocal  
      RFL      X X - X X  v,v     v        reflection vector  
      RSQ      X X - X X  s       ssss     reciprocal square root  
      SCS      - - - - X  s       ss--     sine/cosine without reduction  
      SEQ      X X X X X  v,v     v        set on equal  
      SFL      X X X X X  v,v     v        set on false  
      SGE      X X X X X  v,v     v        set on greater than or equal  
      SGT      X X X X X  v,v     v        set on greater than  
      SIN      X X - X X  s       ssss     sine with reduction to [-PI,PI]  
      SLE      X X X X X  v,v     v        set on less than or equal  
      SLT      X X X X X  v,v     v        set on less than  
      SNE      X X X X X  v,v     v        set on not equal  
      STR      X X X X X  v,v     v        set on true  
      SUB      X X X X X  v,v     v        subtract  
      SWZ      - - - - X  v       v        extended swizzle  
      TEX      - - - X X  v       v        texture sample  
      TXB      - - - X X  v       v        texture sample with bias  
      TXD      - - - X X  v,v,v   v        texture sample w/partials        
      TXP      - - - X X  v       v        texture sample with projection  
      UP2H     - - - X X  s       v        unpack two 16-bit floats  
      UP2US    - - - X X  s       v        unpack two unsigned 16-bit scalars  
      UP4B     - - - X X  s       v        unpack four signed 8-bit scalars  
      UP4UB    - - - X X  s       v        unpack four unsigned 8-bit scalars  
      X2D      X X - X X  v,v,v   v        2D coordinate transformation  
      XPD      - - - - X  v,v     v        cross product  
  
      Table X.5:  Summary of fragment program instructions.  The columns  
      "R", "H", "X", "C", and "S" indicate whether the "R", "H", or "X"  
      precision modifiers, the C condition code update modifier, and the  
      "_SAT" saturation modifier, respectively, are supported for the  
      opcode.  In the input/output columns, "v" indicates a floating-point  
      vector input or output, "s" indicates a floating-point scalar  
      input, "ssss" indicates a scalar output replicated across a  
      4-component result vector, "ss--" indicates two scalar outputs in  
      the first two components, and "c" indicates a condition code test.  
      Instructions describe as "texture sample" also specify a texture  
      image unit identifier and a texture target.  
  
    Modify Section 3.11.4.1, Fragment Program Operands  
  
    (add prior to the discussion of negation) A component-wise absolute  
    value operation can optionally performed on the operand if the operand  
    is surrounded with two "|" characters.  For example, "|src|" indicates  
    that a component-wise absolute value operation should be performed on  
    the variable named "src".  In terms of the grammar, this operation  
    is performed if the <instOperandV> or <instOperandS> grammar rules  
    match <instOperandAbsV> or <instOperandAbsS>, respectively.  
  
    (modify operand load pseudo-code) The following pseudo-code spells  
    out the operand generation process.  In the example, "float" is a  
    floating-point scalar type, while "floatVec" is a four-component  
    vector.  "source" refers to the register used for the operand,  
    matching the <srcReg> rule.  "abs" is TRUE if an absolute value  
    operation should be performed on the operand (<instOperandAbsV> or  
    <instOperandAbsS> rules) "negate" is TRUE if the <optionalSign> rule  
    in <scalarSrcReg> or <swizzleSrcReg> matches "-" and FALSE otherwise.  
    The ".c***", ".*c**", ".**c*", ".***c" modifiers refer to the x,  
    y, z, and w components obtained by the swizzle operation; the ".c"  
    modifier refers to the single component selected for a scalar load.  
  
      floatVec VectorLoad(floatVec source)  
      {  
          floatVec operand;  
  
          operand.x = source.c***;  
          operand.y = source.*c**;  
          operand.z = source.**c*;  
          operand.w = source.***c;  
          if (abs) {  
             operand.x = abs(operand.x);  
             operand.y = abs(operand.y);  
             operand.z = abs(operand.z);  
             operand.w = abs(operand.w);  
          }  
          if (negate) {  
             operand.x = -operand.x;  
             operand.y = -operand.y;  
             operand.z = -operand.z;  
             operand.w = -operand.w;  
          }  
  
          return operand;  
      }  
  
      float ScalarLoad(floatVec source)   
      {  
          float operand;  
  
          operand = source.c;  
          if (abs) {  
            operand = abs(operand);  
          if (negate) {  
            operand = -operand;  
          }  
  
          return operand;  
      }  
  
    Add New Section 3.11.4.X, Fragment Program Operation Precision  
    (insert after Section 3.11.4,2, Fragment Program Parameter Arrays)  
  
    Fragment program implementations may be able to perform instructions  
    with different levels of arithmetic precision.  The "R", "H", and  
    "X" opcode precision modifiers (Section 3.11.4) specify the minimum  
    precision used to perform arithmetic operations.  Instructions with  
    an "R" precision modifiers will be carried out at no less than  
    IEEE single-precision floating-point (8 bits of exponent, 23 bits  
    of mantissa).  Instructions with an "H" precision modifier will  
    be carried out at no less than 16-bit floating-point precision (5  
    bits of exponent, 10 bits of mantissa).  Instructions with an "X"  
    precision modifier will be carried out at no less than signed 12-bit  
    fixed-point precision (two's complement with 10 fraction bits).  
  
    If the result of a computation overflows the range of numbers  
    supported by the instruction precision, the result will be +/-INF  
    (infinity) for "R" and "H" precision, or -2048/1024 or +2047/1024 for  
    "X" precision.  
  
    If no precision modifier is specified, the instruction will be carried  
    out with at least as much precision as the destination variable.  
  
    Rewrite Section 3.11.4.3,  Fragment Program Destination Register  
    Update  
  
    Most fragment program instructions write a 4-component result vector  
    to a single temporary or fragment result register.  Writes to  
    individual components of the destination register are controlled  
    by individual component write masks specified as part of the  
    instruction.  
  
    The component write mask is specified by the <optionalMask> rule  
    found in the <maskedDstReg> rule.  If the optional mask is "",  
    all components are enabled.  Otherwise, the optional mask names  
    the individual components to enable.  The characters "x", "y",  
    "z", and "w" match the x, y, z, and w components, respectively.  
    For example, an optional mask of ".xzw" indicates that the x, z,  
    and w components should be enabled for writing but the y component  
    should not.  The grammar requires that the destination register mask  
    components must be listed in "xyzw" order.  
  
    The condition code write mask is specified by the <ccMask> rule found  
    in the <instResultCC> rule.  The condition code register is loaded and  
    swizzled according to the swizzle codes specified by <swizzleSuffix>.  
    Each component of the swizzled condition code is tested according to  
    the rule given by <ccMaskRule>.  <ccMaskRule> may have the values  
    "EQ", "NE", "LT", "GE", LE", or "GT", which mean to enable writes  
    if the corresponding condition code field evaluates to equal,  
    not equal, less than, greater than or equal, less than or equal,  
    or greater than, respectively.  Comparisons involving condition  
    codes of "UN" (unordered) evaluate to true for "NE" and false  
    otherwise.  For example, if the condition code is (GT,LT,EQ,GT)  
    and the condition code mask is "(NE.zyxw)", the swizzle operation  
    will load (EQ,LT,GT,GT) and the mask will thus will enable writes on  
    the y, z, and w components.  In addition, "TR" always enables writes  
    and "FL" always disables writes, regardless of the condition code.  
    If the condition code mask is empty, it is treated as "(TR)".  
  
    Each component of the destination register is updated with the result  
    of the fragment program instruction if and only if the component is  
    enabled for writes by both the component write mask and the condition  
    code write mask.  Otherwise, the component of the destination register  
    remains unchanged.  
  
    A fragment program instruction can also optionally update the  
    condition code register.  The condition code is updated if  
    the condition code register update suffix "C" is present in the  
    instruction.  The instruction "ADDC" will update the condition code;  
    the otherwise equivalent instruction "ADD" will not.  If condition  
    code updates are enabled, each component of the destination register  
    enabled for writes is compared to zero.  The corresponding component  
    of the condition code is set to "LT", "EQ", or "GT", if the written  
    component is less than, equal to, or greater than zero, respectively.  
    Condition code components are set to "UN" if the written component is  
    NaN (not a number).  Values of -0.0 and +0.0 both evaluate to "EQ".  
    If a component of the destination register is not enabled for writes,  
    the corresponding condition code component is also unchanged.  
  
    In the following example code,  
  
        # R1=(-2, 0, 2, NaN)              R0                  CC  
        MOVC R0, R1;               # ( -2,  0,   2, NaN) (LT,EQ,GT,UN)  
        MOVC R0.xyz, R1.yzwx;      # (  0,  2, NaN, NaN) (EQ,GT,UN,UN)  
        MOVC R0 (NE), R1.zywx;     # (  0,  0, NaN,  -2) (EQ,EQ,UN,LT)  
  
    the first instruction writes (-2,0,2,NaN) to R0 and updates the  
    condition code to (LT,EQ,GT,UN).  The second instruction, only the  
    "x", "y", and "z" components of R0 and the condition code are updated,  
    so R0 ends up with (0,2,NaN,NaN) and the condition code ends up with  
    (EQ,GT,UN,UN).  In the third instruction, the condition code mask  
    disables writes to the x component (its condition code field is "EQ"),  
    so R0 ends up with (0,0,NaN,-2) and the condition code ends up with  
    (EQ,EQ,UN,LT).  
  
    The following pseudocode illustrates the process of writing a result  
    vector to the destination register.  In the pseudocode, "instrmask"  
    refers to the component write mask given by the <optWriteMask>  
    rule.  "ccMaskRule" refers to the condition code mask rule given  
    by <ccMask> and "updatecc" is TRUE if and only if condition code  
    updates are enabled.  "result", "destination", and "cc" refer to  
    the result vector, the register selected by <dstRegister> and the  
    condition code, respectively.  Condition codes do not exist in the  
    VP1 execution environment.  
  
      boolean TestCC(CondCode field) {  
          switch (ccMaskRule) {  
          case "EQ":  return (field == "EQ");  
          case "NE":  return (field != "EQ");  
          case "LT":  return (field == "LT");  
          case "GE":  return (field == "GT" || field == "EQ");  
          case "LE":  return (field == "LT" || field == "EQ");  
          case "GT":  return (field == "GT");  
          case "TR":  return TRUE;  
          case "FL":  return FALSE;  
          case "":    return TRUE;  
          }  
      }  
  
      enum GenerateCC(float value) {  
        if (value == NaN) {  
          return UN;  
        } else if (value < 0) {  
          return LT;  
        } else if (value == 0) {  
          return EQ;  
        } else {  
          return GT;  
        }  
      }  
  
      void UpdateDestination(floatVec destination, floatVec result)  
      {  
          floatVec merged;  
          ccVec    mergedCC;  
  
          // Merge the converted result into the destination register, under  
          // control of the compile- and run-time write masks.  
          merged = destination;  
          mergedCC = cc;  
          if (instrMask.x && TestCC(cc.c***)) {  
              merged.x = result.x;  
              if (updatecc) mergedCC.x = GenerateCC(result.x);  
          }  
          if (instrMask.y && TestCC(cc.*c**)) {  
              merged.y = result.y;  
              if (updatecc) mergedCC.y = GenerateCC(result.y);  
          }  
          if (instrMask.z && TestCC(cc.**c*)) {  
              merged.z = result.z;  
              if (updatecc) mergedCC.z = GenerateCC(result.z);  
          }  
          if (instrMask.w && TestCC(cc.***c)) {  
              merged.w = result.w;  
              if (updatecc) mergedCC.w = GenerateCC(result.w);  
          }  
  
          // Write out the new destination register and condition code.  
          destination = merged;  
          cc = mergedCC;  
      }  
  
    Add to Section 3.11.4.5 of ARB_fragment_program (Fragment Program  
    Options):  
  
    Section 3.11.4.5.3, NV_fragment_program Option  
  
    If a fragment program specifies the "NV_fragment_program" option,  
    the grammar will be extended to support the features found in the  
    NV_fragment_program extension not present in the ARB_fragment_program  
    extension, including:  
  
      * the availability of the following instructions:  
  
          - DDX (partial derivative relative to X),   
          - DDY (partial derivative relative to Y),   
          - PK2H (pack as two half floats),  
          - PK2US (pack as two unsigned shorts),   
          - PK4B (pack as four signed bytes),  
          - PK4UB (pack as four unsigned bytes),   
          - RFL (reflection vector),   
          - SEQ (set on equal to),   
          - SFL (set on false),   
          - SGT (set on greater than),  
          - SLE (set on less than or equal to),  
          - SNE (set on not equal to),  
          - STR (set on true),  
          - TXD (texture lookup with computed partial derivatives),  
          - UP2H (unpack two half floats),  
          - UP2US (unpack two unsigned shorts),  
          - UP4B (unpack four signed bytes),  
          - UP4UB (unpack four unsigned bytes), and  
          - X2D (2D coordinate transformation),  
  
      * opcode precision suffixes "R", "H", and "X", to specify  
        the precision of arithmetic operations ("R" specifies 32-bit  
        floating-point computations, "H" specifies 16-bit floating-point  
        computations, and "X" specifies 12-bit signed fixed-point  
        computations with 10 fraction bits),  
  
      * the availability of the "SHORT" and "LONG" variable precision  
        keywords to control the size of a variable's components,  
  
      * a four-component condition code register to hold the sign of  
        result vector components (useful for comparisons),  
  
      * a condition code update opcode suffix "C", where the results of  
        the instruction are used to update the condition code register,  
  
      * a condition code write mask operator, where the condition code  
        register is swizzled and tested, and the test results are used  
        to mask register writes,  
  
      * an absolute value operator on scalar and swizzled source inputs  
  
    The added functionality is identical to that provided by the  
    NV_fragment_program extension specification.  
  
    Modify Section 3.11.5,  Fragment Program ALU Instruction Set  
  
    Section 3.11.5.30,  DDX:  Derivative Relative to X  
  
    The DDX instruction computes approximate partial derivatives of the  
    four components of the single operand with respect to the X window  
    coordinate to yield a result vector.  The partial derivatives are  
    evaluated at the center of the pixel.  
  
      f = VectorLoad(op0);  
      result = ComputePartialX(f);  
  
    Note that the partial derivates obtained by this instruction are  
    approximate, and derivative-of-derivate instruction sequences may  
    not yield accurate second derivatives.  
  
    Section 3.11.5.31,  DDY:  Derivative Relative to Y  
  
    The DDY instruction computes approximate partial derivatives of the  
    four components of the single operand with respect to the Y window  
    coordinate to yield a result vector.  The partial derivatives are  
    evaluated at the center of the pixel.  
  
      f = VectorLoad(op0);  
      result = ComputePartialY(f);  
  
    Note that the partial derivates obtained by this instruction are  
    approximate, and derivative-of-derivate instruction sequences may  
    not yield accurate second derivatives.  
  
    Section 3.11.5.32,  PK2H:  Pack Two 16-bit Floats  
  
    The PK2H instruction converts the "x" and "y" components of  
    the single operand into 16-bit floating-point format, packs the  
    bit representation of these two floats into a 32-bit value, and  
    replicates that value to all four components of the result vector.  
    The PK2H instruction can be reversed by the UP2H instruction below.  
  
      tmp0 = VectorLoad(op0);  
      /* result obtained by combining raw bits of tmp0.x, tmp0.y */  
      result.x = RawBits(tmp0.x) | (RawBits(tmp0.y) << 16);  
      result.y = RawBits(tmp0.x) | (RawBits(tmp0.y) << 16);  
      result.z = RawBits(tmp0.x) | (RawBits(tmp0.y) << 16);  
      result.w = RawBits(tmp0.x) | (RawBits(tmp0.y) << 16);  
  
    A fragment program will fail to load if it contains a PK2H instruction  
    that writes its results to a variable declared as "SHORT".  
  
    Section 3.11.5.33,  PK2US:  Pack Two Unsigned 16-bit Scalars  
  
    The PK2US instruction converts the "x" and "y" components of the  
    single operand into a packed pair of 16-bit unsigned scalars.  
    The scalars are represented in a bit pattern where all '0' bits  
    corresponds to 0.0 and all '1' bits corresponds to 1.0.  The bit  
    representations of the two converted components are packed into a  
    32-bit value, and that value is replicated to all four components  
    of the result vector.  The PK2US instruction can be reversed by the  
    UP2US instruction below.  
  
      tmp0 = VectorLoad(op0);  
      if (tmp0.x < 0.0) tmp0.x = 0.0;  
      if (tmp0.x > 1.0) tmp0.x = 1.0;  
      if (tmp0.y < 0.0) tmp0.y = 0.0;  
      if (tmp0.y > 1.0) tmp0.y = 1.0;  
      us.x = round(65535.0 * tmp0.x);  /* us is a ushort vector */  
      us.y = round(65535.0 * tmp0.y);  
      /* result obtained by combining raw bits of us. */  
      result.x = ((us.x) | (us.y << 16));  
      result.y = ((us.x) | (us.y << 16));  
      result.z = ((us.x) | (us.y << 16));  
      result.w = ((us.x) | (us.y << 16));  
  
    A fragment program will fail to load if it contains a PK2S instruction  
    that writes its results to a variable declared as "SHORT".  
  
    Section 3.11.5.34,  PK4B:  Pack Four Signed 8-bit Scalars  
  
    The PK4B instruction converts the four components of the single  
    operand into 8-bit signed quantities.  The signed quantities  
    are represented in a bit pattern where all '0' bits corresponds  
    to -128/127 and all '1' bits corresponds to +127/127.  The bit  
    representations of the four converted components are packed into a  
    32-bit value, and that value is replicated to all four components  
    of the result vector.  The PK4B instruction can be reversed by the  
    UP4B instruction below.  
  
      tmp0 = VectorLoad(op0);  
      if (tmp0.x < -128/127) tmp0.x = -128/127;  
      if (tmp0.y < -128/127) tmp0.y = -128/127;  
      if (tmp0.z < -128/127) tmp0.z = -128/127;  
      if (tmp0.w < -128/127) tmp0.w = -128/127;  
      if (tmp0.x > +127/127) tmp0.x = +127/127;  
      if (tmp0.y > +127/127) tmp0.y = +127/127;  
      if (tmp0.z > +127/127) tmp0.z = +127/127;  
      if (tmp0.w > +127/127) tmp0.w = +127/127;  
      ub.x = round(127.0 * tmp0.x + 128.0);  /* ub is a ubyte vector */  
      ub.y = round(127.0 * tmp0.y + 128.0);  
      ub.z = round(127.0 * tmp0.z + 128.0);  
      ub.w = round(127.0 * tmp0.w + 128.0);  
      /* result obtained by combining raw bits of ub. */  
      result.x = ((ub.x) | (ub.y << 8) | (ub.z << 16) | (ub.w << 24));  
      result.y = ((ub.x) | (ub.y << 8) | (ub.z << 16) | (ub.w << 24));  
      result.z = ((ub.x) | (ub.y << 8) | (ub.z << 16) | (ub.w << 24));  
      result.w = ((ub.x) | (ub.y << 8) | (ub.z << 16) | (ub.w << 24));  
  
    A fragment program will fail to load if it contains a PK4B instruction  
    that writes its results to a variable declared as "SHORT".  
  
    Section 3.11.5.35,  PK4UB:  Pack Four Unsigned 8-bit Scalars  
  
    The PK4UB instruction converts the four components of the single  
    operand into a packed grouping of 8-bit unsigned scalars.  The scalars  
    are represented in a bit pattern where all '0' bits corresponds to  
    0.0 and all '1' bits corresponds to 1.0.  The bit representations  
    of the four converted components are packed into a 32-bit value, and  
    that value is replicated to all four components of the result vector.  
    The PK4UB instruction can be reversed by the UP4UB instruction below.  
  
      tmp0 = VectorLoad(op0);  
      if (tmp0.x < 0.0) tmp0.x = 0.0;  
      if (tmp0.x > 1.0) tmp0.x = 1.0;  
      if (tmp0.y < 0.0) tmp0.y = 0.0;  
      if (tmp0.y > 1.0) tmp0.y = 1.0;  
      if (tmp0.z < 0.0) tmp0.z = 0.0;  
      if (tmp0.z > 1.0) tmp0.z = 1.0;  
      if (tmp0.w < 0.0) tmp0.w = 0.0;  
      if (tmp0.w > 1.0) tmp0.w = 1.0;  
      ub.x = round(255.0 * tmp0.x);  /* ub is a ubyte vector */  
      ub.y = round(255.0 * tmp0.y);  
      ub.z = round(255.0 * tmp0.z);  
      ub.w = round(255.0 * tmp0.w);  
      /* result obtained by combining raw bits of ub. */  
      result.x = ((ub.x) | (ub.y << 8) | (ub.z << 16) | (ub.w << 24));  
      result.y = ((ub.x) | (ub.y << 8) | (ub.z << 16) | (ub.w << 24));  
      result.z = ((ub.x) | (ub.y << 8) | (ub.z << 16) | (ub.w << 24));  
      result.w = ((ub.x) | (ub.y << 8) | (ub.z << 16) | (ub.w << 24));  
  
    A fragment program will fail to load if it contains a PK4UB  
    instruction that writes its results to a variable declared as  
    "SHORT".  
  
    Section 3.11.5.36,  RFL:  Reflection Vector  
  
    The RFL instruction computes the reflection of the second vector  
    operand (the "direction" vector) about the vector specified by the  
    first vector operand (the "axis" vector).  Both operands are treated  
    as 3D vectors (the w components are ignored).  The result vector is  
    another 3D vector (the "reflected direction" vector).  The length  
    of the result vector, ignoring rounding errors, should equal that  
    of the second operand.  
  
      axis = VectorLoad(op0);  
      direction = VectorLoad(op1);  
      tmp.w = (axis.x * axis.x + axis.y * axis.y +  
               axis.z * axis.z);  
      tmp.x = (axis.x * direction.x + axis.y * direction.y +   
               axis.z * direction.z);  
      tmp.x = 2.0 * tmp.x;  
      tmp.x = tmp.x / tmp.w;  
      result.x = tmp.x * axis.x - direction.x;  
      result.y = tmp.x * axis.y - direction.y;  
      result.z = tmp.x * axis.z - direction.z;  
  
    A fragment program will fail to load if the w component of the result  
    is enabled in the component write mask.  
  
    Section 3.11.5.37,  SEQ:  Set on Equal  
  
    The SEQ instruction performs a component-wise comparison of the  
    two operands.  Each component of the result vector is 1.0 if the  
    corresponding component of the first operand is equal to that of  
    the second, and 0.0 otherwise.  
  
      tmp0 = VectorLoad(op0);  
      tmp1 = VectorLoad(op1);  
      result.x = (tmp0.x == tmp1.x) ? 1.0 : 0.0;  
      result.y = (tmp0.y == tmp1.y) ? 1.0 : 0.0;  
      result.z = (tmp0.z == tmp1.z) ? 1.0 : 0.0;  
      result.w = (tmp0.w == tmp1.w) ? 1.0 : 0.0;  
  
    Section 3.11.5.38,  SFL:  Set on False  
  
    The SFL instruction is a degenerate case of the other "Set on"  
    instructions that sets all components of the result vector to 0.0.  
  
      result.x = 0.0;  
      result.y = 0.0;  
      result.z = 0.0;  
      result.w = 0.0;  
  
    Section 3.11.5.39,  SGT:  Set on Greater Than  
  
    The SGT instruction performs a component-wise comparison of the  
    two operands.  Each component of the result vector is 1.0 if the  
    corresponding component of the first operands is greater than that  
    of the second, and 0.0 otherwise.  
  
      tmp0 = VectorLoad(op0);  
      tmp1 = VectorLoad(op1);  
      result.x = (tmp0.x > tmp1.x) ? 1.0 : 0.0;  
      result.y = (tmp0.y > tmp1.y) ? 1.0 : 0.0;  
      result.z = (tmp0.z > tmp1.z) ? 1.0 : 0.0;  
      result.w = (tmp0.w > tmp1.w) ? 1.0 : 0.0;  
  
    Section 3.11.5.40,  SLE:  Set on Less Than or Equal  
  
    The SLE instruction performs a component-wise comparison of the  
    two operands.  Each component of the result vector is 1.0 if the  
    corresponding component of the first operand is less than or equal  
    to that of the second, and 0.0 otherwise.  
  
      tmp0 = VectorLoad(op0);  
      tmp1 = VectorLoad(op1);  
      result.x = (tmp0.x <= tmp1.x) ? 1.0 : 0.0;  
      result.y = (tmp0.y <= tmp1.y) ? 1.0 : 0.0;  
      result.z = (tmp0.z <= tmp1.z) ? 1.0 : 0.0;  
      result.w = (tmp0.w <= tmp1.w) ? 1.0 : 0.0;  
  
    Section 3.11.5.41,  SNE:  Set on Not Equal  
  
    The SNE instruction performs a component-wise comparison of the  
    two operands.  Each component of the result vector is 1.0 if the  
    corresponding component of the first operand is not equal to that  
    of the second, and 0.0 otherwise.  
  
      tmp0 = VectorLoad(op0);  
      tmp1 = VectorLoad(op1);  
      result.x = (tmp0.x != tmp1.x) ? 1.0 : 0.0;  
      result.y = (tmp0.y != tmp1.y) ? 1.0 : 0.0;  
      result.z = (tmp0.z != tmp1.z) ? 1.0 : 0.0;  
      result.w = (tmp0.w != tmp1.w) ? 1.0 : 0.0;  
  
    Section 3.11.5.42,  STR:  Set on True  
  
    The STR instruction is a degenerate case of the other "Set on"  
    instructions that sets all components of the result vector to 1.0.  
  
      result.x = 1.0;  
      result.y = 1.0;  
      result.z = 1.0;  
      result.w = 1.0;  
  
    Section 3.11.5.43,  UP2H:  Unpack Two 16-Bit Floats  
  
    The UP2H instruction unpacks two 16-bit floats stored together in  
    a 32-bit scalar operand.  The first 16-bit float (stored in the 16  
    least significant bits) is written into the "x" and "z" components  
    of the result vector; the second is written into the "y" and "w"  
    components of the result vector.  
  
    This operation undoes the type conversion and packing performed by  
    the PK2H instruction.  
  
      tmp = ScalarLoad(op0);  
      result.x = (fp16) (RawBits(tmp) & 0xFFFF);  
      result.y = (fp16) ((RawBits(tmp) >> 16) & 0xFFFF);  
      result.z = (fp16) (RawBits(tmp) & 0xFFFF);  
      result.w = (fp16) ((RawBits(tmp) >> 16) & 0xFFFF);  
      
    A fragment program will fail to load if it contains a UP2H instruction  
    whose operand is a variable declared as "SHORT".  
  
    Section 3.11.5.44,  UP2US:  Unpack Two Unsigned 16-Bit Scalars  
  
    The UP2US instruction unpacks two 16-bit unsigned values packed  
    together in a 32-bit scalar operand.  The unsigned quantities are  
    encoded where a bit pattern of all '0' bits corresponds to 0.0 and  
    a pattern of all '1' bits corresponds to 1.0.  The "x" and "z"  
    components of the result vector are obtained from the 16 least  
    significant bits of the operand; the "y" and "w" components are  
    obtained from the 16 most significant bits.  
  
    This operation undoes the type conversion and packing performed by  
    the PK2US instruction.  
  
      tmp = ScalarLoad(op0);  
      result.x = ((RawBits(tmp) >> 0)  & 0xFFFF) / 65535.0;  
      result.y = ((RawBits(tmp) >> 16) & 0xFFFF) / 65535.0;  
      result.z = ((RawBits(tmp) >> 0)  & 0xFFFF) / 65535.0;  
      result.w = ((RawBits(tmp) >> 16) & 0xFFFF) / 65535.0;  
  
    A fragment program will fail to load if it contains a UP2S instruction  
    whose operand is a variable declared as "SHORT".  
  
    Section 3.11.5.45,  UP4B:  Unpack Four Signed 8-Bit Values  
  
    The UP4B instruction unpacks four 8-bit signed values packed together  
    in a 32-bit scalar operand.  The signed quantities are encoded where  
    a bit pattern of all '0' bits corresponds to -128/127 and a pattern  
    of all '1' bits corresponds to +127/127.  The "x" component of the  
    result vector is the converted value corresponding to the 8 least  
    significant bits of the operand; the "w" component corresponds to  
    the 8 most significant bits.  
  
    This operation undoes the type conversion and packing performed by  
    the PK4B instruction.  
  
      tmp = ScalarLoad(op0);  
      result.x = (((RawBits(tmp) >> 0) & 0xFF) - 128) / 127.0;  
      result.y = (((RawBits(tmp) >> 8) & 0xFF) - 128) / 127.0;  
      result.z = (((RawBits(tmp) >> 16) & 0xFF) - 128) / 127.0;  
      result.w = (((RawBits(tmp) >> 24) & 0xFF) - 128) / 127.0;  
  
    A fragment program will fail to load if it contains a UP4B instruction  
    whose operand is a variable declared as "SHORT".  
  
    Section 3.11.5.46,  UP4UB:  Unpack Four Unsigned 8-Bit Scalars  
  
    The UP4UB instruction unpacks four 8-bit unsigned values packed  
    together in a 32-bit scalar operand.  The unsigned quantities are  
    encoded where a bit pattern of all '0' bits corresponds to 0.0 and a  
    pattern of all '1' bits corresponds to 1.0.  The "x" component of the  
    result vector is obtained from the 8 least significant bits of the  
    operand; the "w" component is obtained from the 8 most significant  
    bits.  
  
    This operation undoes the type conversion and packing performed by  
    the PK4UB instruction.  
  
      tmp = ScalarLoad(op0);  
      result.x = ((RawBits(tmp) >> 0)  & 0xFF) / 255.0;  
      result.y = ((RawBits(tmp) >> 8)  & 0xFF) / 255.0;  
      result.z = ((RawBits(tmp) >> 16) & 0xFF) / 255.0;  
      result.w = ((RawBits(tmp) >> 24) & 0xFF) / 255.0;  
  
    A fragment program will fail to load if it contains a UP4UB  
    instruction whose operand is a variable declared as "SHORT".  
  
    Section 3.11.5.47,  X2D:  2D Coordinate Transformation  
  
    The X2D instruction multiplies the 2D offset vector specified by the  
    "x" and "y" components of the second vector operand by the 2x2 matrix  
    specified by the four components of the third vector operand, and adds  
    the transformed offset vector to the 2D vector specified by the "x"  
    and "y" components of the first vector operand.  The first component  
    of the sum is written to the "x" and "z" components of the result;  
    the second component is written to the "y" and "w" components of  
    the result.  
  
      tmp0 = VectorLoad(op0);  
      tmp1 = VectorLoad(op1);  
      tmp2 = VectorLoad(op2);  
      result.x = tmp0.x + tmp1.x * tmp2.x + tmp1.y * tmp2.y;  
      result.y = tmp0.y + tmp1.x * tmp2.z + tmp1.y * tmp2.w;  
      result.z = tmp0.x + tmp1.x * tmp2.x + tmp1.y * tmp2.y;  
      result.w = tmp0.y + tmp1.x * tmp2.z + tmp1.y * tmp2.w;  
  
    Modify Section, 3.11.6.4 KIL: Kill fragment  
  
    Rather than mapping a coordinate set to a color, this function  
    prevents a fragment from receiving any future processing.  If any  
    component of its source vector is negative, the processing of this  
    fragment will be discontinued and no further outputs to this fragment  
    will occur.  Subsequent stages of the GL pipeline will be skipped  
    for this fragment.  
  
    A KIL instruction may be specified using either a vector operand  
    or a condition code test.  If a vector operand is specified, the  
    following is performed:  
  
      tmp = VectorLoad(op0);  
      if ((tmp.x < 0) || (tmp.y < 0) ||   
          (tmp.z < 0) || (tmp.w < 0))  
      {  
          exit;  
      }  
  
    If a condition code is specified, the following is performed:  
  
      if (TestCC(rc.c***) || TestCC(rc.*c**) ||   
          TestCC(rc.**c*) || TestCC(rc.***c))   
      {  
         exit;  
      }  
  
  
    Add Section 3.11.6.5, TXD: Texture Lookup with Derivatives  
  
    The TXD instruction takes the first three components of its first  
    vector operand and maps them to s, t, and r.  These coordinates are  
    used to sample from the specified texture target on the specified  
    texture image unit in a manner consistent with its parameters.  
  
    The level of detail is computed as specified in section 3.8.  
    In this calculation, ds/dx, dt/dx, and dr/dx are given by the x,  
    y, and z components, respectively, of the second vector operand.  
    ds/dy, dt/dy, and dr/dy are given by the x, y, and z components of  
    the third vector operand.  
      
    The resulting sample is mapped to RGBA as described in table 3.21  
    and written to the result vector.  
  
      tmp = VectorLoad(op0);  
      result = TextureSample(tmp.x, tmp.y, tmp.z, 0.0, op1, op2);  
  
homeprevnext Additions to Chapter 4 of the OpenGL 1.2.1 Specification (Per-Fragment Operations and the Frame Buffer)
  
    None.  
  
homeprevnext Additions to Chapter 5 of the OpenGL 1.2.1 Specification (Special Functions)
  
    None.  
  
homeprevnext Additions to Chapter 6 of the OpenGL 1.2.1 Specification (State and State Requests)
  
    None.  
  
homeprevnext Additions to Appendix A of the OpenGL 1.2.1 Specification (Invariance)
  
    None.  
  
homeprevnext Additions to the AGL/GLX/WGL Specifications
  
    None.  
  
homeprevnext Dependencies on ARB_fragment_program
  
    This specification is based on a modified version of the grammar  
    published in the ARB_fragment_program specification.  This modified  
    grammar (see below) includes a few structural changes to better  
    accommodate new functionality from this and other extensions,  
    but should be functionally equivalent to the ARB_fragment_program  
    grammar.  
  
    <program>               ::= <optionSequence> <statementSequence> "END"  
  
    <optionSequence>        ::= <optionSequence> <option>  
                              | /* empty */  
  
    <option>                ::= "OPTION" <optionName> ";"  
  
    <optionName>            ::= "ARB_fog_exp"  
                              | "ARB_fog_exp2"  
                              | "ARB_fog_linear"  
                              | "ARB_precision_hint_fastest"  
                              | "ARB_precision_hint_nicest"  
  
    <statementSequence>     ::= <statement> <statementSequence>  
                              | /* empty */  
  
    <statement>             ::= <instruction> ";"  
                              | <namingStatement> ";"  
  
    <instruction>           ::= <ALUInstruction>  
                              | <TexInstruction>  
  
    <ALUInstruction>        ::= <VECTORop_instruction>  
                              | <SCALARop_instruction>  
                              | <BINSCop_instruction>  
                              | <BINop_instruction>  
                              | <TRIop_instruction>  
                              | <SWZop_instruction>  
  
    <TexInstruction>        ::= <TEXop_instruction>  
                              | <KILop_instruction>  
  
    <VECTORop_instruction>  ::= <VECTORop> <instResult> "," <instOperandV>  
  
    <VECTORop>              ::= "ABS"  
                              | "FLR"  
                              | "FRC"  
                              | "LIT"  
                              | "MOV"  
  
    <SCALARop_instruction>  ::= <SCALARop> <instResult> "," <instOperandS>  
  
    <SCALARop>              ::= "COS"  
                              | "EX2"  
                              | "LG2"  
                              | "RCP"  
                              | "RSQ"  
                              | "SCS"  
                              | "SIN"  
  
    <BINSCop_instruction>   ::= <BINSCop> <instResult> "," <instOperandS> ","   
                                <instOperandS>  
  
    <BINSCop>               ::= "POW"  
  
    <BINop_instruction>     ::= <BINop> <instResult> "," <instOperandV> ","   
                                <instOperandV>  
  
    <BINop>                 ::= "ADD"  
                              | "DP3"  
                              | "DP4"  
                              | "DPH"  
                              | "DST"  
                              | "MAX"  
                              | "MIN"  
                              | "MUL"  
                              | "SGE"  
                              | "SLT"  
                              | "SUB"  
                              | "XPD"  
  
    <TRIop_instruction>     ::= <TRIop> <instResult> "," <instOperandV> ","   
                                <instOperandV> "," <instOperandV>  
  
    <TRIop>                 ::= "CMP"  
                              | "MAD"  
                              | "LRP"  
  
    <SWZop_instruction>     ::= <SWZop> <instResult> "," <instOperandVNS> ","   
                                <extendedSwizzle>  
  
    <SWZop>                 ::= "SWZ"  
  
    <TEXop_instruction>     ::= <TEXop> <instResult> "," <instOperandV> ","   
                                <texTarget>  
  
    <TEXop>                 ::= "TEX"  
                              | "TXP"  
                              | "TXB"  
  
    <KILop_instruction>     ::= <KILop> <killCond>  
  
    <KILop>                 ::= "KIL"  
  
    <texTarget>             ::= <texImageUnit> "," <texTargetType>  
  
    <texImageUnit>          ::= "texture" <optTexImageUnitNum>  
  
    <optTexImageUnitNum>    ::= /* empty */  
                              | "[" <texImageUnitNum> "]"  
  
    <texImageUnitNum>       ::= <integer>   
                                /*[0,MAX_TEXTURE_IMAGE_UNITS_ARB-1]*/  
  
    <texTargetType>         ::= "1D"  
                              | "2D"  
                              | "3D"  
                              | "CUBE"  
                              | "RECT"  
  
    <killCond>              ::= <instOperandV>  
  
    <instOperandV>          ::= <instOperandBaseV>  
  
    <instOperandBaseV>      ::= <optSign> <attribUseV>  
                              | <optSign> <tempUseV>  
                              | <optSign> <paramUseV>  
  
    <instOperandS>          ::= <instOperandBaseS>  
  
    <instOperandBaseS>      ::= <optSign> <attribUseS>  
                              | <optSign> <tempUseS>  
                              | <optSign> <paramUseS>  
  
    <instOperandVNS>        ::= <attribUseVNS>  
                              | <tempUseVNS>  
                              | <paramUseVNS>  
  
    <instResult>            ::= <instResultBase>  
  
    <instResultBase>        ::= <tempUseW>  
                              | <resultUseW>  
  
    <namingStatement>       ::= <ATTRIB_statement>  
                              | <PARAM_statement>  
                              | <TEMP_statement>  
                              | <OUTPUT_statement>  
                              | <ALIAS_statement>  
  
    <ATTRIB_statement>      ::= "ATTRIB" <establishName> "=" <attribUseD>  
  
    <PARAM_statement>       ::= <PARAM_singleStmt>  
                              | <PARAM_multipleStmt>  
  
    <PARAM_singleStmt>      ::= "PARAM" <establishName> <paramSingleInit>  
  
    <PARAM_multipleStmt>    ::= "PARAM" <establishName> "[" <optArraySize> "]"   
                                <paramMultipleInit>  
  
    <optArraySize>          ::= /* empty */  
                              | <integer> /* [1,MAX_PROGRAM_PARAMETERS_ARB]*/  
  
    <paramSingleInit>       ::= "=" <paramUseDB>  
  
    <paramMultipleInit>     ::= "=" "{" <paramMultInitList> "}"  
  
    <paramMultInitList>     ::= <paramUseDM>  
                              | <paramUseDM> "," <paramMultInitList>  
  
    <TEMP_statement>        ::= "TEMP" <varNameList>  
  
    <OUTPUT_statement>      ::= "OUTPUT" <establishName> "=" <resultUseD>  
  
    <ALIAS_statement>       ::= "ALIAS" <establishName> "=" <establishedName>  
  
    <establishedName>       ::= <tempVarName>  
                              | <addrVarName>  
                              | <attribVarName>  
                              | <paramArrayVarName>  
                              | <paramSingleVarName>  
                              | <resultVarName>  
  
    <varNameList>           ::= <establishName>  
                              | <establishName> "," <varNameList>  
  
    <establishName>         ::= <identifier>  
  
    <attribUseV>            ::= <attribBasic> <swizzleSuffix>  
                              | <attribVarName> <swizzleSuffix>  
                              | <attribColor> <swizzleSuffix>  
                              | <attribColor> "." <colorType> <swizzleSuffix>  
  
    <attribUseS>            ::= <attribBasic> <scalarSuffix>  
                              | <attribVarName> <scalarSuffix>  
                              | <attribColor> <scalarSuffix>  
                              | <attribColor> "." <colorType> <scalarSuffix>  
  
    <attribUseVNS>          ::= <attribBasic>  
                              | <attribVarName>  
                              | <attribColor>  
                              | <attribColor> "." <colorType>  
  
    <attribUseD>            ::= <attribBasic>  
                              | <attribColor>  
                              | <attribColor> "." <colorType>  
  
    <attribBasic>           ::= "fragment" "." <attribFragBasic>  
  
    <attribFragBasic>       ::= "texcoord" <optTexCoordNum>  
                              | "fogcoord"  
                              | "position"  
  
    <attribColor>           ::= "fragment" "." "color"  
  
    <paramUseV>             ::= <paramSingleVarName> <swizzleSuffix>  
                              | <paramArrayVarName> "[" <arrayMem> "]"   
                                <swizzleSuffix>  
                              | <stateSingleItem> <swizzleSuffix>  
                              | <programSingleItem> <swizzleSuffix>  
                              | <constantVector> <swizzleSuffix>  
                              | <constantScalar> <swizzleSuffix>  
  
    <paramUseS>             ::= <paramSingleVarName> <scalarSuffix>  
                              | <paramArrayVarName> "[" <arrayMem> "]"   
                                <scalarSuffix>  
                              | <stateSingleItem> <scalarSuffix>  
                              | <programSingleItem> <scalarSuffix>  
                              | <constantVector> <scalarSuffix>  
                              | <constantScalar> <scalarSuffix>  
  
    <paramUseVNS>           ::= <paramSingleVarName>  
                              | <paramArrayVarName> "[" <arrayMem> "]"  
                              | <stateSingleItem>  
                              | <programSingleItem>  
                              | <constantVector>  
                              | <constantScalar>  
  
    <paramUseDB>            ::= <stateSingleItem>  
                              | <programSingleItem>  
                              | <constantVector>  
                              | <signedConstantScalar>  
  
    <paramUseDM>            ::= <stateMultipleItem>  
                              | <programMultipleItem>  
                              | <constantVector>  
                              | <signedConstantScalar>  
  
    <stateMultipleItem>     ::= <stateSingleItem>  
                              | "state" "." <stateMatrixRows>  
  
    <stateSingleItem>       ::= "state" "." <stateMaterialItem>  
                              | "state" "." <stateLightItem>  
                              | "state" "." <stateLightModelItem>  
                              | "state" "." <stateLightProdItem>  
                              | "state" "." <stateFogItem>  
                              | "state" "." <stateMatrixRow>  
                              | "state" "." <stateTexEnvItem>  
                              | "state" "." <stateDepthItem>  
  
    <stateMaterialItem>     ::= "material" "." <stateMatProperty>  
                              | "material" "." <faceType> "."   
                                <stateMatProperty>  
  
    <stateMatProperty>      ::= "ambient"  
                              | "diffuse"  
                              | "specular"  
                              | "emission"  
                              | "shininess"  
  
    <stateLightItem>        ::= "light" "[" <stateLightNumber> "]" "."   
                                <stateLightProperty>  
  
    <stateLightProperty>    ::= "ambient"  
                              | "diffuse"  
                              | "specular"  
                              | "position"  
                              | "attenuation"  
                              | "spot" "." <stateSpotProperty>  
                              | "half"  
  
    <stateSpotProperty>     ::= "direction"  
  
    <stateLightModelItem>   ::= "lightmodel" <stateLModProperty>  
  
    <stateLModProperty>     ::= "." "ambient"  
                              | "." "scenecolor"  
                              | "." <faceType> "." "scenecolor"  
  
    <stateLightProdItem>    ::= "lightprod" "[" <stateLightNumber> "]" "."   
                                <stateLProdProperty>  
                              | "lightprod" "[" <stateLightNumber> "]" "."   
                                <faceType> "." <stateLProdProperty>  
  
    <stateLProdProperty>    ::= "ambient"  
                              | "diffuse"  
                              | "specular"  
  
    <stateLightNumber>      ::= <integer> /* [0,MAX_LIGHTS-1] */  
  
    <stateFogItem>          ::= "fog" "." <stateFogProperty>  
  
    <stateFogProperty>      ::= "color"  
                              | "params"  
  
    <stateMatrixRows>       ::= <stateMatrixItem>  
                              | <stateMatrixItem> "." <stateMatModifier>  
                              | <stateMatrixItem> "." "row" "["   
                                <stateMatrixRowNum> ".." <stateMatrixRowNum>   
                                "]"  
                              | <stateMatrixItem> "." <stateMatModifier> "."   
                                "row" "[" <stateMatrixRowNum> ".."   
                                <stateMatrixRowNum> "]"  
  
    <stateMatrixRow>        ::= <stateMatrixItem> "." "row" "["   
                                <stateMatrixRowNum> "]"  
                              | <stateMatrixItem> "." <stateMatModifier> "."   
                                "row" "[" <stateMatrixRowNum> "]"  
  
    <stateMatrixItem>       ::= "matrix" "." <stateMatrixName>  
  
    <stateMatModifier>      ::= "inverse"  
                              | "transpose"  
                              | "invtrans"  
  
    <stateMatrixName>       ::= "modelview" <stateOptModMatNum>  
                              | "projection"  
                              | "mvp"  
                              | "texture" <optTexCoordNum>  
                              | "palette" "[" <statePaletteMatNum> "]"  
                              | "program" "[" <stateProgramMatNum> "]"  
  
    <stateMatrixRowNum>     ::= <integer> /* [0,3] */  
  
    <stateOptModMatNum>     ::= /* empty */  
                              | "[" <stateModMatNum> "]"  
  
    <stateModMatNum>        ::= <integer> /*[0,MAX_VERTEX_UNITS_ARB-1]*/  
  
    <statePaletteMatNum>    ::= <integer> /*[0,MAX_PALETTE_MATRICES_ARB-1]*/  
  
    <stateProgramMatNum>    ::= <integer> /*[0,MAX_PROGRAM_MATRICES_ARB-1]*/  
  
    <stateTexEnvItem>       ::= "texenv" <optLegacyTexUnitNum> "."   
                                <stateTexEnvProperty>  
  
    <stateTexEnvProperty>   ::= "color"  
  
    <stateDepthItem>        ::= "depth" "." <stateDepthProperty>  
  
    <stateDepthProperty>    ::= "range"  
  
    <programSingleItem>     ::= <progEnvParam>  
                              | <progLocalParam>  
  
    <programMultipleItem>   ::= <progEnvParams>  
                              | <progLocalParams>  
  
    <progEnvParams>         ::= "program" "." "env" "[" <progEnvParamNums> "]"  
  
    <progEnvParamNums>      ::= <progEnvParamNum>  
                              | <progEnvParamNum> ".." <progEnvParamNum>  
  
    <progEnvParam>          ::= "program" "." "env" "[" <progEnvParamNum> "]"  
  
    <progLocalParams>       ::= "program" "." "local" "[" <progLocalParamNums>   
                                "]"  
  
    <progLocalParamNums>    ::= <progLocalParamNum>  
                              | <progLocalParamNum> ".." <progLocalParamNum>  
  
    <progLocalParam>        ::= "program" "." "local" "[" <progLocalParamNum>   
                                "]"  
  
    <progEnvParamNum>       ::= <integer>   
                                /*[0,MAX_PROGRAM_ENV_PARAMETERS_ARB-1]*/  
  
    <progLocalParamNum>     ::= <integer>   
                                /*[0,MAX_PROGRAM_LOCAL_PARAMETERS_ARB-1]*/  
  
    <constantVector>        ::= "{" <constantVectorList> "}"  
  
    <constantVectorList>    ::= <signedConstantScalar>  
                              | <signedConstantScalar> ","   
                                <signedConstantScalar>  
                              | <signedConstantScalar> ","   
                                <signedConstantScalar> ","   
                                <signedConstantScalar>  
                              | <signedConstantScalar> ","   
                                <signedConstantScalar> ","   
                                <signedConstantScalar> ","   
                                <signedConstantScalar>  
  
    <signedConstantScalar>  ::= <optSign> <constantScalar>  
  
    <constantScalar>        ::= <floatConstant>  
  
    <floatConstant>         ::= <float>  
  
    <tempUseV>              ::= <tempVarName> <swizzleSuffix>  
  
    <tempUseS>              ::= <tempVarName> <scalarSuffix>  
  
    <tempUseVNS>            ::= <tempVarName>  
  
    <tempUseW>              ::= <tempVarName> <optWriteMask>  
  
    <resultUseW>            ::= <resultBasic> <optWriteMask>  
                              | <resultVarName> <optWriteMask>  
  
    <resultUseD>            ::= <resultBasic>  
  
    <resultBasic>           ::= "result" "." <resultFragBasic>  
  
    <resultFragBasic>       ::= "color" <resultOptColorNum>  
                              | "depth"  
  
    <resultOptColorNum>     ::= /* empty */  
  
    <arrayMem>              ::= <arrayMemAbs>  
  
    <arrayMemAbs>           ::= <integer>  
  
    <optWriteMask>          ::= /* empty */  
                              | <xyzwMask>  
                              | <rgbaMask>  
  
    <xyzwMask>              ::= "." "x"  
                              | "." "y"  
                              | "." "xy"  
                              | "." "z"  
                              | "." "xz"  
                              | "." "yz"  
                              | "." "xyz"  
                              | "." "w"  
                              | "." "xw"  
                              | "." "yw"  
                              | "." "xyw"  
                              | "." "zw"  
                              | "." "xzw"  
                              | "." "yzw"  
                              | "." "xyzw"  
  
    <rgbaMask>              ::= "." "r"  
                              | "." "g"  
                              | "." "rg"  
                              | "." "b"  
                              | "." "rb"  
                              | "." "gb"  
                              | "." "rgb"  
                              | "." "a"  
                              | "." "ra"  
                              | "." "ga"  
                              | "." "rga"  
                              | "." "ba"  
                              | "." "rba"  
                              | "." "gba"  
                              | "." "rgba"  
  
    <swizzleSuffix>         ::= /* empty */  
                              | "." <component>  
                              | "." <xyzwComponent> <xyzwComponent>   
                                <xyzwComponent> <xyzwComponent>  
                              | "." <rgbaComponent> <rgbaComponent>   
                                <rgbaComponent> <rgbaComponent>  
  
    <extendedSwizzle>       ::= <extSwizComp> "," <extSwizComp> ","   
                                <extSwizComp> "," <extSwizComp>  
  
    <extSwizComp>           ::= <optSign> <xyzwExtSwizSel>  
                              | <optSign> <rgbaExtSwizSel>  
  
    <xyzwExtSwizSel>        ::= "0"  
                              | "1"  
                              | <xyzwComponent>  
  
    <rgbaExtSwizSel>        ::= <rgbaComponent>  
  
    <scalarSuffix>          ::= "." <component>  
  
    <component>             ::= <xyzwComponent>  
                              | <rgbaComponent>  
  
    <xyzwComponent>         ::= "x"  
                              | "y"  
                              | "z"  
                              | "w"  
  
    <rgbaComponent>         ::= "r"  
                              | "g"  
                              | "b"  
                              | "a"  
  
    <optSign>               ::= /* empty */  
                              | "-"  
                              | "+"  
  
    <faceType>              ::= "front"  
                              | "back"  
  
    <colorType>             ::= "primary"  
                              | "secondary"  
  
    <optTexCoordNum>        ::= /* empty */  
                              | "[" <texCoordNum> "]"  
  
    <texCoordNum>           ::= <integer> /*[0,MAX_TEXTURE_COORDS_ARB-1]*/  
  
    <optLegacyTexUnitNum>   ::= /* empty */  
                              | "[" <legacyTexUnitNum> "]"  
  
    <legacyTexUnitNum>      ::= <integer> /*[0,MAX_TEXTURE_UNITS-1]*/  
  
    The <integer>, <float>, and <identifier> grammar rules match  
    integer constants, floating point constants, and identifier names  
    as described in the ARB_vertex_program specification.  The <float>  
    grammar rule here is identical to the <floatConstant> grammar rule  
    in ARB_vertex_program.  
  
    The grammar rules <tempVarName>, <addrVarName>, <attribVarName>,  
    <paramArrayVarName>, <paramSingleVarName>, <resultVarName> refer  
    to the names of temporary, address register, attribute, program  
    parameter array, program parameter, and result variables declared  
    in the program text.  
  
homeprevnext GLX Protocol
  
    None.  
  
homeprevnext Errors
  
    None.  
  
homeprevnext New State
  
    None.  
  
homeprevnext Revision History
  
    Rev.  Date      Author   Changes  
    ----  --------  -------  --------------------------------------------  
    4     05/27/05  pbrown   Removed required NV_fragment_program dependency;  
                             that extension actually isn't needed although the  
                             functionality it provides obviously is.  
  
    3     07/08/04  pbrown   Fixed entries for KIL and RFL in the opcode  
                             table.  
  
    2     05/16/04  pbrown   Documented terminals in modified fragment program  
                             grammar.   
  
    1     --------  pbrown   Internal pre-release revisions.  
    1     --------  pbrown   Internal pre-release revisions.  
Valid XHTML 1.1! Valid CSS! Last update: November 14, 2006.
Cette page doit être lue avec un navigateur récent respectant le standard XHTML 1.1.