spu_render.c File Reference

Include dependency graph for spu_render.c:

Go to the source code of this file.

Functions
static void	tile_bounding_box (const struct cell_command_render *render, uint *txmin, uint *tymin, uint *box_num_tiles, uint *box_width_tiles)
	Given a rendering command's bounding box (in pixels) compute the location of the corresponding screen tile bounding box.
static boolean	my_tile (uint tx, uint ty)
	Check if the tile at (tx,ty) belongs to this SPU.
static void	get_cz_tiles (uint tx, uint ty)
	Start fetching non-clear color/Z tiles from main memory.
static void	put_cz_tiles (uint tx, uint ty)
	Start putting dirty color/Z tiles back to main memory.
static void	wait_put_cz_tiles (void)
	Wait for 'put' of color/z tiles to complete.
void	cmd_render (const struct cell_command_render *render, uint *pos_incr)
	Render primitives.

---

Function Documentation

void cmd_render	(	const struct cell_command_render *	render,
		uint *	pos_incr
	)

Render primitives.

Parameters:

pos_incr

returns value indicating how may words to skip after this command in the batch buffer

find tiles which intersect the prim bounding box

loop over tiles, rendering tris

Definition at line 168 of file spu_render.c.

References ALIGN16_ATTRIB, align_pointer(), ASSERT, ASSERT_ALIGN16, cell_init_info::buffers, CELL_BUFFER_SIZE, spu_global::cur_ctile_status, spu_global::cur_ztile_status, Debug, spu_global::fb, get_cz_tiles(), spu_framebuffer::height_tiles, cell_init_info::id, spu_global::init, cell_command_render::inline_verts, cell_command_render::min_index, my_tile(), cell_command_render::num_indexes, cell_command_render::num_verts, PIPE_PRIM_TRIANGLES, cell_command_render::prim_type, put_cz_tiles(), ROUNDUP8, spu, TAG_SURFACE_CLEAR, TAG_VERTEX_BUFFER, tile_bounding_box(), tri_draw(), cell_command_render::vertex_buf, cell_command_render::vertex_size, wait_on_mask(), wait_put_cz_tiles(), and spu_framebuffer::width_tiles.

{
   /* we'll DMA into these buffers */
   ubyte vertex_data[CELL_BUFFER_SIZE] ALIGN16_ATTRIB;
   const uint vertex_size = render->vertex_size; /* in bytes */
   /*const*/ uint total_vertex_bytes = render->num_verts * vertex_size;
   uint index_bytes;
   const ubyte *vertices;
   const ushort *indexes;
   uint i, j;


   if (Debug) {
      printf("SPU %u: RENDER prim %u, num_vert=%u  num_ind=%u  "
             "inline_vert=%u\n",
             spu.init.id,
             render->prim_type,
             render->num_verts,
             render->num_indexes,
             render->inline_verts);

      /*
      printf("       bound: %g, %g .. %g, %g\n",
             render->xmin, render->ymin, render->xmax, render->ymax);
      */
   }

   ASSERT(sizeof(*render) % 4 == 0);
   ASSERT(total_vertex_bytes % 16 == 0);
   ASSERT(render->prim_type == PIPE_PRIM_TRIANGLES);
   ASSERT(render->num_indexes % 3 == 0);


   /* indexes are right after the render command in the batch buffer */
   indexes = (const ushort *) (render + 1);
   index_bytes = ROUNDUP8(render->num_indexes * 2);
   *pos_incr = index_bytes / 8 + sizeof(*render) / 8;


   if (render->inline_verts) {
      /* Vertices are after indexes in batch buffer at next 16-byte addr */
      vertices = (const ubyte *) render + (*pos_incr * 8);
      vertices = (const ubyte *) align_pointer((void *) vertices, 16);
      ASSERT_ALIGN16(vertices);
      *pos_incr = ((vertices + total_vertex_bytes) - (ubyte *) render) / 8;
   }
   else {
      /* Begin DMA fetch of vertex buffer */
      ubyte *src = spu.init.buffers[render->vertex_buf];
      ubyte *dest = vertex_data;

      /* skip vertex data we won't use */
#if 01
      src += render->min_index * vertex_size;
      dest += render->min_index * vertex_size;
      total_vertex_bytes -= render->min_index * vertex_size;
#endif
      ASSERT(total_vertex_bytes % 16 == 0);
      ASSERT_ALIGN16(dest);
      ASSERT_ALIGN16(src);

      mfc_get(dest,   /* in vertex_data[] array */
              (unsigned int) src,  /* src in main memory */
              total_vertex_bytes,  /* size */
              TAG_VERTEX_BUFFER,
              0, /* tid */
              0  /* rid */);

      vertices = vertex_data;

      wait_on_mask(1 << TAG_VERTEX_BUFFER);
   }


   uint txmin, tymin, box_width_tiles, box_num_tiles;
   tile_bounding_box(render, &txmin, &tymin,
                     &box_num_tiles, &box_width_tiles);


   /* make sure any pending clears have completed */
   wait_on_mask(1 << TAG_SURFACE_CLEAR); /* XXX temporary */


   for (i = 0; i < box_num_tiles; i++) {
      const uint tx = txmin + i % box_width_tiles;
      const uint ty = tymin + i / box_width_tiles;

      ASSERT(tx < spu.fb.width_tiles);
      ASSERT(ty < spu.fb.height_tiles);

      if (!my_tile(tx, ty))
         continue;

      spu.cur_ctile_status = spu.ctile_status[ty][tx];
      spu.cur_ztile_status = spu.ztile_status[ty][tx];

      get_cz_tiles(tx, ty);

      uint drawn = 0;

      /* loop over tris */
      for (j = 0; j < render->num_indexes; j += 3) {
         const float *v0, *v1, *v2;

         v0 = (const float *) (vertices + indexes[j+0] * vertex_size);
         v1 = (const float *) (vertices + indexes[j+1] * vertex_size);
         v2 = (const float *) (vertices + indexes[j+2] * vertex_size);

         drawn += tri_draw(v0, v1, v2, tx, ty);
      }

      //printf("SPU %u: drew %u of %u\n", spu.init.id, drawn, render->num_indexes/3);

      /* write color/z tiles back to main framebuffer, if dirtied */
      put_cz_tiles(tx, ty);

      wait_put_cz_tiles(); /* XXX seems unnecessary... */

      spu.ctile_status[ty][tx] = spu.cur_ctile_status;
      spu.ztile_status[ty][tx] = spu.cur_ztile_status;
   }

   if (Debug)
      printf("SPU %u: RENDER done\n",
             spu.init.id);
}

static void get_cz_tiles	(	uint	tx,
		uint	ty
	)			[static]

Start fetching non-clear color/Z tiles from main memory.

< mfc_get() called but not yet arrived

< mfc_get() called but not yet arrived

Definition at line 99 of file spu_render.c.

References spu_global::cur_ctile_status, spu_global::cur_ztile_status, get_tile(), spu_global::read_depth, spu, TAG_READ_TILE_COLOR, TAG_READ_TILE_Z, TILE_STATUS_CLEAR, and TILE_STATUS_GETTING.

{
   if (spu.read_depth) {
      if (spu.cur_ztile_status != TILE_STATUS_CLEAR) {
         //printf("SPU %u: getting Z tile %u, %u\n", spu.init.id, tx, ty);
         get_tile(tx, ty, &spu.ztile, TAG_READ_TILE_Z, 1);
         spu.cur_ztile_status = TILE_STATUS_GETTING;
      }
   }

   if (spu.cur_ctile_status != TILE_STATUS_CLEAR) {
      //printf("SPU %u: getting C tile %u, %u\n", spu.init.id, tx, ty);
      get_tile(tx, ty, &spu.ctile, TAG_READ_TILE_COLOR, 0);
      spu.cur_ctile_status = TILE_STATUS_GETTING;
   }
}

static boolean my_tile	(	uint	tx,
		uint	ty
	)			[static]

Check if the tile at (tx,ty) belongs to this SPU.

Definition at line 89 of file spu_render.c.

References spu_global::fb, cell_init_info::id, spu_global::init, cell_init_info::num_spus, spu, and spu_framebuffer::width_tiles.

{
   return (spu.fb.width_tiles * ty + tx) % spu.init.num_spus == spu.init.id;
}

static void put_cz_tiles	(	uint	tx,
		uint	ty
	)			[static]

Start putting dirty color/Z tiles back to main memory.

< modified locally, but not put back yet

< defined in FB, but not in local store

< mfc_get() called but not yet arrived

< defined in FB, but not in local store

< modified locally, but not put back yet

< defined in FB, but not in local store

< mfc_get() called but not yet arrived

< defined in FB, but not in local store

Definition at line 121 of file spu_render.c.

References spu_global::cur_ctile_status, spu_global::cur_ztile_status, put_tile(), spu, TAG_WRITE_TILE_COLOR, TAG_WRITE_TILE_Z, TILE_STATUS_DEFINED, TILE_STATUS_DIRTY, and TILE_STATUS_GETTING.

{
   if (spu.cur_ztile_status == TILE_STATUS_DIRTY) {
      /* tile was modified and needs to be written back */
      //printf("SPU %u: put dirty Z tile %u, %u\n", spu.init.id, tx, ty);
      put_tile(tx, ty, &spu.ztile, TAG_WRITE_TILE_Z, 1);
      spu.cur_ztile_status = TILE_STATUS_DEFINED;
   }
   else if (spu.cur_ztile_status == TILE_STATUS_GETTING) {
      /* tile was never used */
      spu.cur_ztile_status = TILE_STATUS_DEFINED;
      //printf("SPU %u: put getting Z tile %u, %u\n", spu.init.id, tx, ty);
   }

   if (spu.cur_ctile_status == TILE_STATUS_DIRTY) {
      /* tile was modified and needs to be written back */
      //printf("SPU %u: put dirty C tile %u, %u\n", spu.init.id, tx, ty);
      put_tile(tx, ty, &spu.ctile, TAG_WRITE_TILE_COLOR, 0);
      spu.cur_ctile_status = TILE_STATUS_DEFINED;
   }
   else if (spu.cur_ctile_status == TILE_STATUS_GETTING) {
      /* tile was never used */
      spu.cur_ctile_status = TILE_STATUS_DEFINED;
      //printf("SPU %u: put getting C tile %u, %u\n", spu.init.id, tx, ty);
   }
}

static void tile_bounding_box	(	const struct cell_command_render *	render,
		uint *	txmin,
		uint *	tymin,
		uint *	box_num_tiles,
		uint *	box_width_tiles
	)			[static]

Given a rendering command's bounding box (in pixels) compute the location of the corresponding screen tile bounding box.

Definition at line 46 of file spu_render.c.

References ASSERT, spu_global::fb, spu_framebuffer::height_tiles, cell_init_info::id, spu_global::init, spu, TILE_SIZE, spu_framebuffer::width_tiles, cell_command_render::xmax, cell_command_render::xmin, cell_command_render::ymax, and cell_command_render::ymin.

{
#if 0
   /* Debug: full-window bounding box */
   uint txmax = spu.fb.width_tiles - 1;
   uint tymax = spu.fb.height_tiles - 1;
   *txmin = 0;
   *tymin = 0;
   *box_num_tiles = spu.fb.width_tiles * spu.fb.height_tiles;
   *box_width_tiles = spu.fb.width_tiles;
   (void) render;
   (void) txmax;
   (void) tymax;
#else
   uint txmax, tymax, box_height_tiles;

   *txmin = (uint) render->xmin / TILE_SIZE;
   *tymin = (uint) render->ymin / TILE_SIZE;
   txmax = (uint) render->xmax / TILE_SIZE;
   tymax = (uint) render->ymax / TILE_SIZE;
   if (txmax >= spu.fb.width_tiles)
      txmax = spu.fb.width_tiles-1;
   if (tymax >= spu.fb.height_tiles)
      tymax = spu.fb.height_tiles-1;
   *box_width_tiles = txmax - *txmin + 1;
   box_height_tiles = tymax - *tymin + 1;
   *box_num_tiles = *box_width_tiles * box_height_tiles;
#endif
#if 0
   printf("SPU %u: bounds: %g, %g  ...  %g, %g\n", spu.init.id,
          render->xmin, render->ymin, render->xmax, render->ymax);
   printf("SPU %u: tiles:  %u, %u .. %u, %u\n",
           spu.init.id, *txmin, *tymin, txmax, tymax);
   ASSERT(render->xmin <= render->xmax);
   ASSERT(render->ymin <= render->ymax);
#endif
}

static void wait_put_cz_tiles

(

void

)

[static]

Wait for 'put' of color/z tiles to complete.

Definition at line 153 of file spu_render.c.

References spu_global::read_depth, spu, TAG_WRITE_TILE_COLOR, TAG_WRITE_TILE_Z, and wait_on_mask().

{
   wait_on_mask(1 << TAG_WRITE_TILE_COLOR);
   if (spu.read_depth) {
      wait_on_mask(1 << TAG_WRITE_TILE_Z);
   }
}

---