draw_pt_fetch_shade_emit.c File Reference

Include dependency graph for draw_pt_fetch_shade_emit.c:

Go to the source code of this file.

Data Structures
struct	fetch_shade_emit
Functions
static void	fse_prepare (struct draw_pt_middle_end *middle, unsigned prim, unsigned opt, unsigned *max_vertices)
static void	fse_run_linear (struct draw_pt_middle_end *middle, unsigned start, unsigned count)
static void	fse_run (struct draw_pt_middle_end *middle, const unsigned *fetch_elts, unsigned fetch_count, const ushort *draw_elts, unsigned draw_count)
static boolean	fse_run_linear_elts (struct draw_pt_middle_end *middle, unsigned start, unsigned count, const ushort *draw_elts, unsigned draw_count)
static void	fse_finish (struct draw_pt_middle_end *middle)
static void	fse_destroy (struct draw_pt_middle_end *middle)
struct draw_pt_middle_end *	draw_pt_middle_fse (struct draw_context *draw)

---

Function Documentation

struct draw_pt_middle_end* draw_pt_middle_fse

(

struct draw_context *

draw

)

[read]

Definition at line 394 of file draw_pt_fetch_shade_emit.c.

References fetch_shade_emit::base, CALLOC_STRUCT, draw_pt_middle_end::destroy, fetch_shade_emit::draw, draw_pt_middle_end::finish, fse_destroy(), fse_finish(), fse_prepare(), fse_run(), fse_run_linear(), fse_run_linear_elts(), draw_pt_middle_end::prepare, draw_pt_middle_end::run, draw_pt_middle_end::run_linear, and draw_pt_middle_end::run_linear_elts.

{
   struct fetch_shade_emit *fse = CALLOC_STRUCT(fetch_shade_emit);
   if (!fse)
      return NULL;

   fse->base.prepare = fse_prepare;
   fse->base.run = fse_run;
   fse->base.run_linear = fse_run_linear;
   fse->base.run_linear_elts = fse_run_linear_elts;
   fse->base.finish = fse_finish;
   fse->base.destroy = fse_destroy;
   fse->draw = draw;

   return &fse->base;
}

static void fse_destroy

(

struct draw_pt_middle_end *

middle

)

[static]

Definition at line 389 of file draw_pt_fetch_shade_emit.c.

References FREE.

{
   FREE(middle);
}

static void fse_finish

(

struct draw_pt_middle_end *

middle

)

[static]

Definition at line 383 of file draw_pt_fetch_shade_emit.c.

{
}

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

Definition at line 72 of file draw_pt_fetch_shade_emit.c.

References fetch_shade_emit::active, assert, vertex_info::attrib, draw_varient_input::buffer, pipe_vertex_buffer::buffer_offset, draw_context::bypass_clipping, draw_vs_varient_key::clip, draw_vs_varient_key::const_vbuffers, debug_printf(), fetch_shade_emit::draw, draw, draw_vs_lookup_varient(), draw_vs_varient_key::element, vertex_info::emit, EMIT_1F, EMIT_1F_PSIZE, EMIT_2F, EMIT_3F, EMIT_4F, EMIT_4UB, draw_varient_output::format, draw_varient_input::format, vbuf_render::get_vertex_info, draw_context::identity_viewport, draw_varient_element::in, draw_vertex_shader::info, draw_vs_varient::key, fetch_shade_emit::key, MAX2, vbuf_render::max_vertex_buffer_bytes, draw_vs_varient_key::nr_elements, draw_vs_varient_key::nr_inputs, draw_vs_varient_key::nr_outputs, draw_context::nr_vertex_buffers, vertex_info::num_attribs, tgsi_shader_info::num_inputs, draw_varient_output::offset, draw_varient_input::offset, draw_varient_element::out, draw_vs_varient_key::output_stride, pipe_vertex_buffer::pitch, draw_vertex_shader::prepare, draw_context::pt, draw_context::render, draw_vs_varient::set_buffer, vbuf_render::set_primitive, vertex_info::size, pipe_vertex_element::src_format, vertex_info::src_index, pipe_vertex_element::src_offset, draw_context::user, draw_context::vertex_buffer, pipe_vertex_element::vertex_buffer_index, draw_context::vertex_element, draw_context::vertex_shader, draw_vs_varient_key::viewport, fetch_shade_emit::vinfo, draw_context::vs, and draw_varient_output::vs_output.

{
   struct fetch_shade_emit *fse = (struct fetch_shade_emit *)middle;
   struct draw_context *draw = fse->draw;
   unsigned num_vs_inputs = draw->vs.vertex_shader->info.num_inputs;
   const struct vertex_info *vinfo;
   unsigned i;
   unsigned nr_vbs = 0;
   

   if (!draw->render->set_primitive( draw->render, 
                                     prim )) {
      assert(0);
      return;
   }

   /* Must do this after set_primitive() above:
    */
   fse->vinfo = vinfo = draw->render->get_vertex_info(draw->render);
   


   fse->key.output_stride = vinfo->size * 4;
   fse->key.nr_outputs = vinfo->num_attribs;
   fse->key.nr_inputs = num_vs_inputs;

   fse->key.nr_elements = MAX2(fse->key.nr_outputs,     /* outputs - translate to hw format */
                               fse->key.nr_inputs);     /* inputs - fetch from api format */

   fse->key.viewport = !draw->identity_viewport;
   fse->key.clip = !draw->bypass_clipping;
   fse->key.const_vbuffers = 0;

   memset(fse->key.element, 0, 
          fse->key.nr_elements * sizeof(fse->key.element[0]));

   for (i = 0; i < num_vs_inputs; i++) {
      const struct pipe_vertex_element *src = &draw->pt.vertex_element[i];
      fse->key.element[i].in.format = src->src_format;

      /* Consider ignoring these, ie make generated programs
       * independent of this state:
       */
      fse->key.element[i].in.buffer = src->vertex_buffer_index;
      fse->key.element[i].in.offset = src->src_offset;
      nr_vbs = MAX2(nr_vbs, src->vertex_buffer_index + 1);
   }
   
   for (i = 0; i < 5 && i < nr_vbs; i++) {
      if (draw->pt.vertex_buffer[i].pitch == 0)
         fse->key.const_vbuffers |= (1<<i);
   }

   if (0) debug_printf("%s: lookup const_vbuffers: %x\n", __FUNCTION__, fse->key.const_vbuffers);
   
   {
      unsigned dst_offset = 0;

      for (i = 0; i < vinfo->num_attribs; i++) {
         unsigned emit_sz = 0;

         switch (vinfo->attrib[i].emit) {
         case EMIT_4F:
            emit_sz = 4 * sizeof(float);
            break;
         case EMIT_3F:
            emit_sz = 3 * sizeof(float);
            break;
         case EMIT_2F:
            emit_sz = 2 * sizeof(float);
            break;
         case EMIT_1F:
            emit_sz = 1 * sizeof(float);
            break;
         case EMIT_1F_PSIZE:
            emit_sz = 1 * sizeof(float);
            break;
         case EMIT_4UB:
            emit_sz = 4 * sizeof(ubyte);
            break;
         default:
            assert(0);
            break;
         }

         /* The elements in the key correspond to vertex shader output
          * numbers, not to positions in the hw vertex description --
          * that's handled by the output_offset field.
          */
         fse->key.element[i].out.format = vinfo->attrib[i].emit;
         fse->key.element[i].out.vs_output = vinfo->attrib[i].src_index;
         fse->key.element[i].out.offset = dst_offset;
      
         dst_offset += emit_sz;
         assert(fse->key.output_stride >= dst_offset);
      }
   }

   
   fse->active = draw_vs_lookup_varient( draw->vs.vertex_shader, 
                                         &fse->key );

   if (!fse->active) {
      assert(0);
      return ;
   }

   if (0) debug_printf("%s: found const_vbuffers: %x\n", __FUNCTION__, 
                       fse->active->key.const_vbuffers);

   /* Now set buffer pointers:
    */
   for (i = 0; i < draw->pt.nr_vertex_buffers; i++) {
      fse->active->set_buffer( fse->active, 
                               i, 
                               ((const ubyte *) 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;

   /* Probably need to do this somewhere (or fix exec shader not to
    * need it):
    */
   if (1) {
      struct draw_vertex_shader *vs = draw->vs.vertex_shader;
      vs->prepare(vs, draw);
   }
   

   //return TRUE;
}

static void fse_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 282 of file draw_pt_fetch_shade_emit.c.

References fetch_shade_emit::active, vbuf_render::allocate_vertices, assert, debug_printf(), vbuf_render::draw, fetch_shade_emit::draw, draw, draw_do_flush(), draw_dump_emitted_vertex(), DRAW_FLUSH_BACKEND, fetch_shade_emit::key, draw_vs_varient_key::output_stride, vbuf_render::release_vertices, draw_context::render, and fetch_shade_emit::vinfo.

{
   struct fetch_shade_emit *fse = (struct fetch_shade_emit *)middle;
   struct draw_context *draw = fse->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)fse->key.output_stride,
                                               (ushort)fetch_count );
   if (!hw_verts) {
      assert(0);
      return;
   }
         
                                        
   /* Single routine to fetch vertices, run shader and emit HW verts.
    */
   fse->active->run_elts( fse->active, 
                          fetch_elts,
                          fetch_count,
                          hw_verts );

   draw->render->draw( draw->render, 
                       draw_elts, 
                       draw_count );

   if (0) {
      unsigned i;
      for (i = 0; i < fetch_count; i++) {
         debug_printf("\n\n%s vertex %d:\n", __FUNCTION__, i);
         draw_dump_emitted_vertex( fse->vinfo, 
                                   (const uint8_t *)hw_verts + 
                                   fse->key.output_stride * i );
      }
   }


   draw->render->release_vertices( draw->render, 
                                   hw_verts, 
                                   fse->key.output_stride, 
                                   fetch_count );

}

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

Definition at line 225 of file draw_pt_fetch_shade_emit.c.

References fetch_shade_emit::active, vbuf_render::allocate_vertices, assert, debug_printf(), fetch_shade_emit::draw, draw, vbuf_render::draw_arrays, draw_do_flush(), draw_dump_emitted_vertex(), DRAW_FLUSH_BACKEND, fetch_shade_emit::key, draw_vs_varient_key::output_stride, vbuf_render::release_vertices, draw_context::render, and fetch_shade_emit::vinfo.

{
   struct fetch_shade_emit *fse = (struct fetch_shade_emit *)middle;
   struct draw_context *draw = fse->draw;
   char *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)fse->key.output_stride,
                                               (ushort)count );

   if (!hw_verts) {
      assert(0);
      return;
   }

   /* Single routine to fetch vertices, run shader and emit HW verts.
    * Clipping is done elsewhere -- either by the API or on hardware,
    * or for some other reason not required...
    */
   fse->active->run_linear( fse->active, 
                            start, count,
                            hw_verts );

   /* Draw arrays path to avoid re-emitting index list again and
    * again.
    */
   draw->render->draw_arrays( draw->render,
                              0,
                              count );
   
   if (0) {
      unsigned i;
      for (i = 0; i < count; i++) {
         debug_printf("\n\n%s vertex %d: (stride %d, offset %d)\n", __FUNCTION__, i,
                      fse->key.output_stride,
                      fse->key.output_stride * i);

         draw_dump_emitted_vertex( fse->vinfo, 
                                   (const uint8_t *)hw_verts + fse->key.output_stride * i );
      }
   }


   draw->render->release_vertices( draw->render, 
                                   hw_verts, 
                                   fse->key.output_stride, 
                                   count );
}

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

Definition at line 336 of file draw_pt_fetch_shade_emit.c.

References fetch_shade_emit::active, vbuf_render::allocate_vertices, vbuf_render::draw, fetch_shade_emit::draw, draw, draw_do_flush(), DRAW_FLUSH_BACKEND, FALSE, fetch_shade_emit::key, draw_vs_varient_key::output_stride, vbuf_render::release_vertices, draw_context::render, and TRUE.

{
   struct fetch_shade_emit *fse = (struct fetch_shade_emit *)middle;
   struct draw_context *draw = fse->draw;
   char *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)fse->key.output_stride,
                                               (ushort)count );

   if (!hw_verts) {
      return FALSE;
   }

   /* Single routine to fetch vertices, run shader and emit HW verts.
    * Clipping is done elsewhere -- either by the API or on hardware,
    * or for some other reason not required...
    */
   fse->active->run_linear( fse->active, 
                            start, count,
                            hw_verts );


   draw->render->draw( draw->render, 
                       draw_elts, 
                       draw_count );
   


   draw->render->release_vertices( draw->render, 
                                   hw_verts, 
                                   fse->key.output_stride, 
                                   count );

   return TRUE;
}

---