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    (void) cvbr;
 132    /* do nothing */
 133 }
 134
 135
 136 static boolean
 137 sp_vbuf_set_primitive(struct vbuf_render *vbr, unsigned prim)
 138 {
 139    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 140    struct setup_context *setup_ctx = cvbr->setup;
 141
 142    sp_setup_prepare( setup_ctx );
 143
 144    cvbr->softpipe->reduced_prim = u_reduced_prim(prim);
 145    cvbr->prim = prim;
 146    return TRUE;
 147
 148 }
 149
 150
 151 static INLINE cptrf4 get_vert( const void *vertex_buffer,
 152                                int index,
 153                                int stride )
 154 {
 155    return (cptrf4)((char *)vertex_buffer + index * stride);
 156 }
 157
 158
 159 /**
 160  * draw elements / indexed primitives
 161  */
 162 static void
 163 sp_vbuf_draw(struct vbuf_render *vbr, const ushort *indices, uint nr)
 164 {
 165    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 166    struct softpipe_context *softpipe = cvbr->softpipe;
 167    const unsigned stride = softpipe->vertex_info_vbuf.size * sizeof(float);
 168    const void *vertex_buffer = cvbr->vertex_buffer;
 169    struct setup_context *setup_ctx = cvbr->setup;
 170    unsigned i;
 171
 172    switch (cvbr->prim) {
 173    case PIPE_PRIM_POINTS:
 174       for (i = 0; i < nr; i++) {
 175          sp_setup_point( setup_ctx,
 176                       get_vert(vertex_buffer, indices[i-0], stride) );
 177       }
 178       break;
 179
 180    case PIPE_PRIM_LINES:
 181       for (i = 1; i < nr; i += 2) {
 182          sp_setup_line( setup_ctx,
 183                      get_vert(vertex_buffer, indices[i-1], stride),
 184                      get_vert(vertex_buffer, indices[i-0], stride) );
 185       }
 186       break;
 187
 188    case PIPE_PRIM_LINE_STRIP:
 189       for (i = 1; i < nr; i ++) {
 190          sp_setup_line( setup_ctx,
 191                      get_vert(vertex_buffer, indices[i-1], stride),
 192                      get_vert(vertex_buffer, indices[i-0], stride) );
 193       }
 194       break;
 195
 196    case PIPE_PRIM_LINE_LOOP:
 197       for (i = 1; i < nr; i ++) {
 198          sp_setup_line( setup_ctx,
 199                      get_vert(vertex_buffer, indices[i-1], stride),
 200                      get_vert(vertex_buffer, indices[i-0], stride) );
 201       }
 202       if (nr) {
 203          sp_setup_line( setup_ctx,
 204                      get_vert(vertex_buffer, indices[nr-1], stride),
 205                      get_vert(vertex_buffer, indices[0], stride) );
 206       }
 207       break;
 208
 209    case PIPE_PRIM_TRIANGLES:
 210       if (softpipe->rasterizer->flatshade_first) {
 211          for (i = 2; i < nr; i += 3) {
 212             sp_setup_tri( setup_ctx,
 213                        get_vert(vertex_buffer, indices[i-1], stride),
 214                        get_vert(vertex_buffer, indices[i-0], stride),
 215                        get_vert(vertex_buffer, indices[i-2], stride) );
 216          }
 217       }
 218       else {
 219          for (i = 2; i < nr; i += 3) {
 220             sp_setup_tri( setup_ctx,
 221                        get_vert(vertex_buffer, indices[i-2], stride),
 222                        get_vert(vertex_buffer, indices[i-1], stride),
 223                        get_vert(vertex_buffer, indices[i-0], stride) );
 224          }
 225       }
 226       break;
 227
 228    case PIPE_PRIM_TRIANGLE_STRIP:
 229       if (softpipe->rasterizer->flatshade_first) {
 230          for (i = 2; i < nr; i += 1) {
 231             sp_setup_tri( setup_ctx,
 232                        get_vert(vertex_buffer, indices[i+(i&1)-1], stride),
 233                        get_vert(vertex_buffer, indices[i-(i&1)], stride),
 234                        get_vert(vertex_buffer, indices[i-2], stride) );
 235          }
 236       }
 237       else {
 238          for (i = 2; i < nr; i += 1) {
 239             sp_setup_tri( setup_ctx,
 240                        get_vert(vertex_buffer, indices[i+(i&1)-2], stride),
 241                        get_vert(vertex_buffer, indices[i-(i&1)-1], stride),
 242                        get_vert(vertex_buffer, indices[i-0], stride) );
 243          }
 244       }
 245       break;
 246
 247    case PIPE_PRIM_TRIANGLE_FAN:
 248       if (softpipe->rasterizer->flatshade_first) {
 249          for (i = 2; i < nr; i += 1) {
 250             sp_setup_tri( setup_ctx,
 251                        get_vert(vertex_buffer, indices[i-0], stride),
 252                        get_vert(vertex_buffer, indices[0], stride),
 253                        get_vert(vertex_buffer, indices[i-1], stride) );
 254          }
 255       }
 256       else {
 257          for (i = 2; i < nr; i += 1) {
 258             sp_setup_tri( setup_ctx,
 259                        get_vert(vertex_buffer, indices[0], stride),
 260                        get_vert(vertex_buffer, indices[i-1], stride),
 261                        get_vert(vertex_buffer, indices[i-0], stride) );
 262          }
 263       }
 264       break;
 265
 266    case PIPE_PRIM_QUADS:
 267       for (i = 3; i < nr; i += 4) {
 268          sp_setup_tri( setup_ctx,
 269                        get_vert(vertex_buffer, indices[i-3], stride),
 270                        get_vert(vertex_buffer, indices[i-2], stride),
 271                        get_vert(vertex_buffer, indices[i-0], stride) );
 272
 273          sp_setup_tri( setup_ctx,
 274                        get_vert(vertex_buffer, indices[i-2], stride),
 275                        get_vert(vertex_buffer, indices[i-1], stride),
 276                        get_vert(vertex_buffer, indices[i-0], stride) );
 277       }
 278       break;
 279
 280    case PIPE_PRIM_QUAD_STRIP:
 281       for (i = 3; i < nr; i += 2) {
 282          sp_setup_tri( setup_ctx,
 283                        get_vert(vertex_buffer, indices[i-3], stride),
 284                        get_vert(vertex_buffer, indices[i-2], stride),
 285                        get_vert(vertex_buffer, indices[i-0], stride) );
 286          sp_setup_tri( setup_ctx,
 287                        get_vert(vertex_buffer, indices[i-1], stride),
 288                        get_vert(vertex_buffer, indices[i-3], stride),
 289                        get_vert(vertex_buffer, indices[i-0], stride) );
 290       }
 291       break;
 292
 293    case PIPE_PRIM_POLYGON:
 294       /* Almost same as tri fan but the _first_ vertex specifies the flat
 295        * shading color.  Note that the first polygon vertex is passed as
 296        * the last triangle vertex here.
 297        * flatshade_first state makes no difference.
 298        */
 299       for (i = 2; i < nr; i += 1) {
 300          sp_setup_tri( setup_ctx,
 301                     get_vert(vertex_buffer, indices[i-0], stride),
 302                     get_vert(vertex_buffer, indices[i-1], stride),
 303                     get_vert(vertex_buffer, indices[0], stride) );
 304       }
 305       break;
 306
 307    default:
 308       assert(0);
 309    }
 310 }
 311
 312
 313 /**
 314  * This function is hit when the draw module is working in pass-through mode.
 315  * It's up to us to convert the vertex array into point/line/tri prims.
 316  */
 317 static void
 318 sp_vbuf_draw_arrays(struct vbuf_render *vbr, uint start, uint nr)
 319 {
 320    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 321    struct softpipe_context *softpipe = cvbr->softpipe;
 322    struct setup_context *setup_ctx = cvbr->setup;
 323    const unsigned stride = softpipe->vertex_info_vbuf.size * sizeof(float);
 324    const void *vertex_buffer =
 325       (void *) get_vert(cvbr->vertex_buffer, start, stride);
 326    unsigned i;
 327
 328    switch (cvbr->prim) {
 329    case PIPE_PRIM_POINTS:
 330       for (i = 0; i < nr; i++) {
 331          sp_setup_point( setup_ctx,
 332                       get_vert(vertex_buffer, i-0, stride) );
 333       }
 334       break;
 335
 336    case PIPE_PRIM_LINES:
 337       for (i = 1; i < nr; i += 2) {
 338          sp_setup_line( setup_ctx,
 339                      get_vert(vertex_buffer, i-1, stride),
 340                      get_vert(vertex_buffer, i-0, stride) );
 341       }
 342       break;
 343
 344    case PIPE_PRIM_LINE_STRIP:
 345       for (i = 1; i < nr; i ++) {
 346          sp_setup_line( setup_ctx,
 347                      get_vert(vertex_buffer, i-1, stride),
 348                      get_vert(vertex_buffer, i-0, stride) );
 349       }
 350       break;
 351
 352    case PIPE_PRIM_LINE_LOOP:
 353       for (i = 1; i < nr; i ++) {
 354          sp_setup_line( setup_ctx,
 355                      get_vert(vertex_buffer, i-1, stride),
 356                      get_vert(vertex_buffer, i-0, stride) );
 357       }
 358       if (nr) {
 359          sp_setup_line( setup_ctx,
 360                      get_vert(vertex_buffer, nr-1, stride),
 361                      get_vert(vertex_buffer, 0, stride) );
 362       }
 363       break;
 364
 365    case PIPE_PRIM_TRIANGLES:
 366       if (softpipe->rasterizer->flatshade_first) {
 367          for (i = 2; i < nr; i += 3) {
 368             sp_setup_tri( setup_ctx,
 369                        get_vert(vertex_buffer, i-1, stride),
 370                        get_vert(vertex_buffer, i-0, stride),
 371                        get_vert(vertex_buffer, i-2, stride) );
 372          }
 373       }
 374       else {
 375          for (i = 2; i < nr; i += 3) {
 376             sp_setup_tri( setup_ctx,
 377                        get_vert(vertex_buffer, i-2, stride),
 378                        get_vert(vertex_buffer, i-1, stride),
 379                        get_vert(vertex_buffer, i-0, stride) );
 380          }
 381       }
 382       break;
 383
 384    case PIPE_PRIM_TRIANGLE_STRIP:
 385       if (softpipe->rasterizer->flatshade_first) {
 386          for (i = 2; i < nr; i++) {
 387             sp_setup_tri( setup_ctx,
 388                        get_vert(vertex_buffer, i+(i&1)-1, stride),
 389                        get_vert(vertex_buffer, i-(i&1), stride),
 390                        get_vert(vertex_buffer, i-2, stride) );
 391          }
 392       }
 393       else {
 394          for (i = 2; i < nr; i++) {
 395             sp_setup_tri( setup_ctx,
 396                        get_vert(vertex_buffer, i+(i&1)-2, stride),
 397                        get_vert(vertex_buffer, i-(i&1)-1, stride),
 398                        get_vert(vertex_buffer, i-0, stride) );
 399          }
 400       }
 401       break;
 402
 403    case PIPE_PRIM_TRIANGLE_FAN:
 404       if (softpipe->rasterizer->flatshade_first) {
 405          for (i = 2; i < nr; i += 1) {
 406             sp_setup_tri( setup_ctx,
 407                        get_vert(vertex_buffer, i-0, stride),
 408                        get_vert(vertex_buffer, 0, stride),
 409                        get_vert(vertex_buffer, i-1, stride) );
 410          }
 411       }
 412       else {
 413          for (i = 2; i < nr; i += 1) {
 414             sp_setup_tri( setup_ctx,
 415                        get_vert(vertex_buffer, 0, stride),
 416                        get_vert(vertex_buffer, i-1, stride),
 417                        get_vert(vertex_buffer, i-0, stride) );
 418          }
 419       }
 420       break;
 421
 422    case PIPE_PRIM_QUADS:
 423       for (i = 3; i < nr; i += 4) {
 424          sp_setup_tri( setup_ctx,
 425                        get_vert(vertex_buffer, i-3, stride),
 426                        get_vert(vertex_buffer, i-2, stride),
 427                        get_vert(vertex_buffer, i-0, stride) );
 428          sp_setup_tri( setup_ctx,
 429                        get_vert(vertex_buffer, i-2, stride),
 430                        get_vert(vertex_buffer, i-1, stride),
 431                        get_vert(vertex_buffer, i-0, stride) );
 432       }
 433       break;
 434
 435    case PIPE_PRIM_QUAD_STRIP:
 436       for (i = 3; i < nr; i += 2) {
 437          sp_setup_tri( setup_ctx,
 438                        get_vert(vertex_buffer, i-3, stride),
 439                        get_vert(vertex_buffer, i-2, stride),
 440                        get_vert(vertex_buffer, i-0, stride) );
 441          sp_setup_tri( setup_ctx,
 442                        get_vert(vertex_buffer, i-1, stride),
 443                        get_vert(vertex_buffer, i-3, stride),
 444                        get_vert(vertex_buffer, i-0, stride) );
 445       }
 446       break;
 447
 448    case PIPE_PRIM_POLYGON:
 449       /* Almost same as tri fan but the _first_ vertex specifies the flat
 450        * shading color.  Note that the first polygon vertex is passed as
 451        * the last triangle vertex here.
 452        * flatshade_first state makes no difference.
 453        */
 454       for (i = 2; i < nr; i += 1) {
 455          sp_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, 0, stride) );
 459       }
 460       break;
 461
 462    default:
 463       assert(0);
 464    }
 465 }
 466
 467
 468
 469 static void
 470 sp_vbuf_destroy(struct vbuf_render *vbr)
 471 {
 472    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 473    if(cvbr->vertex_buffer)
 474       align_free(cvbr->vertex_buffer);
 475    sp_setup_destroy_context(cvbr->setup);
 476    FREE(cvbr);
 477 }
 478
 479
 480 /**
 481  * Create the post-transform vertex handler for the given context.
 482  */
 483 struct vbuf_render *
 484 sp_create_vbuf_backend(struct softpipe_context *sp)
 485 {
 486    struct softpipe_vbuf_render *cvbr = CALLOC_STRUCT(softpipe_vbuf_render);
 487
 488    assert(sp->draw);
 489
 490    cvbr->base.max_indices = SP_MAX_VBUF_INDEXES;
 491    cvbr->base.max_vertex_buffer_bytes = SP_MAX_VBUF_SIZE;
 492
 493    cvbr->base.get_vertex_info = sp_vbuf_get_vertex_info;
 494    cvbr->base.allocate_vertices = sp_vbuf_allocate_vertices;
 495    cvbr->base.map_vertices = sp_vbuf_map_vertices;
 496    cvbr->base.unmap_vertices = sp_vbuf_unmap_vertices;
 497    cvbr->base.set_primitive = sp_vbuf_set_primitive;
 498    cvbr->base.draw = sp_vbuf_draw;
 499    cvbr->base.draw_arrays = sp_vbuf_draw_arrays;
 500    cvbr->base.release_vertices = sp_vbuf_release_vertices;
 501    cvbr->base.destroy = sp_vbuf_destroy;
 502
 503    cvbr->softpipe = sp;
 504
 505    cvbr->setup = sp_setup_create_context(cvbr->softpipe);
 506
 507    return &cvbr->base;
 508 }