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