src/gallium/drivers/softpipe/sp_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 softpipe 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 "sp_context.h"
  40 #include "sp_setup.h"
  41 #include "sp_state.h"
  42 #include "sp_prim_vbuf.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 SP_MAX_VBUF_INDEXES 1024
  50 #define SP_MAX_VBUF_SIZE    4096
  51
  52 typedef const float (*cptrf4)[4];
  53
  54 /**
  55  * Subclass of vbuf_render.
  56  */
  57 struct softpipe_vbuf_render
  58 {
  59    struct vbuf_render base;
  60    struct softpipe_context *softpipe;
  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 softpipe_vbuf_render *
  73 softpipe_vbuf_render(struct vbuf_render *vbr)
  74 {
  75    return (struct softpipe_vbuf_render *) vbr;
  76 }
  77
  78
  79 /** This tells the draw module about our desired vertex layout */
  80 static const struct vertex_info *
  81 sp_vbuf_get_vertex_info(struct vbuf_render *vbr)
  82 {
  83    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
  84    return softpipe_get_vbuf_vertex_info(cvbr->softpipe);
  85 }
  86
  87
  88 static boolean
  89 sp_vbuf_allocate_vertices(struct vbuf_render *vbr,
  90                           ushort vertex_size, ushort nr_vertices)
  91 {
  92    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
  93    unsigned size = vertex_size * nr_vertices;
  94
  95    if (cvbr->vertex_buffer_size < size) {
  96       align_free(cvbr->vertex_buffer);
  97       cvbr->vertex_buffer = align_malloc(size, 16);
  98       cvbr->vertex_buffer_size = size;
  99    }
 100
 101    cvbr->vertex_size = vertex_size;
 102    cvbr->nr_vertices = nr_vertices;
 103
 104    return cvbr->vertex_buffer != NULL;
 105 }
 106
 107
 108 static void
 109 sp_vbuf_release_vertices(struct vbuf_render *vbr)
 110 {
 111    /* keep the old allocation for next time */
 112 }
 113
 114
 115 static void *
 116 sp_vbuf_map_vertices(struct vbuf_render *vbr)
 117 {
 118    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 119    return cvbr->vertex_buffer;
 120 }
 121
 122
 123 static void
 124 sp_vbuf_unmap_vertices(struct vbuf_render *vbr,
 125                        ushort min_index,
 126                        ushort max_index )
 127 {
 128    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 129    assert( cvbr->vertex_buffer_size >= (max_index+1) * cvbr->vertex_size );
 130    (void) cvbr;
 131    /* do nothing */
 132 }
 133
 134
 135 static boolean
 136 sp_vbuf_set_primitive(struct vbuf_render *vbr, unsigned prim)
 137 {
 138    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 139    struct setup_context *setup_ctx = cvbr->setup;
 140
 141    sp_setup_prepare( setup_ctx );
 142
 143    cvbr->softpipe->reduced_prim = u_reduced_prim(prim);
 144    cvbr->prim = prim;
 145    return TRUE;
 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 sp_vbuf_draw(struct vbuf_render *vbr, const ushort *indices, uint nr)
 162 {
 163    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 164    struct softpipe_context *softpipe = cvbr->softpipe;
 165    const unsigned stride = softpipe->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          sp_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          sp_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          sp_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          sp_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          sp_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 (softpipe->rasterizer->flatshade_first) {
 209          for (i = 2; i < nr; i += 3) {
 210             sp_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             sp_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 (softpipe->rasterizer->flatshade_first) {
 228          for (i = 2; i < nr; i += 1) {
 229             sp_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             sp_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 (softpipe->rasterizer->flatshade_first) {
 247          for (i = 2; i < nr; i += 1) {
 248             sp_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             sp_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       for (i = 3; i < nr; i += 4) {
 266          sp_setup_tri( setup_ctx,
 267                        get_vert(vertex_buffer, indices[i-3], stride),
 268                        get_vert(vertex_buffer, indices[i-2], stride),
 269                        get_vert(vertex_buffer, indices[i-0], stride) );
 270
 271          sp_setup_tri( setup_ctx,
 272                        get_vert(vertex_buffer, indices[i-2], stride),
 273                        get_vert(vertex_buffer, indices[i-1], stride),
 274                        get_vert(vertex_buffer, indices[i-0], stride) );
 275       }
 276       break;
 277
 278    case PIPE_PRIM_QUAD_STRIP:
 279       for (i = 3; i < nr; i += 2) {
 280          sp_setup_tri( setup_ctx,
 281                        get_vert(vertex_buffer, indices[i-3], stride),
 282                        get_vert(vertex_buffer, indices[i-2], stride),
 283                        get_vert(vertex_buffer, indices[i-0], stride) );
 284          sp_setup_tri( setup_ctx,
 285                        get_vert(vertex_buffer, indices[i-1], stride),
 286                        get_vert(vertex_buffer, indices[i-3], stride),
 287                        get_vert(vertex_buffer, indices[i-0], stride) );
 288       }
 289       break;
 290
 291    case PIPE_PRIM_POLYGON:
 292       /* Almost same as tri fan but the _first_ vertex specifies the flat
 293        * shading color.  Note that the first polygon vertex is passed as
 294        * the last triangle vertex here.
 295        * flatshade_first state makes no difference.
 296        */
 297       for (i = 2; i < nr; i += 1) {
 298          sp_setup_tri( setup_ctx,
 299                        get_vert(vertex_buffer, indices[i-0], stride),
 300                        get_vert(vertex_buffer, indices[i-1], stride),
 301                        get_vert(vertex_buffer, indices[0], stride) );
 302       }
 303       break;
 304
 305    default:
 306       assert(0);
 307    }
 308 }
 309
 310
 311 /**
 312  * This function is hit when the draw module is working in pass-through mode.
 313  * It's up to us to convert the vertex array into point/line/tri prims.
 314  */
 315 static void
 316 sp_vbuf_draw_arrays(struct vbuf_render *vbr, uint start, uint nr)
 317 {
 318    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 319    struct softpipe_context *softpipe = cvbr->softpipe;
 320    struct setup_context *setup_ctx = cvbr->setup;
 321    const unsigned stride = softpipe->vertex_info_vbuf.size * sizeof(float);
 322    const void *vertex_buffer =
 323       (void *) get_vert(cvbr->vertex_buffer, start, stride);
 324    unsigned i;
 325
 326    switch (cvbr->prim) {
 327    case PIPE_PRIM_POINTS:
 328       for (i = 0; i < nr; i++) {
 329          sp_setup_point( setup_ctx,
 330                          get_vert(vertex_buffer, i-0, stride) );
 331       }
 332       break;
 333
 334    case PIPE_PRIM_LINES:
 335       for (i = 1; i < nr; i += 2) {
 336          sp_setup_line( setup_ctx,
 337                         get_vert(vertex_buffer, i-1, stride),
 338                         get_vert(vertex_buffer, i-0, stride) );
 339       }
 340       break;
 341
 342    case PIPE_PRIM_LINE_STRIP:
 343       for (i = 1; i < nr; i ++) {
 344          sp_setup_line( setup_ctx,
 345                      get_vert(vertex_buffer, i-1, stride),
 346                      get_vert(vertex_buffer, i-0, stride) );
 347       }
 348       break;
 349
 350    case PIPE_PRIM_LINE_LOOP:
 351       for (i = 1; i < nr; i ++) {
 352          sp_setup_line( setup_ctx,
 353                         get_vert(vertex_buffer, i-1, stride),
 354                         get_vert(vertex_buffer, i-0, stride) );
 355       }
 356       if (nr) {
 357          sp_setup_line( setup_ctx,
 358                         get_vert(vertex_buffer, nr-1, stride),
 359                         get_vert(vertex_buffer, 0, stride) );
 360       }
 361       break;
 362
 363    case PIPE_PRIM_TRIANGLES:
 364       if (softpipe->rasterizer->flatshade_first) {
 365          for (i = 2; i < nr; i += 3) {
 366             sp_setup_tri( setup_ctx,
 367                           get_vert(vertex_buffer, i-1, stride),
 368                           get_vert(vertex_buffer, i-0, stride),
 369                           get_vert(vertex_buffer, i-2, stride) );
 370          }
 371       }
 372       else {
 373          for (i = 2; i < nr; i += 3) {
 374             sp_setup_tri( setup_ctx,
 375                           get_vert(vertex_buffer, i-2, stride),
 376                           get_vert(vertex_buffer, i-1, stride),
 377                           get_vert(vertex_buffer, i-0, stride) );
 378          }
 379       }
 380       break;
 381
 382    case PIPE_PRIM_TRIANGLE_STRIP:
 383       if (softpipe->rasterizer->flatshade_first) {
 384          for (i = 2; i < nr; i++) {
 385             sp_setup_tri( setup_ctx,
 386                           get_vert(vertex_buffer, i+(i&1)-1, stride),
 387                           get_vert(vertex_buffer, i-(i&1), stride),
 388                           get_vert(vertex_buffer, i-2, stride) );
 389          }
 390       }
 391       else {
 392          for (i = 2; i < nr; i++) {
 393             sp_setup_tri( setup_ctx,
 394                           get_vert(vertex_buffer, i+(i&1)-2, stride),
 395                           get_vert(vertex_buffer, i-(i&1)-1, stride),
 396                           get_vert(vertex_buffer, i-0, stride) );
 397          }
 398       }
 399       break;
 400
 401    case PIPE_PRIM_TRIANGLE_FAN:
 402       if (softpipe->rasterizer->flatshade_first) {
 403          for (i = 2; i < nr; i += 1) {
 404             sp_setup_tri( setup_ctx,
 405                           get_vert(vertex_buffer, i-0, stride),
 406                           get_vert(vertex_buffer, 0, stride),
 407                           get_vert(vertex_buffer, i-1, stride) );
 408          }
 409       }
 410       else {
 411          for (i = 2; i < nr; i += 1) {
 412             sp_setup_tri( setup_ctx,
 413                           get_vert(vertex_buffer, 0, stride),
 414                           get_vert(vertex_buffer, i-1, stride),
 415                           get_vert(vertex_buffer, i-0, stride) );
 416          }
 417       }
 418       break;
 419
 420    case PIPE_PRIM_QUADS:
 421       for (i = 3; i < nr; i += 4) {
 422          sp_setup_tri( setup_ctx,
 423                        get_vert(vertex_buffer, i-3, stride),
 424                        get_vert(vertex_buffer, i-2, stride),
 425                        get_vert(vertex_buffer, i-0, stride) );
 426          sp_setup_tri( setup_ctx,
 427                        get_vert(vertex_buffer, i-2, stride),
 428                        get_vert(vertex_buffer, i-1, stride),
 429                        get_vert(vertex_buffer, i-0, stride) );
 430       }
 431       break;
 432
 433    case PIPE_PRIM_QUAD_STRIP:
 434       for (i = 3; i < nr; i += 2) {
 435          sp_setup_tri( setup_ctx,
 436                        get_vert(vertex_buffer, i-3, stride),
 437                        get_vert(vertex_buffer, i-2, stride),
 438                        get_vert(vertex_buffer, i-0, stride) );
 439          sp_setup_tri( setup_ctx,
 440                        get_vert(vertex_buffer, i-1, stride),
 441                        get_vert(vertex_buffer, i-3, stride),
 442                        get_vert(vertex_buffer, i-0, stride) );
 443       }
 444       break;
 445
 446    case PIPE_PRIM_POLYGON:
 447       /* Almost same as tri fan but the _first_ vertex specifies the flat
 448        * shading color.  Note that the first polygon vertex is passed as
 449        * the last triangle vertex here.
 450        * flatshade_first state makes no difference.
 451        */
 452       for (i = 2; i < nr; i += 1) {
 453          sp_setup_tri( setup_ctx,
 454                        get_vert(vertex_buffer, i-1, stride),
 455                        get_vert(vertex_buffer, i-0, stride),
 456                        get_vert(vertex_buffer, 0, stride) );
 457       }
 458       break;
 459
 460    default:
 461       assert(0);
 462    }
 463 }
 464
 465
 466 static void
 467 sp_vbuf_destroy(struct vbuf_render *vbr)
 468 {
 469    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 470    if (cvbr->vertex_buffer)
 471       align_free(cvbr->vertex_buffer);
 472    sp_setup_destroy_context(cvbr->setup);
 473    FREE(cvbr);
 474 }
 475
 476
 477 /**
 478  * Create the post-transform vertex handler for the given context.
 479  */
 480 struct vbuf_render *
 481 sp_create_vbuf_backend(struct softpipe_context *sp)
 482 {
 483    struct softpipe_vbuf_render *cvbr = CALLOC_STRUCT(softpipe_vbuf_render);
 484
 485    assert(sp->draw);
 486
 487    cvbr->base.max_indices = SP_MAX_VBUF_INDEXES;
 488    cvbr->base.max_vertex_buffer_bytes = SP_MAX_VBUF_SIZE;
 489
 490    cvbr->base.get_vertex_info = sp_vbuf_get_vertex_info;
 491    cvbr->base.allocate_vertices = sp_vbuf_allocate_vertices;
 492    cvbr->base.map_vertices = sp_vbuf_map_vertices;
 493    cvbr->base.unmap_vertices = sp_vbuf_unmap_vertices;
 494    cvbr->base.set_primitive = sp_vbuf_set_primitive;
 495    cvbr->base.draw = sp_vbuf_draw;
 496    cvbr->base.draw_arrays = sp_vbuf_draw_arrays;
 497    cvbr->base.release_vertices = sp_vbuf_release_vertices;
 498    cvbr->base.destroy = sp_vbuf_destroy;
 499
 500    cvbr->softpipe = sp;
 501
 502    cvbr->setup = sp_setup_create_context(cvbr->softpipe);
 503
 504    return &cvbr->base;
 505 }