src/mesa/tnl/t_vb_program.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.1
   4  *
   5  * Copyright (C) 1999-2004  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
  95 run_vp( GLcontext *ctx, struct tnl_pipeline_stage *stage )
  96 {
  97    TNLcontext *tnl = TNL_CONTEXT(ctx);
  98    struct vp_stage_data *store = VP_STAGE_DATA(stage);
  99    struct vertex_buffer *VB = &tnl->vb;
 100    struct vertex_program *program = ctx->VertexProgram.Current;
 101    GLuint i;
 102
 103    /* load program parameter registers (they're read-only) */
 104    _mesa_init_vp_per_primitive_registers(ctx);
 105
 106    for (i = 0; i < VB->Count; i++) {
 107       GLuint attr;
 108
 109       _mesa_init_vp_per_vertex_registers(ctx);
 110
 111 #if 0
 112       printf("Input  %d: %f, %f, %f, %f\n", i,
 113              VB->AttribPtr[0]->data[i][0],
 114              VB->AttribPtr[0]->data[i][1],
 115              VB->AttribPtr[0]->data[i][2],
 116              VB->AttribPtr[0]->data[i][3]);
 117       printf("   color: %f, %f, %f, %f\n",
 118              VB->AttribPtr[3]->data[i][0],
 119              VB->AttribPtr[3]->data[i][1],
 120              VB->AttribPtr[3]->data[i][2],
 121              VB->AttribPtr[3]->data[i][3]);
 122       printf("  normal: %f, %f, %f, %f\n",
 123              VB->AttribPtr[2]->data[i][0],
 124              VB->AttribPtr[2]->data[i][1],
 125              VB->AttribPtr[2]->data[i][2],
 126              VB->AttribPtr[2]->data[i][3]);
 127 #endif
 128
 129       /* the vertex array case */
 130       for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
 131          if (program->InputsRead & (1 << attr)) {
 132             const GLubyte *ptr = (const GLubyte*) VB->AttribPtr[attr]->data;
 133             const GLuint size = VB->AttribPtr[attr]->size;
 134             const GLuint stride = VB->AttribPtr[attr]->stride;
 135             const GLfloat *data = (GLfloat *) (ptr + stride * i);
 136             ASSIGN_4V(ctx->VertexProgram.Inputs[attr], 0, 0, 0, 1);
 137             COPY_SZ_4V(ctx->VertexProgram.Inputs[attr], size, data);
 138          }
 139       }
 140
 141       /* execute the program */
 142       ASSERT(program);
 143       _mesa_exec_vertex_program(ctx, program);
 144
 145       /* Fixup fog an point size results if needed */
 146       if (ctx->Fog.Enabled &&
 147           (program->OutputsWritten & (1 << VERT_RESULT_FOGC)) == 0) {
 148          ctx->VertexProgram.Outputs[VERT_RESULT_FOGC][0] = 1.0;
 149       }
 150
 151       if (ctx->VertexProgram.PointSizeEnabled &&
 152           (program->OutputsWritten & (1 << VERT_RESULT_PSIZ)) == 0) {
 153          ctx->VertexProgram.Outputs[VERT_RESULT_PSIZ][0] = ctx->Point.Size;
 154       }
 155
 156       /* copy the output registers into the VB->attribs arrays */
 157       /* XXX (optimize) could use a conditional and smaller loop limit here */
 158       for (attr = 0; attr < 15; attr++) {
 159          COPY_4V(store->attribs[attr].data[i],
 160                  ctx->VertexProgram.Outputs[attr]);
 161       }
 162    }
 163
 164    /* Setup the VB pointers so that the next pipeline stages get
 165     * their data from the right place (the program output arrays).
 166     */
 167    VB->ClipPtr = &store->attribs[VERT_RESULT_HPOS];
 168    VB->ClipPtr->size = 4;
 169    VB->ClipPtr->count = VB->Count;
 170    VB->ColorPtr[0] = &store->attribs[VERT_RESULT_COL0];
 171    VB->ColorPtr[1] = &store->attribs[VERT_RESULT_BFC0];
 172    VB->SecondaryColorPtr[0] = &store->attribs[VERT_RESULT_COL1];
 173    VB->SecondaryColorPtr[1] = &store->attribs[VERT_RESULT_BFC1];
 174    VB->FogCoordPtr = &store->attribs[VERT_RESULT_FOGC];
 175    VB->PointSizePtr = &store->attribs[VERT_RESULT_PSIZ];
 176
 177    VB->AttribPtr[VERT_ATTRIB_COLOR0] = VB->ColorPtr[0];
 178    VB->AttribPtr[VERT_ATTRIB_COLOR1] = VB->SecondaryColorPtr[0];
 179    VB->AttribPtr[VERT_ATTRIB_FOG] = VB->FogCoordPtr;
 180    VB->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->attribs[VERT_RESULT_PSIZ];
 181
 182    for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
 183       VB->AttribPtr[VERT_ATTRIB_TEX0+i] = VB->TexCoordPtr[i] =
 184          &store->attribs[VERT_RESULT_TEX0 + i];
 185    }
 186
 187
 188
 189    /* Cliptest and perspective divide.  Clip functions must clear
 190     * the clipmask.
 191     */
 192    store->ormask = 0;
 193    store->andmask = CLIP_ALL_BITS;
 194
 195    if (tnl->NeedNdcCoords) {
 196       VB->NdcPtr =
 197          _mesa_clip_tab[VB->ClipPtr->size]( VB->ClipPtr,
 198                                             &store->ndcCoords,
 199                                             store->clipmask,
 200                                             &store->ormask,
 201                                             &store->andmask );
 202    }
 203    else {
 204       VB->NdcPtr = 0;
 205       _mesa_clip_np_tab[VB->ClipPtr->size]( VB->ClipPtr,
 206                                             0,
 207                                             store->clipmask,
 208                                             &store->ormask,
 209                                             &store->andmask );
 210    }
 211
 212    if (store->andmask)  /* All vertices are outside the frustum */
 213       return GL_FALSE;
 214
 215
 216    /* This is where we'd do clip testing against the user-defined
 217     * clipping planes, but they're not supported by vertex programs.
 218     */
 219
 220    VB->ClipOrMask = store->ormask;
 221    VB->ClipMask = store->clipmask;
 222
 223    return GL_TRUE;
 224 }
 225
 226
 227 /**
 228  * This function validates stuff.
 229  */
 230 static GLboolean run_validate_program( GLcontext *ctx,
 231                                         struct tnl_pipeline_stage *stage )
 232 {
 233 #if 000
 234    /* XXX do we need any validation for vertex programs? */
 235    GLuint ind = 0;
 236    light_func *tab;
 237
 238    if (ctx->Visual.rgbMode) {
 239       if (ctx->Light._NeedVertices) {
 240          if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
 241             tab = _tnl_light_spec_tab;
 242          else
 243             tab = _tnl_light_tab;
 244       }
 245       else {
 246          if (ctx->Light.EnabledList.next == ctx->Light.EnabledList.prev)
 247             tab = _tnl_light_fast_single_tab;
 248          else
 249             tab = _tnl_light_fast_tab;
 250       }
 251    }
 252    else
 253       tab = _tnl_light_ci_tab;
 254
 255    if (ctx->Light.ColorMaterialEnabled)
 256       ind |= LIGHT_COLORMATERIAL;
 257
 258    if (ctx->Light.Model.TwoSide)
 259       ind |= LIGHT_TWOSIDE;
 260
 261    VP_STAGE_DATA(stage)->light_func_tab = &tab[ind];
 262
 263    /* This and the above should only be done on _NEW_LIGHT:
 264     */
 265    _mesa_validate_all_lighting_tables( ctx );
 266 #endif
 267
 268    /* Now run the stage...
 269     */
 270    stage->run = run_vp;
 271    return stage->run( ctx, stage );
 272 }
 273
 274
 275
 276 /**
 277  * Called the first time stage->run is called.  In effect, don't
 278  * allocate data until the first time the stage is run.
 279  */
 280 static GLboolean run_init_vp( GLcontext *ctx,
 281                               struct tnl_pipeline_stage *stage )
 282 {
 283    TNLcontext *tnl = TNL_CONTEXT(ctx);
 284    struct vertex_buffer *VB = &(tnl->vb);
 285    struct vp_stage_data *store;
 286    const GLuint size = VB->Size;
 287    GLuint i;
 288
 289    stage->privatePtr = MALLOC(sizeof(*store));
 290    store = VP_STAGE_DATA(stage);
 291    if (!store)
 292       return GL_FALSE;
 293
 294    /* Allocate arrays of vertex output values */
 295    for (i = 0; i < 15; i++) {
 296       _mesa_vector4f_alloc( &store->attribs[i], 0, size, 32 );
 297       store->attribs[i].size = 4;
 298    }
 299
 300    /* a few other misc allocations */
 301    _mesa_vector4f_alloc( &store->ndcCoords, 0, size, 32 );
 302    store->clipmask = (GLubyte *) ALIGN_MALLOC(sizeof(GLubyte)*size, 32 );
 303
 304    /* Now validate the stage derived data...
 305     */
 306    stage->run = run_validate_program;
 307    return stage->run( ctx, stage );
 308 }
 309
 310
 311
 312 /**
 313  * Check if vertex program mode is enabled.
 314  * If so, configure the pipeline stage's type, inputs, and outputs.
 315  */
 316 static void check_vp( GLcontext *ctx, struct tnl_pipeline_stage *stage )
 317 {
 318    stage->active = ctx->VertexProgram._Enabled;
 319
 320    if (stage->active) {
 321       /* Set stage->inputs equal to the bitmask of vertex attributes
 322        * which the program needs for inputs.
 323        */
 324       stage->inputs = ctx->VertexProgram.Current->InputsRead;
 325    }
 326 }
 327
 328
 329 /**
 330  * Destructor for this pipeline stage.
 331  */
 332 static void dtr( struct tnl_pipeline_stage *stage )
 333 {
 334    struct vp_stage_data *store = VP_STAGE_DATA(stage);
 335
 336    if (store) {
 337       GLuint i;
 338
 339       /* free the vertex program result arrays */
 340       for (i = 0; i < 15; i++)
 341          _mesa_vector4f_free( &store->attribs[i] );
 342
 343       /* free misc arrays */
 344       _mesa_vector4f_free( &store->ndcCoords );
 345       ALIGN_FREE( store->clipmask );
 346
 347       FREE( store );
 348       stage->privatePtr = 0;
 349    }
 350 }
 351
 352 /**
 353  * Public description of this pipeline stage.
 354  */
 355 const struct tnl_pipeline_stage _tnl_vertex_program_stage =
 356 {
 357    "vertex-program",
 358    _NEW_ALL,    /*XXX FIX */    /* recheck */
 359    _NEW_ALL,    /*XXX FIX */    /* recalc */
 360    GL_FALSE,                    /* active */
 361    0,                           /* inputs - calculated on the fly */
 362    _TNL_BITS_PROG_ANY,          /* outputs -- could calculate */
 363    0,                           /* changed_inputs */
 364    NULL,                        /* private_data */
 365    dtr,                         /* destroy */
 366    check_vp,                    /* check */
 367    run_init_vp                  /* run -- initially set to ctr */
 368 };