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_state.h"
  41 #include "sp_prim_vbuf.h"
  42 #include "sp_prim_setup.h"
  43 #include "sp_setup.h"
  44 #include "draw/draw_context.h"
  45 #include "draw/draw_vbuf.h"
  46 #include "util/u_memory.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    uint prim;
  62    uint vertex_size;
  63    uint vertex_buffer_size;
  64    void *vertex_buffer;
  65 };
  66
  67
  68 /** cast wrapper */
  69 static struct softpipe_vbuf_render *
  70 softpipe_vbuf_render(struct vbuf_render *vbr)
  71 {
  72    return (struct softpipe_vbuf_render *) vbr;
  73 }
  74
  75
  76 static const struct vertex_info *
  77 sp_vbuf_get_vertex_info(struct vbuf_render *vbr)
  78 {
  79    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
  80    return softpipe_get_vbuf_vertex_info(cvbr->softpipe);
  81 }
  82
  83
  84 static boolean
  85 sp_vbuf_allocate_vertices(struct vbuf_render *vbr,
  86                           ushort vertex_size, ushort nr_vertices)
  87 {
  88    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
  89    unsigned size = vertex_size * nr_vertices;
  90
  91    if (cvbr->vertex_buffer_size < size) {
  92       align_free(cvbr->vertex_buffer);
  93       cvbr->vertex_buffer = align_malloc(size, 16);
  94       cvbr->vertex_buffer_size = size;
  95    }
  96
  97    cvbr->vertex_size = vertex_size;
  98    return cvbr->vertex_buffer != NULL;
  99 }
 100
 101 static void
 102 sp_vbuf_release_vertices(struct vbuf_render *vbr)
 103 {
 104    /* keep the old allocation for next time */
 105 }
 106
 107 static void *
 108 sp_vbuf_map_vertices(struct vbuf_render *vbr)
 109 {
 110    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 111    return cvbr->vertex_buffer;
 112 }
 113
 114 static void
 115 sp_vbuf_unmap_vertices(struct vbuf_render *vbr,
 116                        ushort min_index,
 117                        ushort max_index )
 118 {
 119    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 120    assert( cvbr->vertex_buffer_size >= (max_index+1) * cvbr->vertex_size );
 121    /* do nothing */
 122 }
 123
 124
 125 static boolean
 126 sp_vbuf_set_primitive(struct vbuf_render *vbr, unsigned prim)
 127 {
 128    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 129
 130    /* XXX: break this dependency - make setup_context live under
 131     * softpipe, rename the old "setup" draw stage to something else.
 132     */
 133    struct setup_context *setup_ctx = sp_draw_setup_context(cvbr->softpipe->setup);
 134
 135    setup_prepare( setup_ctx );
 136
 137    cvbr->prim = prim;
 138    return TRUE;
 139
 140 }
 141
 142
 143 static INLINE cptrf4 get_vert( const void *vertex_buffer,
 144                                int index,
 145                                int stride )
 146 {
 147    return (cptrf4)((char *)vertex_buffer + index * stride);
 148 }
 149
 150
 151 /**
 152  * draw elements / indexed primitives
 153  */
 154 static void
 155 sp_vbuf_draw(struct vbuf_render *vbr, const ushort *indices, uint nr)
 156 {
 157    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 158    struct softpipe_context *softpipe = cvbr->softpipe;
 159    const unsigned stride = softpipe->vertex_info_vbuf.size * sizeof(float);
 160    const void *vertex_buffer = cvbr->vertex_buffer;
 161    unsigned i;
 162
 163    /* XXX: break this dependency - make setup_context live under
 164     * softpipe, rename the old "setup" draw stage to something else.
 165     */
 166    struct draw_stage *setup = softpipe->setup;
 167    struct setup_context *setup_ctx = sp_draw_setup_context(setup);
 168
 169    switch (cvbr->prim) {
 170    case PIPE_PRIM_POINTS:
 171       for (i = 0; i < nr; i++) {
 172          setup_point( setup_ctx,
 173                       get_vert(vertex_buffer, indices[i-0], stride) );
 174       }
 175       break;
 176
 177    case PIPE_PRIM_LINES:
 178       for (i = 1; i < nr; i += 2) {
 179          setup_line( setup_ctx,
 180                      get_vert(vertex_buffer, indices[i-1], stride),
 181                      get_vert(vertex_buffer, indices[i-0], stride) );
 182       }
 183       break;
 184
 185    case PIPE_PRIM_LINE_STRIP:
 186       for (i = 1; i < nr; i ++) {
 187          setup_line( setup_ctx,
 188                      get_vert(vertex_buffer, indices[i-1], stride),
 189                      get_vert(vertex_buffer, indices[i-0], stride) );
 190       }
 191       break;
 192
 193    case PIPE_PRIM_LINE_LOOP:
 194       for (i = 1; i < nr; i ++) {
 195          setup_line( setup_ctx,
 196                      get_vert(vertex_buffer, indices[i-1], stride),
 197                      get_vert(vertex_buffer, indices[i-0], stride) );
 198       }
 199       if (nr) {
 200          setup_line( setup_ctx,
 201                      get_vert(vertex_buffer, indices[nr-1], stride),
 202                      get_vert(vertex_buffer, indices[0], stride) );
 203       }
 204       break;
 205
 206
 207    case PIPE_PRIM_TRIANGLES:
 208       for (i = 2; i < nr; i += 3) {
 209          setup_tri( setup_ctx,
 210                     get_vert(vertex_buffer, indices[i-2], stride),
 211                     get_vert(vertex_buffer, indices[i-1], stride),
 212                     get_vert(vertex_buffer, indices[i-0], stride));
 213       }
 214       break;
 215
 216    case PIPE_PRIM_TRIANGLE_STRIP:
 217       for (i = 2; i < nr; i += 1) {
 218          setup_tri( setup_ctx,
 219                     get_vert(vertex_buffer, indices[i+(i&1)-2], stride),
 220                     get_vert(vertex_buffer, indices[i-(i&1)-1], stride),
 221                     get_vert(vertex_buffer, indices[i-0], stride));
 222       }
 223       break;
 224
 225    case PIPE_PRIM_TRIANGLE_FAN:
 226    case PIPE_PRIM_POLYGON:
 227       for (i = 2; i < nr; i += 1) {
 228          setup_tri( setup_ctx,
 229                     get_vert(vertex_buffer, indices[0], stride),
 230                     get_vert(vertex_buffer, indices[i-1], stride),
 231                     get_vert(vertex_buffer, indices[i-0], stride));
 232       }
 233       break;
 234    case PIPE_PRIM_QUADS:
 235       for (i = 3; i < nr; i += 4) {
 236          setup_tri( setup_ctx,
 237                     get_vert(vertex_buffer, indices[i-3], stride),
 238                     get_vert(vertex_buffer, indices[i-2], stride),
 239                     get_vert(vertex_buffer, indices[i-0], stride));
 240
 241          setup_tri( setup_ctx,
 242                     get_vert(vertex_buffer, indices[i-2], stride),
 243                     get_vert(vertex_buffer, indices[i-1], stride),
 244                     get_vert(vertex_buffer, indices[i-0], stride));
 245       }
 246       break;
 247    case PIPE_PRIM_QUAD_STRIP:
 248       for (i = 3; i < nr; i += 2) {
 249          setup_tri( setup_ctx,
 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
 254          setup_tri( setup_ctx,
 255                     get_vert(vertex_buffer, indices[i-1], stride),
 256                     get_vert(vertex_buffer, indices[i-3], stride),
 257                     get_vert(vertex_buffer, indices[i-0], stride));
 258       }
 259       break;
 260    default:
 261       assert(0);
 262    }
 263
 264    /* XXX: why are we calling this???  If we had to call something, it
 265     * would be a function in sp_setup.c:
 266     */
 267    sp_draw_flush( setup );
 268 }
 269
 270
 271 /**
 272  * This function is hit when the draw module is working in pass-through mode.
 273  * It's up to us to convert the vertex array into point/line/tri prims.
 274  */
 275 static void
 276 sp_vbuf_draw_arrays(struct vbuf_render *vbr, uint start, uint nr)
 277 {
 278    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 279    struct softpipe_context *softpipe = cvbr->softpipe;
 280    const unsigned stride = softpipe->vertex_info_vbuf.size * sizeof(float);
 281    const void *vertex_buffer =
 282       (void *) get_vert(cvbr->vertex_buffer, start, stride);
 283    unsigned i;
 284
 285    /* XXX: break this dependency - make setup_context live under
 286     * softpipe, rename the old "setup" draw stage to something else.
 287     */
 288    struct draw_stage *setup = softpipe->setup;
 289    struct setup_context *setup_ctx = sp_draw_setup_context(setup);
 290
 291    switch (cvbr->prim) {
 292    case PIPE_PRIM_POINTS:
 293       for (i = 0; i < nr; i++) {
 294          setup_point( setup_ctx,
 295                       get_vert(vertex_buffer, i-0, stride) );
 296       }
 297       break;
 298
 299    case PIPE_PRIM_LINES:
 300       for (i = 1; i < nr; i += 2) {
 301          setup_line( setup_ctx,
 302                      get_vert(vertex_buffer, i-1, stride),
 303                      get_vert(vertex_buffer, i-0, stride) );
 304       }
 305       break;
 306
 307    case PIPE_PRIM_LINE_STRIP:
 308       for (i = 1; i < nr; i ++) {
 309          setup_line( setup_ctx,
 310                      get_vert(vertex_buffer, i-1, stride),
 311                      get_vert(vertex_buffer, i-0, stride) );
 312       }
 313       break;
 314
 315    case PIPE_PRIM_LINE_LOOP:
 316       for (i = 1; i < nr; i ++) {
 317          setup_line( setup_ctx,
 318                      get_vert(vertex_buffer, i-1, stride),
 319                      get_vert(vertex_buffer, i-0, stride) );
 320       }
 321       if (nr) {
 322          setup_line( setup_ctx,
 323                      get_vert(vertex_buffer, nr-1, stride),
 324                      get_vert(vertex_buffer, 0, stride) );
 325       }
 326       break;
 327
 328
 329    case PIPE_PRIM_TRIANGLES:
 330       for (i = 2; i < nr; i += 3) {
 331          setup_tri( setup_ctx,
 332                     get_vert(vertex_buffer, i-2, stride),
 333                     get_vert(vertex_buffer, i-1, stride),
 334                     get_vert(vertex_buffer, i-0, stride));
 335       }
 336       break;
 337
 338    case PIPE_PRIM_TRIANGLE_STRIP:
 339       for (i = 2; i < nr; i += 1) {
 340          setup_tri( setup_ctx,
 341                     get_vert(vertex_buffer, i+(i&1)-2, stride),
 342                     get_vert(vertex_buffer, i-(i&1)-1, stride),
 343                     get_vert(vertex_buffer, i-0, stride));
 344       }
 345       break;
 346
 347    case PIPE_PRIM_TRIANGLE_FAN:
 348    case PIPE_PRIM_POLYGON:
 349       for (i = 2; i < nr; i += 1) {
 350          setup_tri( setup_ctx,
 351                     get_vert(vertex_buffer, 0, stride),
 352                     get_vert(vertex_buffer, i-1, stride),
 353                     get_vert(vertex_buffer, i-0, stride));
 354       }
 355       break;
 356    case PIPE_PRIM_QUADS:
 357       for (i = 3; i < nr; i += 4) {
 358          setup_tri( setup_ctx,
 359                     get_vert(vertex_buffer, i-3, stride),
 360                     get_vert(vertex_buffer, i-2, stride),
 361                     get_vert(vertex_buffer, i-0, stride));
 362
 363          setup_tri( setup_ctx,
 364                     get_vert(vertex_buffer, i-2, stride),
 365                     get_vert(vertex_buffer, i-1, stride),
 366                     get_vert(vertex_buffer, i-0, stride));
 367       }
 368       break;
 369    case PIPE_PRIM_QUAD_STRIP:
 370       for (i = 3; i < nr; i += 2) {
 371          setup_tri( setup_ctx,
 372                     get_vert(vertex_buffer, i-3, stride),
 373                     get_vert(vertex_buffer, i-2, stride),
 374                     get_vert(vertex_buffer, i-0, stride));
 375
 376          setup_tri( setup_ctx,
 377                     get_vert(vertex_buffer, i-1, stride),
 378                     get_vert(vertex_buffer, i-3, stride),
 379                     get_vert(vertex_buffer, i-0, stride));
 380       }
 381       break;
 382    default:
 383       assert(0);
 384    }
 385 }
 386
 387
 388
 389 static void
 390 sp_vbuf_destroy(struct vbuf_render *vbr)
 391 {
 392    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 393    cvbr->softpipe->vbuf_render = NULL;
 394    FREE(cvbr);
 395 }
 396
 397
 398 /**
 399  * Initialize the post-transform vertex buffer information for the given
 400  * context.
 401  */
 402 void
 403 sp_init_vbuf(struct softpipe_context *sp)
 404 {
 405    assert(sp->draw);
 406
 407    sp->vbuf_render = CALLOC_STRUCT(softpipe_vbuf_render);
 408
 409    sp->vbuf_render->base.max_indices = SP_MAX_VBUF_INDEXES;
 410    sp->vbuf_render->base.max_vertex_buffer_bytes = SP_MAX_VBUF_SIZE;
 411
 412    sp->vbuf_render->base.get_vertex_info = sp_vbuf_get_vertex_info;
 413    sp->vbuf_render->base.allocate_vertices = sp_vbuf_allocate_vertices;
 414    sp->vbuf_render->base.map_vertices = sp_vbuf_map_vertices;
 415    sp->vbuf_render->base.unmap_vertices = sp_vbuf_unmap_vertices;
 416    sp->vbuf_render->base.set_primitive = sp_vbuf_set_primitive;
 417    sp->vbuf_render->base.draw = sp_vbuf_draw;
 418    sp->vbuf_render->base.draw_arrays = sp_vbuf_draw_arrays;
 419    sp->vbuf_render->base.release_vertices = sp_vbuf_release_vertices;
 420    sp->vbuf_render->base.destroy = sp_vbuf_destroy;
 421
 422    sp->vbuf_render->softpipe = sp;
 423
 424    sp->vbuf = draw_vbuf_stage(sp->draw, &sp->vbuf_render->base);
 425
 426    draw_set_rasterize_stage(sp->draw, sp->vbuf);
 427
 428    draw_set_render(sp->draw, &sp->vbuf_render->base);
 429 }