fragment program execution
[mesa.git] / src / mesa / tnl / t_vb_program.c
index 4dc5becb28fb3dfb58ffb23c56c9f599a746a06a..f445953e9f1d6f7f3d063a35179e47a3696dff2a 100644 (file)
@@ -1,8 +1,8 @@
-/* $Id: t_vb_program.c,v 1.8 2002/01/06 20:39:20 brianp Exp $ */
+/* $Id: t_vb_program.c,v 1.17 2003/01/14 04:55:47 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  4.1
+ * Version:  5.1
  *
  * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-/*
- * -------- Regarding NV_vertex_program --------
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * 
- * o Redistribution of the source code must contain a copyright notice
- *   and this list of conditions;
- * 
- * o Redistribution in binary and source code form must contain the
- *   following Notice in the software and any documentation and/or other
- *   materials provided with the distribution; and
- * 
- * o The name of Nvidia may not be used to promote or endorse software
- *   derived from the software.
- * 
- * NOTICE: Nvidia hereby grants to each recipient a non-exclusive worldwide
- * royalty free patent license under patent claims that are licensable by
- * Nvidia and which are necessarily required and for which no commercially
- * viable non infringing alternative exists to make, use, sell, offer to sell,
- * import and otherwise transfer the vertex extension for the Mesa 3D Graphics
- * Library as distributed in source code and object code form.  No hardware or
- * hardware implementation (including a semiconductor implementation and chips)
- * are licensed hereunder. If a recipient makes a patent claim or institutes
- * patent litigation against Nvidia or Nvidia's customers for use or sale of
- * Nvidia products, then this license grant as to such recipient shall
- * immediately terminate and recipient immediately agrees to cease use and
- * distribution of the Mesa Program and derivatives thereof. 
- * 
- * THE MESA 3D GRAPHICS LIBRARY IS PROVIDED ON AN "AS IS BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
- * WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-NFRINGEMENT
- * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
- * 
- * NVIDIA SHALL NOT HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION
- * LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE MESA 3D GRAPHICS
- * LIBRARY OR EVIDENCE OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDR, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- * 
- * If you do not comply with this agreement, then Nvidia may cancel the license
- * and rights granted herein.
- * ---------------------------------------------
- */
 
-/*
- * Authors:
- *    Brian Paul
+/**
+ * \file tnl/t_vb_program.c
+ * \brief Pipeline stage for executing NVIDIA vertex programs.
+ * \author Brian Paul,  Keith Whitwell
  */
 
 
 #include "hash.h"
 #include "light.h"
 #include "macros.h"
-#include "mem.h"
+#include "imports.h"
 #include "mmath.h"
 #include "simple_list.h"
 #include "mtypes.h"
-#include "vpexec.h"
+#include "nvvertprog.h"
+#include "nvvertexec.h"
+#include "nvprogram.h"
 
 #include "math/m_translate.h"
 
@@ -98,7 +56,8 @@
 #include "t_imm_exec.h"
 
 
-/* WARNING: these values _MUST_ match the values in the OutputRegisters[]
+/**
+ * \warning These values _MUST_ match the values in the OutputRegisters[]
  * array in vpparse.c!!!
  */
 #define VERT_RESULT_HPOS 0
 #define VERT_RESULT_TEX7 14
 
 
+/*!
+ * Private storage for the vertex program pipeline stage.
+ */
 struct vp_stage_data {
-   /* The results of running the vertex program go into these arrays. */
+   /** The results of running the vertex program go into these arrays. */
    GLvector4f attribs[15];
 
    /* These point to the attribs[VERT_RESULT_COL0, COL1, BFC0, BFC1] arrays */
-   struct gl_client_array color0[2];  /* front and back */
-   struct gl_client_array color1[2];  /* front and back */
+   struct gl_client_array color0[2];  /**< diffuse front and back */
+   struct gl_client_array color1[2];  /**< specular front and back */
 
-   GLvector4f ndcCoords;              /* normalized device coords */
-   GLubyte *clipmask;                 /* clip flags */
-   GLubyte ormask, andmask;
+   GLvector4f ndcCoords;              /**< normalized device coords */
+   GLubyte *clipmask;                 /**< clip flags */
+   GLubyte ormask, andmask;           /**< for clipping */
 };
 
 
 #define VP_STAGE_DATA(stage) ((struct vp_stage_data *)(stage->privatePtr))
 
 
+/**
+ * This function executes vertex programs
+ */
 static GLboolean run_vp( GLcontext *ctx, struct gl_pipeline_stage *stage )
 {
    TNLcontext *tnl = TNL_CONTEXT(ctx);
    struct vp_stage_data *store = VP_STAGE_DATA(stage);
    struct vertex_buffer *VB = &tnl->vb;
    struct vp_machine *machine = &(ctx->VertexProgram.Machine);
-   struct vp_program *program = ctx->VertexProgram.Current;
-   GLint i;
+   struct vertex_program *program = ctx->VertexProgram.Current;
+   GLuint i;
 
-   _mesa_init_tracked_matrices(ctx);
-   _mesa_init_vp_registers(ctx);  /* init temp and result regs */
-   /* XXX if GL_FOG is enabled but the program doesn't write to the
-    * o[FOGC] register, set the fog result to 1.0
-    */
-   /* XXX if GL_VERTEX_PROGRAM_POINT_SIZE_NV is enabled but the program
-    * doesn't write the PSIZ variable then use ctx->Point.Size
-    */
+   _mesa_init_tracked_matrices(ctx); /* load registers with matrices */
+   _mesa_init_vp_registers(ctx);     /* init temp and result regs */
 
    for (i = 0; i < VB->Count; i++) {
       GLuint attr;
@@ -175,32 +134,60 @@ static GLboolean run_vp( GLcontext *ctx, struct gl_pipeline_stage *stage )
 #endif
 
       /* load the input attribute registers */
-      for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
-         if (VB->Flag[i] & (1 << attr)) {
-            COPY_4V(machine->Registers[VP_INPUT_REG_START + attr],
-                    VB->AttribPtr[attr]->data[i]);
+      if (VB->Flag) {
+         /* the traditional glBegin/glVertex/glEnd case */
+         for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
+            if (attr == 0 || (VB->Flag[i] & (1 << attr))) {
+               COPY_4V(machine->Registers[VP_INPUT_REG_START + attr],
+                       VB->AttribPtr[attr]->data[i]);
+            }
+         }
+      }
+      else {
+         /* the vertex array case */
+         for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
+            if (program->InputsRead & (1 << attr)) {
+               const GLubyte *ptr = (const GLubyte*) VB->AttribPtr[attr]->data;
+               const GLuint stride = VB->AttribPtr[attr]->stride;
+               const GLfloat *data = (GLfloat *) (ptr + stride * i);
+               COPY_4V(machine->Registers[VP_INPUT_REG_START + attr], data);
+               /*ASSERT(VB->AttribPtr[attr]->size == 4);*/
+               ASSERT(stride == 4 * sizeof(GLfloat) || stride == 0);
+            }
          }
       }
 
       /* execute the program */
       ASSERT(program);
-      _mesa_exec_program(ctx, program);
+      _mesa_exec_vertex_program(ctx, program);
 
 #if 0
       printf("Output %d: %f, %f, %f, %f\n", i,
-             machine->Registers[VP_OUT_HPOS][0],
-             machine->Registers[VP_OUT_HPOS][1],
-             machine->Registers[VP_OUT_HPOS][2],
-             machine->Registers[VP_OUT_HPOS][3]);
+             machine->Registers[VP_OUTPUT_REG_START + 0][0],
+             machine->Registers[VP_OUTPUT_REG_START + 0][1],
+             machine->Registers[VP_OUTPUT_REG_START + 0][2],
+             machine->Registers[VP_OUTPUT_REG_START + 0][3]);
       printf("   color: %f, %f, %f, %f\n",
-             machine->Registers[VP_OUT_COL0][0],
-             machine->Registers[VP_OUT_COL0][1],
-             machine->Registers[VP_OUT_COL0][2],
-             machine->Registers[VP_OUT_COL0][3]);
+             machine->Registers[VP_OUTPUT_REG_START +_1][0],
+             machine->Registers[VP_OUTPUT_REG_START + 1][1],
+             machine->Registers[VP_OUTPUT_REG_START + 1][2],
+             machine->Registers[VP_OUTPUT_REG_START + 1][3]);
       printf("PointSize[%d]: %g\n", i,
              machine->Registers[VP_OUTPUT_REG_START + VERT_RESULT_PSIZ][0]);
 #endif
 
+      /* Fixup fog an point size results if needed */
+      if (ctx->Fog.Enabled &&
+          (program->OutputsWritten & (1 << VERT_RESULT_FOGC)) == 0) {
+         machine->Registers[VP_OUTPUT_REG_START + VERT_RESULT_FOGC][0] = 1.0;
+      }
+
+      if (ctx->VertexProgram.PointSizeEnabled &&
+          (program->OutputsWritten & (1 << VERT_RESULT_PSIZ)) == 0) {
+         machine->Registers[VP_OUTPUT_REG_START + VERT_RESULT_PSIZ][0]
+            = ctx->Point.Size;
+      }
+
       /* copy the output registers into the VB->attribs arrays */
       /* XXX (optimize) could use a conditional and smaller loop limit here */
       for (attr = 0; attr < 15; attr++) {
@@ -237,7 +224,6 @@ static GLboolean run_vp( GLcontext *ctx, struct gl_pipeline_stage *stage )
                                             store->clipmask,
                                             &store->ormask,
                                             &store->andmask );
-
    }
    else {
       VB->NdcPtr = 0;
@@ -260,15 +246,16 @@ static GLboolean run_vp( GLcontext *ctx, struct gl_pipeline_stage *stage )
    VB->ClipMask = store->clipmask;
 
    /* XXXX what's this?
-   if (VB->ClipPtr == VB->ObjPtr && (VB->importable_data & VERT_OBJ_BIT))
-      VB->importable_data |= VERT_CLIP;
+   if (VB->ClipPtr == VB->ObjPtr && (VB->importable_data & VERT_BIT_POS))
+      VB->importable_data |= VERT_BIT_CLIP;
    */
 
    return GL_TRUE;
 }
 
 
-/* Called in place of do_lighting when the light table may have changed.
+/**
+ * This function validates stuff.
  */
 static GLboolean run_validate_program( GLcontext *ctx,
                                        struct gl_pipeline_stage *stage )
@@ -315,7 +302,10 @@ static GLboolean run_validate_program( GLcontext *ctx,
 }
 
 
-static void init_client_array( struct gl_client_array *a, GLvector4f *vec )
+/**
+ * Initialize a gl_client_array to point into a GLvector4f color vector.
+ */
+static void init_color_array( struct gl_client_array *a, GLvector4f *vec )
 {
    a->Ptr = vec->data;
    a->Size = 4;
@@ -327,7 +317,8 @@ static void init_client_array( struct gl_client_array *a, GLvector4f *vec )
 }
 
 
-/* Called the first time stage->run is called.  In effect, don't
+/**
+ * Called the first time stage->run is called.  In effect, don't
  * allocate data until the first time the stage is run.
  */
 static GLboolean run_init_vp( GLcontext *ctx,
@@ -349,10 +340,10 @@ static GLboolean run_init_vp( GLcontext *ctx,
       _mesa_vector4f_alloc( &store->attribs[i], 0, size, 32 );
 
    /* Make the color0[] and color1[] arrays point into the attribs[] arrays */
-   init_client_array( &store->color0[0], &store->attribs[VERT_RESULT_COL0] );
-   init_client_array( &store->color0[1], &store->attribs[VERT_RESULT_COL1] );
-   init_client_array( &store->color1[0], &store->attribs[VERT_RESULT_BFC0] );
-   init_client_array( &store->color1[1], &store->attribs[VERT_RESULT_BFC1] );
+   init_color_array( &store->color0[0], &store->attribs[VERT_RESULT_COL0] );
+   init_color_array( &store->color0[1], &store->attribs[VERT_RESULT_COL1] );
+   init_color_array( &store->color1[0], &store->attribs[VERT_RESULT_BFC0] );
+   init_color_array( &store->color1[1], &store->attribs[VERT_RESULT_BFC1] );
 
    /* a few other misc allocations */
    _mesa_vector4f_alloc( &store->ndcCoords, 0, size, 32 );
@@ -366,7 +357,7 @@ static GLboolean run_init_vp( GLcontext *ctx,
 
 
 
-/*
+/**
  * Check if vertex program mode is enabled. 
  * If so, configure the pipeline stage's type, inputs, and outputs.
  */
@@ -375,23 +366,33 @@ static void check_vp( GLcontext *ctx, struct gl_pipeline_stage *stage )
    stage->active = ctx->VertexProgram.Enabled;
 
    if (stage->active) {
+      /* I believe this is right - Keith?
+       * Set stage->inputs equal to the bitmask of vertex attributes
+       * which the program needs for inputs.
+       */
+
+      stage->inputs = ctx->VertexProgram.Current->InputsRead;
+
 #if 000
       if (stage->privatePtr)
         stage->run = run_validate_program;
-      stage->inputs = VERT_NORMAL_BIT|VERT_MATERIAL;
+      stage->inputs = VERT_BIT_NORMAL|VERT_BIT_MATERIAL;
       if (ctx->Light._NeedVertices)
-        stage->inputs |= VERT_EYE; /* effectively, even when lighting in obj */
+        stage->inputs |= VERT_BIT_EYE; /* effectively, even when lighting in obj */
       if (ctx->Light.ColorMaterialEnabled)
-        stage->inputs |= VERT_COLOR0_BIT;
+        stage->inputs |= VERT_BIT_COLOR0;
 
-      stage->outputs = VERT_COLOR0_BIT;
+      stage->outputs = VERT_BIT_COLOR0;
       if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
-        stage->outputs |= VERT_COLOR1_BIT;
+        stage->outputs |= VERT_BIT_COLOR1;
 #endif
    }
 }
 
 
+/**
+ * Destructor for this pipeline stage.
+ */
 static void dtr( struct gl_pipeline_stage *stage )
 {
    struct vp_stage_data *store = VP_STAGE_DATA(stage);
@@ -412,16 +413,19 @@ static void dtr( struct gl_pipeline_stage *stage )
    }
 }
 
+/**
+ * Public description of this pipeline stage.
+ */
 const struct gl_pipeline_stage _tnl_vertex_program_stage =
 {
    "vertex-program",
    _NEW_ALL,   /*XXX FIX */    /* recheck */
    _NEW_ALL,   /*XXX FIX */    /* recalc -- modelview dependency
                                 * otherwise not captured by inputs
-                                * (which may be VERT_OBJ_BIT) */
+                                * (which may be VERT_BIT_POS) */
    GL_FALSE,                   /* active */
-   0,                          /* inputs */
-   VERT_CLIP | VERT_COLOR0_BIT,                        /* outputs */
+   /*0*/ VERT_BIT_POS,                         /* inputs  XXX OK? */
+   VERT_BIT_CLIP | VERT_BIT_COLOR0,                    /* outputs XXX OK? */
    0,                          /* changed_inputs */
    NULL,                       /* private_data */
    dtr,                                /* destroy */