src/mesa/tnl/t_vertex.c

   1 /*
   2  * Copyright 2003 VMware, Inc.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * on the rights to use, copy, modify, merge, publish, distribute, sub
   9  * license, and/or sell copies of the Software, and to permit persons to whom
  10  * the Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  19  * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  22  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Keith Whitwell <keithw@vmware.com>
  26  */
  27
  28 #include <stdio.h>
  29 #include "main/glheader.h"
  30 #include "main/context.h"
  31 #include "main/execmem.h"
  32 #include "swrast/s_chan.h"
  33 #include "t_context.h"
  34 #include "t_vertex.h"
  35
  36 #define DBG 0
  37
  38 /* Build and manage clipspace/ndc/window vertices.
  39  */
  40
  41 static GLboolean match_fastpath( struct tnl_clipspace *vtx,
  42                                  const struct tnl_clipspace_fastpath *fp)
  43 {
  44    GLuint j;
  45
  46    if (vtx->attr_count != fp->attr_count)
  47       return GL_FALSE;
  48
  49    for (j = 0; j < vtx->attr_count; j++)
  50       if (vtx->attr[j].format != fp->attr[j].format ||
  51           vtx->attr[j].inputsize != fp->attr[j].size ||
  52           vtx->attr[j].vertoffset != fp->attr[j].offset)
  53          return GL_FALSE;
  54
  55    if (fp->match_strides) {
  56       if (vtx->vertex_size != fp->vertex_size)
  57          return GL_FALSE;
  58
  59       for (j = 0; j < vtx->attr_count; j++)
  60          if (vtx->attr[j].inputstride != fp->attr[j].stride)
  61             return GL_FALSE;
  62    }
  63
  64    return GL_TRUE;
  65 }
  66
  67 static GLboolean search_fastpath_emit( struct tnl_clipspace *vtx )
  68 {
  69    struct tnl_clipspace_fastpath *fp = vtx->fastpath;
  70
  71    for ( ; fp ; fp = fp->next) {
  72       if (match_fastpath(vtx, fp)) {
  73          vtx->emit = fp->func;
  74          return GL_TRUE;
  75       }
  76    }
  77
  78    return GL_FALSE;
  79 }
  80
  81 void _tnl_register_fastpath( struct tnl_clipspace *vtx,
  82                              GLboolean match_strides )
  83 {
  84    struct tnl_clipspace_fastpath *fastpath = CALLOC_STRUCT(tnl_clipspace_fastpath);
  85    GLuint i;
  86
  87    if (fastpath == NULL) {
  88       _mesa_error_no_memory(__func__);
  89       return;
  90    }
  91
  92    fastpath->vertex_size = vtx->vertex_size;
  93    fastpath->attr_count = vtx->attr_count;
  94    fastpath->match_strides = match_strides;
  95    fastpath->func = vtx->emit;
  96    fastpath->attr = malloc(vtx->attr_count * sizeof(fastpath->attr[0]));
  97
  98    if (fastpath->attr == NULL) {
  99       free(fastpath);
 100       _mesa_error_no_memory(__func__);
 101       return;
 102    }
 103
 104    for (i = 0; i < vtx->attr_count; i++) {
 105       fastpath->attr[i].format = vtx->attr[i].format;
 106       fastpath->attr[i].stride = vtx->attr[i].inputstride;
 107       fastpath->attr[i].size = vtx->attr[i].inputsize;
 108       fastpath->attr[i].offset = vtx->attr[i].vertoffset;
 109    }
 110
 111    fastpath->next = vtx->fastpath;
 112    vtx->fastpath = fastpath;
 113 }
 114
 115
 116
 117 /***********************************************************************
 118  * Build codegen functions or return generic ones:
 119  */
 120 static void choose_emit_func( struct gl_context *ctx, GLuint count, GLubyte *dest)
 121 {
 122    struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
 123    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 124    struct tnl_clipspace_attr *a = vtx->attr;
 125    const GLuint attr_count = vtx->attr_count;
 126    GLuint j;
 127
 128    for (j = 0; j < attr_count; j++) {
 129       GLvector4f *vptr = VB->AttribPtr[a[j].attrib];
 130       a[j].inputstride = vptr->stride;
 131       a[j].inputsize = vptr->size;
 132       a[j].emit = a[j].insert[vptr->size - 1]; /* not always used */
 133    }
 134
 135    vtx->emit = NULL;
 136
 137    /* Does this match an existing (hardwired, codegen or known-bad)
 138     * fastpath?
 139     */
 140    if (search_fastpath_emit(vtx)) {
 141       /* Use this result.  If it is null, then it is already known
 142        * that the current state will fail for codegen and there is no
 143        * point trying again.
 144        */
 145    }
 146    else if (vtx->codegen_emit) {
 147       vtx->codegen_emit(ctx);
 148    }
 149
 150    if (!vtx->emit) {
 151       _tnl_generate_hardwired_emit(ctx);
 152    }
 153
 154    /* Otherwise use the generic version:
 155     */
 156    if (!vtx->emit)
 157       vtx->emit = _tnl_generic_emit;
 158
 159    vtx->emit( ctx, count, dest );
 160 }
 161
 162
 163
 164 static void choose_interp_func( struct gl_context *ctx,
 165                                 GLfloat t,
 166                                 GLuint edst, GLuint eout, GLuint ein,
 167                                 GLboolean force_boundary )
 168 {
 169    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 170    GLboolean unfilled = (ctx->Polygon.FrontMode != GL_FILL ||
 171                          ctx->Polygon.BackMode != GL_FILL);
 172    GLboolean twosided = ctx->Light.Enabled && ctx->Light.Model.TwoSide;
 173
 174    if (vtx->need_extras && (twosided || unfilled)) {
 175       vtx->interp = _tnl_generic_interp_extras;
 176    } else {
 177       vtx->interp = _tnl_generic_interp;
 178    }
 179
 180    vtx->interp( ctx, t, edst, eout, ein, force_boundary );
 181 }
 182
 183
 184 static void choose_copy_pv_func(  struct gl_context *ctx, GLuint edst, GLuint esrc )
 185 {
 186    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 187    GLboolean unfilled = (ctx->Polygon.FrontMode != GL_FILL ||
 188                          ctx->Polygon.BackMode != GL_FILL);
 189
 190    GLboolean twosided = ctx->Light.Enabled && ctx->Light.Model.TwoSide;
 191
 192    if (vtx->need_extras && (twosided || unfilled)) {
 193       vtx->copy_pv = _tnl_generic_copy_pv_extras;
 194    } else {
 195       vtx->copy_pv = _tnl_generic_copy_pv;
 196    }
 197
 198    vtx->copy_pv( ctx, edst, esrc );
 199 }
 200
 201
 202 /***********************************************************************
 203  * Public entrypoints, mostly dispatch to the above:
 204  */
 205
 206
 207 /* Interpolate between two vertices to produce a third:
 208  */
 209 void _tnl_interp( struct gl_context *ctx,
 210                   GLfloat t,
 211                   GLuint edst, GLuint eout, GLuint ein,
 212                   GLboolean force_boundary )
 213 {
 214    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 215    vtx->interp( ctx, t, edst, eout, ein, force_boundary );
 216 }
 217
 218 /* Copy colors from one vertex to another:
 219  */
 220 void _tnl_copy_pv(  struct gl_context *ctx, GLuint edst, GLuint esrc )
 221 {
 222    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 223    vtx->copy_pv( ctx, edst, esrc );
 224 }
 225
 226
 227 /* Extract a named attribute from a hardware vertex.  Will have to
 228  * reverse any viewport transformation, swizzling or other conversions
 229  * which may have been applied:
 230  */
 231 void _tnl_get_attr( struct gl_context *ctx, const void *vin,
 232                               GLenum attr, GLfloat *dest )
 233 {
 234    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 235    const struct tnl_clipspace_attr *a = vtx->attr;
 236    const GLuint attr_count = vtx->attr_count;
 237    GLuint j;
 238
 239    for (j = 0; j < attr_count; j++) {
 240       if (a[j].attrib == attr) {
 241          a[j].extract( &a[j], dest, (GLubyte *)vin + a[j].vertoffset );
 242          return;
 243       }
 244    }
 245
 246    /* Else return the value from ctx->Current.
 247     */
 248    if (attr == _TNL_ATTRIB_POINTSIZE) {
 249       /* If the hardware vertex doesn't have point size then use size from
 250        * struct gl_context.  XXX this will be wrong if drawing attenuated points!
 251        */
 252       dest[0] = ctx->Point.Size;
 253    }
 254    else {
 255       memcpy( dest, ctx->Current.Attrib[attr], 4*sizeof(GLfloat));
 256    }
 257 }
 258
 259
 260 /* Complementary operation to the above.
 261  */
 262 void _tnl_set_attr( struct gl_context *ctx, void *vout,
 263                     GLenum attr, const GLfloat *src )
 264 {
 265    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 266    const struct tnl_clipspace_attr *a = vtx->attr;
 267    const GLuint attr_count = vtx->attr_count;
 268    GLuint j;
 269
 270    for (j = 0; j < attr_count; j++) {
 271       if (a[j].attrib == attr) {
 272          a[j].insert[4-1]( &a[j], (GLubyte *)vout + a[j].vertoffset, src );
 273          return;
 274       }
 275    }
 276 }
 277
 278
 279 void *_tnl_get_vertex( struct gl_context *ctx, GLuint nr )
 280 {
 281    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 282
 283    return vtx->vertex_buf + nr * vtx->vertex_size;
 284 }
 285
 286 void _tnl_invalidate_vertex_state( struct gl_context *ctx, GLuint new_state )
 287 {
 288    /* if two-sided lighting changes or filled/unfilled polygon state changes */
 289    if (new_state & (_NEW_LIGHT | _NEW_POLYGON) ) {
 290       struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 291       vtx->new_inputs = ~0;
 292       vtx->interp = choose_interp_func;
 293       vtx->copy_pv = choose_copy_pv_func;
 294    }
 295 }
 296
 297 static void invalidate_funcs( struct tnl_clipspace *vtx )
 298 {
 299    vtx->emit = choose_emit_func;
 300    vtx->interp = choose_interp_func;
 301    vtx->copy_pv = choose_copy_pv_func;
 302    vtx->new_inputs = ~0;
 303 }
 304
 305 GLuint _tnl_install_attrs( struct gl_context *ctx, const struct tnl_attr_map *map,
 306                            GLuint nr, const GLfloat *vp,
 307                            GLuint unpacked_size )
 308 {
 309    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 310    GLuint offset = 0;
 311    GLuint i, j;
 312
 313    assert(nr < _TNL_ATTRIB_MAX);
 314    assert(nr == 0 || map[0].attrib == VERT_ATTRIB_POS);
 315
 316    vtx->new_inputs = ~0;
 317    vtx->need_viewport = GL_FALSE;
 318
 319    if (vp) {
 320       vtx->need_viewport = GL_TRUE;
 321    }
 322
 323    for (j = 0, i = 0; i < nr; i++) {
 324       const GLuint format = map[i].format;
 325       if (format == EMIT_PAD) {
 326          if (DBG)
 327             printf("%d: pad %d, offset %d\n", i,
 328                    map[i].offset, offset);
 329
 330          offset += map[i].offset;
 331
 332       }
 333       else {
 334          GLuint tmpoffset;
 335
 336          if (unpacked_size)
 337             tmpoffset = map[i].offset;
 338          else
 339             tmpoffset = offset;
 340
 341          if (vtx->attr_count != j ||
 342              vtx->attr[j].attrib != map[i].attrib ||
 343              vtx->attr[j].format != format ||
 344              vtx->attr[j].vertoffset != tmpoffset) {
 345             invalidate_funcs(vtx);
 346
 347             vtx->attr[j].attrib = map[i].attrib;
 348             vtx->attr[j].format = format;
 349             vtx->attr[j].vp = vp;
 350             vtx->attr[j].insert = _tnl_format_info[format].insert;
 351             vtx->attr[j].extract = _tnl_format_info[format].extract;
 352             vtx->attr[j].vertattrsize = _tnl_format_info[format].attrsize;
 353             vtx->attr[j].vertoffset = tmpoffset;
 354          }
 355
 356
 357          if (DBG)
 358             printf("%d: %s, vp %p, offset %d\n", i,
 359                    _tnl_format_info[format].name, (void *)vp,
 360                    vtx->attr[j].vertoffset);
 361
 362          offset += _tnl_format_info[format].attrsize;
 363          j++;
 364       }
 365    }
 366
 367    vtx->attr_count = j;
 368
 369    if (unpacked_size)
 370       vtx->vertex_size = unpacked_size;
 371    else
 372       vtx->vertex_size = offset;
 373
 374    assert(vtx->vertex_size <= vtx->max_vertex_size);
 375    return vtx->vertex_size;
 376 }
 377
 378
 379
 380 void _tnl_invalidate_vertices( struct gl_context *ctx, GLuint newinputs )
 381 {
 382    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 383    vtx->new_inputs |= newinputs;
 384 }
 385
 386
 387 /* This event has broader use beyond this file - will move elsewhere
 388  * and probably invoke a driver callback.
 389  */
 390 void _tnl_notify_pipeline_output_change( struct gl_context *ctx )
 391 {
 392    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 393    invalidate_funcs(vtx);
 394 }
 395
 396
 397 static void adjust_input_ptrs( struct gl_context *ctx, GLint diff)
 398 {
 399    struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
 400    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 401    struct tnl_clipspace_attr *a = vtx->attr;
 402    const GLuint count = vtx->attr_count;
 403    GLuint j;
 404
 405    diff -= 1;
 406    for (j=0; j<count; ++j) {
 407            register GLvector4f *vptr = VB->AttribPtr[a->attrib];
 408            (a++)->inputptr += diff*vptr->stride;
 409    }
 410 }
 411
 412 static void update_input_ptrs( struct gl_context *ctx, GLuint start )
 413 {
 414    struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
 415    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 416    struct tnl_clipspace_attr *a = vtx->attr;
 417    const GLuint count = vtx->attr_count;
 418    GLuint j;
 419
 420    for (j = 0; j < count; j++) {
 421       GLvector4f *vptr = VB->AttribPtr[a[j].attrib];
 422
 423       if (vtx->emit != choose_emit_func) {
 424          assert(a[j].inputstride == vptr->stride);
 425          assert(a[j].inputsize == vptr->size);
 426       }
 427
 428       a[j].inputptr = ((GLubyte *)vptr->data) + start * vptr->stride;
 429    }
 430
 431    if (a->vp) {
 432       vtx->vp_scale[0] = a->vp[MAT_SX];
 433       vtx->vp_scale[1] = a->vp[MAT_SY];
 434       vtx->vp_scale[2] = a->vp[MAT_SZ];
 435       vtx->vp_scale[3] = 1.0;
 436       vtx->vp_xlate[0] = a->vp[MAT_TX];
 437       vtx->vp_xlate[1] = a->vp[MAT_TY];
 438       vtx->vp_xlate[2] = a->vp[MAT_TZ];
 439       vtx->vp_xlate[3] = 0.0;
 440    }
 441 }
 442
 443
 444 void _tnl_build_vertices( struct gl_context *ctx,
 445                           GLuint start,
 446                           GLuint end,
 447                           GLuint newinputs )
 448 {
 449    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 450    update_input_ptrs( ctx, start );
 451    vtx->emit( ctx, end - start,
 452               (GLubyte *)(vtx->vertex_buf +
 453                           start * vtx->vertex_size));
 454 }
 455
 456 /* Emit VB vertices start..end to dest.  Note that VB vertex at
 457  * postion start will be emitted to dest at position zero.
 458  */
 459 void *_tnl_emit_vertices_to_buffer( struct gl_context *ctx,
 460                                     GLuint start,
 461                                     GLuint end,
 462                                     void *dest )
 463 {
 464    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 465
 466    update_input_ptrs(ctx, start);
 467    /* Note: dest should not be adjusted for non-zero 'start' values:
 468     */
 469    vtx->emit( ctx, end - start, (GLubyte*) dest );
 470    return (void *)((GLubyte *)dest + vtx->vertex_size * (end - start));
 471 }
 472
 473 /* Emit indexed VB vertices start..end to dest.  Note that VB vertex at
 474  * postion start will be emitted to dest at position zero.
 475  */
 476
 477 void *_tnl_emit_indexed_vertices_to_buffer( struct gl_context *ctx,
 478                                             const GLuint *elts,
 479                                             GLuint start,
 480                                             GLuint end,
 481                                             void *dest )
 482 {
 483    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 484    GLuint oldIndex;
 485    GLubyte *cdest = dest;
 486
 487    update_input_ptrs(ctx, oldIndex = elts[start++]);
 488    vtx->emit( ctx, 1, cdest );
 489    cdest += vtx->vertex_size;
 490
 491    for (; start < end; ++start) {
 492       adjust_input_ptrs(ctx, elts[start] - oldIndex);
 493       oldIndex = elts[start];
 494       vtx->emit( ctx, 1, cdest);
 495       cdest += vtx->vertex_size;
 496    }
 497
 498    return (void *) cdest;
 499 }
 500
 501
 502 void _tnl_init_vertices( struct gl_context *ctx,
 503                         GLuint vb_size,
 504                         GLuint max_vertex_size )
 505 {
 506    struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 507
 508    _tnl_install_attrs( ctx, NULL, 0, NULL, 0 );
 509
 510    vtx->need_extras = GL_TRUE;
 511    if (max_vertex_size > vtx->max_vertex_size) {
 512       _tnl_free_vertices( ctx );
 513       vtx->max_vertex_size = max_vertex_size;
 514       vtx->vertex_buf = _mesa_align_calloc(vb_size * max_vertex_size, 32 );
 515       invalidate_funcs(vtx);
 516    }
 517
 518    switch(CHAN_TYPE) {
 519    case GL_UNSIGNED_BYTE:
 520       vtx->chan_scale[0] = 255.0;
 521       vtx->chan_scale[1] = 255.0;
 522       vtx->chan_scale[2] = 255.0;
 523       vtx->chan_scale[3] = 255.0;
 524       break;
 525    case GL_UNSIGNED_SHORT:
 526       vtx->chan_scale[0] = 65535.0;
 527       vtx->chan_scale[1] = 65535.0;
 528       vtx->chan_scale[2] = 65535.0;
 529       vtx->chan_scale[3] = 65535.0;
 530       break;
 531    default:
 532       vtx->chan_scale[0] = 1.0;
 533       vtx->chan_scale[1] = 1.0;
 534       vtx->chan_scale[2] = 1.0;
 535       vtx->chan_scale[3] = 1.0;
 536       break;
 537    }
 538
 539    vtx->identity[0] = 0.0;
 540    vtx->identity[1] = 0.0;
 541    vtx->identity[2] = 0.0;
 542    vtx->identity[3] = 1.0;
 543
 544    vtx->codegen_emit = NULL;
 545
 546 #ifdef USE_SSE_ASM
 547    if (!getenv("MESA_NO_CODEGEN"))
 548       vtx->codegen_emit = _tnl_generate_sse_emit;
 549 #endif
 550 }
 551
 552
 553 void _tnl_free_vertices( struct gl_context *ctx )
 554 {
 555    TNLcontext *tnl = TNL_CONTEXT(ctx);
 556    if (tnl) {
 557       struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
 558       struct tnl_clipspace_fastpath *fp, *tmp;
 559
 560       _mesa_align_free(vtx->vertex_buf);
 561       vtx->vertex_buf = NULL;
 562
 563       for (fp = vtx->fastpath ; fp ; fp = tmp) {
 564          tmp = fp->next;
 565          free(fp->attr);
 566
 567          /* KW: At the moment, fp->func is constrained to be allocated by
 568           * _mesa_exec_alloc(), as the hardwired fastpaths in
 569           * t_vertex_generic.c are handled specially.  It would be nice
 570           * to unify them, but this probably won't change until this
 571           * module gets another overhaul.
 572           */
 573          _mesa_exec_free((void *) fp->func);
 574          free(fp);
 575       }
 576
 577       vtx->fastpath = NULL;
 578    }
 579 }