src/gallium/drivers/cell/ppu/cell_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  * Vertex buffer code.  The draw module transforms vertices to window
  30  * coords, etc. and emits the vertices into buffer supplied by this module.
  31  * When a vertex buffer is full, or we flush, we'll send the vertex data
  32  * to the SPUs.
  33  *
  34  * Authors
  35  *  Brian Paul
  36  */
  37
  38
  39 #include "cell_batch.h"
  40 #include "cell_context.h"
  41 #include "cell_fence.h"
  42 #include "cell_flush.h"
  43 #include "cell_spu.h"
  44 #include "cell_vbuf.h"
  45 #include "draw/draw_vbuf.h"
  46 #include "util/u_memory.h"
  47
  48
  49 /** Allow vertex data to be inlined after RENDER command */
  50 #define ALLOW_INLINE_VERTS 1
  51
  52
  53 /**
  54  * Subclass of vbuf_render because we need a cell_context pointer in
  55  * a few places.
  56  */
  57 struct cell_vbuf_render
  58 {
  59    struct vbuf_render base;
  60    struct cell_context *cell;
  61    uint prim;            /**< PIPE_PRIM_x */
  62    uint vertex_size;     /**< in bytes */
  63    void *vertex_buffer;  /**< just for debug, really */
  64    uint vertex_buf;      /**< in [0, CELL_NUM_BUFFERS-1] */
  65 };
  66
  67
  68 /** cast wrapper */
  69 static struct cell_vbuf_render *
  70 cell_vbuf_render(struct vbuf_render *vbr)
  71 {
  72    return (struct cell_vbuf_render *) vbr;
  73 }
  74
  75
  76
  77 static const struct vertex_info *
  78 cell_vbuf_get_vertex_info(struct vbuf_render *vbr)
  79 {
  80    struct cell_vbuf_render *cvbr = cell_vbuf_render(vbr);
  81    return &cvbr->cell->vertex_info;
  82 }
  83
  84
  85 static void *
  86 cell_vbuf_allocate_vertices(struct vbuf_render *vbr,
  87                             ushort vertex_size, ushort nr_vertices)
  88 {
  89    struct cell_vbuf_render *cvbr = cell_vbuf_render(vbr);
  90    /*printf("Alloc verts %u * %u\n", vertex_size, nr_vertices);*/
  91
  92    assert(cvbr->vertex_buf == ~0);
  93    cvbr->vertex_buf = cell_get_empty_buffer(cvbr->cell);
  94    cvbr->vertex_buffer = cvbr->cell->buffer[cvbr->vertex_buf];
  95    cvbr->vertex_size = vertex_size;
  96    return cvbr->vertex_buffer;
  97 }
  98
  99
 100 static void
 101 cell_vbuf_release_vertices(struct vbuf_render *vbr, void *vertices,
 102                            unsigned vertex_size, unsigned vertices_used)
 103 {
 104    struct cell_vbuf_render *cvbr = cell_vbuf_render(vbr);
 105    struct cell_context *cell = cvbr->cell;
 106
 107    /*
 108    printf("%s vertex_buf = %u  count = %u\n",
 109           __FUNCTION__, cvbr->vertex_buf, vertices_used);
 110    */
 111
 112    /* Make sure texture buffers aren't released until we're done rendering
 113     * with them.
 114     */
 115    cell_add_fenced_textures(cell);
 116
 117    /* Tell SPUs they can release the vert buf */
 118    if (cvbr->vertex_buf != ~0U) {
 119       struct cell_command_release_verts *release
 120          = (struct cell_command_release_verts *)
 121          cell_batch_alloc(cell, sizeof(struct cell_command_release_verts));
 122       release->opcode = CELL_CMD_RELEASE_VERTS;
 123       release->vertex_buf = cvbr->vertex_buf;
 124    }
 125
 126    cvbr->vertex_buf = ~0;
 127    cell_flush_int(cell, 0x0);
 128
 129    assert(vertices == cvbr->vertex_buffer);
 130    cvbr->vertex_buffer = NULL;
 131 }
 132
 133
 134
 135 static boolean
 136 cell_vbuf_set_primitive(struct vbuf_render *vbr, unsigned prim)
 137 {
 138    struct cell_vbuf_render *cvbr = cell_vbuf_render(vbr);
 139    cvbr->prim = prim;
 140    /*printf("cell_set_prim %u\n", prim);*/
 141    return TRUE;
 142 }
 143
 144
 145 static void
 146 cell_vbuf_draw(struct vbuf_render *vbr,
 147                const ushort *indices,
 148                uint nr_indices)
 149 {
 150    struct cell_vbuf_render *cvbr = cell_vbuf_render(vbr);
 151    struct cell_context *cell = cvbr->cell;
 152    float xmin, ymin, xmax, ymax;
 153    uint i;
 154    uint nr_vertices = 0, min_index = ~0;
 155    const void *vertices = cvbr->vertex_buffer;
 156    const uint vertex_size = cvbr->vertex_size;
 157
 158    for (i = 0; i < nr_indices; i++) {
 159       if (indices[i] > nr_vertices)
 160          nr_vertices = indices[i];
 161       if (indices[i] < min_index)
 162          min_index = indices[i];
 163    }
 164    nr_vertices++;
 165
 166 #if 0
 167    /*if (min_index > 0)*/
 168       printf("%s min_index = %u\n", __FUNCTION__, min_index);
 169 #endif
 170
 171 #if 0
 172    printf("cell_vbuf_draw() nr_indices = %u nr_verts = %u\n",
 173           nr_indices, nr_vertices);
 174    printf("  ");
 175    for (i = 0; i < nr_indices; i += 3) {
 176       printf("%u %u %u, ", indices[i+0], indices[i+1], indices[i+2]);
 177    }
 178    printf("\n");
 179 #elif 0
 180    printf("cell_vbuf_draw() nr_indices = %u nr_verts = %u  indexes = [%u %u %u ...]\n",
 181           nr_indices, nr_vertices,
 182           indices[0], indices[1], indices[2]);
 183    printf("ind space = %u, vert space = %u, space = %u\n",
 184           nr_indices * 2,
 185           nr_vertices * 4 * cell->vertex_info.size,
 186           cell_batch_free_space(cell));
 187 #endif
 188
 189    /* compute x/y bounding box */
 190    xmin = ymin = 1e50;
 191    xmax = ymax = -1e50;
 192    for (i = min_index; i < nr_vertices; i++) {
 193       const float *v = (float *) ((ubyte *) vertices + i * vertex_size);
 194       if (v[0] < xmin)
 195          xmin = v[0];
 196       if (v[0] > xmax)
 197          xmax = v[0];
 198       if (v[1] < ymin)
 199          ymin = v[1];
 200       if (v[1] > ymax)
 201          ymax = v[1];
 202    }
 203 #if 0
 204    printf("PPU Bounds %g, %g .. %g, %g\n", xmin, ymin, xmax, ymax);
 205    fflush(stdout);
 206 #endif
 207
 208    if (cvbr->prim != PIPE_PRIM_TRIANGLES)
 209       return; /* only render tris for now */
 210
 211    /* build/insert batch RENDER command */
 212    {
 213       const uint index_bytes = ROUNDUP8(nr_indices * 2);
 214       const uint vertex_bytes = nr_vertices * 4 * cell->vertex_info.size;
 215       const uint batch_size = sizeof(struct cell_command_render) + index_bytes;
 216
 217       struct cell_command_render *render
 218          = (struct cell_command_render *)
 219          cell_batch_alloc(cell, batch_size);
 220
 221       render->opcode = CELL_CMD_RENDER;
 222       render->prim_type = cvbr->prim;
 223
 224       render->num_indexes = nr_indices;
 225       render->min_index = min_index;
 226
 227       /* append indices after render command */
 228       memcpy(render + 1, indices, nr_indices * 2);
 229
 230       /* if there's room, append vertices after the indices, else leave
 231        * vertices in the original/separate buffer.
 232        */
 233       render->vertex_size = 4 * cell->vertex_info.size;
 234       render->num_verts = nr_vertices;
 235       if (ALLOW_INLINE_VERTS &&
 236           min_index == 0 &&
 237           vertex_bytes + 16 <= cell_batch_free_space(cell)) {
 238          /* vertex data inlined, after indices, at 16-byte boundary */
 239          void *dst = cell_batch_alloc_aligned(cell, vertex_bytes, 16);
 240          memcpy(dst, vertices, vertex_bytes);
 241          render->inline_verts = TRUE;
 242          render->vertex_buf = ~0;
 243       }
 244       else {
 245          /* vertex data in separate buffer */
 246          render->inline_verts = FALSE;
 247          ASSERT(cvbr->vertex_buf >= 0);
 248          render->vertex_buf = cvbr->vertex_buf;
 249       }
 250
 251       render->xmin = xmin;
 252       render->ymin = ymin;
 253       render->xmax = xmax;
 254       render->ymax = ymax;
 255    }
 256
 257 #if 0
 258    /* helpful for debug */
 259    cell_flush_int(cell, CELL_FLUSH_WAIT);
 260 #endif
 261 }
 262
 263
 264 static void
 265 cell_vbuf_destroy(struct vbuf_render *vbr)
 266 {
 267    struct cell_vbuf_render *cvbr = cell_vbuf_render(vbr);
 268    cvbr->cell->vbuf_render = NULL;
 269    FREE(cvbr);
 270 }
 271
 272
 273 /**
 274  * Initialize the post-transform vertex buffer information for the given
 275  * context.
 276  */
 277 void
 278 cell_init_vbuf(struct cell_context *cell)
 279 {
 280    assert(cell->draw);
 281
 282    cell->vbuf_render = CALLOC_STRUCT(cell_vbuf_render);
 283
 284    /* The max number of indexes is what can fix into a batch buffer,
 285     * minus the render and release-verts commands.
 286     */
 287    cell->vbuf_render->base.max_indices
 288       = (CELL_BUFFER_SIZE
 289          - sizeof(struct cell_command_render)
 290          - sizeof(struct cell_command_release_verts))
 291       / sizeof(ushort);
 292    cell->vbuf_render->base.max_vertex_buffer_bytes = CELL_BUFFER_SIZE;
 293
 294    cell->vbuf_render->base.get_vertex_info = cell_vbuf_get_vertex_info;
 295    cell->vbuf_render->base.allocate_vertices = cell_vbuf_allocate_vertices;
 296    cell->vbuf_render->base.set_primitive = cell_vbuf_set_primitive;
 297    cell->vbuf_render->base.draw = cell_vbuf_draw;
 298    cell->vbuf_render->base.release_vertices = cell_vbuf_release_vertices;
 299    cell->vbuf_render->base.destroy = cell_vbuf_destroy;
 300
 301    cell->vbuf_render->cell = cell;
 302 #if 1
 303    cell->vbuf_render->vertex_buf = ~0;
 304 #endif
 305
 306    cell->vbuf = draw_vbuf_stage(cell->draw, &cell->vbuf_render->base);
 307 }