src/gallium/drivers/llvmpipe/lp_prim_vbuf.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 /**
  29  * Interface between 'draw' module's output and the llvmpipe rasterizer/setup
  30  * code.  When the 'draw' module has finished filling a vertex buffer, the
  31  * draw_arrays() functions below will be called.  Loop over the vertices and
  32  * call the point/line/tri setup functions.
  33  *
  34  * Authors
  35  *  Brian Paul
  36  */
  37
  38
  39 #include "lp_context.h"
  40 #include "lp_state.h"
  41 #include "lp_prim_vbuf.h"
  42 #include "lp_setup.h"
  43 #include "draw/draw_context.h"
  44 #include "draw/draw_vbuf.h"
  45 #include "util/u_memory.h"
  46 #include "util/u_prim.h"
  47
  48
  49 #define LP_MAX_VBUF_INDEXES 1024
  50 #define LP_MAX_VBUF_SIZE    4096
  51
  52 typedef const float (*cptrf4)[4];
  53
  54 /**
  55  * Subclass of vbuf_render.
  56  */
  57 struct llvmpipe_vbuf_render
  58 {
  59    struct vbuf_render base;
  60    struct llvmpipe_context *llvmpipe;
  61    struct setup_context *setup;
  62
  63    uint prim;
  64    uint vertex_size;
  65    uint nr_vertices;
  66    uint vertex_buffer_size;
  67    void *vertex_buffer;
  68 };
  69
  70
  71 /** cast wrapper */
  72 static struct llvmpipe_vbuf_render *
  73 llvmpipe_vbuf_render(struct vbuf_render *vbr)
  74 {
  75    return (struct llvmpipe_vbuf_render *) vbr;
  76 }
  77
  78
  79
  80
  81
  82
  83
  84 static const struct vertex_info *
  85 lp_vbuf_get_vertex_info(struct vbuf_render *vbr)
  86 {
  87    struct llvmpipe_vbuf_render *cvbr = llvmpipe_vbuf_render(vbr);
  88    return llvmpipe_get_vbuf_vertex_info(cvbr->llvmpipe);
  89 }
  90
  91
  92 static boolean
  93 lp_vbuf_allocate_vertices(struct vbuf_render *vbr,
  94                           ushort vertex_size, ushort nr_vertices)
  95 {
  96    struct llvmpipe_vbuf_render *cvbr = llvmpipe_vbuf_render(vbr);
  97    unsigned size = vertex_size * nr_vertices;
  98
  99    if (cvbr->vertex_buffer_size < size) {
 100       align_free(cvbr->vertex_buffer);
 101       cvbr->vertex_buffer = align_malloc(size, 16);
 102       cvbr->vertex_buffer_size = size;
 103    }
 104
 105    cvbr->vertex_size = vertex_size;
 106    cvbr->nr_vertices = nr_vertices;
 107
 108    return cvbr->vertex_buffer != NULL;
 109 }
 110
 111 static void
 112 lp_vbuf_release_vertices(struct vbuf_render *vbr)
 113 {
 114    /* keep the old allocation for next time */
 115 }
 116
 117 static void *
 118 lp_vbuf_map_vertices(struct vbuf_render *vbr)
 119 {
 120    struct llvmpipe_vbuf_render *cvbr = llvmpipe_vbuf_render(vbr);
 121    return cvbr->vertex_buffer;
 122 }
 123
 124 static void
 125 lp_vbuf_unmap_vertices(struct vbuf_render *vbr,
 126                        ushort min_index,
 127                        ushort max_index )
 128 {
 129    struct llvmpipe_vbuf_render *cvbr = llvmpipe_vbuf_render(vbr);
 130    assert( cvbr->vertex_buffer_size >= (max_index+1) * cvbr->vertex_size );
 131    /* do nothing */
 132 }
 133
 134
 135 static boolean
 136 lp_vbuf_set_primitive(struct vbuf_render *vbr, unsigned prim)
 137 {
 138    struct llvmpipe_vbuf_render *cvbr = llvmpipe_vbuf_render(vbr);
 139
 140    llvmpipe_update_derived( cvbr->llvmpipe );
 141
 142    cvbr->llvmpipe->reduced_prim = u_reduced_prim(prim);
 143    cvbr->prim = prim;
 144    return TRUE;
 145
 146 }
 147
 148
 149 static INLINE cptrf4 get_vert( const void *vertex_buffer,
 150                                int index,
 151                                int stride )
 152 {
 153    return (cptrf4)((char *)vertex_buffer + index * stride);
 154 }
 155
 156
 157 /**
 158  * draw elements / indexed primitives
 159  */
 160 static void
 161 lp_vbuf_draw(struct vbuf_render *vbr, const ushort *indices, uint nr)
 162 {
 163    struct llvmpipe_vbuf_render *cvbr = llvmpipe_vbuf_render(vbr);
 164    struct llvmpipe_context *llvmpipe = cvbr->llvmpipe;
 165    const unsigned stride = llvmpipe->vertex_info_vbuf.size * sizeof(float);
 166    const void *vertex_buffer = cvbr->vertex_buffer;
 167    struct setup_context *setup_ctx = cvbr->setup;
 168    unsigned i;
 169
 170    switch (cvbr->prim) {
 171    case PIPE_PRIM_POINTS:
 172       for (i = 0; i < nr; i++) {
 173          lp_setup_point( setup_ctx,
 174                       get_vert(vertex_buffer, indices[i-0], stride) );
 175       }
 176       break;
 177
 178    case PIPE_PRIM_LINES:
 179       for (i = 1; i < nr; i += 2) {
 180          lp_setup_line( setup_ctx,
 181                      get_vert(vertex_buffer, indices[i-1], stride),
 182                      get_vert(vertex_buffer, indices[i-0], stride) );
 183       }
 184       break;
 185
 186    case PIPE_PRIM_LINE_STRIP:
 187       for (i = 1; i < nr; i ++) {
 188          lp_setup_line( setup_ctx,
 189                      get_vert(vertex_buffer, indices[i-1], stride),
 190                      get_vert(vertex_buffer, indices[i-0], stride) );
 191       }
 192       break;
 193
 194    case PIPE_PRIM_LINE_LOOP:
 195       for (i = 1; i < nr; i ++) {
 196          lp_setup_line( setup_ctx,
 197                      get_vert(vertex_buffer, indices[i-1], stride),
 198                      get_vert(vertex_buffer, indices[i-0], stride) );
 199       }
 200       if (nr) {
 201          lp_setup_line( setup_ctx,
 202                      get_vert(vertex_buffer, indices[nr-1], stride),
 203                      get_vert(vertex_buffer, indices[0], stride) );
 204       }
 205       break;
 206
 207    case PIPE_PRIM_TRIANGLES:
 208       if (llvmpipe->rasterizer->flatshade_first) {
 209          for (i = 2; i < nr; i += 3) {
 210             lp_setup_tri( setup_ctx,
 211                        get_vert(vertex_buffer, indices[i-1], stride),
 212                        get_vert(vertex_buffer, indices[i-0], stride),
 213                        get_vert(vertex_buffer, indices[i-2], stride) );
 214          }
 215       }
 216       else {
 217          for (i = 2; i < nr; i += 3) {
 218             lp_setup_tri( setup_ctx,
 219                        get_vert(vertex_buffer, indices[i-2], stride),
 220                        get_vert(vertex_buffer, indices[i-1], stride),
 221                        get_vert(vertex_buffer, indices[i-0], stride) );
 222          }
 223       }
 224       break;
 225
 226    case PIPE_PRIM_TRIANGLE_STRIP:
 227       if (llvmpipe->rasterizer->flatshade_first) {
 228          for (i = 2; i < nr; i += 1) {
 229             lp_setup_tri( setup_ctx,
 230                        get_vert(vertex_buffer, indices[i+(i&1)-1], stride),
 231                        get_vert(vertex_buffer, indices[i-(i&1)], stride),
 232                        get_vert(vertex_buffer, indices[i-2], stride) );
 233          }
 234       }
 235       else {
 236          for (i = 2; i < nr; i += 1) {
 237             lp_setup_tri( setup_ctx,
 238                        get_vert(vertex_buffer, indices[i+(i&1)-2], stride),
 239                        get_vert(vertex_buffer, indices[i-(i&1)-1], stride),
 240                        get_vert(vertex_buffer, indices[i-0], stride) );
 241          }
 242       }
 243       break;
 244
 245    case PIPE_PRIM_TRIANGLE_FAN:
 246       if (llvmpipe->rasterizer->flatshade_first) {
 247          for (i = 2; i < nr; i += 1) {
 248             lp_setup_tri( setup_ctx,
 249                        get_vert(vertex_buffer, indices[i-0], stride),
 250                        get_vert(vertex_buffer, indices[0], stride),
 251                        get_vert(vertex_buffer, indices[i-1], stride) );
 252          }
 253       }
 254       else {
 255          for (i = 2; i < nr; i += 1) {
 256             lp_setup_tri( setup_ctx,
 257                        get_vert(vertex_buffer, indices[0], stride),
 258                        get_vert(vertex_buffer, indices[i-1], stride),
 259                        get_vert(vertex_buffer, indices[i-0], stride) );
 260          }
 261       }
 262       break;
 263
 264    case PIPE_PRIM_QUADS:
 265       if (llvmpipe->rasterizer->flatshade_first) {
 266          for (i = 3; i < nr; i += 4) {
 267             lp_setup_tri( setup_ctx,
 268                        get_vert(vertex_buffer, indices[i-2], stride),
 269                        get_vert(vertex_buffer, indices[i-1], stride),
 270                        get_vert(vertex_buffer, indices[i-3], stride) );
 271             lp_setup_tri( setup_ctx,
 272                        get_vert(vertex_buffer, indices[i-1], stride),
 273                        get_vert(vertex_buffer, indices[i-0], stride),
 274                        get_vert(vertex_buffer, indices[i-3], stride) );
 275          }
 276       }
 277       else {
 278          for (i = 3; i < nr; i += 4) {
 279             lp_setup_tri( setup_ctx,
 280                        get_vert(vertex_buffer, indices[i-3], stride),
 281                        get_vert(vertex_buffer, indices[i-2], stride),
 282                        get_vert(vertex_buffer, indices[i-0], stride) );
 283
 284             lp_setup_tri( setup_ctx,
 285                        get_vert(vertex_buffer, indices[i-2], stride),
 286                        get_vert(vertex_buffer, indices[i-1], stride),
 287                        get_vert(vertex_buffer, indices[i-0], stride) );
 288          }
 289       }
 290       break;
 291
 292    case PIPE_PRIM_QUAD_STRIP:
 293       if (llvmpipe->rasterizer->flatshade_first) {
 294          for (i = 3; i < nr; i += 2) {
 295             lp_setup_tri( setup_ctx,
 296                        get_vert(vertex_buffer, indices[i-0], stride),
 297                        get_vert(vertex_buffer, indices[i-1], stride),
 298                        get_vert(vertex_buffer, indices[i-3], stride));
 299             lp_setup_tri( setup_ctx,
 300                        get_vert(vertex_buffer, indices[i-2], stride),
 301                        get_vert(vertex_buffer, indices[i-0], stride),
 302                        get_vert(vertex_buffer, indices[i-3], stride) );
 303          }
 304       }
 305       else {
 306          for (i = 3; i < nr; i += 2) {
 307             lp_setup_tri( setup_ctx,
 308                        get_vert(vertex_buffer, indices[i-3], stride),
 309                        get_vert(vertex_buffer, indices[i-2], stride),
 310                        get_vert(vertex_buffer, indices[i-0], stride) );
 311             lp_setup_tri( setup_ctx,
 312                        get_vert(vertex_buffer, indices[i-1], stride),
 313                        get_vert(vertex_buffer, indices[i-3], stride),
 314                        get_vert(vertex_buffer, indices[i-0], stride) );
 315          }
 316       }
 317       break;
 318
 319    case PIPE_PRIM_POLYGON:
 320       /* Almost same as tri fan but the _first_ vertex specifies the flat
 321        * shading color.  Note that the first polygon vertex is passed as
 322        * the last triangle vertex here.
 323        * flatshade_first state makes no difference.
 324        */
 325       for (i = 2; i < nr; i += 1) {
 326          lp_setup_tri( setup_ctx,
 327                     get_vert(vertex_buffer, indices[i-0], stride),
 328                     get_vert(vertex_buffer, indices[i-1], stride),
 329                     get_vert(vertex_buffer, indices[0], stride) );
 330       }
 331       break;
 332
 333    default:
 334       assert(0);
 335    }
 336 }
 337
 338
 339 /**
 340  * This function is hit when the draw module is working in pass-through mode.
 341  * It's up to us to convert the vertex array into point/line/tri prims.
 342  */
 343 static void
 344 lp_vbuf_draw_arrays(struct vbuf_render *vbr, uint start, uint nr)
 345 {
 346    struct llvmpipe_vbuf_render *cvbr = llvmpipe_vbuf_render(vbr);
 347    struct llvmpipe_context *llvmpipe = cvbr->llvmpipe;
 348    struct setup_context *setup_ctx = cvbr->setup;
 349    const unsigned stride = llvmpipe->vertex_info_vbuf.size * sizeof(float);
 350    const void *vertex_buffer =
 351       (void *) get_vert(cvbr->vertex_buffer, start, stride);
 352    unsigned i;
 353
 354    switch (cvbr->prim) {
 355    case PIPE_PRIM_POINTS:
 356       for (i = 0; i < nr; i++) {
 357          lp_setup_point( setup_ctx,
 358                       get_vert(vertex_buffer, i-0, stride) );
 359       }
 360       break;
 361
 362    case PIPE_PRIM_LINES:
 363       for (i = 1; i < nr; i += 2) {
 364          lp_setup_line( setup_ctx,
 365                      get_vert(vertex_buffer, i-1, stride),
 366                      get_vert(vertex_buffer, i-0, stride) );
 367       }
 368       break;
 369
 370    case PIPE_PRIM_LINE_STRIP:
 371       for (i = 1; i < nr; i ++) {
 372          lp_setup_line( setup_ctx,
 373                      get_vert(vertex_buffer, i-1, stride),
 374                      get_vert(vertex_buffer, i-0, stride) );
 375       }
 376       break;
 377
 378    case PIPE_PRIM_LINE_LOOP:
 379       for (i = 1; i < nr; i ++) {
 380          lp_setup_line( setup_ctx,
 381                      get_vert(vertex_buffer, i-1, stride),
 382                      get_vert(vertex_buffer, i-0, stride) );
 383       }
 384       if (nr) {
 385          lp_setup_line( setup_ctx,
 386                      get_vert(vertex_buffer, nr-1, stride),
 387                      get_vert(vertex_buffer, 0, stride) );
 388       }
 389       break;
 390
 391    case PIPE_PRIM_TRIANGLES:
 392       if (llvmpipe->rasterizer->flatshade_first) {
 393          for (i = 2; i < nr; i += 3) {
 394             lp_setup_tri( setup_ctx,
 395                        get_vert(vertex_buffer, i-1, stride),
 396                        get_vert(vertex_buffer, i-0, stride),
 397                        get_vert(vertex_buffer, i-2, stride) );
 398          }
 399       }
 400       else {
 401          for (i = 2; i < nr; i += 3) {
 402             lp_setup_tri( setup_ctx,
 403                        get_vert(vertex_buffer, i-2, stride),
 404                        get_vert(vertex_buffer, i-1, stride),
 405                        get_vert(vertex_buffer, i-0, stride) );
 406          }
 407       }
 408       break;
 409
 410    case PIPE_PRIM_TRIANGLE_STRIP:
 411       if (llvmpipe->rasterizer->flatshade_first) {
 412          for (i = 2; i < nr; i++) {
 413             lp_setup_tri( setup_ctx,
 414                        get_vert(vertex_buffer, i+(i&1)-1, stride),
 415                        get_vert(vertex_buffer, i-(i&1), stride),
 416                        get_vert(vertex_buffer, i-2, stride) );
 417          }
 418       }
 419       else {
 420          for (i = 2; i < nr; i++) {
 421             lp_setup_tri( setup_ctx,
 422                        get_vert(vertex_buffer, i+(i&1)-2, stride),
 423                        get_vert(vertex_buffer, i-(i&1)-1, stride),
 424                        get_vert(vertex_buffer, i-0, stride) );
 425          }
 426       }
 427       break;
 428
 429    case PIPE_PRIM_TRIANGLE_FAN:
 430       if (llvmpipe->rasterizer->flatshade_first) {
 431          for (i = 2; i < nr; i += 1) {
 432             lp_setup_tri( setup_ctx,
 433                        get_vert(vertex_buffer, i-0, stride),
 434                        get_vert(vertex_buffer, 0, stride),
 435                        get_vert(vertex_buffer, i-1, stride) );
 436          }
 437       }
 438       else {
 439          for (i = 2; i < nr; i += 1) {
 440             lp_setup_tri( setup_ctx,
 441                        get_vert(vertex_buffer, 0, stride),
 442                        get_vert(vertex_buffer, i-1, stride),
 443                        get_vert(vertex_buffer, i-0, stride) );
 444          }
 445       }
 446       break;
 447
 448    case PIPE_PRIM_QUADS:
 449       if (llvmpipe->rasterizer->flatshade_first) {
 450          for (i = 3; i < nr; i += 4) {
 451             lp_setup_tri( setup_ctx,
 452                        get_vert(vertex_buffer, i-2, stride),
 453                        get_vert(vertex_buffer, i-1, stride),
 454                        get_vert(vertex_buffer, i-3, stride) );
 455             lp_setup_tri( setup_ctx,
 456                        get_vert(vertex_buffer, i-1, stride),
 457                        get_vert(vertex_buffer, i-0, stride),
 458                        get_vert(vertex_buffer, i-3, stride) );
 459          }
 460       }
 461       else {
 462          for (i = 3; i < nr; i += 4) {
 463             lp_setup_tri( setup_ctx,
 464                        get_vert(vertex_buffer, i-3, stride),
 465                        get_vert(vertex_buffer, i-2, stride),
 466                        get_vert(vertex_buffer, i-0, stride) );
 467             lp_setup_tri( setup_ctx,
 468                        get_vert(vertex_buffer, i-2, stride),
 469                        get_vert(vertex_buffer, i-1, stride),
 470                        get_vert(vertex_buffer, i-0, stride) );
 471          }
 472       }
 473       break;
 474
 475    case PIPE_PRIM_QUAD_STRIP:
 476       if (llvmpipe->rasterizer->flatshade_first) {
 477          for (i = 3; i < nr; i += 2) {
 478             lp_setup_tri( setup_ctx,
 479                        get_vert(vertex_buffer, i-0, stride),
 480                        get_vert(vertex_buffer, i-1, stride),
 481                        get_vert(vertex_buffer, i-3, stride) );
 482             lp_setup_tri( setup_ctx,
 483                        get_vert(vertex_buffer, i-2, stride),
 484                        get_vert(vertex_buffer, i-0, stride),
 485                        get_vert(vertex_buffer, i-3, stride) );
 486          }
 487       }
 488       else {
 489          for (i = 3; i < nr; i += 2) {
 490             lp_setup_tri( setup_ctx,
 491                        get_vert(vertex_buffer, i-3, stride),
 492                        get_vert(vertex_buffer, i-2, stride),
 493                        get_vert(vertex_buffer, i-0, stride) );
 494             lp_setup_tri( setup_ctx,
 495                        get_vert(vertex_buffer, i-1, stride),
 496                        get_vert(vertex_buffer, i-3, stride),
 497                        get_vert(vertex_buffer, i-0, stride) );
 498          }
 499       }
 500       break;
 501
 502    case PIPE_PRIM_POLYGON:
 503       /* Almost same as tri fan but the _first_ vertex specifies the flat
 504        * shading color.  Note that the first polygon vertex is passed as
 505        * the last triangle vertex here.
 506        * flatshade_first state makes no difference.
 507        */
 508       for (i = 2; i < nr; i += 1) {
 509          lp_setup_tri( setup_ctx,
 510                     get_vert(vertex_buffer, i-1, stride),
 511                     get_vert(vertex_buffer, i-0, stride),
 512                     get_vert(vertex_buffer, 0, stride) );
 513       }
 514       break;
 515
 516    default:
 517       assert(0);
 518    }
 519 }
 520
 521
 522
 523 static void
 524 lp_vbuf_destroy(struct vbuf_render *vbr)
 525 {
 526    FREE(vbr);
 527 }
 528
 529
 530 /**
 531  * Create the post-transform vertex handler for the given context.
 532  */
 533 struct vbuf_render *
 534 lp_create_vbuf_backend(struct llvmpipe_context *lp)
 535 {
 536    struct llvmpipe_vbuf_render *cvbr = CALLOC_STRUCT(llvmpipe_vbuf_render);
 537
 538    assert(lp->draw);
 539    assert(lp->setup);
 540
 541
 542    cvbr->base.max_indices = LP_MAX_VBUF_INDEXES;
 543    cvbr->base.max_vertex_buffer_bytes = LP_MAX_VBUF_SIZE;
 544
 545    cvbr->base.get_vertex_info = lp_vbuf_get_vertex_info;
 546    cvbr->base.allocate_vertices = lp_vbuf_allocate_vertices;
 547    cvbr->base.map_vertices = lp_vbuf_map_vertices;
 548    cvbr->base.unmap_vertices = lp_vbuf_unmap_vertices;
 549    cvbr->base.set_primitive = lp_vbuf_set_primitive;
 550    cvbr->base.draw = lp_vbuf_draw;
 551    cvbr->base.draw_arrays = lp_vbuf_draw_arrays;
 552    cvbr->base.release_vertices = lp_vbuf_release_vertices;
 553    cvbr->base.destroy = lp_vbuf_destroy;
 554
 555    cvbr->llvmpipe = lp;
 556    cvbr->setup = lp->setup;
 557
 558    return &cvbr->base;
 559 }