cell_vbuf.c File Reference

Include dependency graph for cell_vbuf.c:

Go to the source code of this file.

Data Structures
struct	cell_vbuf_render
	Subclass of vbuf_render because we need a cell_context pointer in a few places. More...
Defines
#define	ALLOW_INLINE_VERTS   1
	Vertex buffer code.
Functions
static struct cell_vbuf_render *	cell_vbuf_render (struct vbuf_render *vbr)
	cast wrapper
static struct vertex_info *	cell_vbuf_get_vertex_info (struct vbuf_render *vbr)
static void *	cell_vbuf_allocate_vertices (struct vbuf_render *vbr, ushort vertex_size, ushort nr_vertices)
static void	cell_vbuf_release_vertices (struct vbuf_render *vbr, void *vertices, unsigned vertex_size, unsigned vertices_used)
static boolean	cell_vbuf_set_primitive (struct vbuf_render *vbr, unsigned prim)
static void	cell_vbuf_draw (struct vbuf_render *vbr, const ushort *indices, uint nr_indices)
static void	cell_vbuf_destroy (struct vbuf_render *vbr)
void	cell_init_vbuf (struct cell_context *cell)
	Initialize the post-transform vertex buffer information for the given context.

---

Define Documentation

#define ALLOW_INLINE_VERTS   1

Vertex buffer code.

The draw module transforms vertices to window coords, etc. and emits the vertices into buffer supplied by this module. When a vertex buffer is full, or we flush, we'll send the vertex data to the SPUs.

Authors Brian Paul Allow vertex data to be inlined after RENDER command

Definition at line 49 of file cell_vbuf.c.

---

Function Documentation

void cell_init_vbuf

(

struct cell_context *

cell

)

Initialize the post-transform vertex buffer information for the given context.

Definition at line 272 of file cell_vbuf.c.

References vbuf_render::allocate_vertices, assert, cell_vbuf_render::base, CALLOC_STRUCT, cell_vbuf_render::cell, CELL_BUFFER_SIZE, cell_vbuf_allocate_vertices(), cell_vbuf_destroy(), cell_vbuf_draw(), cell_vbuf_get_vertex_info(), cell_vbuf_release_vertices(), cell_vbuf_set_primitive(), vbuf_render::destroy, vbuf_render::draw, cell_context::draw, draw_vbuf_stage(), vbuf_render::get_vertex_info, vbuf_render::max_indices, vbuf_render::max_vertex_buffer_bytes, vbuf_render::release_vertices, vbuf_render::set_primitive, cell_context::vbuf, cell_context::vbuf_render, and cell_vbuf_render::vertex_buf.

{
   assert(cell->draw);

   cell->vbuf_render = CALLOC_STRUCT(cell_vbuf_render);

   /* The max number of indexes is what can fix into a batch buffer,
    * minus the render and release-verts commands.
    */
   cell->vbuf_render->base.max_indices
      = (CELL_BUFFER_SIZE
         - sizeof(struct cell_command_render)
         - sizeof(struct cell_command_release_verts))
      / sizeof(ushort);
   cell->vbuf_render->base.max_vertex_buffer_bytes = CELL_BUFFER_SIZE;

   cell->vbuf_render->base.get_vertex_info = cell_vbuf_get_vertex_info;
   cell->vbuf_render->base.allocate_vertices = cell_vbuf_allocate_vertices;
   cell->vbuf_render->base.set_primitive = cell_vbuf_set_primitive;
   cell->vbuf_render->base.draw = cell_vbuf_draw;
   cell->vbuf_render->base.release_vertices = cell_vbuf_release_vertices;
   cell->vbuf_render->base.destroy = cell_vbuf_destroy;

   cell->vbuf_render->cell = cell;
#if 1
   cell->vbuf_render->vertex_buf = ~0;
#endif

   cell->vbuf = draw_vbuf_stage(cell->draw, &cell->vbuf_render->base);
}

static void* cell_vbuf_allocate_vertices	(	struct vbuf_render *	vbr,
		ushort	vertex_size,
		ushort	nr_vertices
	)			[static]

Definition at line 85 of file cell_vbuf.c.

References assert, cell_vbuf_render::cell, cell_get_empty_buffer(), cell_vbuf_render(), cell_vbuf_render::vertex_buf, cell_vbuf_render::vertex_buffer, and cell_vbuf_render::vertex_size.

{
   struct cell_vbuf_render *cvbr = cell_vbuf_render(vbr);
   /*printf("Alloc verts %u * %u\n", vertex_size, nr_vertices);*/

   assert(cvbr->vertex_buf == ~0);
   cvbr->vertex_buf = cell_get_empty_buffer(cvbr->cell);
   cvbr->vertex_buffer = cvbr->cell->buffer[cvbr->vertex_buf];
   cvbr->vertex_size = vertex_size;
   return cvbr->vertex_buffer;
}

static void cell_vbuf_destroy

(

struct vbuf_render *

vbr

)

[static]

Definition at line 259 of file cell_vbuf.c.

References cell_vbuf_render::cell, cell_vbuf_render(), FREE, and cell_context::vbuf_render.

{
   struct cell_vbuf_render *cvbr = cell_vbuf_render(vbr);
   cvbr->cell->vbuf_render = NULL;
   FREE(cvbr);
}

static void cell_vbuf_draw	(	struct vbuf_render *	vbr,
		const ushort *	indices,
		uint	nr_indices
	)			[static]

Definition at line 140 of file cell_vbuf.c.

References ALLOW_INLINE_VERTS, ASSERT, cell_vbuf_render::cell, cell_batch_alloc(), cell_batch_alloc_aligned(), cell_batch_free_space(), CELL_CMD_RENDER, cell_flush_int(), CELL_FLUSH_WAIT, cell_vbuf_render(), FALSE, cell_command_render::inline_verts, cell_command_render::min_index, cell_command_render::num_indexes, cell_command_render::num_verts, cell_command_render::opcode, PIPE_PRIM_TRIANGLES, cell_vbuf_render::prim, cell_command_render::prim_type, ROUNDUP8, vertex_info::size, TRUE, cell_vbuf_render::vertex_buf, cell_command_render::vertex_buf, cell_vbuf_render::vertex_buffer, cell_context::vertex_info, cell_command_render::vertex_size, cell_vbuf_render::vertex_size, cell_command_render::xmax, cell_command_render::xmin, cell_command_render::ymax, and cell_command_render::ymin.

{
   struct cell_vbuf_render *cvbr = cell_vbuf_render(vbr);
   struct cell_context *cell = cvbr->cell;
   float xmin, ymin, xmax, ymax;
   uint i;
   uint nr_vertices = 0, min_index = ~0;
   const void *vertices = cvbr->vertex_buffer;
   const uint vertex_size = cvbr->vertex_size;

   for (i = 0; i < nr_indices; i++) {
      if (indices[i] > nr_vertices)
         nr_vertices = indices[i];
      if (indices[i] < min_index)
         min_index = indices[i];
   }
   nr_vertices++;

#if 0
   /*if (min_index > 0)*/
      printf("%s min_index = %u\n", __FUNCTION__, min_index);
#endif

#if 0
   printf("cell_vbuf_draw() nr_indices = %u nr_verts = %u\n",
          nr_indices, nr_vertices);
   printf("  ");
   for (i = 0; i < nr_indices; i += 3) {
      printf("%u %u %u, ", indices[i+0], indices[i+1], indices[i+2]);
   }
   printf("\n");
#elif 0
   printf("cell_vbuf_draw() nr_indices = %u nr_verts = %u  indexes = [%u %u %u ...]\n",
          nr_indices, nr_vertices,
          indices[0], indices[1], indices[2]);
   printf("ind space = %u, vert space = %u, space = %u\n",
          nr_indices * 2,
          nr_vertices * 4 * cell->vertex_info.size,
          cell_batch_free_space(cell));
#endif

   /* compute x/y bounding box */
   xmin = ymin = 1e50;
   xmax = ymax = -1e50;
   for (i = min_index; i < nr_vertices; i++) {
      const float *v = (float *) ((ubyte *) vertices + i * vertex_size);
      if (v[0] < xmin)
         xmin = v[0];
      if (v[0] > xmax)
         xmax = v[0];
      if (v[1] < ymin)
         ymin = v[1];
      if (v[1] > ymax)
         ymax = v[1];
   }
#if 0
   printf("PPU Bounds %g, %g .. %g, %g\n", xmin, ymin, xmax, ymax);
   fflush(stdout);
#endif

   if (cvbr->prim != PIPE_PRIM_TRIANGLES)
      return; /* only render tris for now */

   /* build/insert batch RENDER command */
   {
      const uint index_bytes = ROUNDUP8(nr_indices * 2);
      const uint vertex_bytes = nr_vertices * 4 * cell->vertex_info.size;
      const uint batch_size = sizeof(struct cell_command_render) + index_bytes;

      struct cell_command_render *render
         = (struct cell_command_render *)
         cell_batch_alloc(cell, batch_size);

      render->opcode = CELL_CMD_RENDER;
      render->prim_type = cvbr->prim;

      render->num_indexes = nr_indices;
      render->min_index = min_index;

      /* append indices after render command */
      memcpy(render + 1, indices, nr_indices * 2);

      /* if there's room, append vertices after the indices, else leave
       * vertices in the original/separate buffer.
       */
      render->vertex_size = 4 * cell->vertex_info.size;
      render->num_verts = nr_vertices;
      if (ALLOW_INLINE_VERTS &&
          min_index == 0 &&
          vertex_bytes + 16 <= cell_batch_free_space(cell)) {
         /* vertex data inlined, after indices, at 16-byte boundary */
         void *dst = cell_batch_alloc_aligned(cell, vertex_bytes, 16);
         memcpy(dst, vertices, vertex_bytes);
         render->inline_verts = TRUE;
         render->vertex_buf = ~0;
      }
      else {
         /* vertex data in separate buffer */
         render->inline_verts = FALSE;
         ASSERT(cvbr->vertex_buf >= 0);
         render->vertex_buf = cvbr->vertex_buf;
      }

      render->xmin = xmin;
      render->ymin = ymin;
      render->xmax = xmax;
      render->ymax = ymax;
   }

#if 0
   /* helpful for debug */
   cell_flush_int(cell, CELL_FLUSH_WAIT);
#endif
}

static struct vertex_info* cell_vbuf_get_vertex_info

(

struct vbuf_render *

vbr

)

[static, read]

Definition at line 77 of file cell_vbuf.c.

References cell_vbuf_render::cell, cell_vbuf_render(), and cell_context::vertex_info.

{
   struct cell_vbuf_render *cvbr = cell_vbuf_render(vbr);
   return &cvbr->cell->vertex_info;
}

static void cell_vbuf_release_vertices	(	struct vbuf_render *	vbr,
		void *	vertices,
		unsigned	vertex_size,
		unsigned	vertices_used
	)			[static]

Definition at line 100 of file cell_vbuf.c.

References assert, cell_vbuf_render::cell, cell_batch_alloc(), CELL_CMD_RELEASE_VERTS, cell_flush_int(), cell_vbuf_render(), cell_command_release_verts::opcode, cell_command_release_verts::vertex_buf, cell_vbuf_render::vertex_buf, and cell_vbuf_render::vertex_buffer.

{
   struct cell_vbuf_render *cvbr = cell_vbuf_render(vbr);
   struct cell_context *cell = cvbr->cell;

   /*
   printf("%s vertex_buf = %u  count = %u\n",
          __FUNCTION__, cvbr->vertex_buf, vertices_used);
   */

   /* Tell SPUs they can release the vert buf */
   if (cvbr->vertex_buf != ~0U) {
      struct cell_command_release_verts *release
         = (struct cell_command_release_verts *)
         cell_batch_alloc(cell, sizeof(struct cell_command_release_verts));
      release->opcode = CELL_CMD_RELEASE_VERTS;
      release->vertex_buf = cvbr->vertex_buf;
   }

   cvbr->vertex_buf = ~0;
   cell_flush_int(cell, 0x0);

   assert(vertices == cvbr->vertex_buffer);
   cvbr->vertex_buffer = NULL;
}

static struct cell_vbuf_render* cell_vbuf_render

(

struct vbuf_render *

vbr

)

[static, read]

cast wrapper

Definition at line 69 of file cell_vbuf.c.

{
   return (struct cell_vbuf_render *) vbr;
}

static boolean cell_vbuf_set_primitive	(	struct vbuf_render *	vbr,
		unsigned	prim
	)			[static]

Definition at line 130 of file cell_vbuf.c.

References cell_vbuf_render(), cell_vbuf_render::prim, and TRUE.

{
   struct cell_vbuf_render *cvbr = cell_vbuf_render(vbr);
   cvbr->prim = prim;
   /*printf("cell_set_prim %u\n", prim);*/
   return TRUE;
}

---