Name

    NV_vertex_program2_option

Name Strings

    GL_NV_vertex_program2_option

Contact

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

Status

    Shipping.

Version

    Last Modified:      06/23/2004
    NVIDIA Revision:    3

Number

    305

Dependencies

    ARB_vertex_program is required.

Overview

    This extension provides additional vertex program functionality
    to extend the standard ARB_vertex_program language and execution
    environment.  ARB programs wishing to use this added functionality
    need only add:

        OPTION NV_vertex_program2;

    to the beginning of their vertex programs.

    The functionality provided by this extension, which is roughly
    equivalent to that provided by the NV_vertex_program2 extension,
    includes:

      * general purpose dynamic branching,

      * subroutine calls,

      * data-dependent conditional write masks,

      * programmable user clip distances,

      * address registers with four components (instead of just one),

      * absolute value operator on scalar and swizzled operand loads,

      * rudimentary address register math,

      * SIN and COS trigonometry instructions, and

      * fully orthogonal "set on" instructions, including a "set sign"
        instruction.

Issues

    Why is this a separate extension, rather than just an additional
    feature of NV_vertex_program2?

      RESOLVED:  The NV_vertex_program2 specification was completed
      (with a published implementation) prior to the completion of
      ARB_vertex_program.  Future NVIDIA vertex program extensions should
      contain extensions to the ARB_vertex_program execution environment
      as a standard feature.

    NV_vertex_program1_1 contains one feature not found in
    ARB_vertex_program: the "RCC" (reciprocal clamped) instruction.
    Should a "NV_vertex_program1_1" program option be provided to expose
    this small amount of missing functionality?

      RESOLVED:  No.  By itself, that functionality is not all that
      interesting.

    Should this extension provide a mechanism to specify an "ARB"
    version of NV_vertex_program state programs (!!VSP1.0)?

      RESOLVED:  No.

    Should a similar option be provided to expose ARB_vertex_program
    features not found in NV_vertex_program (e.g., local parameters, state
    bindings, certain "macro" instructions) under the NV_vertex_program
    interface?

      RESOLVED:  No.  Why not just write an ARB program in that case?

    The ARB_vertex_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_vertex_program2_option grammar will correct
      this problem, which should be fixed in future revisions to the
      ARB language.

New Procedures and Functions

    None.

New Tokens

    Accepted by the <pname> parameter of GetProgramivARB:

        MAX_PROGRAM_EXEC_INSTRUCTIONS_NV                0x88F4
        MAX_PROGRAM_CALL_DEPTH_NV                       0x88F5

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

    Modify Section 2.11, Clipping (p. 42)

    (insert before the second paragraph, p. 43) In vertex program mode,
    conventional user clipping is performed if the vertex program is
    position-invariant (section 2.14.4.5.1).  When the vertex program
    is not position-invariant, it can write a single floating-point clip
    distance for each supported clip plane.  The half-space corresponding
    to clip plane <n> is given by the set of points that satisfy the
    inequality

      c_n(P) >=0,

    where c_n(P) is the value of clip distance <n> at point P.  For point
    primitives, c_n(P) is simply the clip distance for the vertex in
    question.  For line and triangle primitives, per-vertex clip distances
    are interpolated using a weighted mean, with weights derived according
    to the algorithms described in sections 3.4 and 3.5.

    Modify Section 2.14.2, Vertex Program Grammar and Restrictions

    (mostly add to existing grammar rules, modify a few existing grammar
    rules -- changes marked with "***")

    <optionName>            ::= "NV_vertex_program2"

    <statement>             ::= <branchLabel> ":"

    <instruction>           ::= <FlowInstruction>

    <ALUInstruction>        ::= <ARAop_instruction>

    <FlowInstruction>       ::= <BRAop_instruction>
                              | <FLOWCCop_instruction>

    <VECTORop>              ::= "SSG"

    <SCALARop>              ::= "COS"
                              | "RCC"
                              | "SIN"

    <BINop>                 ::= "SEQ"
                              | "SFL"
                              | "SGT"
                              | "SLE"
                              | "SNE"
                              | "STR"

    <ARLop>                 ::= "ARR"

    <ARLop_src>             ::= <instOperandV>  
                                  (*** instead of <instOperandS>)

    <ARAop_instruction>     ::= <ARAop> <instResultAddr> "," 
                                <instOperandAddrVNS>

    <ARAop>                 ::= "ARA"

    <BRAop_instruction>     ::= <BRAop> <branchLabel> <optBranchCond>

    <BRAop>                 ::= "BRA"
                              | "CAL"

    <FLOWCCop_instruction>  ::= <FLOWCCop> <optBranchCond>

    <FLOWCCop>              ::= "RET"

    <optBranchCond>         ::= /* empty */
                              | <ccMask>

    <instOperandV>          ::= <instOperandAbsV>

    <instOperandAbsV>       ::= <optSign> "|" <instOperandBaseV> "|"

    <instOperandS>          ::= <instOperandAbsS>

    <instOperandAbsS>       ::= <optSign> "|" <instOperandBaseS> "|"


    <instOperandAddrVNS>    ::= <addrUseVNS>

    <instResult>            ::= <instResultCC>

    <instResultCC>          ::= <instResultBase> <ccMask>

    <instResultAddr>        ::= <instResultAddrCC>

    <instResultAddrCC>      ::= <instResultAddrBase> <ccMask>

    <branchLabel>           ::= <identifier>

    <paramUseV>             ::= <constantScalar> 
                                  (*** instead of <constantScalar>
                                       <swizzleSuffix>)

    <paramUseS>             ::= <constantScalar> 
                                  (*** instead of <constantScalar>
                                       <scalarSuffix>)

    <resultVtxBasic>        ::= "clip" "[" <clipPlaneNum> "]"

    <addrUseVNS>            ::= <addrVarName>

    <addrUseW>              ::= <addrVarName> <optAddrWriteMask>
                                  (*** instead of <addrVarName> 
                                       <addrWriteMask>)

    <ccMask>                ::= "(" <ccTest> ")"

    <ccTest>                ::= <ccMaskRule> <swizzleSuffix>

    <ccMaskRule>            ::= "EQ"
                              | "GE"
                              | "GT"
                              | "LE"
                              | "LT"
                              | "NE"
                              | "TR"
                              | "FL"

    <optAddrWriteMask>      ::= <optWriteMask> 
                                  (*** instead of "." "x")

    <addrComponent>         ::= <xyzwComponent> 
                                  (*** instead of "x")

    (modify description of reserved identifiers)
    
    ... The following strings are reserved keywords and may not be used
    as identifiers:

        ABS, ADD, ADDRESS, ALIAS, ARA, ARL, ARR, ATTRIB, BRA, CAL, COS,
        DP3, DP4, DPH, DST, END, EX2, EXP, FLR, FRC, LG2, LIT, LOG, MAD,
        MAX, MIN, MOV, MUL, OPTION, OUTPUT, PARAM, POW, RCC, RCP, RET,
        RSQ, SEQ, SFL, SGE, SGT, SIN, SLE, SLT, SNE, SUB, SSG, STR, SWZ,
        TEMP, XPD, program, result, state, and vertex.

    Add to Section 2.14.3.4, Vertex Program Results

    (add to binding table)

      Binding                        Components  Description
      -----------------------------  ----------  ----------------------------
      result.clip[n]                 (d,*,*,*)   clip plane distance

    (add a paragraph before the last one) If a result variable binding
    matches "result.clip[n]", updates to the "x" component of the result
    variable set the clip distance for clip plane <n>.

    (modify last paragraph) When in vertex program mode, all attributes
    of a transformed vertex, except for clip distances, are undefined
    at each vertex program invocation.  Any results, or even individual
    components of results, that are not written to during vertex program
    execution remain undefined.  All clip distances are initially zero,
    and remain zero if not written by the vertex program.

    Modify Section 2.14.3.5, Vertex Program Address Registers

    (modify first paragraph) Vertex program address register variables are
    a set of four-component signed integer vectors.  Address registers
    are used as indices when performing relative addressing in program
    parameter arrays (section 2.14.4.2).

    (modify third paragraph) Vertex program address register variables are
    undefined at each vertex program invocation.  Address registers can
    be written by the ARA, ARL, and ARL instructions (section 2.14.5),
    and will be read by the ARA instruction and when a program uses
    relative addressing in program parameter arrays.

    Add New Section 2.14.3.X, Condition Code Register (insert after
    Section 2.14.3.5, Vertex Program Address Registers)

    The vertex 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 vertex program instructions can optionally update the condition
    code register.  When a vertex 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 vertex program executes.

    Modify Section 2.14.4, Vertex Program Execution Environment

    (modify 3rd paragraph) Vertex programs execute a sequence of
    instructions, with support for conditional and unconditional branches,
    subroutine calls, and returns.  Vertex programs begin by executing
    the instruction following the label "main".  If no label "main" is
    defined, execution begins at the first instruction in the program.
    Instructions are executed in the order specified in the program,
    jumping when specified in branch instructions, until the end of the
    program is reached.

    (modify instruction table) There are forty-two vertex program
    instructions.  Vertex program instructions may have an optional
    suffix of "C" to allow an update of the condition code register
    (section 2.14.3.X).  For example, there are two instructions to
    perform vector addition, "ADD" and "ADDC".  The instructions and their
    respective input and output parameters are summarized in Table X.5.

      Instruction    Inputs  Output   Description
      -----------    ------  ------   --------------------------------
      ABS[C]         v       v        absolute value
      ADD[C]         v,v     v        add
      ARA[C]         a       a        address register add
      ARL[C]         s       a        address register load
      ARR[C]         v       a        address register load (round)
      BRA            c       -        branch
      CAL            c       -        subroutine call
      COS[C]         s       ssss     cosine
      DP3[C]         v,v     ssss     3-component dot product
      DP4[C]         v,v     ssss     4-component dot product
      DPH[C]         v,v     ssss     homogeneous dot product
      DST[C]         v,v     v        distance vector
      EX2[C]         s       ssss     exponential base 2
      EXP[C]         s       v        exponential base 2 (approximate)
      FLR[C]         v       v        floor
      FRC[C]         v       v        fraction
      LG2[C]         s       ssss     logarithm base 2
      LIT[C]         v       v        compute light coefficients
      LOG[C]         s       v        logarithm base 2 (approximate)
      MAD[C]         v,v,v   v        multiply and add
      MAX[C]         v,v     v        maximum
      MIN[C]         v,v     v        minimum
      MOV[C]         v       v        move
      MUL[C]         v,v     v        multiply
      POW[C]         s,s     ssss     exponentiate
      RCC[C]         s       ssss     reciprocal (clamped)
      RCP[C]         s       ssss     reciprocal
      RET            c       -        subroutine return
      RSQ[C]         s       ssss     reciprocal square root
      SEQ[C]         v,v     v        set on equal
      SFL[C]         v,v     v        set on false
      SGE[C]         v,v     v        set on greater than or equal
      SGT[C]         v,v     v        set on greater than
      SIN[C]         s       ssss     sine
      SLE[C]         v,v     v        set on less than or equal
      SLT[C]         v,v     v        set on less than
      SNE[C]         v,v     v        set on not equal
      SSG[C]         v       v        set sign
      STR[C]         v,v     v        set on true
      SUB[C]         v,v     v        subtract
      SWZ[C]         v       v        extended swizzle
      XPD[C]         v,v     v        cross product

      Table X.5:  Summary of vertex program instructions.  "[C]" indicates
      that the opcode supports the condition code update modifier. "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, "a" indicates a
      vector address register, and "c" indicates a condition code test.

    Modify Section 2.14.4.1, Vertex 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;
      }

    Rewrite Section 2.14.4.3,  Vertex Program Destination Register Update

    Most vertex program instructions write a 4-component result vector to
    a single temporary or vertex 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> and <instResultAddrCC> rules.  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 vertex 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 vertex 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;
      }

    While this rule describes floating-point results, the same logic
    applies to the integer results generated by the ARA, ARL, and ARR
    instructions.

    Add Section 2.14.4.X, Vertex Program Branching (before Section
    2.14.4.4, Vertex Program Result Processing)

    Vertex programs can contain one or more instruction labels, matching
    the grammar rule <branchLabel>.  An instruction label can be referred
    to explicitly in branch (BRA) or subroutine call (CAL) instructions.
    Instruction labels can be defined or used at any point in the body
    of a program, and can be used in instructions before being defined
    in the program string.

    Branching instructions can be conditional.  The branch condition
    is specified by the <optBranchCond> grammar rule and may depend on
    the contents of the condition code register.  Branch conditions are
    evaluated by evaluating a condition code write mask in exactly the
    same manner as done for register writes (section 2.14.2.2).  If any
    of the four components of the condition code write mask are enabled,
    the branch is taken and execution continues with the instruction
    following the label specified in the instruction.  Otherwise, the
    instruction is ignored and vertex program execution continues with
    the next instruction.  In the following example code,

        MOVC CC, c[0];         # c[0]=(-2, 0, 2, NaN), CC gets (LT,EQ,GT,UN)
        BRA label1 (LT.xyzw);
        MOV R0,R1;             # not executed
      label1:
        BRA label2 (LT.wyzw);
        MOV R0,R2;             # executed
      label2:

    the first BRA instruction loads a condition code of (LT,EQ,GT,UN)
    while the second BRA instruction loads a condition code of
    (UN,EQ,GT,UN).  The first branch will be taken because the "x"
    component evaluates to LT; the second branch will not be taken
    because no component evaluates to LT.

    Vertex programs can specify subroutine calls.  When a subroutine
    call (CAL) instruction is executed, a reference to the instruction
    immediately following the CAL instruction is pushed onto the
    call stack.  When a subroutine return (RET) instruction is
    executed, an instruction reference is popped off the call stack
    and program execution continues with the popped instruction.
    A vertex program will terminate if a CAL instruction is executed
    with MAX_PROGRAM_CALL_DEPTH_NV entries already in the call stack or
    if a RET instruction is executed with an empty call stack.

    If a vertex program has an instruction label "main", program
    execution begins with the instruction immediately following the
    instruction label.  Otherwise, program execution begins with the
    first instruction of the program.  Instructions will be executed
    sequentially in the order specified in the program, although
    branch instructions will affect the instruction execution order,
    as described above.  A vertex program will terminate after executing
    a RET instruction with an empty call stack.  A vertex program will
    also terminate after executing the last instruction in the program,
    unless that instruction was a taken branch.

    A vertex program will fail to load if an instruction refers to a
    label that is not defined in the program string.

    A vertex program will terminate abnormally if a subroutine call
    instruction produces a call stack overflow.  Additionally,
    a vertex program will terminate abnormally after executing
    MAX_PROGRAM_EXEC_INSTRUCTIONS instructions to prevent hangs caused
    by infinite loops in the program.

    When a vertex program terminates, normally or abnormally, it will
    emit a vertex whose attributes are taken from the final values of
    the vertex result registers (section 2.14.1.5).

    Modify Section 2.14.4.4,  Vertex Program Result Processing

    (modify 3rd paragraph) Transformed vertices are then assembled into
    primitives and clipped as described in section 2.11.  Clip distance
    results are used to control user clip planes.
    
    Add to Section 2.14.4.5, Vertex Program Options:

    Section 2.14.4.5.2, NV_vertex_program2 Option

    If a vertex program specifies the "NV_vertex_program2" program option,
    the grammar will be extended to support the features found in the
    NV_vertex_program2 extension not present in the ARB_vertex_program
    extension, including:

      * the availability of the following instructions:  

          - ARA (address register add, useful for looping), 
          - ARR (address register load with round), 
          - BRA (branch), 
          - CAL (subroutine call), 
          - COS (cosine), 
          - RET (subroutine return), 
          - SEQ (set on equal), 
          - SFL (set on false), 
          - SGT (set on greater than), 
          - SIN (sine), 
          - SLE (set on less than or equal), 
          - SNE (set on not equal), 
          - SSG (set sign), and
          - STR (set on true).

      * up to MAX_CALL_DEPTH_NV levels of subroutine calls/returns,

      * 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,

      * six clip distance result bindings that can be used to perform
        more complicated user clipping operations than those provided
        with the position invariant program option,

      * four-component address registers (instead of one-component
        registers in ARB_vertex_program), with the "ARL" instruction
        extended to produce a vector result,

      * an absolute value operator on scalar and swizzled operands.

    The added functionality is identical to that provided by
    NV_vertex_program2 extension specification.

    Modify Section 2.14.5.3,  ARL:  Address Register Load

    The ARL instruction loads a single vector operand and performs a
    component-wise floor operation to generate a signed integer result
    vector.

      tmp = VectorLoad(op0);
      iresult.x = floor(tmp.x);
      iresult.y = floor(tmp.y);
      iresult.z = floor(tmp.z);
      iresult.w = floor(tmp.w);

    The floor operation returns the largest integer less than or equal
    to the operand.  For example floor(-1.7) = -2.0, floor(+1.0) = +1.0,
    and floor(+3.7) = +3.0.

    Note that in the unextended ARB_vertex_program specification, the ARL
    instruction loads a scalar operand and generates a scalar result.  

    Add to Section 2.14.5,  Vertex Program Instruction Set

    Section 2.14.5.28,  ARA:  Address Register Add

    The ARA instruction adds two pairs of components of a vector address
    register operand to produce an integer result vector.  The "x" and "z"
    components of the result vector contain the sum of the "x" and "z"
    components of the operand; the "y" and "w" components of the result
    vector contain the sum of the "y" and "w" components of the operand.

      itmp = AddrVectorLoad(op0);
      iresult.x = itmp.x + itmp.z;
      iresult.y = itmp.y + itmp.w;
      iresult.z = itmp.x + itmp.z;
      iresult.w = itmp.y + itmp.w;

    Component swizzling is not supported when the operand is loaded.

    Section 2.14.5.29,  ARR:  Address Register Load (with round)

    The ARR instruction loads a single vector operand and performs a
    component-wise round operation to generate a signed integer result
    vector.

      tmp = VectorLoad(op0);
      iresult.x = round(tmp.x);
      iresult.y = round(tmp.y);
      iresult.z = round(tmp.z);
      iresult.w = round(tmp.w);

    The round operation returns the nearest integer to the operand.  If the
    fractional portion of the operand is 0.5, round() selects the nearest even
    integer.  For example round(-1.7) = -2.0, round(+1.0) = +1.0, and
    round(+3.7) = +4.0.

    Section 2.14.5.30,  BRA:  Branch

    The BRA instruction conditionally transfers control to the instruction
    following the label specified in the instruction.  The following
    pseudocode describes the operation of the instruction:

      if (TestCC(cc.c***) || TestCC(cc.*c**) || 
          TestCC(cc.**c*) || TestCC(cc.***c)) {
        // continue execution at instruction following <branchLabel>
      } else {
        // do nothing
      }

    In the pseudocode, <branchLabel> is the label specified in the
    instruction according to the <branchLabel> grammar rule.

    Section 2.14.5.31,  CAL:  Subroutine Call

    The CAL instruction conditionally transfers control to the instruction
    following the label specified in the instruction.  It also pushes a
    reference to the instruction immediately following the CAL instruction
    onto the call stack, where execution will continue after executing
    the matching RET instruction.  The following pseudocode describes
    the operation of the instruction:

      if (TestCC(cc.c***) || TestCC(cc.*c**) || 
          TestCC(cc.**c*) || TestCC(cc.***c)) {
        if (callStackDepth >= MAX_PROGRAM_CALL_DEPTH_NV) {
          // terminate vertex program
        } else {
          callStack[callStackDepth] = nextInstruction;
          callStackDepth++;
        }
        // continue execution at instruction following <branchLabel>
      } else {
        // do nothing
      }

    In the pseudocode, <branchLabel> is the label specified in the
    instruction matching the <branchLabel> grammar rule, <callStackDepth>
    is the current depth of the call stack, <callStack> is an array
    holding the call stack, and <nextInstruction> is a reference to the
    instruction immediately following the present one in the program
    string.

    If the call stack overflows, the vertex program terminates abnormally and
    all vertex program results are undefined.

    Section 2.14.5.32,  COS:  Cosine

    The COS instruction approximates the cosine of the angle specified
    by the scalar operand and replicates the approximation to all four
    components of the result vector.  The angle is specified in radians
    and does not have to be in the range [0,2*PI].

      tmp = ScalarLoad(op0);
      result.x = ApproxCosine(tmp);
      result.y = ApproxCosine(tmp);
      result.z = ApproxCosine(tmp);
      result.w = ApproxCosine(tmp);

    Section 2.14.5.33,  RCC:  Reciprocal (Clamped)

    The RCC instruction approximates the reciprocal of the scalar operand,
    clamps the result to one of two ranges, and replicates the clamped
    result to all four components of the result vector.

    If the approximated reciprocal is greater than 0.0, the result is
    clamped to the range [2^-64, 2^+64].  If the approximate reciprocal
    is not greater than zero, the result is clamped to the range [-2^+64,
    -2^-64].

      tmp = ScalarLoad(op0);
      result.x = ClampApproxReciprocal(tmp);
      result.y = ClampApproxReciprocal(tmp);
      result.z = ClampApproxReciprocal(tmp);
      result.w = ClampApproxReciprocal(tmp);

    The following rule applies to reciprocation:

      1. ApproxReciprocal(+1.0) = +1.0.

    Section 2.14.5.34,  RET:  Subroutine Call Return

    The RET instruction conditionally returns from a subroutine initiated
    by a CAL instruction by popping an instruction reference off the
    top of the call stack and transferring control to the referenced
    instruction.  The following pseudocode describes the operation of
    the instruction:

      if (TestCC(cc.c***) || TestCC(cc.*c**) || 
          TestCC(cc.**c*) || TestCC(cc.***c)) {
        if (callStackDepth <= 0) {
          // terminate vertex program
        } else {
          callStackDepth--;
          instruction = callStack[callStackDepth];
        }

        // continue execution at <instruction>
      } else {
        // do nothing
      }

    In the pseudocode, <callStackDepth> is the depth of the call stack,
    <callStack> is an array holding the call stack, and <instruction> is
    a reference to an instruction previously pushed onto the call stack.

    If the call stack is empty when RET executes, the vertex program
    terminates normally.

    Section 2.14.5.35,  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 2.14.5.36,  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 2.14.5.37,  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 2.14.5.38,  SIN:  Sine

    The SIN instruction approximates the sine of the angle specified by
    the scalar operand and replicates it to all four components of the
    result vector.  The angle is specified in radians and does not have
    to be in the range [0,2*PI].

      tmp = ScalarLoad(op0);
      result.x = ApproxSine(tmp);
      result.y = ApproxSine(tmp);
      result.z = ApproxSine(tmp);
      result.w = ApproxSine(tmp);

    Section 2.14.5.39,  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 2.14.5.40,  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 2.14.5.41,  SSG:  Set Sign

    The SSG instruction generates a result vector containing the signs of
    each component of the single vector operand.  Each component of the
    result vector is 1.0 if the corresponding component of the operand
    is greater than zero, 0.0 if the corresponding component of the
    operand is equal to zero, and -1.0 if the corresponding component
    of the operand is less than zero.

      tmp = VectorLoad(op0);
      result.x = SetSign(tmp.x);
      result.y = SetSign(tmp.y);
      result.z = SetSign(tmp.z);
      result.w = SetSign(tmp.w);

    Section 2.14.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;

Additions to Chapter 3 of the OpenGL 1.4 Specification (Rasterization)

    None.

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

    None.

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

    None.

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

    None.

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

    None.

Additions to the AGL/GLX/WGL Specifications

    None.

Dependencies on ARB_vertex_program

    This specification is based on a modified version of the grammar
    published in the ARB_vertex_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_vertex_program grammar.

    <program>               ::= <optionSequence> <statementSequence> "END"

    <optionSequence>        ::= <optionSequence> <option>
                              | /* empty */

    <option>                ::= "OPTION" <optionName> ";"

    <optionName>            ::= "ARB_position_invariant"

    <statementSequence>     ::= <statement> <statementSequence>
                              | /* empty */

    <statement>             ::= <instruction> ";"
                              | <namingStatement> ";"

    <instruction>           ::= <ALUInstruction>

    <ALUInstruction>        ::= <VECTORop_instruction>
                              | <SCALARop_instruction>
                              | <BINSCop_instruction>
                              | <BINop_instruction>
                              | <TRIop_instruction>
                              | <SWZop_instruction>
                              | <ARLop_instruction>

    <VECTORop_instruction>  ::= <VECTORop> <instResult> "," <instOperandV>

    <VECTORop>              ::= "ABS"
                              | "FLR"
                              | "FRC"
                              | "LIT"
                              | "MOV"

    <SCALARop_instruction>  ::= <SCALARop> <instResult> "," <instOperandS>

    <SCALARop>              ::= "EX2"
                              | "EXP"
                              | "LG2"
                              | "LOG"
                              | "RCP"
                              | "RSQ"

    <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>                 ::= "MAD"

    <SWZop_instruction>     ::= <SWZop> <instResult> "," <instOperandVNS> "," 
                                <extendedSwizzle>

    <SWZop>                 ::= "SWZ"

    <ARLop_instruction>     ::= <ARLop> <instResultAddr> "," <ARLop_src>

    <ARLop>                 ::= "ARL"

    <ARLop_src>             ::= <instOperandS>

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

    <instResultAddr>        ::= <instResultAddrBase>

    <instResultAddrBase>    ::= <addrUseW>

    <namingStatement>       ::= <ATTRIB_statement>
                              | <PARAM_statement>
                              | <TEMP_statement>
                              | <OUTPUT_statement>
                              | <ALIAS_statement>
                              | <ADDRESS_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>

    <ADDRESS_statement>     ::= "ADDRESS" <varNameList>

    <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>           ::= "vertex" "." <attribVtxBasic>

    <attribVtxBasic>        ::= "position"
                              | "weight" <vtxOptWeightNum>
                              | "normal"
                              | "fogcoord"
                              | "texcoord" <optTexCoordNum>
                              | "matrixindex" "[" <vtxWeightNum> "]"
                              | "attrib" "[" <vtxAttribNum> "]"

    <attribColor>           ::= "vertex" "." "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" "." <stateTexGenItem>
                              | "state" "." <stateClipPlaneItem>
                              | "state" "." <statePointItem>

    <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]*/

    <stateTexGenItem>       ::= "texgen" <optTexCoordNum> "." 
                                <stateTexGenType> "." <stateTexGenCoord>

    <stateTexGenType>       ::= "eye"
                              | "object"

    <stateTexGenCoord>      ::= "s"
                              | "t"
                              | "r"
                              | "q"

    <stateClipPlaneItem>    ::= "clip" "[" <clipPlaneNum> "]" "." "plane"

    <statePointItem>        ::= "point" "." <statePointProperty>

    <statePointProperty>    ::= "size"
                              | "attenuation"

    <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>
                              | <resultVtxColor> <optWriteMask>
                              | <resultVtxColor> "." <colorType> 
                                <optWriteMask>
                              | <resultVtxColor> "." <faceType> <optWriteMask>
                              | <resultVtxColor> "." <faceType> "." 
                                <colorType> "." <optWriteMask>

    <resultUseD>            ::= <resultBasic>
                              | <resultVtxColor>
                              | <resultVtxColor> "." <colorType>
                              | <resultVtxColor> "." <faceType>
                              | <resultVtxColor> "." <faceType> "." 
                                <colorType>

    <resultBasic>           ::= "result" "." <resultVtxBasic>

    <resultVtxBasic>        ::= "position"
                              | "fogcoord"
                              | "pointsize"
                              | "texcoord" <optTexCoordNum>

    <resultVtxColor>        ::= "result" "." "color"

    <arrayMem>              ::= <arrayMemAbs>
                              | <arrayMemRel>

    <arrayMemRel>           ::= <addrUseS> <arrayMemRelOffset>

    <arrayMemAbs>           ::= <integer>

    <arrayMemRelOffset>     ::= /* empty */
                              | "+" <integer>
                              | "-" <integer>

    <addrUseS>              ::= <addrVarName> <scalarAddrSuffix>

    <addrUseW>              ::= <addrVarName> <addrWriteMask>

    <addrWriteMask>         ::= "." "x"

    <optWriteMask>          ::= /* empty */
                              | <xyzwMask>

    <xyzwMask>              ::= "." "x"
                              | "." "y"
                              | "." "xy"
                              | "." "z"
                              | "." "xz"
                              | "." "yz"
                              | "." "xyz"
                              | "." "w"
                              | "." "xw"
                              | "." "yw"
                              | "." "xyw"
                              | "." "zw"
                              | "." "xzw"
                              | "." "yzw"
                              | "." "xyzw"

    <swizzleSuffix>         ::= /* empty */
                              | "." <component>
                              | "." <xyzwComponent> <xyzwComponent> 
                                <xyzwComponent> <xyzwComponent>

    <extendedSwizzle>       ::= <extSwizComp> "," <extSwizComp> "," 
                                <extSwizComp> "," <extSwizComp>

    <extSwizComp>           ::= <optSign> <xyzwExtSwizSel>

    <xyzwExtSwizSel>        ::= "0"
                              | "1"
                              | <xyzwComponent>

    <scalarAddrSuffix>      ::= "." <addrComponent>

    <addrComponent>         ::= "x"

    <scalarSuffix>          ::= "." <component>

    <component>             ::= <xyzwComponent>

    <xyzwComponent>         ::= "x"
                              | "y"
                              | "z"
                              | "w"

    <optSign>               ::= /* empty */
                              | "-"
                              | "+"

    <faceType>              ::= "front"
                              | "back"

    <colorType>             ::= "primary"
                              | "secondary"

    <vtxAttribNum>          ::= <integer> /*[0,MAX_VERTEX_ATTRIBS_ARB-1]*/

    <vtxOptWeightNum>       ::= /* empty */
                              | "[" <vtxWeightNum> "]"

    <vtxWeightNum>          ::= <integer> /*[0,MAX_VERTEX_UNITS_ARB-1] must be 
                                divisible by four */

    <optTexCoordNum>        ::= /* empty */
                              | "[" <texCoordNum> "]"

    <texCoordNum>           ::= <integer> /*[0,MAX_TEXTURE_COORDS_ARB-1]*/

    <clipPlaneNum>          ::= <integer> /*[0,MAX_CLIP_PLANES-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.


New Implementation Dependent State
                                                                  Min
    Get Value                            Type    Get Command      Value   Description         Sec       Attrib
    -----------------------------------  ----    ---------------  ------  -----------------   --------  ------
    MAX_PROGRAM_EXEC_INSTRUCTIONS_NV     Z+      GetProgramivARB  65536   maximum program     2.14.4.4  -
                                                                          execution inst-
                                                                          ruction count
    MAX_PROGRAM_CALL_DEPTH_NV            Z+      GetProgramivARB  4       maximum program     2.14.4.4  -
                                                                          call stack depth

    (add to Table X.11.  New Implementation-Dependent Values Introduced
    by ARB_vertex_program.  Values queried by GetProgramivARB require
    a <pname> of VERTEX_PROGRAM_ARB.)

Revision History

    Rev.  Date      Author   Changes
    ----  --------  -------  --------------------------------------------
    3     06/23/04  pbrown   Documented that vertex results are undefined
                             if the call stack overflows, and clarified that
                             RET with an empty call stack is not an error.

    2     05/16/04  pbrown   Documented terminals in modified vertex program
                             grammar. 

    1     --------  pbrown   Internal pre-release revisions.