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
  80
  81
  82
  83
  84 static const struct vertex_info *
  85 sp_vbuf_get_vertex_info(struct vbuf_render *vbr)
  86 {
  87    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
  88    return softpipe_get_vbuf_vertex_info(cvbr->softpipe);
  89 }
  90
  91
  92 static boolean
  93 sp_vbuf_allocate_vertices(struct vbuf_render *vbr,
  94                           ushort vertex_size, ushort nr_vertices)
  95 {
  96    struct softpipe_vbuf_render *cvbr = softpipe_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 sp_vbuf_release_vertices(struct vbuf_render *vbr)
 113 {
 114    /* keep the old allocation for next time */
 115 }
 116
 117 static void *
 118 sp_vbuf_map_vertices(struct vbuf_render *vbr)
 119 {
 120    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 121    return cvbr->vertex_buffer;
 122 }
 123
 124 static void
 125 sp_vbuf_unmap_vertices(struct vbuf_render *vbr,
 126                        ushort min_index,
 127                        ushort max_index )
 128 {
 129    struct softpipe_vbuf_render *cvbr = softpipe_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 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
 150 static INLINE cptrf4 get_vert( const void *vertex_buffer,
 151                                int index,
 152                                int stride )
 153 {
 154    return (cptrf4)((char *)vertex_buffer + index * stride);
 155 }
 156
 157
 158 /**
 159  * draw elements / indexed primitives
 160  */
 161 static void
 162 sp_vbuf_draw(struct vbuf_render *vbr, const ushort *indices, uint nr)
 163 {
 164    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 165    struct softpipe_context *softpipe = cvbr->softpipe;
 166    const unsigned stride = softpipe->vertex_info_vbuf.size * sizeof(float);
 167    const void *vertex_buffer = cvbr->vertex_buffer;
 168    struct setup_context *setup_ctx = cvbr->setup;
 169    unsigned i;
 170
 171    switch (cvbr->prim) {
 172    case PIPE_PRIM_POINTS:
 173       for (i = 0; i < nr; i++) {
 174          sp_setup_point( setup_ctx,
 175                       get_vert(vertex_buffer, indices[i-0], stride) );
 176       }
 177       break;
 178
 179    case PIPE_PRIM_LINES:
 180       for (i = 1; i < nr; i += 2) {
 181          sp_setup_line( setup_ctx,
 182                      get_vert(vertex_buffer, indices[i-1], stride),
 183                      get_vert(vertex_buffer, indices[i-0], stride) );
 184       }
 185       break;
 186
 187    case PIPE_PRIM_LINE_STRIP:
 188       for (i = 1; i < nr; i ++) {
 189          sp_setup_line( setup_ctx,
 190                      get_vert(vertex_buffer, indices[i-1], stride),
 191                      get_vert(vertex_buffer, indices[i-0], stride) );
 192       }
 193       break;
 194
 195    case PIPE_PRIM_LINE_LOOP:
 196       for (i = 1; i < nr; i ++) {
 197          sp_setup_line( setup_ctx,
 198                      get_vert(vertex_buffer, indices[i-1], stride),
 199                      get_vert(vertex_buffer, indices[i-0], stride) );
 200       }
 201       if (nr) {
 202          sp_setup_line( setup_ctx,
 203                      get_vert(vertex_buffer, indices[nr-1], stride),
 204                      get_vert(vertex_buffer, indices[0], stride) );
 205       }
 206       break;
 207
 208    case PIPE_PRIM_TRIANGLES:
 209       if (softpipe->rasterizer->flatshade_first) {
 210          for (i = 2; i < nr; i += 3) {
 211             sp_setup_tri( setup_ctx,
 212                        get_vert(vertex_buffer, indices[i-1], stride),
 213                        get_vert(vertex_buffer, indices[i-0], stride),
 214                        get_vert(vertex_buffer, indices[i-2], stride) );
 215          }
 216       }
 217       else {
 218          for (i = 2; i < nr; i += 3) {
 219             sp_setup_tri( setup_ctx,
 220                        get_vert(vertex_buffer, indices[i-2], stride),
 221                        get_vert(vertex_buffer, indices[i-1], stride),
 222                        get_vert(vertex_buffer, indices[i-0], stride) );
 223          }
 224       }
 225       break;
 226
 227    case PIPE_PRIM_TRIANGLE_STRIP:
 228       if (softpipe->rasterizer->flatshade_first) {
 229          for (i = 2; i < nr; i += 1) {
 230             sp_setup_tri( setup_ctx,
 231                        get_vert(vertex_buffer, indices[i+(i&1)-1], stride),
 232                        get_vert(vertex_buffer, indices[i-(i&1)], stride),
 233                        get_vert(vertex_buffer, indices[i-2], stride) );
 234          }
 235       }
 236       else {
 237          for (i = 2; i < nr; i += 1) {
 238             sp_setup_tri( setup_ctx,
 239                        get_vert(vertex_buffer, indices[i+(i&1)-2], stride),
 240                        get_vert(vertex_buffer, indices[i-(i&1)-1], stride),
 241                        get_vert(vertex_buffer, indices[i-0], stride) );
 242          }
 243       }
 244       break;
 245
 246    case PIPE_PRIM_TRIANGLE_FAN:
 247       if (softpipe->rasterizer->flatshade_first) {
 248          for (i = 2; i < nr; i += 1) {
 249             sp_setup_tri( setup_ctx,
 250                        get_vert(vertex_buffer, indices[i-0], stride),
 251                        get_vert(vertex_buffer, indices[0], stride),
 252                        get_vert(vertex_buffer, indices[i-1], stride) );
 253          }
 254       }
 255       else {
 256          for (i = 2; i < nr; i += 1) {
 257             sp_setup_tri( setup_ctx,
 258                        get_vert(vertex_buffer, indices[0], stride),
 259                        get_vert(vertex_buffer, indices[i-1], stride),
 260                        get_vert(vertex_buffer, indices[i-0], stride) );
 261          }
 262       }
 263       break;
 264
 265    case PIPE_PRIM_QUADS:
 266       if (softpipe->rasterizer->flatshade_first) {
 267          for (i = 3; i < nr; i += 4) {
 268             sp_setup_tri( setup_ctx,
 269                        get_vert(vertex_buffer, indices[i-2], stride),
 270                        get_vert(vertex_buffer, indices[i-1], stride),
 271                        get_vert(vertex_buffer, indices[i-3], stride) );
 272             sp_setup_tri( setup_ctx,
 273                        get_vert(vertex_buffer, indices[i-1], stride),
 274                        get_vert(vertex_buffer, indices[i-0], stride),
 275                        get_vert(vertex_buffer, indices[i-3], stride) );
 276          }
 277       }
 278       else {
 279          for (i = 3; i < nr; i += 4) {
 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
 285             sp_setup_tri( setup_ctx,
 286                        get_vert(vertex_buffer, indices[i-2], stride),
 287                        get_vert(vertex_buffer, indices[i-1], stride),
 288                        get_vert(vertex_buffer, indices[i-0], stride) );
 289          }
 290       }
 291       break;
 292
 293    case PIPE_PRIM_QUAD_STRIP:
 294       if (softpipe->rasterizer->flatshade_first) {
 295          for (i = 3; i < nr; i += 2) {
 296             sp_setup_tri( setup_ctx,
 297                        get_vert(vertex_buffer, indices[i-0], stride),
 298                        get_vert(vertex_buffer, indices[i-1], stride),
 299                        get_vert(vertex_buffer, indices[i-3], stride));
 300             sp_setup_tri( setup_ctx,
 301                        get_vert(vertex_buffer, indices[i-2], stride),
 302                        get_vert(vertex_buffer, indices[i-0], stride),
 303                        get_vert(vertex_buffer, indices[i-3], stride) );
 304          }
 305       }
 306       else {
 307          for (i = 3; i < nr; i += 2) {
 308             sp_setup_tri( setup_ctx,
 309                        get_vert(vertex_buffer, indices[i-3], stride),
 310                        get_vert(vertex_buffer, indices[i-2], stride),
 311                        get_vert(vertex_buffer, indices[i-0], stride) );
 312             sp_setup_tri( setup_ctx,
 313                        get_vert(vertex_buffer, indices[i-1], stride),
 314                        get_vert(vertex_buffer, indices[i-3], stride),
 315                        get_vert(vertex_buffer, indices[i-0], stride) );
 316          }
 317       }
 318       break;
 319
 320    case PIPE_PRIM_POLYGON:
 321       /* Almost same as tri fan but the _first_ vertex specifies the flat
 322        * shading color.  Note that the first polygon vertex is passed as
 323        * the last triangle vertex here.
 324        * flatshade_first state makes no difference.
 325        */
 326       for (i = 2; i < nr; i += 1) {
 327          sp_setup_tri( setup_ctx,
 328                     get_vert(vertex_buffer, indices[i-0], stride),
 329                     get_vert(vertex_buffer, indices[i-1], stride),
 330                     get_vert(vertex_buffer, indices[0], stride) );
 331       }
 332       break;
 333
 334    default:
 335       assert(0);
 336    }
 337 }
 338
 339
 340 /**
 341  * This function is hit when the draw module is working in pass-through mode.
 342  * It's up to us to convert the vertex array into point/line/tri prims.
 343  */
 344 static void
 345 sp_vbuf_draw_arrays(struct vbuf_render *vbr, uint start, uint nr)
 346 {
 347    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 348    struct softpipe_context *softpipe = cvbr->softpipe;
 349    struct setup_context *setup_ctx = cvbr->setup;
 350    const unsigned stride = softpipe->vertex_info_vbuf.size * sizeof(float);
 351    const void *vertex_buffer =
 352       (void *) get_vert(cvbr->vertex_buffer, start, stride);
 353    unsigned i;
 354
 355    switch (cvbr->prim) {
 356    case PIPE_PRIM_POINTS:
 357       for (i = 0; i < nr; i++) {
 358          sp_setup_point( setup_ctx,
 359                       get_vert(vertex_buffer, i-0, stride) );
 360       }
 361       break;
 362
 363    case PIPE_PRIM_LINES:
 364       for (i = 1; i < nr; i += 2) {
 365          sp_setup_line( setup_ctx,
 366                      get_vert(vertex_buffer, i-1, stride),
 367                      get_vert(vertex_buffer, i-0, stride) );
 368       }
 369       break;
 370
 371    case PIPE_PRIM_LINE_STRIP:
 372       for (i = 1; i < nr; i ++) {
 373          sp_setup_line( setup_ctx,
 374                      get_vert(vertex_buffer, i-1, stride),
 375                      get_vert(vertex_buffer, i-0, stride) );
 376       }
 377       break;
 378
 379    case PIPE_PRIM_LINE_LOOP:
 380       for (i = 1; i < nr; i ++) {
 381          sp_setup_line( setup_ctx,
 382                      get_vert(vertex_buffer, i-1, stride),
 383                      get_vert(vertex_buffer, i-0, stride) );
 384       }
 385       if (nr) {
 386          sp_setup_line( setup_ctx,
 387                      get_vert(vertex_buffer, nr-1, stride),
 388                      get_vert(vertex_buffer, 0, stride) );
 389       }
 390       break;
 391
 392    case PIPE_PRIM_TRIANGLES:
 393       if (softpipe->rasterizer->flatshade_first) {
 394          for (i = 2; i < nr; i += 3) {
 395             sp_setup_tri( setup_ctx,
 396                        get_vert(vertex_buffer, i-1, stride),
 397                        get_vert(vertex_buffer, i-0, stride),
 398                        get_vert(vertex_buffer, i-2, stride) );
 399          }
 400       }
 401       else {
 402          for (i = 2; i < nr; i += 3) {
 403             sp_setup_tri( setup_ctx,
 404                        get_vert(vertex_buffer, i-2, stride),
 405                        get_vert(vertex_buffer, i-1, stride),
 406                        get_vert(vertex_buffer, i-0, stride) );
 407          }
 408       }
 409       break;
 410
 411    case PIPE_PRIM_TRIANGLE_STRIP:
 412       if (softpipe->rasterizer->flatshade_first) {
 413          for (i = 2; i < nr; i++) {
 414             sp_setup_tri( setup_ctx,
 415                        get_vert(vertex_buffer, i+(i&1)-1, stride),
 416                        get_vert(vertex_buffer, i-(i&1), stride),
 417                        get_vert(vertex_buffer, i-2, stride) );
 418          }
 419       }
 420       else {
 421          for (i = 2; i < nr; i++) {
 422             sp_setup_tri( setup_ctx,
 423                        get_vert(vertex_buffer, i+(i&1)-2, stride),
 424                        get_vert(vertex_buffer, i-(i&1)-1, stride),
 425                        get_vert(vertex_buffer, i-0, stride) );
 426          }
 427       }
 428       break;
 429
 430    case PIPE_PRIM_TRIANGLE_FAN:
 431       if (softpipe->rasterizer->flatshade_first) {
 432          for (i = 2; i < nr; i += 1) {
 433             sp_setup_tri( setup_ctx,
 434                        get_vert(vertex_buffer, i-0, stride),
 435                        get_vert(vertex_buffer, 0, stride),
 436                        get_vert(vertex_buffer, i-1, stride) );
 437          }
 438       }
 439       else {
 440          for (i = 2; i < nr; i += 1) {
 441             sp_setup_tri( setup_ctx,
 442                        get_vert(vertex_buffer, 0, stride),
 443                        get_vert(vertex_buffer, i-1, stride),
 444                        get_vert(vertex_buffer, i-0, stride) );
 445          }
 446       }
 447       break;
 448
 449    case PIPE_PRIM_QUADS:
 450       if (softpipe->rasterizer->flatshade_first) {
 451          for (i = 3; i < nr; i += 4) {
 452             sp_setup_tri( setup_ctx,
 453                        get_vert(vertex_buffer, i-2, stride),
 454                        get_vert(vertex_buffer, i-1, stride),
 455                        get_vert(vertex_buffer, i-3, stride) );
 456             sp_setup_tri( setup_ctx,
 457                        get_vert(vertex_buffer, i-1, stride),
 458                        get_vert(vertex_buffer, i-0, stride),
 459                        get_vert(vertex_buffer, i-3, stride) );
 460          }
 461       }
 462       else {
 463          for (i = 3; i < nr; i += 4) {
 464             sp_setup_tri( setup_ctx,
 465                        get_vert(vertex_buffer, i-3, stride),
 466                        get_vert(vertex_buffer, i-2, stride),
 467                        get_vert(vertex_buffer, i-0, stride) );
 468             sp_setup_tri( setup_ctx,
 469                        get_vert(vertex_buffer, i-2, stride),
 470                        get_vert(vertex_buffer, i-1, stride),
 471                        get_vert(vertex_buffer, i-0, stride) );
 472          }
 473       }
 474       break;
 475
 476    case PIPE_PRIM_QUAD_STRIP:
 477       if (softpipe->rasterizer->flatshade_first) {
 478          for (i = 3; i < nr; i += 2) {
 479             sp_setup_tri( setup_ctx,
 480                        get_vert(vertex_buffer, i-0, stride),
 481                        get_vert(vertex_buffer, i-1, stride),
 482                        get_vert(vertex_buffer, i-3, stride) );
 483             sp_setup_tri( setup_ctx,
 484                        get_vert(vertex_buffer, i-2, stride),
 485                        get_vert(vertex_buffer, i-0, stride),
 486                        get_vert(vertex_buffer, i-3, stride) );
 487          }
 488       }
 489       else {
 490          for (i = 3; i < nr; i += 2) {
 491             sp_setup_tri( setup_ctx,
 492                        get_vert(vertex_buffer, i-3, stride),
 493                        get_vert(vertex_buffer, i-2, stride),
 494                        get_vert(vertex_buffer, i-0, stride) );
 495             sp_setup_tri( setup_ctx,
 496                        get_vert(vertex_buffer, i-1, stride),
 497                        get_vert(vertex_buffer, i-3, stride),
 498                        get_vert(vertex_buffer, i-0, stride) );
 499          }
 500       }
 501       break;
 502
 503    case PIPE_PRIM_POLYGON:
 504       /* Almost same as tri fan but the _first_ vertex specifies the flat
 505        * shading color.  Note that the first polygon vertex is passed as
 506        * the last triangle vertex here.
 507        * flatshade_first state makes no difference.
 508        */
 509       for (i = 2; i < nr; i += 1) {
 510          sp_setup_tri( setup_ctx,
 511                     get_vert(vertex_buffer, i-1, stride),
 512                     get_vert(vertex_buffer, i-0, stride),
 513                     get_vert(vertex_buffer, 0, stride) );
 514       }
 515       break;
 516
 517    default:
 518       assert(0);
 519    }
 520 }
 521
 522
 523
 524 static void
 525 sp_vbuf_destroy(struct vbuf_render *vbr)
 526 {
 527    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 528    sp_setup_destroy_context(cvbr->setup);
 529    FREE(cvbr);
 530 }
 531
 532
 533 /**
 534  * Create the post-transform vertex handler for the given context.
 535  */
 536 struct vbuf_render *
 537 sp_create_vbuf_backend(struct softpipe_context *sp)
 538 {
 539    struct softpipe_vbuf_render *cvbr = CALLOC_STRUCT(softpipe_vbuf_render);
 540
 541    assert(sp->draw);
 542
 543
 544    cvbr->base.max_indices = SP_MAX_VBUF_INDEXES;
 545    cvbr->base.max_vertex_buffer_bytes = SP_MAX_VBUF_SIZE;
 546
 547    cvbr->base.get_vertex_info = sp_vbuf_get_vertex_info;
 548    cvbr->base.allocate_vertices = sp_vbuf_allocate_vertices;
 549    cvbr->base.map_vertices = sp_vbuf_map_vertices;
 550    cvbr->base.unmap_vertices = sp_vbuf_unmap_vertices;
 551    cvbr->base.set_primitive = sp_vbuf_set_primitive;
 552    cvbr->base.draw = sp_vbuf_draw;
 553    cvbr->base.draw_arrays = sp_vbuf_draw_arrays;
 554    cvbr->base.release_vertices = sp_vbuf_release_vertices;
 555    cvbr->base.destroy = sp_vbuf_destroy;
 556
 557    cvbr->softpipe = sp;
 558
 559    cvbr->setup = sp_setup_create_context(cvbr->softpipe);
 560
 561    return &cvbr->base;
 562 }