src/mesa/main/arbvertparse.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  5.1
   4  *
   5  * Copyright (C) 1999-2003  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #define DEBUG_VP 0
  26
  27 /**
  28  * \file arbvertparse.c
  29  * ARB_vertex_program parser.
  30  * \author Karl Rasche
  31  */
  32
  33 #include "glheader.h"
  34 #include "context.h"
  35 #include "hash.h"
  36 #include "imports.h"
  37 #include "macros.h"
  38 #include "mtypes.h"
  39 #include "nvprogram.h"
  40 #include "nvvertparse.h"
  41 #include "nvvertprog.h"
  42
  43 #include "arbparse.h"
  44
  45
  46 static GLvoid
  47 debug_vp_inst(GLint num, struct vp_instruction *vp)
  48 {
  49    GLint a;
  50
  51    for (a=0; a<num; a++) {
  52       switch (vp[a].Opcode) {
  53          case VP_OPCODE_MOV:
  54             fprintf(stderr, "VP_OPCODE_MOV"); break;
  55
  56          case VP_OPCODE_LIT:
  57             fprintf(stderr, "VP_OPCODE_LIT"); break;
  58
  59          case VP_OPCODE_RCP:
  60             fprintf(stderr, "VP_OPCODE_RCP"); break;
  61
  62          case VP_OPCODE_RSQ:
  63             fprintf(stderr, "VP_OPCODE_RSQ"); break;
  64
  65          case VP_OPCODE_EXP:
  66             fprintf(stderr, "VP_OPCODE_EXP"); break;
  67
  68          case VP_OPCODE_LOG:
  69             fprintf(stderr, "VP_OPCODE_LOG"); break;
  70
  71          case VP_OPCODE_MUL:
  72             fprintf(stderr, "VP_OPCODE_MUL"); break;
  73
  74          case VP_OPCODE_ADD:
  75             fprintf(stderr, "VP_OPCODE_ADD"); break;
  76
  77          case VP_OPCODE_DP3:
  78             fprintf(stderr, "VP_OPCODE_DP3"); break;
  79
  80          case VP_OPCODE_DP4:
  81             fprintf(stderr, "VP_OPCODE_DP4"); break;
  82
  83          case VP_OPCODE_DST:
  84             fprintf(stderr, "VP_OPCODE_DST"); break;
  85
  86          case VP_OPCODE_MIN:
  87             fprintf(stderr, "VP_OPCODE_MIN"); break;
  88
  89          case VP_OPCODE_MAX:
  90             fprintf(stderr, "VP_OPCODE_MAX"); break;
  91
  92          case VP_OPCODE_SLT:
  93             fprintf(stderr, "VP_OPCODE_SLT"); break;
  94
  95          case VP_OPCODE_SGE:
  96             fprintf(stderr, "VP_OPCODE_SGE"); break;
  97
  98          case VP_OPCODE_MAD:
  99             fprintf(stderr, "VP_OPCODE_MAD"); break;
 100
 101          case VP_OPCODE_ARL:
 102             fprintf(stderr, "VP_OPCODE_ARL"); break;
 103
 104          case VP_OPCODE_DPH:
 105             fprintf(stderr, "VP_OPCODE_DPH"); break;
 106
 107          case VP_OPCODE_RCC:
 108             fprintf(stderr, "VP_OPCODE_RCC"); break;
 109
 110          case VP_OPCODE_SUB:
 111             fprintf(stderr, "VP_OPCODE_SUB"); break;
 112
 113          case VP_OPCODE_ABS:
 114             fprintf(stderr, "VP_OPCODE_ABS"); break;
 115
 116          case VP_OPCODE_FLR:
 117             fprintf(stderr, "VP_OPCODE_FLR"); break;
 118
 119          case VP_OPCODE_FRC:
 120             fprintf(stderr, "VP_OPCODE_FRC"); break;
 121
 122          case VP_OPCODE_EX2:
 123             fprintf(stderr, "VP_OPCODE_EX2"); break;
 124
 125          case VP_OPCODE_LG2:
 126             fprintf(stderr, "VP_OPCODE_LG2"); break;
 127
 128          case VP_OPCODE_POW:
 129             fprintf(stderr, "VP_OPCODE_POW"); break;
 130
 131          case VP_OPCODE_XPD:
 132             fprintf(stderr, "VP_OPCODE_XPD"); break;
 133
 134          case VP_OPCODE_SWZ:
 135             fprintf(stderr, "VP_OPCODE_SWZ"); break;
 136
 137          case VP_OPCODE_END:
 138             fprintf(stderr, "VP_OPCODE_END"); break;
 139       }
 140
 141       fprintf(stderr, " D(0x%x:%d:%d%d%d%d) ", vp[a].DstReg.File, vp[a].DstReg.Index,
 142           vp[a].DstReg.WriteMask[0],
 143           vp[a].DstReg.WriteMask[1],
 144           vp[a].DstReg.WriteMask[2],
 145           vp[a].DstReg.WriteMask[3]);
 146
 147       fprintf(stderr, "S1(0x%x:%d:%d%d%d%d) ", vp[a].SrcReg[0].File, vp[a].SrcReg[0].Index,
 148           vp[a].SrcReg[0].Swizzle[0],
 149           vp[a].SrcReg[0].Swizzle[1],
 150           vp[a].SrcReg[0].Swizzle[2],
 151           vp[a].SrcReg[0].Swizzle[3]);
 152
 153       fprintf(stderr, "S2(0x%x:%d:%d%d%d%d) ", vp[a].SrcReg[1].File, vp[a].SrcReg[1].Index,
 154           vp[a].SrcReg[1].Swizzle[0],
 155           vp[a].SrcReg[1].Swizzle[1],
 156           vp[a].SrcReg[1].Swizzle[2],
 157           vp[a].SrcReg[1].Swizzle[3]);
 158
 159       fprintf(stderr, "S3(0x%x:%d:%d%d%d%d)",  vp[a].SrcReg[2].File, vp[a].SrcReg[2].Index,
 160           vp[a].SrcReg[2].Swizzle[0],
 161           vp[a].SrcReg[2].Swizzle[1],
 162           vp[a].SrcReg[2].Swizzle[2],
 163           vp[a].SrcReg[2].Swizzle[3]);
 164
 165       fprintf(stderr, "\n");
 166    }
 167 }
 168
 169
 170 void
 171 _mesa_parse_arb_vertex_program(GLcontext * ctx, GLenum target,
 172                                const GLubyte * str, GLsizei len,
 173                                struct vertex_program *program)
 174 {
 175    GLuint retval;
 176    struct arb_program ap;
 177
 178         retval = _mesa_parse_arb_program(ctx, str, len, &ap);
 179
 180    /* XXX: Parse error. Cleanup things and return */
 181    if (retval)
 182    {
 183       return;
 184    }
 185
 186    /* XXX: Eh.. we parsed something that wasn't a vertex program. doh! */
 187    if (ap.type != GL_VERTEX_PROGRAM_ARB)
 188    {
 189       return;
 190    }
 191
 192 #if DEBUG_VP
 193    debug_vp_inst(ap.Base.NumInstructions, ap.VPInstructions);
 194 #endif
 195
 196    /* copy the relvant contents of the arb_program struct into the
 197     * fragment_program struct
 198     */
 199    program->Base.NumInstructions = ap.Base.NumInstructions;
 200    program->Base.NumTemporaries  = ap.Base.NumTemporaries;
 201    program->Base.NumParameters   = ap.Base.NumParameters;
 202    program->Base.NumAttributes   = ap.Base.NumAttributes;
 203    program->Base.NumAddressRegs  = ap.Base.NumAddressRegs;
 204
 205    program->Instructions   = ap.VPInstructions;
 206    program->IsPositionInvariant = ap.HintPositionInvariant;
 207    program->InputsRead     = ap.InputsRead;
 208    program->OutputsWritten = ap.OutputsWritten;
 209    program->Parameters     = ap.Parameters;
 210 }