draw_context.h File Reference

Include dependency graph for draw_context.h:

Go to the source code of this file.

Functions
struct draw_context *	draw_create (void)
void	draw_destroy (struct draw_context *draw)
void	draw_set_viewport_state (struct draw_context *draw, const struct pipe_viewport_state *viewport)
	Set the draw module's viewport state.
void	draw_set_clip_state (struct draw_context *pipe, const struct pipe_clip_state *clip)
	Set the draw module's clipping state.
void	draw_set_rasterizer_state (struct draw_context *draw, const struct pipe_rasterizer_state *raster)
	Register new primitive rasterization/rendering state.
void	draw_set_rasterize_stage (struct draw_context *draw, struct draw_stage *stage)
	Plug in the primitive rendering/rasterization stage (which is the last stage in the drawing pipeline).
void	draw_wide_point_threshold (struct draw_context *draw, float threshold)
	Tells the draw module to draw points with triangles if their size is greater than this threshold.
void	draw_wide_line_threshold (struct draw_context *draw, float threshold)
	Tells the draw module to draw lines with triangles if their width is greater than this threshold.
void	draw_enable_line_stipple (struct draw_context *draw, boolean enable)
	Tells the draw module whether or not to implement line stipple.
void	draw_enable_point_sprites (struct draw_context *draw, boolean enable)
	Tells draw module whether to convert points to quads for sprite mode.
void	draw_set_mrd (struct draw_context *draw, double mrd)
	Specify the Minimum Resolvable Depth factor for polygon offset.
boolean	draw_install_aaline_stage (struct draw_context *draw, struct pipe_context *pipe)
	Called by drivers that want to install this AA line prim stage into the draw module's pipeline.
boolean	draw_install_aapoint_stage (struct draw_context *draw, struct pipe_context *pipe)
	Called by drivers that want to install this AA point prim stage into the draw module's pipeline.
boolean	draw_install_pstipple_stage (struct draw_context *draw, struct pipe_context *pipe)
	Called by drivers that want to install this polygon stipple stage into the draw module's pipeline.
int	draw_find_vs_output (const struct draw_context *draw, uint semantic_name, uint semantic_index)
	Ask the draw module for the location/slot of the given vertex attribute in a post-transformed vertex.
uint	draw_num_vs_outputs (const struct draw_context *draw)
	Return number of vertex shader outputs.
struct draw_vertex_shader *	draw_create_vertex_shader (struct draw_context *draw, const struct pipe_shader_state *shader)
void	draw_bind_vertex_shader (struct draw_context *draw, struct draw_vertex_shader *dvs)
void	draw_delete_vertex_shader (struct draw_context *draw, struct draw_vertex_shader *dvs)
void	draw_set_vertex_buffers (struct draw_context *draw, unsigned count, const struct pipe_vertex_buffer *buffers)
void	draw_set_vertex_elements (struct draw_context *draw, unsigned count, const struct pipe_vertex_element *elements)
void	draw_set_mapped_element_buffer_range (struct draw_context *draw, unsigned eltSize, unsigned min_index, unsigned max_index, const void *elements)
	Tell the drawing context about the index/element buffer to use (ala glDrawElements) If no element buffer is to be used (i.e.
void	draw_set_mapped_element_buffer (struct draw_context *draw, unsigned eltSize, const void *elements)
void	draw_set_mapped_vertex_buffer (struct draw_context *draw, unsigned attr, const void *buffer)
	Tell drawing context where to find mapped vertex buffers.
void	draw_set_mapped_constant_buffer (struct draw_context *draw, const void *buffer, unsigned size)
void	draw_set_edgeflags (struct draw_context *draw, const unsigned *edgeflag)
void	draw_arrays (struct draw_context *draw, unsigned prim, unsigned start, unsigned count)
	Draw vertex arrays This is the main entrypoint into the drawing module.
void	draw_flush (struct draw_context *draw)
void	draw_set_render (struct draw_context *draw, struct vbuf_render *render)
void	draw_set_driver_clipping (struct draw_context *draw, boolean bypass_clipping)
void	draw_set_force_passthrough (struct draw_context *draw, boolean enable)
boolean	draw_need_pipeline (const struct draw_context *draw, const struct pipe_rasterizer_state *rasterizer, unsigned prim)

---

Function Documentation

void draw_arrays	(	struct draw_context *	draw,
		unsigned	prim,
		unsigned	start,
		unsigned	count
	)

Draw vertex arrays This is the main entrypoint into the drawing module.

Parameters:

	prim	one of PIPE_PRIM_x
	start	index of first vertex to draw
	count	number of vertices to draw

Definition at line 278 of file draw_pt.c.

References pipe_vertex_buffer::buffer_offset, debug_printf(), draw_do_flush(), DRAW_FLUSH_STATE_CHANGE, draw_print_arrays(), draw_pt_arrays(), draw_pt_reduced_prim(), MIN2, pipe_vertex_element::nr_components, draw_context::nr_vertex_buffers, draw_context::nr_vertex_elements, pf_name(), pipe_vertex_buffer::pitch, draw_context::pt, draw_context::reduced_prim, reduced_prim, pipe_vertex_element::src_format, draw_vertex_shader::state, tgsi_dump(), pipe_shader_state::tokens, draw_context::user, draw_context::vertex_buffer, draw_context::vertex_element, draw_context::vertex_shader, and draw_context::vs.

{
   unsigned reduced_prim = draw_pt_reduced_prim(prim);
   if (reduced_prim != draw->reduced_prim) {
      draw_do_flush( draw, DRAW_FLUSH_STATE_CHANGE );
      draw->reduced_prim = reduced_prim;
   }

   if (0)
      draw_print_arrays(draw, prim, start, MIN2(count, 20));

#if 0
   {
      int i;
      debug_printf("draw_arrays(prim=%u start=%u count=%u):\n",
                   prim, start, count);
      tgsi_dump(draw->vs.vertex_shader->state.tokens, 0);
      debug_printf("Elements:\n");
      for (i = 0; i < draw->pt.nr_vertex_elements; i++) {
         debug_printf("  format=%s comps=%u\n",
                      pf_name(draw->pt.vertex_element[i].src_format),
                      draw->pt.vertex_element[i].nr_components);
      }
      debug_printf("Buffers:\n");
      for (i = 0; i < draw->pt.nr_vertex_buffers; i++) {
         debug_printf("  pitch=%u offset=%u ptr=%p\n",
                      draw->pt.vertex_buffer[i].pitch,
                      draw->pt.vertex_buffer[i].buffer_offset,
                      draw->pt.user.vbuffer[i]);
      }
   }
#endif

   /* drawing done here: */
   draw_pt_arrays(draw, prim, start, count);
}

void draw_bind_vertex_shader	(	struct draw_context *	draw,
		struct draw_vertex_shader *	dvs
	)

Definition at line 108 of file draw_vs.c.

References draw_do_flush(), DRAW_FLUSH_STATE_CHANGE, draw_vertex_shader::info, tgsi_shader_info::num_outputs, draw_context::num_vs_outputs, draw_vertex_shader::position_output, draw_context::position_output, draw_vertex_shader::prepare, draw_context::vertex_shader, and draw_context::vs.

{
   draw_do_flush( draw, DRAW_FLUSH_STATE_CHANGE );
   
   if (dvs) 
   {
      draw->vs.vertex_shader = dvs;
      draw->vs.num_vs_outputs = dvs->info.num_outputs;
      draw->vs.position_output = dvs->position_output;
      dvs->prepare( dvs, draw );
   }
   else {
      draw->vs.vertex_shader = NULL;
      draw->vs.num_vs_outputs = 0;
   }
}

struct draw_context* draw_create

(

void

)

[read]

Definition at line 43 of file draw_context.c.

References ASSIGN_4V, CALLOC_STRUCT, draw, draw_destroy(), draw_pipeline_init(), draw_pt_init(), draw_vs_init(), draw_context::nr_planes, draw_context::plane, and draw_context::reduced_prim.

{
   struct draw_context *draw = CALLOC_STRUCT( draw_context );
   if (draw == NULL)
      goto fail;

   ASSIGN_4V( draw->plane[0], -1,  0,  0, 1 );
   ASSIGN_4V( draw->plane[1],  1,  0,  0, 1 );
   ASSIGN_4V( draw->plane[2],  0, -1,  0, 1 );
   ASSIGN_4V( draw->plane[3],  0,  1,  0, 1 );
   ASSIGN_4V( draw->plane[4],  0,  0,  1, 1 ); /* yes these are correct */
   ASSIGN_4V( draw->plane[5],  0,  0, -1, 1 ); /* mesa's a bit wonky */
   draw->nr_planes = 6;


   draw->reduced_prim = ~0; /* != any of PIPE_PRIM_x */


   if (!draw_pipeline_init( draw ))
      goto fail;

   if (!draw_pt_init( draw ))
      goto fail;

   if (!draw_vs_init( draw ))
      goto fail;

   return draw;

fail:
   draw_destroy( draw );   
   return NULL;
}

struct draw_vertex_shader* draw_create_vertex_shader	(	struct draw_context *	draw,
		const struct pipe_shader_state *	shader
	)			[read]

Definition at line 79 of file draw_vs.c.

References assert, draw_create_vs_exec(), draw_create_vs_llvm(), draw_create_vs_sse(), draw_vertex_shader::info, tgsi_shader_info::num_outputs, tgsi_shader_info::output_semantic_index, tgsi_shader_info::output_semantic_name, draw_vertex_shader::position_output, and TGSI_SEMANTIC_POSITION.

{
   struct draw_vertex_shader *vs;

   vs = draw_create_vs_llvm( draw, shader );
   if (!vs) {
      vs = draw_create_vs_sse( draw, shader );
      if (!vs) {
         vs = draw_create_vs_exec( draw, shader );
      }
   }

   if (vs)
   {
      uint i;
      for (i = 0; i < vs->info.num_outputs; i++) {
         if (vs->info.output_semantic_name[i] == TGSI_SEMANTIC_POSITION &&
             vs->info.output_semantic_index[i] == 0)
            vs->position_output = i;
      }
   }

   assert(vs);
   return vs;
}

void draw_delete_vertex_shader	(	struct draw_context *	draw,
		struct draw_vertex_shader *	dvs
	)

Definition at line 128 of file draw_vs.c.

References draw_vertex_shader::delete, draw_vs_varient::destroy, draw_vertex_shader::nr_varients, and draw_vertex_shader::varient.

{
   unsigned i;

   for (i = 0; i < dvs->nr_varients; i++) 
      dvs->varient[i]->destroy( dvs->varient[i] );

   dvs->nr_varients = 0;

   dvs->delete( dvs );
}

void draw_destroy

(

struct draw_context *

draw

)

Definition at line 78 of file draw_context.c.

References draw_pipeline_destroy(), draw_pt_destroy(), draw_vs_destroy(), and FREE.

{
   if (!draw)
      return;



   /* Not so fast -- we're just borrowing this at the moment.
    * 
   if (draw->render)
      draw->render->destroy( draw->render );
   */

   draw_pipeline_destroy( draw );
   draw_pt_destroy( draw );
   draw_vs_destroy( draw );

   FREE( draw );
}

void draw_enable_line_stipple	(	struct draw_context *	draw,
		boolean	enable
	)

Tells the draw module whether or not to implement line stipple.

Definition at line 269 of file draw_context.c.

References draw_do_flush(), DRAW_FLUSH_STATE_CHANGE, draw_context::line_stipple, and draw_context::pipeline.

{
   draw_do_flush( draw, DRAW_FLUSH_STATE_CHANGE );
   draw->pipeline.line_stipple = enable;
}

void draw_enable_point_sprites	(	struct draw_context *	draw,
		boolean	enable
	)

Tells draw module whether to convert points to quads for sprite mode.

Definition at line 280 of file draw_context.c.

References draw_do_flush(), DRAW_FLUSH_STATE_CHANGE, draw_context::pipeline, and draw_context::point_sprite.

{
   draw_do_flush( draw, DRAW_FLUSH_STATE_CHANGE );
   draw->pipeline.point_sprite = enable;
}

int draw_find_vs_output	(	const struct draw_context *	draw,
		uint	semantic_name,
		uint	semantic_index
	)

Ask the draw module for the location/slot of the given vertex attribute in a post-transformed vertex.

With this function, drivers that use the draw module should have no reason to track the current vertex shader.

Note that the draw module may sometimes generate vertices with extra attributes (such as texcoords for AA lines). The driver can call this function to find those attributes.

Zero is returned if the attribute is not found since this is a don't care / undefined situtation. Returning -1 would be a bit more work for the drivers.

Definition at line 311 of file draw_context.c.

References draw_context::extra_vp_outputs, draw_vertex_shader::info, tgsi_shader_info::num_outputs, tgsi_shader_info::output_semantic_index, tgsi_shader_info::output_semantic_name, draw_context::semantic_index, draw_context::semantic_name, draw_context::slot, draw_context::vertex_shader, and draw_context::vs.

{
   const struct draw_vertex_shader *vs = draw->vs.vertex_shader;
   uint i;
   for (i = 0; i < vs->info.num_outputs; i++) {
      if (vs->info.output_semantic_name[i] == semantic_name &&
          vs->info.output_semantic_index[i] == semantic_index)
         return i;
   }

   /* XXX there may be more than one extra vertex attrib.
    * For example, simulated gl_FragCoord and gl_PointCoord.
    */
   if (draw->extra_vp_outputs.semantic_name == semantic_name &&
       draw->extra_vp_outputs.semantic_index == semantic_index) {
      return draw->extra_vp_outputs.slot;
   }
   return 0;
}

void draw_flush

(

struct draw_context *

draw

)

Definition at line 100 of file draw_context.c.

References draw_do_flush(), and DRAW_FLUSH_BACKEND.

{
   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
}

boolean draw_install_aaline_stage	(	struct draw_context *	draw,
		struct pipe_context *	pipe
	)

Called by drivers that want to install this AA line prim stage into the draw module's pipeline.

This will not be used if the hardware has native support for AA lines.

Definition at line 865 of file draw_pipe_aaline.c.

References draw_context::aaline, aaline_bind_fs_state(), aaline_bind_sampler_states(), aaline_create_fs_state(), aaline_create_sampler(), aaline_create_texture(), aaline_delete_fs_state(), aaline_set_sampler_textures(), pipe_context::bind_fs_state, pipe_context::bind_sampler_states, pipe_context::create_fs_state, pipe_context::delete_fs_state, draw_stage::destroy, pipe_context::draw, draw_aaline_stage(), aaline_stage::driver_bind_fs_state, aaline_stage::driver_bind_sampler_states, aaline_stage::driver_create_fs_state, aaline_stage::driver_delete_fs_state, aaline_stage::driver_set_sampler_textures, FALSE, aaline_stage::pipe, draw_context::pipeline, pipe_context::set_sampler_textures, aaline_stage::stage, and TRUE.

{
   struct aaline_stage *aaline;

   pipe->draw = (void *) draw;

   /*
    * Create / install AA line drawing / prim stage
    */
   aaline = draw_aaline_stage( draw );
   if (!aaline)
      goto fail;

   aaline->pipe = pipe;

   /* create special texture, sampler state */
   if (!aaline_create_texture(aaline))
      goto fail;

   if (!aaline_create_sampler(aaline))
      goto fail;

   /* save original driver functions */
   aaline->driver_create_fs_state = pipe->create_fs_state;
   aaline->driver_bind_fs_state = pipe->bind_fs_state;
   aaline->driver_delete_fs_state = pipe->delete_fs_state;

   aaline->driver_bind_sampler_states = pipe->bind_sampler_states;
   aaline->driver_set_sampler_textures = pipe->set_sampler_textures;

   /* override the driver's functions */
   pipe->create_fs_state = aaline_create_fs_state;
   pipe->bind_fs_state = aaline_bind_fs_state;
   pipe->delete_fs_state = aaline_delete_fs_state;

   pipe->bind_sampler_states = aaline_bind_sampler_states;
   pipe->set_sampler_textures = aaline_set_sampler_textures;
   
   /* Install once everything is known to be OK:
    */
   draw->pipeline.aaline = &aaline->stage;

   return TRUE;

 fail:
   if (aaline)
      aaline->stage.destroy( &aaline->stage );
   
   return FALSE;
}

boolean draw_install_aapoint_stage	(	struct draw_context *	draw,
		struct pipe_context *	pipe
	)

Called by drivers that want to install this AA point prim stage into the draw module's pipeline.

This will not be used if the hardware has native support for AA points.

Definition at line 839 of file draw_pipe_aapoint.c.

References draw_context::aapoint, aapoint_bind_fs_state(), aapoint_create_fs_state(), aapoint_delete_fs_state(), pipe_context::bind_fs_state, pipe_context::create_fs_state, pipe_context::delete_fs_state, draw_stage::destroy, pipe_context::draw, draw_aapoint_stage(), aapoint_stage::driver_bind_fs_state, aapoint_stage::driver_create_fs_state, aapoint_stage::driver_delete_fs_state, FALSE, aapoint_stage::pipe, draw_context::pipeline, aapoint_stage::stage, and TRUE.

{
   struct aapoint_stage *aapoint;

   pipe->draw = (void *) draw;

   /*
    * Create / install AA point drawing / prim stage
    */
   aapoint = draw_aapoint_stage( draw );
   if (aapoint == NULL)
      goto fail;

   aapoint->pipe = pipe;

   /* save original driver functions */
   aapoint->driver_create_fs_state = pipe->create_fs_state;
   aapoint->driver_bind_fs_state = pipe->bind_fs_state;
   aapoint->driver_delete_fs_state = pipe->delete_fs_state;

   /* override the driver's functions */
   pipe->create_fs_state = aapoint_create_fs_state;
   pipe->bind_fs_state = aapoint_bind_fs_state;
   pipe->delete_fs_state = aapoint_delete_fs_state;

   draw->pipeline.aapoint = &aapoint->stage;

   return TRUE;

 fail:
   if (aapoint)
      aapoint->stage.destroy( &aapoint->stage );

   return FALSE;

boolean draw_install_pstipple_stage	(	struct draw_context *	draw,
		struct pipe_context *	pipe
	)

Called by drivers that want to install this polygon stipple stage into the draw module's pipeline.

This will not be used if the hardware has native support for polygon stipple.

Definition at line 720 of file draw_pipe_pstipple.c.

References pipe_context::bind_fs_state, pipe_context::bind_sampler_states, pipe_context::create_fs_state, pipe_context::delete_fs_state, draw_stage::destroy, pipe_context::draw, draw_pstip_stage(), pstip_stage::driver_bind_fs_state, pstip_stage::driver_bind_sampler_states, pstip_stage::driver_create_fs_state, pstip_stage::driver_delete_fs_state, pstip_stage::driver_set_polygon_stipple, pstip_stage::driver_set_sampler_textures, FALSE, pstip_stage::pipe, draw_context::pipeline, pstip_bind_fs_state(), pstip_bind_sampler_states(), pstip_create_fs_state(), pstip_create_sampler(), pstip_create_texture(), pstip_delete_fs_state(), pstip_set_polygon_stipple(), pstip_set_sampler_textures(), draw_context::pstipple, pipe_context::set_polygon_stipple, pipe_context::set_sampler_textures, pstip_stage::stage, and TRUE.

{
   struct pstip_stage *pstip;

   pipe->draw = (void *) draw;

   /*
    * Create / install pgon stipple drawing / prim stage
    */
   pstip = draw_pstip_stage( draw );
   if (pstip == NULL)
      goto fail;

   draw->pipeline.pstipple = &pstip->stage;

   pstip->pipe = pipe;

   /* create special texture, sampler state */
   if (!pstip_create_texture(pstip))
      goto fail;

   if (!pstip_create_sampler(pstip))
      goto fail;

   /* save original driver functions */
   pstip->driver_create_fs_state = pipe->create_fs_state;
   pstip->driver_bind_fs_state = pipe->bind_fs_state;
   pstip->driver_delete_fs_state = pipe->delete_fs_state;

   pstip->driver_bind_sampler_states = pipe->bind_sampler_states;
   pstip->driver_set_sampler_textures = pipe->set_sampler_textures;
   pstip->driver_set_polygon_stipple = pipe->set_polygon_stipple;

   /* override the driver's functions */
   pipe->create_fs_state = pstip_create_fs_state;
   pipe->bind_fs_state = pstip_bind_fs_state;
   pipe->delete_fs_state = pstip_delete_fs_state;

   pipe->bind_sampler_states = pstip_bind_sampler_states;
   pipe->set_sampler_textures = pstip_set_sampler_textures;
   pipe->set_polygon_stipple = pstip_set_polygon_stipple;

   return TRUE;

 fail:
   if (pstip)
      pstip->stage.destroy( &pstip->stage );

   return FALSE;
}

boolean draw_need_pipeline	(	const struct draw_context *	draw,
		const struct pipe_rasterizer_state *	rasterizer,
		unsigned	prim
	)

uint draw_num_vs_outputs

(

const struct draw_context *

draw

)

Return number of vertex shader outputs.

Definition at line 337 of file draw_context.c.

References draw_context::extra_vp_outputs, draw_vertex_shader::info, tgsi_shader_info::num_outputs, draw_context::slot, draw_context::vertex_shader, and draw_context::vs.

{
   uint count = draw->vs.vertex_shader->info.num_outputs;
   if (draw->extra_vp_outputs.slot > 0)
      count++;
   return count;
}

void draw_set_clip_state	(	struct draw_context *	pipe,
		const struct pipe_clip_state *	clip
	)

Set the draw module's clipping state.

Definition at line 163 of file draw_context.c.

References assert, draw_do_flush(), DRAW_FLUSH_STATE_CHANGE, pipe_clip_state::nr, draw_context::nr_planes, PIPE_MAX_CLIP_PLANES, draw_context::plane, and pipe_clip_state::ucp.

{
   draw_do_flush( draw, DRAW_FLUSH_STATE_CHANGE );

   assert(clip->nr <= PIPE_MAX_CLIP_PLANES);
   memcpy(&draw->plane[6], clip->ucp, clip->nr * sizeof(clip->ucp[0]));
   draw->nr_planes = 6 + clip->nr;
}

void draw_set_driver_clipping	(	struct draw_context *	draw,
		boolean	bypass_clipping
	)

Definition at line 135 of file draw_context.c.

References pipe_rasterizer_state::bypass_clipping, draw_context::bypass_clipping, draw_do_flush(), DRAW_FLUSH_STATE_CHANGE, draw_context::driver, and draw_context::rasterizer.

{
   draw_do_flush( draw, DRAW_FLUSH_STATE_CHANGE );

   draw->driver.bypass_clipping = bypass_clipping;
   draw->bypass_clipping = (draw->rasterizer->bypass_clipping || 
                            draw->driver.bypass_clipping);
}

void draw_set_edgeflags	(	struct draw_context *	draw,
		const unsigned *	edgeflag
	)

Definition at line 353 of file draw_context.c.

References draw_context::pt, and draw_context::user.

{
   draw->pt.user.edgeflag = edgeflag;
}

void draw_set_force_passthrough	(	struct draw_context *	draw,
		boolean	enable
	)

Definition at line 288 of file draw_context.c.

References draw_do_flush(), DRAW_FLUSH_STATE_CHANGE, and draw_context::force_passthrough.

{
   draw_do_flush( draw, DRAW_FLUSH_STATE_CHANGE );
   draw->force_passthrough = enable;
}

void draw_set_mapped_constant_buffer	(	struct draw_context *	draw,
		const void *	buffer,
		unsigned	size
	)

Definition at line 232 of file draw_context.c.

References draw_vs_set_constants(), draw_context::pt, and draw_context::user.

{
   draw->pt.user.constants = buffer;
   draw_vs_set_constants( draw, (const float (*)[4])buffer, size );
}

void draw_set_mapped_element_buffer	(	struct draw_context *	draw,
		unsigned	eltSize,
		const void *	elements
	)

Definition at line 387 of file draw_context.c.

References draw_context::pt, and draw_context::user.

{
   draw->pt.user.elts = elements;
   draw->pt.user.eltSize = eltSize;
   draw->pt.user.min_index = 0;
   draw->pt.user.max_index = 0xffffffff;
}

void draw_set_mapped_element_buffer_range	(	struct draw_context *	draw,
		unsigned	eltSize,
		unsigned	min_index,
		unsigned	max_index,
		const void *	elements
	)

Tell the drawing context about the index/element buffer to use (ala glDrawElements) If no element buffer is to be used (i.e.

glDrawArrays) then this should be called with eltSize=0 and elements=NULL.

Parameters:

	draw	the drawing context
	eltSize	size of each element (1, 2 or 4 bytes)
	elements	the element buffer ptr

Definition at line 373 of file draw_context.c.

References draw_context::pt, and draw_context::user.

{
   draw->pt.user.elts = elements;
   draw->pt.user.eltSize = eltSize;
   draw->pt.user.min_index = min_index;
   draw->pt.user.max_index = max_index;
}

void draw_set_mapped_vertex_buffer	(	struct draw_context *	draw,
		unsigned	attr,
		const void *	buffer
	)

Tell drawing context where to find mapped vertex buffers.

Definition at line 224 of file draw_context.c.

References draw_context::pt, and draw_context::user.

{
   draw->pt.user.vbuffer[attr] = buffer;
}

void draw_set_mrd	(	struct draw_context *	draw,
		double	mrd
	)

Specify the Minimum Resolvable Depth factor for polygon offset.

This factor potentially depends on the number of Z buffer bits, the rasterization algorithm and the arithmetic performed on Z values between vertex shading and rasterization. It will vary from one driver to another.

Definition at line 113 of file draw_context.c.

References draw_context::mrd.

{
   draw->mrd = mrd;
}

void draw_set_rasterize_stage	(	struct draw_context *	draw,
		struct draw_stage *	stage
	)

Plug in the primitive rendering/rasterization stage (which is the last stage in the drawing pipeline).

This is provided by the device driver.

Definition at line 151 of file draw_context.c.

References draw_do_flush(), DRAW_FLUSH_STATE_CHANGE, draw_context::pipeline, and draw_context::rasterize.

{
   draw_do_flush( draw, DRAW_FLUSH_STATE_CHANGE );

   draw->pipeline.rasterize = stage;
}

void draw_set_rasterizer_state	(	struct draw_context *	draw,
		const struct pipe_rasterizer_state *	raster
	)

Register new primitive rasterization/rendering state.

This causes the drawing pipeline to be rebuilt.

Definition at line 123 of file draw_context.c.

References pipe_rasterizer_state::bypass_clipping, draw_context::bypass_clipping, draw_do_flush(), DRAW_FLUSH_STATE_CHANGE, draw_context::driver, and draw_context::rasterizer.

{
   draw_do_flush( draw, DRAW_FLUSH_STATE_CHANGE );

   draw->rasterizer = raster;
   draw->bypass_clipping =
      ((draw->rasterizer && draw->rasterizer->bypass_clipping) ||
       draw->driver.bypass_clipping);
}

void draw_set_render	(	struct draw_context *	draw,
		struct vbuf_render *	render
	)

Definition at line 347 of file draw_context.c.

References draw_context::render.

{
   draw->render = render;
}

void draw_set_vertex_buffers	(	struct draw_context *	draw,
		unsigned	count,
		const struct pipe_vertex_buffer *	buffers
	)

Definition at line 197 of file draw_context.c.

References assert, draw_context::nr_vertex_buffers, PIPE_MAX_ATTRIBS, draw_context::pt, and draw_context::vertex_buffer.

{
   assert(count <= PIPE_MAX_ATTRIBS);

   memcpy(draw->pt.vertex_buffer, buffers, count * sizeof(buffers[0]));
   draw->pt.nr_vertex_buffers = count;
}

void draw_set_vertex_elements	(	struct draw_context *	draw,
		unsigned	count,
		const struct pipe_vertex_element *	elements
	)

Definition at line 209 of file draw_context.c.

References assert, draw_context::nr_vertex_elements, PIPE_MAX_ATTRIBS, draw_context::pt, and draw_context::vertex_element.

{
   assert(count <= PIPE_MAX_ATTRIBS);

   memcpy(draw->pt.vertex_element, elements, count * sizeof(elements[0]));
   draw->pt.nr_vertex_elements = count;
}

void draw_set_viewport_state	(	struct draw_context *	draw,
		const struct pipe_viewport_state *	viewport
	)

Set the draw module's viewport state.

Definition at line 177 of file draw_context.c.

References draw_do_flush(), DRAW_FLUSH_STATE_CHANGE, draw_vs_set_viewport(), draw_context::identity_viewport, pipe_viewport_state::scale, pipe_viewport_state::translate, and draw_context::viewport.

{
   draw_do_flush( draw, DRAW_FLUSH_STATE_CHANGE );
   draw->viewport = *viewport; /* struct copy */
   draw->identity_viewport = (viewport->scale[0] == 1.0f &&
                              viewport->scale[1] == 1.0f &&
                              viewport->scale[2] == 1.0f &&
                              viewport->scale[3] == 1.0f &&
                              viewport->translate[0] == 0.0f &&
                              viewport->translate[1] == 0.0f &&
                              viewport->translate[2] == 0.0f &&
                              viewport->translate[3] == 0.0f);

   draw_vs_set_viewport( draw, viewport );
}

void draw_wide_line_threshold	(	struct draw_context *	draw,
		float	threshold
	)

Tells the draw module to draw lines with triangles if their width is greater than this threshold.

Definition at line 258 of file draw_context.c.

References draw_do_flush(), DRAW_FLUSH_STATE_CHANGE, draw_context::pipeline, and draw_context::wide_line_threshold.

{
   draw_do_flush( draw, DRAW_FLUSH_STATE_CHANGE );
   draw->pipeline.wide_line_threshold = threshold;
}

void draw_wide_point_threshold	(	struct draw_context *	draw,
		float	threshold
	)

Tells the draw module to draw points with triangles if their size is greater than this threshold.

Definition at line 246 of file draw_context.c.

References draw_do_flush(), DRAW_FLUSH_STATE_CHANGE, draw_context::pipeline, and draw_context::wide_point_threshold.

{
   draw_do_flush( draw, DRAW_FLUSH_STATE_CHANGE );
   draw->pipeline.wide_point_threshold = threshold;
}

---