draw_pt_fetch_emit.c File Reference

Include dependency graph for draw_pt_fetch_emit.c:

Go to the source code of this file.

Data Structures
struct	fetch_emit_middle_end
Functions
static void	fetch_emit_prepare (struct draw_pt_middle_end *middle, unsigned prim, unsigned opt, unsigned *max_vertices)
static void	fetch_emit_run (struct draw_pt_middle_end *middle, const unsigned *fetch_elts, unsigned fetch_count, const ushort *draw_elts, unsigned draw_count)
static void	fetch_emit_run_linear (struct draw_pt_middle_end *middle, unsigned start, unsigned count)
static boolean	fetch_emit_run_linear_elts (struct draw_pt_middle_end *middle, unsigned start, unsigned count, const ushort *draw_elts, unsigned draw_count)
static void	fetch_emit_finish (struct draw_pt_middle_end *middle)
static void	fetch_emit_destroy (struct draw_pt_middle_end *middle)
struct draw_pt_middle_end *	draw_pt_fetch_emit (struct draw_context *draw)

---

Function Documentation

struct draw_pt_middle_end* draw_pt_fetch_emit

(

struct draw_context *

draw

)

[read]

Definition at line 390 of file draw_pt_fetch_emit.c.

References fetch_emit_middle_end::base, fetch_emit_middle_end::cache, CALLOC_STRUCT, draw_pt_middle_end::destroy, fetch_emit_middle_end::draw, fetch_emit_destroy(), fetch_emit_finish(), fetch_emit_prepare(), fetch_emit_run(), fetch_emit_run_linear(), fetch_emit_run_linear_elts(), draw_pt_middle_end::finish, FREE, draw_pt_middle_end::prepare, draw_pt_middle_end::run, draw_pt_middle_end::run_linear, draw_pt_middle_end::run_linear_elts, and translate_cache_create().

{
   struct fetch_emit_middle_end *fetch_emit = CALLOC_STRUCT( fetch_emit_middle_end );
   if (fetch_emit == NULL)
      return NULL;

   fetch_emit->cache = translate_cache_create();
   if (!fetch_emit->cache) {
      FREE(fetch_emit);
      return NULL;
   }

   fetch_emit->base.prepare    = fetch_emit_prepare;
   fetch_emit->base.run        = fetch_emit_run;
   fetch_emit->base.run_linear = fetch_emit_run_linear;
   fetch_emit->base.run_linear_elts = fetch_emit_run_linear_elts;
   fetch_emit->base.finish     = fetch_emit_finish;
   fetch_emit->base.destroy    = fetch_emit_destroy;

   fetch_emit->draw = draw;
     
   return &fetch_emit->base;
}

static void fetch_emit_destroy

(

struct draw_pt_middle_end *

middle

)

[static]

Definition at line 379 of file draw_pt_fetch_emit.c.

References fetch_emit_middle_end::cache, FREE, and translate_cache_destroy().

{
   struct fetch_emit_middle_end *feme = (struct fetch_emit_middle_end *)middle;

   if (feme->cache)
      translate_cache_destroy(feme->cache);

   FREE(middle);
}

static void fetch_emit_finish

(

struct draw_pt_middle_end *

middle

)

[static]

Definition at line 374 of file draw_pt_fetch_emit.c.

{
   /* nothing to do */
}

static void fetch_emit_prepare	(	struct draw_pt_middle_end *	middle,
		unsigned	prim,
		unsigned	opt,
		unsigned *	max_vertices
	)			[static]

Definition at line 91 of file draw_pt_fetch_emit.c.

References assert, vertex_info::attrib, pipe_vertex_buffer::buffer_offset, fetch_emit_middle_end::cache, fetch_emit_middle_end::draw, draw, translate_key::element, vertex_info::emit, EMIT_1F, EMIT_1F_PSIZE, EMIT_2F, EMIT_3F, EMIT_4F, vbuf_render::get_vertex_info, translate_element::input_buffer, translate_element::input_format, translate_element::input_offset, translate::key, vbuf_render::max_vertex_buffer_bytes, translate_key::nr_elements, draw_context::nr_vertex_buffers, vertex_info::num_attribs, translate_element::output_format, translate_element::output_offset, translate_key::output_stride, PIPE_FORMAT_NONE, PIPE_FORMAT_R32_FLOAT, PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, pipe_vertex_buffer::pitch, pipe_rasterizer_state::point_size, fetch_emit_middle_end::point_size, draw_context::pt, draw_context::rasterizer, draw_context::render, translate::set_buffer, vbuf_render::set_primitive, vertex_info::size, pipe_vertex_element::src_format, vertex_info::src_index, pipe_vertex_element::src_offset, fetch_emit_middle_end::translate, translate_cache_find(), translate_key_compare(), translate_key_sanitize(), draw_context::user, draw_context::vertex_buffer, pipe_vertex_element::vertex_buffer_index, draw_context::vertex_element, and fetch_emit_middle_end::vinfo.

{
   struct fetch_emit_middle_end *feme = (struct fetch_emit_middle_end *)middle;
   struct draw_context *draw = feme->draw;
   const struct vertex_info *vinfo;
   unsigned i, dst_offset;
   boolean ok;
   struct translate_key key;


   ok = draw->render->set_primitive( draw->render, 
                                     prim );
   if (!ok) {
      assert(0);
      return;
   }
   
   /* Must do this after set_primitive() above:
    */
   vinfo = feme->vinfo = draw->render->get_vertex_info(draw->render);
   
   

   /* Transform from API vertices to HW vertices, skipping the
    * pipeline_vertex intermediate step.
    */
   dst_offset = 0;
   memset(&key, 0, sizeof(key));

   for (i = 0; i < vinfo->num_attribs; i++) {
      const struct pipe_vertex_element *src = &draw->pt.vertex_element[vinfo->attrib[i].src_index];

      unsigned emit_sz = 0;
      unsigned input_format = src->src_format;
      unsigned input_buffer = src->vertex_buffer_index;
      unsigned input_offset = src->src_offset;
      unsigned output_format;

      switch (vinfo->attrib[i].emit) {
      case EMIT_4F:
         output_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
         emit_sz = 4 * sizeof(float);
         break;
      case EMIT_3F:
         output_format = PIPE_FORMAT_R32G32B32_FLOAT;
         emit_sz = 3 * sizeof(float);
         break;
      case EMIT_2F:
         output_format = PIPE_FORMAT_R32G32_FLOAT;
         emit_sz = 2 * sizeof(float);
         break;
      case EMIT_1F:
         output_format = PIPE_FORMAT_R32_FLOAT;
         emit_sz = 1 * sizeof(float);
         break;
      case EMIT_1F_PSIZE:
         input_format = PIPE_FORMAT_R32_FLOAT;
         input_buffer = draw->pt.nr_vertex_buffers;
         input_offset = 0;
         output_format = PIPE_FORMAT_R32_FLOAT;
         emit_sz = 1 * sizeof(float);
         break;
      default:
         assert(0);
         output_format = PIPE_FORMAT_NONE;
         emit_sz = 0;
         continue;
      }

      key.element[i].input_format = input_format;
      key.element[i].input_buffer = input_buffer;
      key.element[i].input_offset = input_offset;
      key.element[i].output_format = output_format;
      key.element[i].output_offset = dst_offset;
      
      dst_offset += emit_sz;
   }

   key.nr_elements = vinfo->num_attribs;
   key.output_stride = vinfo->size * 4;

   /* Don't bother with caching at this stage:
    */
   if (!feme->translate ||
       translate_key_compare(&feme->translate->key, &key) != 0) 
   {
      translate_key_sanitize(&key);
      feme->translate = translate_cache_find(feme->cache,
                                             &key);


      feme->translate->set_buffer(feme->translate, 
                                  draw->pt.nr_vertex_buffers, 
                                  &feme->point_size,
                                  0);
   }
   
   feme->point_size = draw->rasterizer->point_size;

   for (i = 0; i < draw->pt.nr_vertex_buffers; i++) {
      feme->translate->set_buffer(feme->translate, 
                                  i, 
                                  ((char *)draw->pt.user.vbuffer[i] + 
                                   draw->pt.vertex_buffer[i].buffer_offset),
                                  draw->pt.vertex_buffer[i].pitch );
   }

   *max_vertices = (draw->render->max_vertex_buffer_bytes / 
                    (vinfo->size * 4));

   /* Return an even number of verts.
    * This prevents "parity" errors when splitting long triangle strips which
    * can lead to front/back culling mix-ups.
    * Every other triangle in a strip has an alternate front/back orientation
    * so splitting at an odd position can cause the orientation of subsequent
    * triangles to get reversed.
    */
   *max_vertices = *max_vertices & ~1;
}

static void fetch_emit_run	(	struct draw_pt_middle_end *	middle,
		const unsigned *	fetch_elts,
		unsigned	fetch_count,
		const ushort *	draw_elts,
		unsigned	draw_count
	)			[static]

Definition at line 218 of file draw_pt_fetch_emit.c.

References vbuf_render::allocate_vertices, assert, debug_printf(), vbuf_render::draw, fetch_emit_middle_end::draw, draw, draw_do_flush(), draw_dump_emitted_vertex(), DRAW_FLUSH_BACKEND, translate::key, translate_key::output_stride, vbuf_render::release_vertices, draw_context::render, vertex_info::size, fetch_emit_middle_end::translate, and fetch_emit_middle_end::vinfo.

{
   struct fetch_emit_middle_end *feme = (struct fetch_emit_middle_end *)middle;
   struct draw_context *draw = feme->draw;
   void *hw_verts;
   
   /* XXX: need to flush to get prim_vbuf.c to release its allocation?? 
    */
   draw_do_flush( draw, DRAW_FLUSH_BACKEND );

   hw_verts = draw->render->allocate_vertices( draw->render,
                                               (ushort)feme->translate->key.output_stride,
                                               (ushort)fetch_count );
   if (!hw_verts) {
      assert(0);
      return;
   }
         
                                        
   /* Single routine to fetch vertices and emit HW verts.
    */
   feme->translate->run_elts( feme->translate, 
                              fetch_elts,
                              fetch_count,
                              hw_verts );

   if (0) {
      unsigned i;
      for (i = 0; i < fetch_count; i++) {
         debug_printf("\n\nvertex %d:\n", i);
         draw_dump_emitted_vertex( feme->vinfo, 
                                   (const uint8_t *)hw_verts + feme->vinfo->size * 4 * i );
      }
   }

   /* XXX: Draw arrays path to avoid re-emitting index list again and
    * again.
    */
   draw->render->draw( draw->render, 
                       draw_elts, 
                       draw_count );

   /* Done -- that was easy, wasn't it: 
    */
   draw->render->release_vertices( draw->render, 
                                   hw_verts, 
                                   feme->translate->key.output_stride, 
                                   fetch_count );

}

static void fetch_emit_run_linear	(	struct draw_pt_middle_end *	middle,
		unsigned	start,
		unsigned	count
	)			[static]

Definition at line 274 of file draw_pt_fetch_emit.c.

References vbuf_render::allocate_vertices, assert, debug_printf(), fetch_emit_middle_end::draw, draw, vbuf_render::draw_arrays, draw_do_flush(), draw_dump_emitted_vertex(), DRAW_FLUSH_BACKEND, translate::key, translate_key::output_stride, vbuf_render::release_vertices, draw_context::render, vertex_info::size, fetch_emit_middle_end::translate, and fetch_emit_middle_end::vinfo.

{
   struct fetch_emit_middle_end *feme = (struct fetch_emit_middle_end *)middle;
   struct draw_context *draw = feme->draw;
   void *hw_verts;

   /* XXX: need to flush to get prim_vbuf.c to release its allocation??
    */
   draw_do_flush( draw, DRAW_FLUSH_BACKEND );

   hw_verts = draw->render->allocate_vertices( draw->render,
                                               (ushort)feme->translate->key.output_stride,
                                               (ushort)count );
   if (!hw_verts) {
      assert(0);
      return;
   }

   /* Single routine to fetch vertices and emit HW verts.
    */
   feme->translate->run( feme->translate,
                         start,
                         count,
                         hw_verts );

   if (0) {
      unsigned i;
      for (i = 0; i < count; i++) {
         debug_printf("\n\nvertex %d:\n", i);
         draw_dump_emitted_vertex( feme->vinfo,
                                   (const uint8_t *)hw_verts + feme->vinfo->size * 4 * i );
      }
   }

   /* XXX: Draw arrays path to avoid re-emitting index list again and
    * again.
    */
   draw->render->draw_arrays( draw->render,
                              0, /*start*/
                              count );

   /* Done -- that was easy, wasn't it:
    */
   draw->render->release_vertices( draw->render,
                                   hw_verts,
                                   feme->translate->key.output_stride,
                                   count );

}

static boolean fetch_emit_run_linear_elts	(	struct draw_pt_middle_end *	middle,
		unsigned	start,
		unsigned	count,
		const ushort *	draw_elts,
		unsigned	draw_count
	)			[static]

Definition at line 327 of file draw_pt_fetch_emit.c.

References vbuf_render::allocate_vertices, vbuf_render::draw, fetch_emit_middle_end::draw, draw, draw_do_flush(), DRAW_FLUSH_BACKEND, FALSE, translate::key, translate_key::output_stride, vbuf_render::release_vertices, draw_context::render, fetch_emit_middle_end::translate, and TRUE.

{
   struct fetch_emit_middle_end *feme = (struct fetch_emit_middle_end *)middle;
   struct draw_context *draw = feme->draw;
   void *hw_verts;

   /* XXX: need to flush to get prim_vbuf.c to release its allocation??
    */
   draw_do_flush( draw, DRAW_FLUSH_BACKEND );

   hw_verts = draw->render->allocate_vertices( draw->render,
                                               (ushort)feme->translate->key.output_stride,
                                               (ushort)count );
   if (!hw_verts) 
      return FALSE;

   /* Single routine to fetch vertices and emit HW verts.
    */
   feme->translate->run( feme->translate,
                         start,
                         count,
                         hw_verts );

   /* XXX: Draw arrays path to avoid re-emitting index list again and
    * again.
    */
   draw->render->draw( draw->render, 
                       draw_elts, 
                       draw_count );

   /* Done -- that was easy, wasn't it:
    */
   draw->render->release_vertices( draw->render,
                                   hw_verts,
                                   feme->translate->key.output_stride,
                                   count );

   return TRUE;
}

---