src/gallium/drivers/llvmpipe/lp_setup_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_setup_context.h"
  40 #include "draw/draw_vbuf.h"
  41 #include "draw/draw_vertex.h"
  42 #include "util/u_memory.h"
  43
  44
  45 #define LP_MAX_VBUF_INDEXES 1024
  46 #define LP_MAX_VBUF_SIZE    4096
  47
  48
  49
  50 /** cast wrapper */
  51 static struct lp_setup_context *
  52 lp_setup_context(struct vbuf_render *vbr)
  53 {
  54    return (struct lp_setup_context *) vbr;
  55 }
  56
  57
  58
  59 static const struct vertex_info *
  60 lp_setup_get_vertex_info(struct vbuf_render *vbr)
  61 {
  62    struct lp_setup_context *setup = lp_setup_context(vbr);
  63    return setup->vertex_info;
  64 }
  65
  66
  67 static boolean
  68 lp_setup_allocate_vertices(struct vbuf_render *vbr,
  69                           ushort vertex_size, ushort nr_vertices)
  70 {
  71    struct lp_setup_context *setup = lp_setup_context(vbr);
  72    unsigned size = vertex_size * nr_vertices;
  73
  74    if (setup->vertex_buffer_size < size) {
  75       align_free(setup->vertex_buffer);
  76       setup->vertex_buffer = align_malloc(size, 16);
  77       setup->vertex_buffer_size = size;
  78    }
  79
  80    setup->vertex_size = vertex_size;
  81    setup->nr_vertices = nr_vertices;
  82
  83    return setup->vertex_buffer != NULL;
  84 }
  85
  86 static void
  87 lp_setup_release_vertices(struct vbuf_render *vbr)
  88 {
  89    /* keep the old allocation for next time */
  90 }
  91
  92 static void *
  93 lp_setup_map_vertices(struct vbuf_render *vbr)
  94 {
  95    struct lp_setup_context *setup = lp_setup_context(vbr);
  96    return setup->vertex_buffer;
  97 }
  98
  99 static void
 100 lp_setup_unmap_vertices(struct vbuf_render *vbr,
 101                        ushort min_index,
 102                        ushort max_index )
 103 {
 104    struct lp_setup_context *setup = lp_setup_context(vbr);
 105    assert( setup->vertex_buffer_size >= (max_index+1) * setup->vertex_size );
 106    /* do nothing */
 107 }
 108
 109
 110 static boolean
 111 lp_setup_set_primitive(struct vbuf_render *vbr, unsigned prim)
 112 {
 113    lp_setup_context(vbr)->prim = prim;
 114    return TRUE;
 115 }
 116
 117 typedef const float (*const_float4_ptr)[4];
 118
 119 static INLINE const_float4_ptr get_vert( const void *vertex_buffer,
 120                                          int index,
 121                                          int stride )
 122 {
 123    return (const_float4_ptr)((char *)vertex_buffer + index * stride);
 124 }
 125
 126 /**
 127  * draw elements / indexed primitives
 128  */
 129 static void
 130 lp_setup_draw(struct vbuf_render *vbr, const ushort *indices, uint nr)
 131 {
 132    struct lp_setup_context *setup = lp_setup_context(vbr);
 133    const unsigned stride = setup->vertex_info->size * sizeof(float);
 134    const void *vertex_buffer = setup->vertex_buffer;
 135    unsigned i;
 136
 137    lp_setup_update_state(setup);
 138
 139    switch (setup->prim) {
 140    case PIPE_PRIM_POINTS:
 141       for (i = 0; i < nr; i++) {
 142          setup->point( setup,
 143                        get_vert(vertex_buffer, indices[i-0], stride) );
 144       }
 145       break;
 146
 147    case PIPE_PRIM_LINES:
 148       for (i = 1; i < nr; i += 2) {
 149          setup->line( setup,
 150                       get_vert(vertex_buffer, indices[i-1], stride),
 151                       get_vert(vertex_buffer, indices[i-0], stride) );
 152       }
 153       break;
 154
 155    case PIPE_PRIM_LINE_STRIP:
 156       for (i = 1; i < nr; i ++) {
 157          setup->line( setup,
 158                       get_vert(vertex_buffer, indices[i-1], stride),
 159                       get_vert(vertex_buffer, indices[i-0], stride) );
 160       }
 161       break;
 162
 163    case PIPE_PRIM_LINE_LOOP:
 164       for (i = 1; i < nr; i ++) {
 165          setup->line( setup,
 166                       get_vert(vertex_buffer, indices[i-1], stride),
 167                       get_vert(vertex_buffer, indices[i-0], stride) );
 168       }
 169       if (nr) {
 170          setup->line( setup,
 171                       get_vert(vertex_buffer, indices[nr-1], stride),
 172                       get_vert(vertex_buffer, indices[0], stride) );
 173       }
 174       break;
 175
 176    case PIPE_PRIM_TRIANGLES:
 177       if (setup->flatshade_first) {
 178          for (i = 2; i < nr; i += 3) {
 179             setup->triangle( setup,
 180                              get_vert(vertex_buffer, indices[i-1], stride),
 181                              get_vert(vertex_buffer, indices[i-0], stride),
 182                              get_vert(vertex_buffer, indices[i-2], stride) );
 183          }
 184       }
 185       else {
 186          for (i = 2; i < nr; i += 3) {
 187             setup->triangle( setup,
 188                              get_vert(vertex_buffer, indices[i-2], stride),
 189                              get_vert(vertex_buffer, indices[i-1], stride),
 190                              get_vert(vertex_buffer, indices[i-0], stride) );
 191          }
 192       }
 193       break;
 194
 195    case PIPE_PRIM_TRIANGLE_STRIP:
 196       if (setup->flatshade_first) {
 197          for (i = 2; i < nr; i += 1) {
 198             setup->triangle( setup,
 199                              get_vert(vertex_buffer, indices[i+(i&1)-1], stride),
 200                              get_vert(vertex_buffer, indices[i-(i&1)], stride),
 201                              get_vert(vertex_buffer, indices[i-2], stride) );
 202          }
 203       }
 204       else {
 205          for (i = 2; i < nr; i += 1) {
 206             setup->triangle( setup,
 207                              get_vert(vertex_buffer, indices[i+(i&1)-2], stride),
 208                              get_vert(vertex_buffer, indices[i-(i&1)-1], stride),
 209                              get_vert(vertex_buffer, indices[i-0], stride) );
 210          }
 211       }
 212       break;
 213
 214    case PIPE_PRIM_TRIANGLE_FAN:
 215       if (setup->flatshade_first) {
 216          for (i = 2; i < nr; i += 1) {
 217             setup->triangle( setup,
 218                              get_vert(vertex_buffer, indices[i-0], stride),
 219                              get_vert(vertex_buffer, indices[0], stride),
 220                              get_vert(vertex_buffer, indices[i-1], stride) );
 221          }
 222       }
 223       else {
 224          for (i = 2; i < nr; i += 1) {
 225             setup->triangle( setup,
 226                              get_vert(vertex_buffer, indices[0], stride),
 227                              get_vert(vertex_buffer, indices[i-1], stride),
 228                              get_vert(vertex_buffer, indices[i-0], stride) );
 229          }
 230       }
 231       break;
 232
 233    case PIPE_PRIM_QUADS:
 234       for (i = 3; i < nr; i += 4) {
 235          setup->triangle( setup,
 236                           get_vert(vertex_buffer, indices[i-3], stride),
 237                           get_vert(vertex_buffer, indices[i-2], stride),
 238                           get_vert(vertex_buffer, indices[i-0], stride) );
 239
 240          setup->triangle( setup,
 241                           get_vert(vertex_buffer, indices[i-2], stride),
 242                           get_vert(vertex_buffer, indices[i-1], stride),
 243                           get_vert(vertex_buffer, indices[i-0], stride) );
 244       }
 245       break;
 246
 247    case PIPE_PRIM_QUAD_STRIP:
 248       for (i = 3; i < nr; i += 2) {
 249          setup->triangle( setup,
 250                           get_vert(vertex_buffer, indices[i-3], stride),
 251                           get_vert(vertex_buffer, indices[i-2], stride),
 252                           get_vert(vertex_buffer, indices[i-0], stride) );
 253          setup->triangle( setup,
 254                           get_vert(vertex_buffer, indices[i-1], stride),
 255                           get_vert(vertex_buffer, indices[i-3], stride),
 256                           get_vert(vertex_buffer, indices[i-0], stride) );
 257       }
 258       break;
 259
 260    case PIPE_PRIM_POLYGON:
 261       /* Almost same as tri fan but the _first_ vertex specifies the flat
 262        * shading color.  Note that the first polygon vertex is passed as
 263        * the last triangle vertex here.
 264        * flatshade_first state makes no difference.
 265        */
 266       for (i = 2; i < nr; i += 1) {
 267          setup->triangle( setup,
 268                           get_vert(vertex_buffer, indices[i-0], stride),
 269                           get_vert(vertex_buffer, indices[i-1], stride),
 270                           get_vert(vertex_buffer, indices[0], stride) );
 271       }
 272       break;
 273
 274    default:
 275       assert(0);
 276    }
 277 }
 278
 279
 280 /**
 281  * This function is hit when the draw module is working in pass-through mode.
 282  * It's up to us to convert the vertex array into point/line/tri prims.
 283  */
 284 static void
 285 lp_setup_draw_arrays(struct vbuf_render *vbr, uint start, uint nr)
 286 {
 287    struct lp_setup_context *setup = lp_setup_context(vbr);
 288    const unsigned stride = setup->vertex_info->size * sizeof(float);
 289    const void *vertex_buffer =
 290       (void *) get_vert(setup->vertex_buffer, start, stride);
 291    unsigned i;
 292
 293    lp_setup_update_state(setup);
 294
 295    switch (setup->prim) {
 296    case PIPE_PRIM_POINTS:
 297       for (i = 0; i < nr; i++) {
 298          setup->point( setup,
 299                        get_vert(vertex_buffer, i-0, stride) );
 300       }
 301       break;
 302
 303    case PIPE_PRIM_LINES:
 304       for (i = 1; i < nr; i += 2) {
 305          setup->line( setup,
 306                       get_vert(vertex_buffer, i-1, stride),
 307                       get_vert(vertex_buffer, i-0, stride) );
 308       }
 309       break;
 310
 311    case PIPE_PRIM_LINE_STRIP:
 312       for (i = 1; i < nr; i ++) {
 313          setup->line( setup,
 314                       get_vert(vertex_buffer, i-1, stride),
 315                       get_vert(vertex_buffer, i-0, stride) );
 316       }
 317       break;
 318
 319    case PIPE_PRIM_LINE_LOOP:
 320       for (i = 1; i < nr; i ++) {
 321          setup->line( setup,
 322                       get_vert(vertex_buffer, i-1, stride),
 323                       get_vert(vertex_buffer, i-0, stride) );
 324       }
 325       if (nr) {
 326          setup->line( setup,
 327                       get_vert(vertex_buffer, nr-1, stride),
 328                       get_vert(vertex_buffer, 0, stride) );
 329       }
 330       break;
 331
 332    case PIPE_PRIM_TRIANGLES:
 333       if (setup->flatshade_first) {
 334          for (i = 2; i < nr; i += 3) {
 335             setup->triangle( setup,
 336                              get_vert(vertex_buffer, i-1, stride),
 337                              get_vert(vertex_buffer, i-0, stride),
 338                              get_vert(vertex_buffer, i-2, stride) );
 339          }
 340       }
 341       else {
 342          for (i = 2; i < nr; i += 3) {
 343             setup->triangle( setup,
 344                              get_vert(vertex_buffer, i-2, stride),
 345                              get_vert(vertex_buffer, i-1, stride),
 346                              get_vert(vertex_buffer, i-0, stride) );
 347          }
 348       }
 349       break;
 350
 351    case PIPE_PRIM_TRIANGLE_STRIP:
 352       if (setup->flatshade_first) {
 353          for (i = 2; i < nr; i++) {
 354             setup->triangle( setup,
 355                              get_vert(vertex_buffer, i+(i&1)-1, stride),
 356                              get_vert(vertex_buffer, i-(i&1), stride),
 357                              get_vert(vertex_buffer, i-2, stride) );
 358          }
 359       }
 360       else {
 361          for (i = 2; i < nr; i++) {
 362             setup->triangle( setup,
 363                              get_vert(vertex_buffer, i+(i&1)-2, stride),
 364                              get_vert(vertex_buffer, i-(i&1)-1, stride),
 365                              get_vert(vertex_buffer, i-0, stride) );
 366          }
 367       }
 368       break;
 369
 370    case PIPE_PRIM_TRIANGLE_FAN:
 371       if (setup->flatshade_first) {
 372          for (i = 2; i < nr; i += 1) {
 373             setup->triangle( setup,
 374                              get_vert(vertex_buffer, i-0, stride),
 375                              get_vert(vertex_buffer, 0, stride),
 376                              get_vert(vertex_buffer, i-1, stride) );
 377          }
 378       }
 379       else {
 380          for (i = 2; i < nr; i += 1) {
 381             setup->triangle( setup,
 382                              get_vert(vertex_buffer, 0, stride),
 383                              get_vert(vertex_buffer, i-1, stride),
 384                              get_vert(vertex_buffer, i-0, stride) );
 385          }
 386       }
 387       break;
 388
 389    case PIPE_PRIM_QUADS:
 390       for (i = 3; i < nr; i += 4) {
 391          setup->triangle( setup,
 392                           get_vert(vertex_buffer, i-3, stride),
 393                           get_vert(vertex_buffer, i-2, stride),
 394                           get_vert(vertex_buffer, i-0, stride) );
 395          setup->triangle( setup,
 396                           get_vert(vertex_buffer, i-2, stride),
 397                           get_vert(vertex_buffer, i-1, stride),
 398                           get_vert(vertex_buffer, i-0, stride) );
 399       }
 400       break;
 401
 402    case PIPE_PRIM_QUAD_STRIP:
 403       for (i = 3; i < nr; i += 2) {
 404          setup->triangle( setup,
 405                           get_vert(vertex_buffer, i-3, stride),
 406                           get_vert(vertex_buffer, i-2, stride),
 407                           get_vert(vertex_buffer, i-0, stride) );
 408          setup->triangle( setup,
 409                           get_vert(vertex_buffer, i-1, stride),
 410                           get_vert(vertex_buffer, i-3, stride),
 411                           get_vert(vertex_buffer, i-0, stride) );
 412       }
 413       break;
 414
 415    case PIPE_PRIM_POLYGON:
 416       /* Almost same as tri fan but the _first_ vertex specifies the flat
 417        * shading color.  Note that the first polygon vertex is passed as
 418        * the last triangle vertex here.
 419        * flatshade_first state makes no difference.
 420        */
 421       for (i = 2; i < nr; i += 1) {
 422          setup->triangle( setup,
 423                           get_vert(vertex_buffer, i-1, stride),
 424                           get_vert(vertex_buffer, i-0, stride),
 425                           get_vert(vertex_buffer, 0, stride) );
 426       }
 427       break;
 428
 429    default:
 430       assert(0);
 431    }
 432 }
 433
 434
 435
 436 static void
 437 lp_setup_vbuf_destroy(struct vbuf_render *vbr)
 438 {
 439    lp_setup_destroy(lp_setup_context(vbr));
 440 }
 441
 442
 443 /**
 444  * Create the post-transform vertex handler for the given context.
 445  */
 446 void
 447 lp_setup_init_vbuf(struct lp_setup_context *setup)
 448 {
 449    setup->base.max_indices = LP_MAX_VBUF_INDEXES;
 450    setup->base.max_vertex_buffer_bytes = LP_MAX_VBUF_SIZE;
 451
 452    setup->base.get_vertex_info = lp_setup_get_vertex_info;
 453    setup->base.allocate_vertices = lp_setup_allocate_vertices;
 454    setup->base.map_vertices = lp_setup_map_vertices;
 455    setup->base.unmap_vertices = lp_setup_unmap_vertices;
 456    setup->base.set_primitive = lp_setup_set_primitive;
 457    setup->base.draw = lp_setup_draw;
 458    setup->base.draw_arrays = lp_setup_draw_arrays;
 459    setup->base.release_vertices = lp_setup_release_vertices;
 460    setup->base.destroy = lp_setup_vbuf_destroy;
 461 }