src/mesa/tnl/t_vb_program.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.1
   4  *
   5  * Copyright (C) 1999-2007  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 vertex programs.
  29  * \author Brian Paul,  Keith Whitwell
  30  */
  31
  32
  33 #include "main/glheader.h"
  34 #include "main/colormac.h"
  35 #include "main/context.h"
  36 #include "main/macros.h"
  37 #include "main/imports.h"
  38 #include "shader/prog_instruction.h"
  39 #include "shader/prog_statevars.h"
  40 #include "shader/prog_execute.h"
  41 #include "swrast/s_context.h"
  42 #include "swrast/s_texfilter.h"
  43
  44 #include "tnl/tnl.h"
  45 #include "tnl/t_context.h"
  46 #include "tnl/t_pipeline.h"
  47
  48
  49
  50 /*!
  51  * Private storage for the vertex program pipeline stage.
  52  */
  53 struct vp_stage_data {
  54    /** The results of running the vertex program go into these arrays. */
  55    GLvector4f results[VERT_RESULT_MAX];
  56
  57    GLvector4f ndcCoords;              /**< normalized device coords */
  58    GLubyte *clipmask;                 /**< clip flags */
  59    GLubyte ormask, andmask;           /**< for clipping */
  60 };
  61
  62
  63 #define VP_STAGE_DATA(stage) ((struct vp_stage_data *)(stage->privatePtr))
  64
  65
  66 static void
  67 userclip( GLcontext *ctx,
  68           GLvector4f *clip,
  69           GLubyte *clipmask,
  70           GLubyte *clipormask,
  71           GLubyte *clipandmask )
  72 {
  73    GLuint p;
  74
  75    for (p = 0; p < ctx->Const.MaxClipPlanes; p++) {
  76       if (ctx->Transform.ClipPlanesEnabled & (1 << p)) {
  77          GLuint nr, i;
  78          const GLfloat a = ctx->Transform._ClipUserPlane[p][0];
  79          const GLfloat b = ctx->Transform._ClipUserPlane[p][1];
  80          const GLfloat c = ctx->Transform._ClipUserPlane[p][2];
  81          const GLfloat d = ctx->Transform._ClipUserPlane[p][3];
  82          GLfloat *coord = (GLfloat *)clip->data;
  83          GLuint stride = clip->stride;
  84          GLuint count = clip->count;
  85
  86          for (nr = 0, i = 0 ; i < count ; i++) {
  87             GLfloat dp = (coord[0] * a +
  88                           coord[1] * b +
  89                           coord[2] * c +
  90                           coord[3] * d);
  91
  92             if (dp < 0) {
  93                nr++;
  94                clipmask[i] |= CLIP_USER_BIT;
  95             }
  96
  97             STRIDE_F(coord, stride);
  98          }
  99
 100          if (nr > 0) {
 101             *clipormask |= CLIP_USER_BIT;
 102             if (nr == count) {
 103                *clipandmask |= CLIP_USER_BIT;
 104                return;
 105             }
 106          }
 107       }
 108    }
 109 }
 110
 111
 112 static GLboolean
 113 do_ndc_cliptest(GLcontext *ctx, struct vp_stage_data *store)
 114 {
 115    TNLcontext *tnl = TNL_CONTEXT(ctx);
 116    struct vertex_buffer *VB = &tnl->vb;
 117    /* Cliptest and perspective divide.  Clip functions must clear
 118     * the clipmask.
 119     */
 120    store->ormask = 0;
 121    store->andmask = CLIP_FRUSTUM_BITS;
 122
 123    if (tnl->NeedNdcCoords) {
 124       VB->NdcPtr =
 125          _mesa_clip_tab[VB->ClipPtr->size]( VB->ClipPtr,
 126                                             &store->ndcCoords,
 127                                             store->clipmask,
 128                                             &store->ormask,
 129                                             &store->andmask );
 130    }
 131    else {
 132       VB->NdcPtr = NULL;
 133       _mesa_clip_np_tab[VB->ClipPtr->size]( VB->ClipPtr,
 134                                             NULL,
 135                                             store->clipmask,
 136                                             &store->ormask,
 137                                             &store->andmask );
 138    }
 139
 140    if (store->andmask) {
 141       /* All vertices are outside the frustum */
 142       return GL_FALSE;
 143    }
 144
 145    /* Test userclip planes.  This contributes to VB->ClipMask.
 146     */
 147    /** XXX NEW_SLANG _Enabled ??? */
 148    if (ctx->Transform.ClipPlanesEnabled && (!ctx->VertexProgram._Enabled ||
 149       ctx->VertexProgram.Current->IsPositionInvariant)) {
 150       userclip( ctx,
 151                 VB->ClipPtr,
 152                 store->clipmask,
 153                 &store->ormask,
 154                 &store->andmask );
 155
 156       if (store->andmask) {
 157          return GL_FALSE;
 158       }
 159    }
 160
 161    VB->ClipAndMask = store->andmask;
 162    VB->ClipOrMask = store->ormask;
 163    VB->ClipMask = store->clipmask;
 164
 165    return GL_TRUE;
 166 }
 167
 168
 169 /**
 170  * XXX the texture sampling code in this module is a bit of a hack.
 171  * The texture sampling code is in swrast, though it doesn't have any
 172  * real dependencies on the rest of swrast.  It should probably be
 173  * moved into main/ someday.
 174  */
 175 static void
 176 vp_fetch_texel(GLcontext *ctx, const GLfloat texcoord[4], GLfloat lambda,
 177                GLuint unit, GLfloat color[4])
 178 {
 179    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 180
 181    /* XXX use a float-valued TextureSample routine here!!! */
 182    swrast->TextureSample[unit](ctx, ctx->Texture.Unit[unit]._Current,
 183                                1, (const GLfloat (*)[4]) texcoord,
 184                                &lambda,  (GLfloat (*)[4]) color);
 185 }
 186
 187
 188 /**
 189  * Called via ctx->Driver.ProgramStringNotify() after a new vertex program
 190  * string has been parsed.
 191  */
 192 void
 193 _tnl_program_string(GLcontext *ctx, GLenum target, struct gl_program *program)
 194 {
 195    /* No-op.
 196     * If we had derived anything from the program that was private to this
 197     * stage we'd recompute/validate it here.
 198     */
 199 }
 200
 201
 202 /**
 203  * Initialize virtual machine state prior to executing vertex program.
 204  */
 205 static void
 206 init_machine(GLcontext *ctx, struct gl_program_machine *machine)
 207 {
 208    /* Input registers get initialized from the current vertex attribs */
 209    MEMCPY(machine->VertAttribs, ctx->Current.Attrib,
 210           MAX_VERTEX_PROGRAM_ATTRIBS * 4 * sizeof(GLfloat));
 211
 212    if (ctx->VertexProgram._Current->IsNVProgram) {
 213       GLuint i;
 214       /* Output/result regs are initialized to [0,0,0,1] */
 215       for (i = 0; i < MAX_NV_VERTEX_PROGRAM_OUTPUTS; i++) {
 216          ASSIGN_4V(machine->Outputs[i], 0.0F, 0.0F, 0.0F, 1.0F);
 217       }
 218       /* Temp regs are initialized to [0,0,0,0] */
 219       for (i = 0; i < MAX_NV_VERTEX_PROGRAM_TEMPS; i++) {
 220          ASSIGN_4V(machine->Temporaries[i], 0.0F, 0.0F, 0.0F, 0.0F);
 221       }
 222       for (i = 0; i < MAX_VERTEX_PROGRAM_ADDRESS_REGS; i++) {
 223          ASSIGN_4V(machine->AddressReg[i], 0, 0, 0, 0);
 224       }
 225    }
 226
 227    machine->NumDeriv = 0;
 228
 229    /* init condition codes */
 230    machine->CondCodes[0] = COND_EQ;
 231    machine->CondCodes[1] = COND_EQ;
 232    machine->CondCodes[2] = COND_EQ;
 233    machine->CondCodes[3] = COND_EQ;
 234
 235    /* init call stack */
 236    machine->StackDepth = 0;
 237
 238    machine->FetchTexelLod = vp_fetch_texel;
 239    machine->FetchTexelDeriv = NULL; /* not used by vertex programs */
 240
 241    machine->Samplers = ctx->VertexProgram._Current->Base.SamplerUnits;
 242 }
 243
 244
 245 /**
 246  * Map the texture images which the vertex program will access (if any).
 247  */
 248 static void
 249 map_textures(GLcontext *ctx, const struct gl_vertex_program *vp)
 250 {
 251    GLuint u;
 252
 253    if (!ctx->Driver.MapTexture)
 254       return;
 255
 256    for (u = 0; u < ctx->Const.MaxVertexTextureImageUnits; u++) {
 257       if (vp->Base.TexturesUsed[u]) {
 258          /* Note: _Current *should* correspond to the target indicated
 259           * in TexturesUsed[u].
 260           */
 261          ctx->Driver.MapTexture(ctx, ctx->Texture.Unit[u]._Current);
 262       }
 263    }
 264 }
 265
 266
 267 /**
 268  * Unmap the texture images which were used by the vertex program (if any).
 269  */
 270 static void
 271 unmap_textures(GLcontext *ctx, const struct gl_vertex_program *vp)
 272 {
 273    GLuint u;
 274
 275    if (!ctx->Driver.MapTexture)
 276       return;
 277
 278    for (u = 0; u < ctx->Const.MaxVertexTextureImageUnits; u++) {
 279       if (vp->Base.TexturesUsed[u]) {
 280          /* Note: _Current *should* correspond to the target indicated
 281           * in TexturesUsed[u].
 282           */
 283          ctx->Driver.UnmapTexture(ctx, ctx->Texture.Unit[u]._Current);
 284       }
 285    }
 286 }
 287
 288
 289 /**
 290  * This function executes vertex programs
 291  */
 292 static GLboolean
 293 run_vp( GLcontext *ctx, struct tnl_pipeline_stage *stage )
 294 {
 295    TNLcontext *tnl = TNL_CONTEXT(ctx);
 296    struct vp_stage_data *store = VP_STAGE_DATA(stage);
 297    struct vertex_buffer *VB = &tnl->vb;
 298    struct gl_vertex_program *program = ctx->VertexProgram._Current;
 299    struct gl_program_machine machine;
 300    GLuint outputs[VERT_RESULT_MAX], numOutputs;
 301    GLuint i, j;
 302
 303    if (!program)
 304       return GL_TRUE;
 305
 306    if (program->IsNVProgram) {
 307       _mesa_load_tracked_matrices(ctx);
 308    }
 309    else {
 310       /* ARB program or vertex shader */
 311       _mesa_load_state_parameters(ctx, program->Base.Parameters);
 312    }
 313
 314    /* make list of outputs to save some time below */
 315    numOutputs = 0;
 316    for (i = 0; i < VERT_RESULT_MAX; i++) {
 317       if (program->Base.OutputsWritten & (1 << i)) {
 318          outputs[numOutputs++] = i;
 319       }
 320    }
 321
 322    map_textures(ctx, program);
 323
 324    for (i = 0; i < VB->Count; i++) {
 325       GLuint attr;
 326
 327       init_machine(ctx, &machine);
 328
 329 #if 0
 330       printf("Input  %d: %f, %f, %f, %f\n", i,
 331              VB->AttribPtr[0]->data[i][0],
 332              VB->AttribPtr[0]->data[i][1],
 333              VB->AttribPtr[0]->data[i][2],
 334              VB->AttribPtr[0]->data[i][3]);
 335       printf("   color: %f, %f, %f, %f\n",
 336              VB->AttribPtr[3]->data[i][0],
 337              VB->AttribPtr[3]->data[i][1],
 338              VB->AttribPtr[3]->data[i][2],
 339              VB->AttribPtr[3]->data[i][3]);
 340       printf("  normal: %f, %f, %f, %f\n",
 341              VB->AttribPtr[2]->data[i][0],
 342              VB->AttribPtr[2]->data[i][1],
 343              VB->AttribPtr[2]->data[i][2],
 344              VB->AttribPtr[2]->data[i][3]);
 345 #endif
 346
 347       /* the vertex array case */
 348       for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
 349          if (program->Base.InputsRead & (1 << attr)) {
 350             const GLubyte *ptr = (const GLubyte*) VB->AttribPtr[attr]->data;
 351             const GLuint size = VB->AttribPtr[attr]->size;
 352             const GLuint stride = VB->AttribPtr[attr]->stride;
 353             const GLfloat *data = (GLfloat *) (ptr + stride * i);
 354             COPY_CLEAN_4V(machine.VertAttribs[attr], size, data);
 355          }
 356       }
 357
 358       /* execute the program */
 359       _mesa_execute_program(ctx, &program->Base, &machine);
 360
 361       /* copy the output registers into the VB->attribs arrays */
 362       for (j = 0; j < numOutputs; j++) {
 363          const GLuint attr = outputs[j];
 364          COPY_4V(store->results[attr].data[i], machine.Outputs[attr]);
 365       }
 366 #if 0
 367       printf("HPOS: %f %f %f %f\n",
 368              machine.Outputs[0][0],
 369              machine.Outputs[0][1],
 370              machine.Outputs[0][2],
 371              machine.Outputs[0][3]);
 372 #endif
 373    }
 374
 375    unmap_textures(ctx, program);
 376
 377    /* Fixup fog and point size results if needed */
 378    if (program->IsNVProgram) {
 379       if (ctx->Fog.Enabled &&
 380           (program->Base.OutputsWritten & (1 << VERT_RESULT_FOGC)) == 0) {
 381          for (i = 0; i < VB->Count; i++) {
 382             store->results[VERT_RESULT_FOGC].data[i][0] = 1.0;
 383          }
 384       }
 385
 386       if (ctx->VertexProgram.PointSizeEnabled &&
 387           (program->Base.OutputsWritten & (1 << VERT_RESULT_PSIZ)) == 0) {
 388          for (i = 0; i < VB->Count; i++) {
 389             store->results[VERT_RESULT_PSIZ].data[i][0] = ctx->Point.Size;
 390          }
 391       }
 392    }
 393
 394    if (program->IsPositionInvariant) {
 395       /* We need the exact same transform as in the fixed function path here
 396        * to guarantee invariance, depending on compiler optimization flags
 397        * results could be different otherwise.
 398        */
 399       VB->ClipPtr = TransformRaw( &store->results[0],
 400                                   &ctx->_ModelProjectMatrix,
 401                                   VB->AttribPtr[0] );
 402
 403       /* Drivers expect this to be clean to element 4...
 404        */
 405       switch (VB->ClipPtr->size) {
 406       case 1:
 407          /* impossible */
 408       case 2:
 409          _mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 2 );
 410          /* fall-through */
 411       case 3:
 412          _mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 3 );
 413          /* fall-through */
 414       case 4:
 415          break;
 416       }
 417    }
 418    else {
 419       /* Setup the VB pointers so that the next pipeline stages get
 420        * their data from the right place (the program output arrays).
 421        */
 422       VB->ClipPtr = &store->results[VERT_RESULT_HPOS];
 423       VB->ClipPtr->size = 4;
 424       VB->ClipPtr->count = VB->Count;
 425    }
 426
 427    VB->ColorPtr[0] = &store->results[VERT_RESULT_COL0];
 428    VB->ColorPtr[1] = &store->results[VERT_RESULT_BFC0];
 429    VB->SecondaryColorPtr[0] = &store->results[VERT_RESULT_COL1];
 430    VB->SecondaryColorPtr[1] = &store->results[VERT_RESULT_BFC1];
 431    VB->FogCoordPtr = &store->results[VERT_RESULT_FOGC];
 432
 433    VB->AttribPtr[VERT_ATTRIB_COLOR0] = &store->results[VERT_RESULT_COL0];
 434    VB->AttribPtr[VERT_ATTRIB_COLOR1] = &store->results[VERT_RESULT_COL1];
 435    VB->AttribPtr[VERT_ATTRIB_FOG] = &store->results[VERT_RESULT_FOGC];
 436    VB->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->results[VERT_RESULT_PSIZ];
 437
 438    for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
 439       VB->TexCoordPtr[i] =
 440       VB->AttribPtr[_TNL_ATTRIB_TEX0 + i]
 441          = &store->results[VERT_RESULT_TEX0 + i];
 442    }
 443
 444    for (i = 0; i < ctx->Const.MaxVarying; i++) {
 445       if (program->Base.OutputsWritten & (1 << (VERT_RESULT_VAR0 + i))) {
 446          /* Note: varying results get put into the generic attributes */
 447          VB->AttribPtr[VERT_ATTRIB_GENERIC0+i]
 448             = &store->results[VERT_RESULT_VAR0 + i];
 449       }
 450    }
 451
 452
 453    /* Perform NDC and cliptest operations:
 454     */
 455    return do_ndc_cliptest(ctx, store);
 456 }
 457
 458
 459 /**
 460  * Called the first time stage->run is called.  In effect, don't
 461  * allocate data until the first time the stage is run.
 462  */
 463 static GLboolean
 464 init_vp(GLcontext *ctx, struct tnl_pipeline_stage *stage)
 465 {
 466    TNLcontext *tnl = TNL_CONTEXT(ctx);
 467    struct vertex_buffer *VB = &(tnl->vb);
 468    struct vp_stage_data *store;
 469    const GLuint size = VB->Size;
 470    GLuint i;
 471
 472    stage->privatePtr = MALLOC(sizeof(*store));
 473    store = VP_STAGE_DATA(stage);
 474    if (!store)
 475       return GL_FALSE;
 476
 477    /* Allocate arrays of vertex output values */
 478    for (i = 0; i < VERT_RESULT_MAX; i++) {
 479       _mesa_vector4f_alloc( &store->results[i], 0, size, 32 );
 480       store->results[i].size = 4;
 481    }
 482
 483    /* a few other misc allocations */
 484    _mesa_vector4f_alloc( &store->ndcCoords, 0, size, 32 );
 485    store->clipmask = (GLubyte *) ALIGN_MALLOC(sizeof(GLubyte)*size, 32 );
 486
 487    return GL_TRUE;
 488 }
 489
 490
 491 /**
 492  * Destructor for this pipeline stage.
 493  */
 494 static void
 495 dtr(struct tnl_pipeline_stage *stage)
 496 {
 497    struct vp_stage_data *store = VP_STAGE_DATA(stage);
 498
 499    if (store) {
 500       GLuint i;
 501
 502       /* free the vertex program result arrays */
 503       for (i = 0; i < VERT_RESULT_MAX; i++)
 504          _mesa_vector4f_free( &store->results[i] );
 505
 506       /* free misc arrays */
 507       _mesa_vector4f_free( &store->ndcCoords );
 508       ALIGN_FREE( store->clipmask );
 509
 510       FREE( store );
 511       stage->privatePtr = NULL;
 512    }
 513 }
 514
 515
 516 static void
 517 validate_vp_stage(GLcontext *ctx, struct tnl_pipeline_stage *stage)
 518 {
 519    if (ctx->VertexProgram._Current) {
 520       _swrast_update_texture_samplers(ctx);
 521    }
 522 }
 523
 524
 525
 526 /**
 527  * Public description of this pipeline stage.
 528  */
 529 const struct tnl_pipeline_stage _tnl_vertex_program_stage =
 530 {
 531    "vertex-program",
 532    NULL,                        /* private_data */
 533    init_vp,                     /* create */
 534    dtr,                         /* destroy */
 535    validate_vp_stage,           /* validate */
 536    run_vp                       /* run -- initially set to ctr */
 537 };