Name

    NV_fragment_program_option

Name Strings

    GL_NV_fragment_program_option

Contact

    Pat Brown, NVIDIA Corporation (pbrown 'at' nvidia.com)

Status

    Shipping.

Version

    Last Modified:      05/27/2005
    NVIDIA Revision:    4

Number

    303

Dependencies

    ARB_fragment_program is required.

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.

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.

New Procedures and Functions

    None.

New Tokens

    None.

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

    None.

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

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

    None.

Additions to Chapter 5 of the OpenGL 1.2.1 Specification (Special
Functions)

    None.

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

    None.

Additions to Appendix A of the OpenGL 1.2.1 Specification (Invariance)

    None.

Additions to the AGL/GLX/WGL Specifications

    None.

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.

GLX Protocol

    None.

Errors

    None.

New State

    None.

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.