Initial checking of new ARB_frag/vertex program parser

src/mesa/main/arbfragparse.c

@@ -22,11 +22,12 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+#define DEBUG_FP 0
 
 /**
  * \file arbfragparse.c
  * ARB_fragment_program parser.
- * \author 
+ * \author Karl Rasche
  */
 
 #include "glheader.h"
@@ -34,13 +35,189 @@
 #include "imports.h"
 #include "macros.h"
 #include "mtypes.h"
+#include "arbparse.h"
 #include "arbfragparse.h"
 
+static void
+debug_fp_inst(GLint num, struct fp_instruction *fp)
+{
+   GLint a;
+ 
+   fprintf(stderr, "PROGRAM_OUTPUT: 0x%x\n",    PROGRAM_OUTPUT);
+   fprintf(stderr, "PROGRAM_INPUT: 0x%x\n",     PROGRAM_INPUT);
+   fprintf(stderr, "PROGRAM_TEMPORARY: 0x%x\n", PROGRAM_TEMPORARY);
+
+   for (a=0; a<num; a++) {
+      switch (fp[a].Opcode) {
+         case FP_OPCODE_END:
+            fprintf(stderr, "FP_OPCODE_END"); break;
+
+         case  FP_OPCODE_ABS:
+            fprintf(stderr, "FP_OPCODE_ABS"); break;
+
+         case  FP_OPCODE_ADD:
+            fprintf(stderr, "FP_OPCODE_ADD"); break;
+
+         case  FP_OPCODE_CMP:
+            fprintf(stderr, "FP_OPCODE_CMP"); break;
+
+         case  FP_OPCODE_COS:
+            fprintf(stderr, "FP_OPCODE_COS"); break;
+
+         case  FP_OPCODE_DP3:
+            fprintf(stderr, "FP_OPCODE_DP3"); break;
+
+         case  FP_OPCODE_DP4:
+            fprintf(stderr, "FP_OPCODE_DP4"); break;
+
+         case  FP_OPCODE_DPH:
+            fprintf(stderr, "FP_OPCODE_DPH"); break;
+
+         case  FP_OPCODE_DST:
+            fprintf(stderr, "FP_OPCODE_DST"); break;
+
+         case  FP_OPCODE_EX2:
+            fprintf(stderr, "FP_OPCODE_EX2"); break;
+
+         case  FP_OPCODE_FLR:
+            fprintf(stderr, "FP_OPCODE_FLR"); break;
+
+         case  FP_OPCODE_FRC:
+            fprintf(stderr, "FP_OPCODE_FRC"); break;
+
+         case  FP_OPCODE_KIL:
+            fprintf(stderr, "FP_OPCODE_KIL"); break;
+
+         case  FP_OPCODE_LG2:
+            fprintf(stderr, "FP_OPCODE_LG2"); break;
+
+         case  FP_OPCODE_LIT:
+            fprintf(stderr, "FP_OPCODE_LIT"); break;
+
+         case  FP_OPCODE_LRP:
+            fprintf(stderr, "FP_OPCODE_LRP"); break;
+
+         case  FP_OPCODE_MAD:
+            fprintf(stderr, "FP_OPCODE_MAD"); break;
+
+         case  FP_OPCODE_MAX:
+            fprintf(stderr, "FP_OPCODE_MAX"); break;
+
+         case  FP_OPCODE_MIN:
+            fprintf(stderr, "FP_OPCODE_MIN"); break;
+
+         case  FP_OPCODE_MOV:
+            fprintf(stderr, "FP_OPCODE_MOV"); break;
+
+         case  FP_OPCODE_MUL:
+            fprintf(stderr, "FP_OPCODE_MUL"); break;
+
+         case  FP_OPCODE_POW:
+            fprintf(stderr, "FP_OPCODE_POW"); break;
+
+         case  FP_OPCODE_RCP:
+            fprintf(stderr, "FP_OPCODE_RCP"); break;
+
+         case  FP_OPCODE_RSQ:
+            fprintf(stderr, "FP_OPCODE_RSQ"); break;
+
+         case  FP_OPCODE_SCS:
+            fprintf(stderr, "FP_OPCODE_SCS"); break;
+
+         case  FP_OPCODE_SIN:
+            fprintf(stderr, "FP_OPCODE_SIN"); break;
+
+         case  FP_OPCODE_SLT:
+            fprintf(stderr, "FP_OPCODE_SLT"); break;
+
+         case  FP_OPCODE_SUB:
+            fprintf(stderr, "FP_OPCODE_SUB"); break;
+
+         case  FP_OPCODE_SWZ:
+            fprintf(stderr, "FP_OPCODE_SWZ"); break;
+
+         case  FP_OPCODE_TEX:
+            fprintf(stderr, "FP_OPCODE_TEX"); break;
+
+         case  FP_OPCODE_TXB:
+            fprintf(stderr, "FP_OPCODE_TXB"); break;
+
+         case  FP_OPCODE_TXP:
+            fprintf(stderr, "FP_OPCODE_TXP"); break;
+
+         case  FP_OPCODE_X2D:
+            fprintf(stderr, "FP_OPCODE_XPD"); break;
+      }
+
+      fprintf(stderr, " D(0x%x:%d:%d%d%d%d) ", 
+         fp[a].DstReg.File, fp[a].DstReg.Index,
+         fp[a].DstReg.WriteMask[0], fp[a].DstReg.WriteMask[1], 
+         fp[a].DstReg.WriteMask[2], fp[a].DstReg.WriteMask[3]); 
+						 
+      fprintf(stderr, "S1(0x%x:%d:%d%d%d%d) ", fp[a].SrcReg[0].File, fp[a].SrcReg[0].Index,
+         fp[a].SrcReg[0].Swizzle[0],
+         fp[a].SrcReg[0].Swizzle[1],
+         fp[a].SrcReg[0].Swizzle[2],
+         fp[a].SrcReg[0].Swizzle[3]);
+
+      fprintf(stderr, "S2(0x%x:%d:%d%d%d%d) ", fp[a].SrcReg[1].File, fp[a].SrcReg[1].Index,
+        fp[a].SrcReg[1].Swizzle[0],
+        fp[a].SrcReg[1].Swizzle[1],
+        fp[a].SrcReg[1].Swizzle[2],
+        fp[a].SrcReg[1].Swizzle[3]);
+
+      fprintf(stderr, "S3(0x%x:%d:%d%d%d%d)",  fp[a].SrcReg[2].File, fp[a].SrcReg[2].Index,
+        fp[a].SrcReg[2].Swizzle[0],
+        fp[a].SrcReg[2].Swizzle[1],
+        fp[a].SrcReg[2].Swizzle[2],
+        fp[a].SrcReg[2].Swizzle[3]);
+
+      fprintf(stderr, "\n");
+   }
+}
 
 void
 _mesa_parse_arb_fragment_program(GLcontext * ctx, GLenum target,
                                  const GLubyte * str, GLsizei len,
                                  struct fragment_program *program)
 {
+   GLuint retval;
+   struct arb_program ap;
+	
+   retval = _mesa_parse_arb_program(ctx, str, len, &ap);
+
+   /* XXX: Parse error. Cleanup things and return */	
+   if (retval)
+   {
+      return;
+   }
+
+   /* XXX: Eh.. we parsed something that wasn't a fragment program. doh! */
+   if (ap.type != GL_FRAGMENT_PROGRAM_ARB)
+   {
+      return;      
+   }
+
+#if DEBUG_FP
+   debug_fp_inst(ap.Base.NumInstructions, ap.FPInstructions);
+#endif
 
+   /* copy the relvant contents of the arb_program struct into the 
+    * fragment_program struct
+    */
+   program->Base.NumInstructions = ap.Base.NumInstructions;
+   program->Base.NumTemporaries  = ap.Base.NumTemporaries;
+   program->Base.NumParameters   = ap.Base.NumParameters;
+   program->Base.NumAttributes   = ap.Base.NumAttributes;
+   program->Base.NumAddressRegs  = ap.Base.NumAddressRegs;
+	
+   program->Instructions   = ap.FPInstructions;
+   program->InputsRead     = ap.InputsRead;
+   program->OutputsWritten = ap.OutputsWritten;
+   for  (retval=0; retval<MAX_TEXTURE_IMAGE_UNITS; retval++)
+      program->TexturesUsed[retval] = ap.TexturesUsed[retval];
+   program->NumAluInstructions = ap.NumAluInstructions;
+   program->NumTexInstructions = ap.NumTexInstructions;
+   program->NumTexIndirections = ap.NumTexIndirections;
+   program->Parameters         = ap.Parameters;
 }

src/mesa/main/extensions.c

@@ -281,9 +281,11 @@ void
 _mesa_enable_1_4_extensions(GLcontext *ctx)
 {
    ctx->Extensions.ARB_depth_texture = GL_TRUE;
+   ctx->Extensions.ARB_fragment_program = GL_TRUE;
    ctx->Extensions.ARB_shadow = GL_TRUE;
    ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE;
    ctx->Extensions.ARB_texture_mirrored_repeat = GL_TRUE;
+   ctx->Extensions.ARB_vertex_program = GL_TRUE;
    ctx->Extensions.ARB_window_pos = GL_TRUE;
    ctx->Extensions.EXT_blend_color = GL_TRUE;
    ctx->Extensions.EXT_blend_func_separate = GL_TRUE;

src/mesa/main/mtypes.h

@@ -1446,7 +1446,8 @@ enum register_file
    PROGRAM_ENV_PARAM,
    PROGRAM_NAMED_PARAM,
    PROGRAM_STATE_VAR,
-   PROGRAM_WRITE_ONLY
+   PROGRAM_WRITE_ONLY,
+	PROGRAM_ADDRESS
 };
 
 
@@ -1485,6 +1486,7 @@ struct vertex_program
    GLboolean IsPositionInvariant;  /* GL_NV_vertex_program1_1 */
    GLuint InputsRead;     /* Bitmask of which input regs are read */
    GLuint OutputsWritten; /* Bitmask of which output regs are written to */
+   struct program_parameter_list *Parameters; /**< array [NumParameters] */
 };
 
 

src/mesa/main/nvvertexec.c

@@ -64,6 +64,23 @@ _mesa_init_vp_registers(GLcontext *ctx)
    }
 
    /* The program parameters aren't touched */
+	/* XXX: This should be moved to glBegin() time, but its safe (and slow!) 
+	 *       here - Karl
+	 */
+   if (ctx->VertexProgram.Current->Parameters) {
+
+      /* Grab the state */			  
+      _mesa_load_state_parameters(ctx, ctx->VertexProgram.Current->Parameters);
+
+		/* And copy it into the program state */
+      for (i=0; i<ctx->VertexProgram.Current->Parameters->NumParameters; i++) {
+         MEMCPY(ctx->VertexProgram.Parameters[i], 
+            &ctx->VertexProgram.Current->Parameters->Parameters[i].Values,	
+            4*sizeof(GLfloat));				
+      }				  
+				  
+   }
+
 }
 
 
@@ -234,13 +251,11 @@ get_register_pointer( const struct vp_src_register *source,
             return state->Inputs[source->Index];
          case PROGRAM_LOCAL_PARAM:
             /* XXX fix */
-            return state->Temporaries[source->Index];
+            return state->Temporaries[source->Index]; 
          case PROGRAM_ENV_PARAM:
             return state->Parameters[source->Index];
          case PROGRAM_STATE_VAR:
-            /* XXX fix */
-            return NULL;
-            break;
+            return state->Parameters[source->Index];
          default:
             _mesa_problem(NULL,
                           "Bad source register file in fetch_vector4(vp)");