src/mesa/tnl/t_vb_program.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
  26 /**
  27  * \file tnl/t_vb_program.c
  28  * \brief Pipeline stage for executing NVIDIA vertex programs.
  29  * \author Brian Paul,  Keith Whitwell
  30  */
  31
  32
  33 #include "glheader.h"
  34 #include "api_noop.h"
  35 #include "colormac.h"
  36 #include "context.h"
  37 #include "dlist.h"
  38 #include "hash.h"
  39 #include "light.h"
  40 #include "macros.h"
  41 #include "imports.h"
  42 #include "simple_list.h"
  43 #include "mtypes.h"
  44 #include "nvvertprog.h"
  45 #include "nvvertexec.h"
  46 #include "nvprogram.h"
  47
  48 #include "math/m_translate.h"
  49
  50 #include "t_context.h"
  51 #include "t_pipeline.h"
  52
  53
  54 /**
  55  * \warning These values _MUST_ match the values in the OutputRegisters[]
  56  * array in vpparse.c!!!
  57  */
  58 #define VERT_RESULT_HPOS 0
  59 #define VERT_RESULT_COL0 1
  60 #define VERT_RESULT_COL1 2
  61 #define VERT_RESULT_BFC0 3
  62 #define VERT_RESULT_BFC1 4
  63 #define VERT_RESULT_FOGC 5
  64 #define VERT_RESULT_PSIZ 6
  65 #define VERT_RESULT_TEX0 7
  66 #define VERT_RESULT_TEX1 8
  67 #define VERT_RESULT_TEX2 9
  68 #define VERT_RESULT_TEX3 10
  69 #define VERT_RESULT_TEX4 11
  70 #define VERT_RESULT_TEX5 12
  71 #define VERT_RESULT_TEX6 13
  72 #define VERT_RESULT_TEX7 14
  73
  74
  75 /*!
  76  * Private storage for the vertex program pipeline stage.
  77  */
  78 struct vp_stage_data {
  79    /** The results of running the vertex program go into these arrays. */
  80    GLvector4f attribs[15];
  81
  82    GLvector4f ndcCoords;              /**< normalized device coords */
  83    GLubyte *clipmask;                 /**< clip flags */
  84    GLubyte ormask, andmask;           /**< for clipping */
  85 };
  86
  87
  88 #define VP_STAGE_DATA(stage) ((struct vp_stage_data *)(stage->privatePtr))
  89
  90
  91 /**
  92  * This function executes vertex programs
  93  */
  94 static GLboolean run_vp( GLcontext *ctx, struct tnl_pipeline_stage *stage )
  95 {
  96    TNLcontext *tnl = TNL_CONTEXT(ctx);
  97    struct vp_stage_data *store = VP_STAGE_DATA(stage);
  98    struct vertex_buffer *VB = &tnl->vb;
  99    struct vertex_program *program = ctx->VertexProgram.Current;
 100    GLuint i;
 101
 102    _mesa_init_tracked_matrices(ctx); /* load registers with matrices */
 103    _mesa_init_vp_registers(ctx);     /* init temp and result regs */
 104
 105    for (i = 0; i < VB->Count; i++) {
 106       GLuint attr;
 107
 108 #if 0
 109       printf("Input  %d: %f, %f, %f, %f\n", i,
 110              VB->AttribPtr[0]->data[i][0],
 111              VB->AttribPtr[0]->data[i][1],
 112              VB->AttribPtr[0]->data[i][2],
 113              VB->AttribPtr[0]->data[i][3]);
 114       printf("   color: %f, %f, %f, %f\n",
 115              VB->AttribPtr[3]->data[i][0],
 116              VB->AttribPtr[3]->data[i][1],
 117              VB->AttribPtr[3]->data[i][2],
 118              VB->AttribPtr[3]->data[i][3]);
 119       printf("  normal: %f, %f, %f, %f\n",
 120              VB->AttribPtr[2]->data[i][0],
 121              VB->AttribPtr[2]->data[i][1],
 122              VB->AttribPtr[2]->data[i][2],
 123              VB->AttribPtr[2]->data[i][3]);
 124 #endif
 125
 126       /* the vertex array case */
 127       for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
 128          if (program->InputsRead & (1 << attr)) {
 129             const GLubyte *ptr = (const GLubyte*) VB->AttribPtr[attr]->data;
 130             const GLuint size = VB->AttribPtr[attr]->size;
 131             const GLuint stride = VB->AttribPtr[attr]->stride;
 132             const GLfloat *data = (GLfloat *) (ptr + stride * i);
 133             ASSIGN_4V(ctx->VertexProgram.Inputs[attr], 0, 0, 0, 1);
 134             COPY_SZ_4V(ctx->VertexProgram.Inputs[attr], size, data);
 135          }
 136       }
 137
 138       /* execute the program */
 139       ASSERT(program);
 140       _mesa_exec_vertex_program(ctx, program);
 141
 142       /* Fixup fog an point size results if needed */
 143       if (ctx->Fog.Enabled &&
 144           (program->OutputsWritten & (1 << VERT_RESULT_FOGC)) == 0) {
 145          ctx->VertexProgram.Outputs[VERT_RESULT_FOGC][0] = 1.0;
 146       }
 147
 148       if (ctx->VertexProgram.PointSizeEnabled &&
 149           (program->OutputsWritten & (1 << VERT_RESULT_PSIZ)) == 0) {
 150          ctx->VertexProgram.Outputs[VERT_RESULT_PSIZ][0] = ctx->Point.Size;
 151       }
 152
 153       /* copy the output registers into the VB->attribs arrays */
 154       /* XXX (optimize) could use a conditional and smaller loop limit here */
 155       for (attr = 0; attr < 15; attr++) {
 156          COPY_4V(store->attribs[attr].data[i],
 157                  ctx->VertexProgram.Outputs[attr]);
 158       }
 159    }
 160
 161    /* Setup the VB pointers so that the next pipeline stages get
 162     * their data from the right place (the program output arrays).
 163     */
 164    VB->ClipPtr = &store->attribs[VERT_RESULT_HPOS];
 165    VB->ClipPtr->size = 4;
 166    VB->ClipPtr->count = VB->Count;
 167    VB->ColorPtr[0] = &store->attribs[VERT_RESULT_COL0];
 168    VB->ColorPtr[1] = &store->attribs[VERT_RESULT_BFC0];
 169    VB->SecondaryColorPtr[0] = &store->attribs[VERT_RESULT_COL1];
 170    VB->SecondaryColorPtr[1] = &store->attribs[VERT_RESULT_BFC1];
 171    VB->FogCoordPtr = &store->attribs[VERT_RESULT_FOGC];
 172    VB->PointSizePtr = &store->attribs[VERT_RESULT_PSIZ];
 173
 174    VB->AttribPtr[VERT_ATTRIB_COLOR0] = VB->ColorPtr[0];
 175    VB->AttribPtr[VERT_ATTRIB_COLOR1] = VB->SecondaryColorPtr[0];
 176    VB->AttribPtr[VERT_ATTRIB_FOG] = VB->FogCoordPtr;
 177
 178    for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
 179       VB->AttribPtr[VERT_ATTRIB_TEX0+i] = VB->TexCoordPtr[i] =
 180          &store->attribs[VERT_RESULT_TEX0 + i];
 181    }
 182
 183
 184
 185    /* Cliptest and perspective divide.  Clip functions must clear
 186     * the clipmask.
 187     */
 188    store->ormask = 0;
 189    store->andmask = CLIP_ALL_BITS;
 190
 191    if (tnl->NeedNdcCoords) {
 192       VB->NdcPtr =
 193          _mesa_clip_tab[VB->ClipPtr->size]( VB->ClipPtr,
 194                                             &store->ndcCoords,
 195                                             store->clipmask,
 196                                             &store->ormask,
 197                                             &store->andmask );
 198    }
 199    else {
 200       VB->NdcPtr = 0;
 201       _mesa_clip_np_tab[VB->ClipPtr->size]( VB->ClipPtr,
 202                                             0,
 203                                             store->clipmask,
 204                                             &store->ormask,
 205                                             &store->andmask );
 206    }
 207
 208    if (store->andmask)  /* All vertices are outside the frustum */
 209       return GL_FALSE;
 210
 211
 212    /* This is where we'd do clip testing against the user-defined
 213     * clipping planes, but they're not supported by vertex programs.
 214     */
 215
 216    VB->ClipOrMask = store->ormask;
 217    VB->ClipMask = store->clipmask;
 218
 219    return GL_TRUE;
 220 }
 221
 222
 223 /**
 224  * This function validates stuff.
 225  */
 226 static GLboolean run_validate_program( GLcontext *ctx,
 227                                         struct tnl_pipeline_stage *stage )
 228 {
 229 #if 000
 230    /* XXX do we need any validation for vertex programs? */
 231    GLuint ind = 0;
 232    light_func *tab;
 233
 234    if (ctx->Visual.rgbMode) {
 235       if (ctx->Light._NeedVertices) {
 236          if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
 237             tab = _tnl_light_spec_tab;
 238          else
 239             tab = _tnl_light_tab;
 240       }
 241       else {
 242          if (ctx->Light.EnabledList.next == ctx->Light.EnabledList.prev)
 243             tab = _tnl_light_fast_single_tab;
 244          else
 245             tab = _tnl_light_fast_tab;
 246       }
 247    }
 248    else
 249       tab = _tnl_light_ci_tab;
 250
 251    if (ctx->Light.ColorMaterialEnabled)
 252       ind |= LIGHT_COLORMATERIAL;
 253
 254    if (ctx->Light.Model.TwoSide)
 255       ind |= LIGHT_TWOSIDE;
 256
 257    VP_STAGE_DATA(stage)->light_func_tab = &tab[ind];
 258
 259    /* This and the above should only be done on _NEW_LIGHT:
 260     */
 261    _mesa_validate_all_lighting_tables( ctx );
 262 #endif
 263
 264    /* Now run the stage...
 265     */
 266    stage->run = run_vp;
 267    return stage->run( ctx, stage );
 268 }
 269
 270
 271
 272 /**
 273  * Called the first time stage->run is called.  In effect, don't
 274  * allocate data until the first time the stage is run.
 275  */
 276 static GLboolean run_init_vp( GLcontext *ctx,
 277                               struct tnl_pipeline_stage *stage )
 278 {
 279    TNLcontext *tnl = TNL_CONTEXT(ctx);
 280    struct vertex_buffer *VB = &(tnl->vb);
 281    struct vp_stage_data *store;
 282    const GLuint size = VB->Size;
 283    GLuint i;
 284
 285    stage->privatePtr = MALLOC(sizeof(*store));
 286    store = VP_STAGE_DATA(stage);
 287    if (!store)
 288       return GL_FALSE;
 289
 290    /* Allocate arrays of vertex output values */
 291    for (i = 0; i < 15; i++) {
 292       _mesa_vector4f_alloc( &store->attribs[i], 0, size, 32 );
 293       store->attribs[i].size = 4;
 294    }
 295
 296    /* a few other misc allocations */
 297    _mesa_vector4f_alloc( &store->ndcCoords, 0, size, 32 );
 298    store->clipmask = (GLubyte *) ALIGN_MALLOC(sizeof(GLubyte)*size, 32 );
 299
 300    /* Now validate the stage derived data...
 301     */
 302    stage->run = run_validate_program;
 303    return stage->run( ctx, stage );
 304 }
 305
 306
 307
 308 /**
 309  * Check if vertex program mode is enabled.
 310  * If so, configure the pipeline stage's type, inputs, and outputs.
 311  */
 312 static void check_vp( GLcontext *ctx, struct tnl_pipeline_stage *stage )
 313 {
 314    stage->active = ctx->VertexProgram.Enabled;
 315
 316    if (stage->active) {
 317       /* Set stage->inputs equal to the bitmask of vertex attributes
 318        * which the program needs for inputs.
 319        */
 320       stage->inputs = ctx->VertexProgram.Current->InputsRead;
 321    }
 322 }
 323
 324
 325 /**
 326  * Destructor for this pipeline stage.
 327  */
 328 static void dtr( struct tnl_pipeline_stage *stage )
 329 {
 330    struct vp_stage_data *store = VP_STAGE_DATA(stage);
 331
 332    if (store) {
 333       GLuint i;
 334
 335       /* free the vertex program result arrays */
 336       for (i = 0; i < 15; i++)
 337          _mesa_vector4f_free( &store->attribs[i] );
 338
 339       /* free misc arrays */
 340       _mesa_vector4f_free( &store->ndcCoords );
 341       ALIGN_FREE( store->clipmask );
 342
 343       FREE( store );
 344       stage->privatePtr = 0;
 345    }
 346 }
 347
 348 /**
 349  * Public description of this pipeline stage.
 350  */
 351 const struct tnl_pipeline_stage _tnl_vertex_program_stage =
 352 {
 353    "vertex-program",
 354    _NEW_ALL,    /*XXX FIX */    /* recheck */
 355    _NEW_ALL,    /*XXX FIX */    /* recalc */
 356    GL_FALSE,                    /* active */
 357    0,                           /* inputs - calculated on the fly */
 358    _TNL_BITS_PROG_ANY,          /* outputs -- could calculate */
 359    0,                           /* changed_inputs */
 360    NULL,                        /* private_data */
 361    dtr,                         /* destroy */
 362    check_vp,                    /* check */
 363    run_init_vp                  /* run -- initially set to ctr */
 364 };