cell_draw_arrays.c File Reference

Include dependency graph for cell_draw_arrays.c:

Go to the source code of this file.

Functions
static void	cell_map_constant_buffers (struct cell_context *sp)
static void	cell_unmap_constant_buffers (struct cell_context *sp)
static boolean	cell_draw_range_elements (struct pipe_context *pipe, struct pipe_buffer *indexBuffer, unsigned indexSize, unsigned min_index, unsigned max_index, unsigned mode, unsigned start, unsigned count)
	Draw vertex arrays, with optional indexing.
static boolean	cell_draw_elements (struct pipe_context *pipe, struct pipe_buffer *indexBuffer, unsigned indexSize, unsigned mode, unsigned start, unsigned count)
static boolean	cell_draw_arrays (struct pipe_context *pipe, unsigned mode, unsigned start, unsigned count)
static void	cell_set_edgeflags (struct pipe_context *pipe, const unsigned *edgeflags)
void	cell_init_draw_functions (struct cell_context *cell)

---

Function Documentation

static boolean cell_draw_arrays	(	struct pipe_context *	pipe,
		unsigned	mode,
		unsigned	start,
		unsigned	count
	)			[static]

Definition at line 167 of file cell_draw_arrays.c.

References cell_draw_elements().

{
   return cell_draw_elements(pipe, NULL, 0, mode, start, count);
}

static boolean cell_draw_elements	(	struct pipe_context *	pipe,
		struct pipe_buffer *	indexBuffer,
		unsigned	indexSize,
		unsigned	mode,
		unsigned	start,
		unsigned	count
	)			[static]

Definition at line 154 of file cell_draw_arrays.c.

References cell_draw_range_elements().

{
   return cell_draw_range_elements( pipe, indexBuffer,
                                    indexSize,
                                    0, 0xffffffff,
                                    mode, start, count );
}

static boolean cell_draw_range_elements	(	struct pipe_context *	pipe,
		struct pipe_buffer *	indexBuffer,
		unsigned	indexSize,
		unsigned	min_index,
		unsigned	max_index,
		unsigned	mode,
		unsigned	start,
		unsigned	count
	)			[static]

Draw vertex arrays, with optional indexing.

Basically, map the vertex buffers (and drawing surfaces), then hand off the drawing to the 'draw' module.

XXX should the element buffer be specified/bound with a separate function?

Definition at line 89 of file cell_draw_arrays.c.

References pipe_vertex_buffer::buffer, cell_context(), cell_flush_buffer_range(), cell_map_constant_buffers(), cell_unmap_constant_buffers(), cell_update_derived(), cell_context::dirty, cell_context::draw, draw, draw_arrays(), draw_set_mapped_element_buffer(), draw_set_mapped_vertex_buffer(), cell_context::num_vertex_buffers, pipe_buffer_map(), pipe_buffer_unmap(), PIPE_BUFFER_USAGE_CPU_READ, pipe_context::screen, pipe_buffer::size, TRUE, and cell_context::vertex_buffer.

{
   struct cell_context *sp = cell_context(pipe);
   struct draw_context *draw = sp->draw;
   unsigned i;

   if (sp->dirty)
      cell_update_derived( sp );

#if 0
   cell_map_surfaces(sp);
#endif
   cell_map_constant_buffers(sp);

   /*
    * Map vertex buffers
    */
   for (i = 0; i < sp->num_vertex_buffers; i++) {
      void *buf = pipe_buffer_map(pipe->screen,
                                           sp->vertex_buffer[i].buffer,
                                           PIPE_BUFFER_USAGE_CPU_READ);
      cell_flush_buffer_range(sp, buf, sp->vertex_buffer[i].buffer->size);
      draw_set_mapped_vertex_buffer(draw, i, buf);
   }
   /* Map index buffer, if present */
   if (indexBuffer) {
      void *mapped_indexes = pipe_buffer_map(pipe->screen,
                                                      indexBuffer,
                                                      PIPE_BUFFER_USAGE_CPU_READ);
      draw_set_mapped_element_buffer(draw, indexSize, mapped_indexes);
   }
   else {
      /* no index/element buffer */
      draw_set_mapped_element_buffer(draw, 0, NULL);
   }


   /* draw! */
   draw_arrays(draw, mode, start, count);

   /*
    * unmap vertex/index buffers - will cause draw module to flush
    */
   for (i = 0; i < sp->num_vertex_buffers; i++) {
      draw_set_mapped_vertex_buffer(draw, i, NULL);
      pipe_buffer_unmap(pipe->screen, sp->vertex_buffer[i].buffer);
   }
   if (indexBuffer) {
      draw_set_mapped_element_buffer(draw, 0, NULL);
      pipe_buffer_unmap(pipe->screen, indexBuffer);
   }

   /* Note: leave drawing surfaces mapped */
   cell_unmap_constant_buffers(sp);

   return TRUE;
}

void cell_init_draw_functions

(

struct cell_context *

cell

)

Definition at line 184 of file cell_draw_arrays.c.

References cell_draw_arrays(), cell_draw_elements(), cell_draw_range_elements(), cell_set_edgeflags(), pipe_context::draw_arrays, pipe_context::draw_elements, pipe_context::draw_range_elements, cell_context::pipe, and pipe_context::set_edgeflags.

{
   cell->pipe.draw_arrays = cell_draw_arrays;
   cell->pipe.draw_elements = cell_draw_elements;
   cell->pipe.draw_range_elements = cell_draw_range_elements;
   cell->pipe.set_edgeflags = cell_set_edgeflags;
}

static void cell_map_constant_buffers

(

struct cell_context *

sp

)

[static]

Definition at line 49 of file cell_draw_arrays.c.

References pipe_constant_buffer::buffer, pipe_winsys::buffer_map, cell_flush_buffer_range(), cell_context::constants, cell_context::draw, draw_set_mapped_constant_buffer(), cell_context::mapped_constants, cell_context::pipe, PIPE_BUFFER_USAGE_CPU_READ, PIPE_SHADER_VERTEX, pipe_buffer::size, pipe_constant_buffer::size, and pipe_context::winsys.

{
   struct pipe_winsys *ws = sp->pipe.winsys;
   uint i;
   for (i = 0; i < 2; i++) {
      if (sp->constants[i].size) {
         sp->mapped_constants[i] = ws->buffer_map(ws, sp->constants[i].buffer,
                                                  PIPE_BUFFER_USAGE_CPU_READ);
         cell_flush_buffer_range(sp, sp->mapped_constants[i], 
                                 sp->constants[i].buffer->size);
      }
   }

   draw_set_mapped_constant_buffer(sp->draw,
                                   sp->mapped_constants[PIPE_SHADER_VERTEX],
                                   sp->constants[PIPE_SHADER_VERTEX].size);
}

static void cell_set_edgeflags	(	struct pipe_context *	pipe,
		const unsigned *	edgeflags
	)			[static]

Definition at line 175 of file cell_draw_arrays.c.

References cell_context(), cell_context::draw, and draw_set_edgeflags().

{
   struct cell_context *cell = cell_context(pipe);
   draw_set_edgeflags(cell->draw, edgeflags);
}

static void cell_unmap_constant_buffers

(

struct cell_context *

sp

)

[static]

Definition at line 68 of file cell_draw_arrays.c.

References pipe_constant_buffer::buffer, pipe_winsys::buffer_unmap, cell_context::constants, cell_context::mapped_constants, cell_context::pipe, pipe_constant_buffer::size, and pipe_context::winsys.

{
   struct pipe_winsys *ws = sp->pipe.winsys;
   uint i;
   for (i = 0; i < 2; i++) {
      if (sp->constants[i].size)
         ws->buffer_unmap(ws, sp->constants[i].buffer);
      sp->mapped_constants[i] = NULL;
   }
}

---