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