draw_pt_fetch_shade_pipeline.c File Reference

Include dependency graph for draw_pt_fetch_shade_pipeline.c:

Go to the source code of this file.

Data Structures
struct	fetch_pipeline_middle_end
Functions
static void	fetch_pipeline_prepare (struct draw_pt_middle_end *middle, unsigned prim, unsigned opt, unsigned *max_vertices)
static void	fetch_pipeline_run (struct draw_pt_middle_end *middle, const unsigned *fetch_elts, unsigned fetch_count, const ushort *draw_elts, unsigned draw_count)
static void	fetch_pipeline_linear_run (struct draw_pt_middle_end *middle, unsigned start, unsigned count)
static boolean	fetch_pipeline_linear_run_elts (struct draw_pt_middle_end *middle, unsigned start, unsigned count, const ushort *draw_elts, unsigned draw_count)
static void	fetch_pipeline_finish (struct draw_pt_middle_end *middle)
static void	fetch_pipeline_destroy (struct draw_pt_middle_end *middle)
struct draw_pt_middle_end *	draw_pt_fetch_pipeline_or_emit (struct draw_context *draw)

---

Function Documentation

struct draw_pt_middle_end* draw_pt_fetch_pipeline_or_emit

(

struct draw_context *

draw

)

[read]

Definition at line 362 of file draw_pt_fetch_shade_pipeline.c.

References fetch_pipeline_middle_end::base, CALLOC_STRUCT, draw_pt_middle_end::destroy, fetch_pipeline_middle_end::draw, draw_pt_emit_create(), draw_pt_fetch_create(), draw_pt_post_vs_create(), fetch_pipeline_middle_end::emit, fetch_pipeline_middle_end::fetch, fetch_pipeline_destroy(), fetch_pipeline_finish(), fetch_pipeline_linear_run(), fetch_pipeline_linear_run_elts(), fetch_pipeline_prepare(), fetch_pipeline_run(), draw_pt_middle_end::finish, fetch_pipeline_middle_end::post_vs, 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_pipeline_middle_end *fpme = CALLOC_STRUCT( fetch_pipeline_middle_end );
   if (!fpme)
      goto fail;

   fpme->base.prepare        = fetch_pipeline_prepare;
   fpme->base.run            = fetch_pipeline_run;
   fpme->base.run_linear     = fetch_pipeline_linear_run;
   fpme->base.run_linear_elts = fetch_pipeline_linear_run_elts;
   fpme->base.finish         = fetch_pipeline_finish;
   fpme->base.destroy        = fetch_pipeline_destroy;

   fpme->draw = draw;

   fpme->fetch = draw_pt_fetch_create( draw );
   if (!fpme->fetch)
      goto fail;

   fpme->post_vs = draw_pt_post_vs_create( draw );
   if (!fpme->post_vs)
      goto fail;

   fpme->emit = draw_pt_emit_create( draw );
   if (!fpme->emit) 
      goto fail;

   return &fpme->base;

 fail:
   if (fpme)
      fetch_pipeline_destroy( &fpme->base );

   return NULL;
}

static void fetch_pipeline_destroy

(

struct draw_pt_middle_end *

middle

)

[static]

Definition at line 345 of file draw_pt_fetch_shade_pipeline.c.

References draw_pt_emit_destroy(), draw_pt_fetch_destroy(), draw_pt_post_vs_destroy(), fetch_pipeline_middle_end::emit, fetch_pipeline_middle_end::fetch, FREE, and fetch_pipeline_middle_end::post_vs.

{
   struct fetch_pipeline_middle_end *fpme = (struct fetch_pipeline_middle_end *)middle;

   if (fpme->fetch)
      draw_pt_fetch_destroy( fpme->fetch );

   if (fpme->emit)
      draw_pt_emit_destroy( fpme->emit );

   if (fpme->post_vs)
      draw_pt_post_vs_destroy( fpme->post_vs );

   FREE(middle);
}

static void fetch_pipeline_finish

(

struct draw_pt_middle_end *

middle

)

[static]

Definition at line 340 of file draw_pt_fetch_shade_pipeline.c.

{
   /* nothing to do */
}

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

Definition at line 191 of file draw_pt_fetch_shade_pipeline.c.

References align(), assert, fetch_pipeline_middle_end::draw, draw, draw_pipeline_run_linear(), draw_pt_emit_linear(), draw_pt_fetch_run_linear(), draw_pt_post_vs_run(), fetch_pipeline_middle_end::emit, fetch_pipeline_middle_end::fetch, FREE, MALLOC, fetch_pipeline_middle_end::opt, fetch_pipeline_middle_end::post_vs, fetch_pipeline_middle_end::prim, draw_context::pt, PT_PIPELINE, PT_SHADE, draw_vertex_shader::run_linear, draw_context::user, draw_context::vertex_shader, fetch_pipeline_middle_end::vertex_size, and draw_context::vs.

{
   struct fetch_pipeline_middle_end *fpme = (struct fetch_pipeline_middle_end *)middle;
   struct draw_context *draw = fpme->draw;
   struct draw_vertex_shader *shader = draw->vs.vertex_shader;
   unsigned opt = fpme->opt;
   unsigned alloc_count = align( count, 4 );

   struct vertex_header *pipeline_verts =
      (struct vertex_header *)MALLOC(fpme->vertex_size * alloc_count);

   if (!pipeline_verts) {
      /* Not much we can do here - just skip the rendering.
       */
      assert(0);
      return;
   }

   /* Fetch into our vertex buffer
    */
   draw_pt_fetch_run_linear( fpme->fetch,
                             start,
                             count,
                             (char *)pipeline_verts );

   /* Run the shader, note that this overwrites the data[] parts of
    * the pipeline verts.  If there is no shader, ie a bypass shader,
    * then the inputs == outputs, and are already in the correct
    * place.
    */
   if (opt & PT_SHADE)
   {
      shader->run_linear(shader,
                         (const float (*)[4])pipeline_verts->data,
                         (      float (*)[4])pipeline_verts->data,
                         (const float (*)[4])draw->pt.user.constants,
                         count,
                         fpme->vertex_size,
                         fpme->vertex_size);
   }

   if (draw_pt_post_vs_run( fpme->post_vs,
                            pipeline_verts,
                            count,
                            fpme->vertex_size ))
   {
      opt |= PT_PIPELINE;
   }

   /* Do we need to run the pipeline?
    */
   if (opt & PT_PIPELINE) {
      draw_pipeline_run_linear( fpme->draw,
                                fpme->prim,
                                pipeline_verts,
                                count,
                                fpme->vertex_size);
   }
   else {
      draw_pt_emit_linear( fpme->emit,
                           (const float (*)[4])pipeline_verts->data,
                           count,
                           fpme->vertex_size,
                           0, /*start*/
                           count );
   }

   FREE(pipeline_verts);
}

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

Definition at line 265 of file draw_pt_fetch_shade_pipeline.c.

References align(), fetch_pipeline_middle_end::draw, draw, draw_pipeline_run(), draw_pt_emit(), draw_pt_fetch_run_linear(), draw_pt_post_vs_run(), fetch_pipeline_middle_end::emit, FALSE, fetch_pipeline_middle_end::fetch, FREE, MALLOC, fetch_pipeline_middle_end::opt, fetch_pipeline_middle_end::post_vs, fetch_pipeline_middle_end::prim, draw_context::pt, PT_PIPELINE, PT_SHADE, draw_vertex_shader::run_linear, TRUE, draw_context::user, draw_context::vertex_shader, fetch_pipeline_middle_end::vertex_size, and draw_context::vs.

{
   struct fetch_pipeline_middle_end *fpme = (struct fetch_pipeline_middle_end *)middle;
   struct draw_context *draw = fpme->draw;
   struct draw_vertex_shader *shader = draw->vs.vertex_shader;
   unsigned opt = fpme->opt;
   unsigned alloc_count = align( count, 4 );

   struct vertex_header *pipeline_verts =
      (struct vertex_header *)MALLOC(fpme->vertex_size * alloc_count);

   if (!pipeline_verts) 
      return FALSE;

   /* Fetch into our vertex buffer
    */
   draw_pt_fetch_run_linear( fpme->fetch,
                             start,
                             count,
                             (char *)pipeline_verts );

   /* Run the shader, note that this overwrites the data[] parts of
    * the pipeline verts.  If there is no shader, ie a bypass shader,
    * then the inputs == outputs, and are already in the correct
    * place.
    */
   if (opt & PT_SHADE)
   {
      shader->run_linear(shader,
                         (const float (*)[4])pipeline_verts->data,
                         (      float (*)[4])pipeline_verts->data,
                         (const float (*)[4])draw->pt.user.constants,
                         count,
                         fpme->vertex_size,
                         fpme->vertex_size);
   }

   if (draw_pt_post_vs_run( fpme->post_vs,
                            pipeline_verts,
                            count,
                            fpme->vertex_size ))
   {
      opt |= PT_PIPELINE;
   }

   /* Do we need to run the pipeline?
    */
   if (opt & PT_PIPELINE) {
      draw_pipeline_run( fpme->draw,
                         fpme->prim,
                         pipeline_verts,
                         count,
                         fpme->vertex_size,
                         draw_elts,
                         draw_count );
   }
   else {
      draw_pt_emit( fpme->emit,
                    (const float (*)[4])pipeline_verts->data,
                    count,
                    fpme->vertex_size,
                    draw_elts,
                    draw_count );
   }

   FREE(pipeline_verts);
   return TRUE;
}

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

Definition at line 53 of file draw_pt_fetch_shade_pipeline.c.

References draw_context::bypass_clipping, fetch_pipeline_middle_end::draw, draw, DRAW_PIPE_MAX_VERTICES, draw_pt_emit_prepare(), draw_pt_fetch_prepare(), draw_pt_post_vs_prepare(), fetch_pipeline_middle_end::emit, fetch_pipeline_middle_end::fetch, pipe_rasterizer_state::gl_rasterization_rules, draw_context::identity_viewport, draw_vertex_shader::info, MAX2, tgsi_shader_info::num_inputs, tgsi_shader_info::num_outputs, fetch_pipeline_middle_end::opt, fetch_pipeline_middle_end::post_vs, draw_vertex_shader::prepare, fetch_pipeline_middle_end::prim, PT_PIPELINE, draw_context::rasterizer, draw_context::vertex_shader, fetch_pipeline_middle_end::vertex_size, and draw_context::vs.

{
   struct fetch_pipeline_middle_end *fpme = (struct fetch_pipeline_middle_end *)middle;
   struct draw_context *draw = fpme->draw;
   struct draw_vertex_shader *vs = draw->vs.vertex_shader;

   /* Add one to num_outputs because the pipeline occasionally tags on
    * an additional texcoord, eg for AA lines.
    */
   unsigned nr = MAX2( vs->info.num_inputs,
                       vs->info.num_outputs + 1 );

   fpme->prim = prim;
   fpme->opt = opt;

   /* Always leave room for the vertex header whether we need it or
    * not.  It's hard to get rid of it in particular because of the
    * viewport code in draw_pt_post_vs.c.  
    */
   fpme->vertex_size = sizeof(struct vertex_header) + nr * 4 * sizeof(float);

   

   draw_pt_fetch_prepare( fpme->fetch, 
                          fpme->vertex_size );

   /* XXX: it's not really gl rasterization rules we care about here,
    * but gl vs dx9 clip spaces.
    */
   draw_pt_post_vs_prepare( fpme->post_vs,
                            (boolean)draw->bypass_clipping,
                            (boolean)draw->identity_viewport,
                            (boolean)draw->rasterizer->gl_rasterization_rules );
                            

   if (!(opt & PT_PIPELINE)) {
      draw_pt_emit_prepare( fpme->emit, 
                            prim,
                            max_vertices );

      *max_vertices = MAX2( *max_vertices,
                            DRAW_PIPE_MAX_VERTICES );
   }
   else {
      *max_vertices = DRAW_PIPE_MAX_VERTICES; 
   }

   /* return even number */
   *max_vertices = *max_vertices & ~1;

   /* No need to prepare the shader.
    */
   vs->prepare(vs, draw);
}

static void fetch_pipeline_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 113 of file draw_pt_fetch_shade_pipeline.c.

References align(), assert, fetch_pipeline_middle_end::draw, draw, draw_pipeline_run(), draw_pt_emit(), draw_pt_fetch_run(), draw_pt_post_vs_run(), fetch_pipeline_middle_end::emit, fetch_pipeline_middle_end::fetch, FREE, MALLOC, fetch_pipeline_middle_end::opt, fetch_pipeline_middle_end::post_vs, fetch_pipeline_middle_end::prim, draw_context::pt, PT_PIPELINE, PT_SHADE, draw_vertex_shader::run_linear, draw_context::user, draw_context::vertex_shader, fetch_pipeline_middle_end::vertex_size, and draw_context::vs.

{
   struct fetch_pipeline_middle_end *fpme = (struct fetch_pipeline_middle_end *)middle;
   struct draw_context *draw = fpme->draw;
   struct draw_vertex_shader *shader = draw->vs.vertex_shader;
   unsigned opt = fpme->opt;
   unsigned alloc_count = align( fetch_count, 4 );

   struct vertex_header *pipeline_verts = 
      (struct vertex_header *)MALLOC(fpme->vertex_size * alloc_count);

   if (!pipeline_verts) {
      /* Not much we can do here - just skip the rendering.
       */
      assert(0);
      return;
   }

   /* Fetch into our vertex buffer
    */
   draw_pt_fetch_run( fpme->fetch,
                      fetch_elts, 
                      fetch_count,
                      (char *)pipeline_verts );

   /* Run the shader, note that this overwrites the data[] parts of
    * the pipeline verts.  If there is no shader, ie a bypass shader,
    * then the inputs == outputs, and are already in the correct
    * place.
    */
   if (opt & PT_SHADE)
   {
      shader->run_linear(shader, 
                         (const float (*)[4])pipeline_verts->data,
                         (      float (*)[4])pipeline_verts->data,
                         (const float (*)[4])draw->pt.user.constants,
                         fetch_count,
                         fpme->vertex_size,
                         fpme->vertex_size);
   }

   if (draw_pt_post_vs_run( fpme->post_vs,
                            pipeline_verts,
                            fetch_count,
                            fpme->vertex_size ))
   {
      opt |= PT_PIPELINE;
   }

   /* Do we need to run the pipeline?
    */
   if (opt & PT_PIPELINE) {
      draw_pipeline_run( fpme->draw,
                         fpme->prim,
                         pipeline_verts,
                         fetch_count,
                         fpme->vertex_size,
                         draw_elts,
                         draw_count );
   }
   else {
      draw_pt_emit( fpme->emit,
                    (const float (*)[4])pipeline_verts->data,
                    fetch_count,
                    fpme->vertex_size,
                    draw_elts,
                    draw_count );
   }


   FREE(pipeline_verts);
}

---