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  * Post-transform vertex buffering.  This is an optional part of the
  30  * softpipe rendering pipeline.
  31  * Probably not desired in general, but useful for testing/debuggin.
  32  * Enabled/Disabled with SP_VBUF env var.
  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 static void
 135 sp_vbuf_draw(struct vbuf_render *vbr, const ushort *indices, uint nr)
 136 {
 137    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 138    struct softpipe_context *softpipe = cvbr->softpipe;
 139    unsigned stride = softpipe->vertex_info_vbuf.size * sizeof(float);
 140    unsigned i;
 141    const void *vertex_buffer = cvbr->vertex_buffer;
 142
 143    /* XXX: break this dependency - make setup_context live under
 144     * softpipe, rename the old "setup" draw stage to something else.
 145     */
 146    struct draw_stage *setup = softpipe->setup;
 147    struct setup_context *setup_ctx = sp_draw_setup_context(softpipe->setup);
 148
 149
 150    switch (cvbr->prim) {
 151    case PIPE_PRIM_POINTS:
 152       for (i = 0; i < nr; i++) {
 153          setup_point( setup_ctx,
 154                       get_vert(vertex_buffer, indices[i-0], stride) );
 155       }
 156       break;
 157
 158    case PIPE_PRIM_LINES:
 159       for (i = 1; i < nr; i += 2) {
 160          setup_line( setup_ctx,
 161                      get_vert(vertex_buffer, indices[i-1], stride),
 162                      get_vert(vertex_buffer, indices[i-0], stride) );
 163       }
 164       break;
 165
 166    case PIPE_PRIM_LINE_STRIP:
 167       for (i = 1; i < nr; i ++) {
 168          setup_line( setup_ctx,
 169                      get_vert(vertex_buffer, indices[i-1], stride),
 170                      get_vert(vertex_buffer, indices[i-0], stride) );
 171       }
 172       break;
 173
 174    case PIPE_PRIM_LINE_LOOP:
 175       for (i = 1; i < nr; i ++) {
 176          setup_line( setup_ctx,
 177                      get_vert(vertex_buffer, indices[i-1], stride),
 178                      get_vert(vertex_buffer, indices[i-0], stride) );
 179       }
 180       if (nr) {
 181          setup_line( setup_ctx,
 182                      get_vert(vertex_buffer, indices[nr-1], stride),
 183                      get_vert(vertex_buffer, indices[0], stride) );
 184       }
 185       break;
 186
 187
 188    case PIPE_PRIM_TRIANGLES:
 189       for (i = 2; i < nr; i += 3) {
 190          setup_tri( setup_ctx,
 191                     get_vert(vertex_buffer, indices[i-2], stride),
 192                     get_vert(vertex_buffer, indices[i-1], stride),
 193                     get_vert(vertex_buffer, indices[i-0], stride));
 194       }
 195       break;
 196
 197    case PIPE_PRIM_TRIANGLE_STRIP:
 198       for (i = 2; i < nr; i += 1) {
 199          setup_tri( setup_ctx,
 200                     get_vert(vertex_buffer, indices[i+(i&1)-2], stride),
 201                     get_vert(vertex_buffer, indices[i-(i&1)-1], stride),
 202                     get_vert(vertex_buffer, indices[i-0], stride));
 203       }
 204       break;
 205
 206    case PIPE_PRIM_TRIANGLE_FAN:
 207    case PIPE_PRIM_POLYGON:
 208       for (i = 2; i < nr; i += 1) {
 209          setup_tri( setup_ctx,
 210                     get_vert(vertex_buffer, indices[0], stride),
 211                     get_vert(vertex_buffer, indices[i-1], stride),
 212                     get_vert(vertex_buffer, indices[i-0], stride));
 213       }
 214       break;
 215    case PIPE_PRIM_QUADS:
 216       for (i = 3; i < nr; i += 4) {
 217          setup_tri( setup_ctx,
 218                     get_vert(vertex_buffer, indices[i-3], stride),
 219                     get_vert(vertex_buffer, indices[i-2], stride),
 220                     get_vert(vertex_buffer, indices[i-0], stride));
 221
 222          setup_tri( setup_ctx,
 223                     get_vert(vertex_buffer, indices[i-2], stride),
 224                     get_vert(vertex_buffer, indices[i-1], stride),
 225                     get_vert(vertex_buffer, indices[i-0], stride));
 226       }
 227       break;
 228    case PIPE_PRIM_QUAD_STRIP:
 229       for (i = 3; i < nr; i += 2) {
 230          setup_tri( setup_ctx,
 231                     get_vert(vertex_buffer, indices[i-3], stride),
 232                     get_vert(vertex_buffer, indices[i-2], stride),
 233                     get_vert(vertex_buffer, indices[i-0], stride));
 234
 235          setup_tri( setup_ctx,
 236                     get_vert(vertex_buffer, indices[i-1], stride),
 237                     get_vert(vertex_buffer, indices[i-3], stride),
 238                     get_vert(vertex_buffer, indices[i-0], stride));
 239       }
 240       break;
 241    default:
 242       assert(0);
 243    }
 244
 245    /* XXX: why are we calling this???  If we had to call something, it
 246     * would be a function in sp_setup.c:
 247     */
 248    sp_draw_flush( setup );
 249 }
 250
 251
 252 /**
 253  * This function is hit when the draw module is working in pass-through mode.
 254  * It's up to us to convert the vertex array into point/line/tri prims.
 255  */
 256 static void
 257 sp_vbuf_draw_arrays(struct vbuf_render *vbr, uint start, uint nr)
 258 {
 259    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 260    struct softpipe_context *softpipe = cvbr->softpipe;
 261    struct draw_stage *setup = softpipe->setup;
 262    const void *vertex_buffer = NULL;
 263    const unsigned stride = softpipe->vertex_info_vbuf.size * sizeof(float);
 264    unsigned i;
 265    struct setup_context *setup_ctx = sp_draw_setup_context(setup);
 266
 267    vertex_buffer = (void *)get_vert(cvbr->vertex_buffer, start, stride);
 268
 269    switch (cvbr->prim) {
 270    case PIPE_PRIM_POINTS:
 271       for (i = 0; i < nr; i++) {
 272          setup_point( setup_ctx,
 273                       get_vert(vertex_buffer, i-0, stride) );
 274       }
 275       break;
 276
 277    case PIPE_PRIM_LINES:
 278       for (i = 1; i < nr; i += 2) {
 279          setup_line( setup_ctx,
 280                      get_vert(vertex_buffer, i-1, stride),
 281                      get_vert(vertex_buffer, i-0, stride) );
 282       }
 283       break;
 284
 285    case PIPE_PRIM_LINE_STRIP:
 286       for (i = 1; i < nr; i ++) {
 287          setup_line( setup_ctx,
 288                      get_vert(vertex_buffer, i-1, stride),
 289                      get_vert(vertex_buffer, i-0, stride) );
 290       }
 291       break;
 292
 293    case PIPE_PRIM_LINE_LOOP:
 294       for (i = 1; i < nr; i ++) {
 295          setup_line( setup_ctx,
 296                      get_vert(vertex_buffer, i-1, stride),
 297                      get_vert(vertex_buffer, i-0, stride) );
 298       }
 299       if (nr) {
 300          setup_line( setup_ctx,
 301                      get_vert(vertex_buffer, nr-1, stride),
 302                      get_vert(vertex_buffer, 0, stride) );
 303       }
 304       break;
 305
 306
 307    case PIPE_PRIM_TRIANGLES:
 308       for (i = 2; i < nr; i += 3) {
 309          setup_tri( setup_ctx,
 310                     get_vert(vertex_buffer, i-2, stride),
 311                     get_vert(vertex_buffer, i-1, stride),
 312                     get_vert(vertex_buffer, i-0, stride));
 313       }
 314       break;
 315
 316    case PIPE_PRIM_TRIANGLE_STRIP:
 317       for (i = 2; i < nr; i += 1) {
 318          setup_tri( setup_ctx,
 319                     get_vert(vertex_buffer, i+(i&1)-2, stride),
 320                     get_vert(vertex_buffer, i-(i&1)-1, stride),
 321                     get_vert(vertex_buffer, i-0, stride));
 322       }
 323       break;
 324
 325    case PIPE_PRIM_TRIANGLE_FAN:
 326    case PIPE_PRIM_POLYGON:
 327       for (i = 2; i < nr; i += 1) {
 328          setup_tri( setup_ctx,
 329                     get_vert(vertex_buffer, 0, stride),
 330                     get_vert(vertex_buffer, i-1, stride),
 331                     get_vert(vertex_buffer, i-0, stride));
 332       }
 333       break;
 334    case PIPE_PRIM_QUADS:
 335       for (i = 3; i < nr; i += 4) {
 336          setup_tri( setup_ctx,
 337                     get_vert(vertex_buffer, i-3, stride),
 338                     get_vert(vertex_buffer, i-2, stride),
 339                     get_vert(vertex_buffer, i-0, stride));
 340
 341          setup_tri( setup_ctx,
 342                     get_vert(vertex_buffer, i-2, stride),
 343                     get_vert(vertex_buffer, i-1, stride),
 344                     get_vert(vertex_buffer, i-0, stride));
 345       }
 346       break;
 347    case PIPE_PRIM_QUAD_STRIP:
 348       for (i = 3; i < nr; i += 2) {
 349          setup_tri( setup_ctx,
 350                     get_vert(vertex_buffer, i-3, stride),
 351                     get_vert(vertex_buffer, i-2, stride),
 352                     get_vert(vertex_buffer, i-0, stride));
 353
 354          setup_tri( setup_ctx,
 355                     get_vert(vertex_buffer, i-1, stride),
 356                     get_vert(vertex_buffer, i-3, stride),
 357                     get_vert(vertex_buffer, i-0, stride));
 358       }
 359       break;
 360    default:
 361       assert(0);
 362    }
 363 }
 364
 365
 366
 367 static void
 368 sp_vbuf_destroy(struct vbuf_render *vbr)
 369 {
 370    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
 371    cvbr->softpipe->vbuf_render = NULL;
 372    FREE(cvbr);
 373 }
 374
 375
 376 /**
 377  * Initialize the post-transform vertex buffer information for the given
 378  * context.
 379  */
 380 void
 381 sp_init_vbuf(struct softpipe_context *sp)
 382 {
 383    assert(sp->draw);
 384
 385    sp->vbuf_render = CALLOC_STRUCT(softpipe_vbuf_render);
 386
 387    sp->vbuf_render->base.max_indices = SP_MAX_VBUF_INDEXES;
 388    sp->vbuf_render->base.max_vertex_buffer_bytes = SP_MAX_VBUF_SIZE;
 389
 390    sp->vbuf_render->base.get_vertex_info = sp_vbuf_get_vertex_info;
 391    sp->vbuf_render->base.allocate_vertices = sp_vbuf_allocate_vertices;
 392    sp->vbuf_render->base.set_primitive = sp_vbuf_set_primitive;
 393    sp->vbuf_render->base.draw = sp_vbuf_draw;
 394    sp->vbuf_render->base.draw_arrays = sp_vbuf_draw_arrays;
 395    sp->vbuf_render->base.release_vertices = sp_vbuf_release_vertices;
 396    sp->vbuf_render->base.destroy = sp_vbuf_destroy;
 397
 398    sp->vbuf_render->softpipe = sp;
 399
 400    sp->vbuf = draw_vbuf_stage(sp->draw, &sp->vbuf_render->base);
 401
 402    draw_set_rasterize_stage(sp->draw, sp->vbuf);
 403
 404    draw_set_render(sp->draw, &sp->vbuf_render->base);
 405 }