draw_pipe_pstipple.c File Reference

Include dependency graph for draw_pipe_pstipple.c:

Go to the source code of this file.

Data Structures
struct	pstip_fragment_shader
	Polygon stipple stage: implement polygon stipple with texture map and fragment program. More...
struct	pstip_stage
	Subclass of draw_stage. More...
struct	pstip_transform_context
	Subclass of tgsi_transform_context, used for transforming the user's fragment shader to add the special AA instructions. More...
Defines
#define	MAX   1000
Functions
static void	pstip_transform_decl (struct tgsi_transform_context *ctx, struct tgsi_full_declaration *decl)
	TGSI declaration transform callback.
static void	pstip_transform_immed (struct tgsi_transform_context *ctx, struct tgsi_full_immediate *immed)
static int	free_bit (uint bitfield)
	Find the lowest zero bit in the given word, or -1 if bitfield is all ones.
static void	pstip_transform_inst (struct tgsi_transform_context *ctx, struct tgsi_full_instruction *inst)
	TGSI instruction transform callback.
static boolean	generate_pstip_fs (struct pstip_stage *pstip)
	Generate the frag shader we'll use for doing polygon stipple.
static void	pstip_update_texture (struct pstip_stage *pstip)
	Load texture image with current stipple pattern.
static boolean	pstip_create_texture (struct pstip_stage *pstip)
	Create the texture map we'll use for stippling.
static boolean	pstip_create_sampler (struct pstip_stage *pstip)
	Create the sampler CSO that'll be used for stippling.
static boolean	bind_pstip_fragment_shader (struct pstip_stage *pstip)
	When we're about to draw our first stipple polygon in a batch, this function is called to tell the driver to bind our modified fragment shader.
static struct pstip_stage *	pstip_stage (struct draw_stage *stage)
static void	pstip_first_tri (struct draw_stage *stage, struct prim_header *header)
static void	pstip_flush (struct draw_stage *stage, unsigned flags)
static void	pstip_reset_stipple_counter (struct draw_stage *stage)
static void	pstip_destroy (struct draw_stage *stage)
static struct pstip_stage *	draw_pstip_stage (struct draw_context *draw)
static struct pstip_stage *	pstip_stage_from_pipe (struct pipe_context *pipe)
static void *	pstip_create_fs_state (struct pipe_context *pipe, const struct pipe_shader_state *fs)
	This function overrides the driver's create_fs_state() function and will typically be called by the state tracker.
static void	pstip_bind_fs_state (struct pipe_context *pipe, void *fs)
static void	pstip_delete_fs_state (struct pipe_context *pipe, void *fs)
static void	pstip_bind_sampler_states (struct pipe_context *pipe, unsigned num, void **sampler)
static void	pstip_set_sampler_textures (struct pipe_context *pipe, unsigned num, struct pipe_texture **texture)
static void	pstip_set_polygon_stipple (struct pipe_context *pipe, const struct pipe_poly_stipple *stipple)
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.

---

Define Documentation

#define MAX   1000

---

Function Documentation

static boolean bind_pstip_fragment_shader

(

struct pstip_stage *

pstip

)

[static]

When we're about to draw our first stipple polygon in a batch, this function is called to tell the driver to bind our modified fragment shader.

Definition at line 474 of file draw_pipe_pstipple.c.

References draw_stage::draw, draw, pstip_stage::driver_bind_fs_state, FALSE, pstip_stage::fs, generate_pstip_fs(), pstip_stage::pipe, pstip_fragment_shader::pstip_fs, pstip_stage::stage, draw_context::suspend_flushing, and TRUE.

{
   struct draw_context *draw = pstip->stage.draw;
   if (!pstip->fs->pstip_fs &&
       !generate_pstip_fs(pstip))
      return FALSE;

   draw->suspend_flushing = TRUE;
   pstip->driver_bind_fs_state(pstip->pipe, pstip->fs->pstip_fs);
   draw->suspend_flushing = FALSE;
   return TRUE;
}

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;
}

static struct pstip_stage* draw_pstip_stage

(

struct draw_context *

draw

)

[static, read]

Definition at line 584 of file draw_pipe_pstipple.c.

References CALLOC_STRUCT, draw_stage::destroy, draw_stage::draw, draw_alloc_temp_verts(), draw_pipe_passthrough_line(), draw_pipe_passthrough_point(), draw_stage::flush, draw_stage::line, draw_stage::next, draw_stage::point, pstip_destroy(), pstip_first_tri(), pstip_flush(), pstip_reset_stipple_counter(), draw_stage::reset_stipple_counter, pstip_stage::stage, and draw_stage::tri.

{
   struct pstip_stage *pstip = CALLOC_STRUCT(pstip_stage);

   draw_alloc_temp_verts( &pstip->stage, 8 );

   pstip->stage.draw = draw;
   pstip->stage.next = NULL;
   pstip->stage.point = draw_pipe_passthrough_point;
   pstip->stage.line = draw_pipe_passthrough_line;
   pstip->stage.tri = pstip_first_tri;
   pstip->stage.flush = pstip_flush;
   pstip->stage.reset_stipple_counter = pstip_reset_stipple_counter;
   pstip->stage.destroy = pstip_destroy;

   return pstip;
}

static int free_bit

(

uint

bitfield

)

[static]

Find the lowest zero bit in the given word, or -1 if bitfield is all ones.

Definition at line 172 of file draw_pipe_pstipple.c.

{
   int i;
   for (i = 0; i < 32; i++) {
      if ((bitfield & (1 << i)) == 0)
         return i;
   }
   return -1;
}

static boolean generate_pstip_fs

(

struct pstip_stage *

pstip

)

[static]

Generate the frag shader we'll use for doing polygon stipple.

This will be the user's shader prefixed with a TEX and KIL instruction.

Definition at line 325 of file draw_pipe_pstipple.c.

References assert, pstip_transform_context::base, pstip_stage::driver_create_fs_state, FALSE, pstip_transform_context::firstInstruction, pstip_transform_context::freeSampler, pstip_stage::fs, MALLOC, MAX, pstip_transform_context::maxInput, pstip_stage::pipe, PIPE_MAX_SAMPLERS, pstip_fragment_shader::pstip_fs, pstip_transform_decl(), pstip_transform_immed(), pstip_transform_inst(), pstip_fragment_shader::sampler_unit, pstip_fragment_shader::state, pstip_transform_context::texTemp, tgsi_dump(), tgsi_transform_shader(), pipe_shader_state::tokens, tgsi_transform_context::transform_declaration, tgsi_transform_context::transform_immediate, tgsi_transform_context::transform_instruction, TRUE, and pstip_transform_context::wincoordInput.

{
   const struct pipe_shader_state *orig_fs = &pstip->fs->state;
   /*struct draw_context *draw = pstip->stage.draw;*/
   struct pipe_shader_state pstip_fs;
   struct pstip_transform_context transform;

#define MAX 1000

   pstip_fs = *orig_fs; /* copy to init */
   pstip_fs.tokens = MALLOC(sizeof(struct tgsi_token) * MAX);
   if (pstip_fs.tokens == NULL)
      return FALSE;

   memset(&transform, 0, sizeof(transform));
   transform.wincoordInput = -1;
   transform.maxInput = -1;
   transform.texTemp = -1;
   transform.firstInstruction = TRUE;
   transform.base.transform_instruction = pstip_transform_inst;
   transform.base.transform_declaration = pstip_transform_decl;
   transform.base.transform_immediate = pstip_transform_immed;

   tgsi_transform_shader(orig_fs->tokens,
                         (struct tgsi_token *) pstip_fs.tokens,
                         MAX, &transform.base);

#if 0 /* DEBUG */
   tgsi_dump(orig_fs->tokens, 0);
   tgsi_dump(pstip_fs.tokens, 0);
#endif

   pstip->fs->sampler_unit = transform.freeSampler;
   assert(pstip->fs->sampler_unit < PIPE_MAX_SAMPLERS);

   pstip->fs->pstip_fs = pstip->driver_create_fs_state(pstip->pipe, &pstip_fs);

   return TRUE;
}

static void pstip_bind_fs_state	(	struct pipe_context *	pipe,
		void *	fs
	)			[static]

Definition at line 634 of file draw_pipe_pstipple.c.

References pstip_stage::driver_bind_fs_state, pstip_fragment_shader::driver_fs, pstip_stage::fs, pstip_stage::pipe, and pstip_stage_from_pipe().

{
   struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
   struct pstip_fragment_shader *aafs = (struct pstip_fragment_shader *) fs;
   /* save current */
   pstip->fs = aafs;
   /* pass-through */
   pstip->driver_bind_fs_state(pstip->pipe,
                               (aafs ? aafs->driver_fs : NULL));
}

static void pstip_bind_sampler_states	(	struct pipe_context *	pipe,
		unsigned	num,
		void **	sampler
	)			[static]

Definition at line 658 of file draw_pipe_pstipple.c.

References pstip_stage::driver_bind_sampler_states, pstip_stage::num_samplers, pstip_stage::pipe, PIPE_MAX_SAMPLERS, pstip_stage_from_pipe(), pstip_stage::samplers, and pstip_stage::state.

{
   struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
   uint i;

   /* save current */
   memcpy(pstip->state.samplers, sampler, num * sizeof(void *));
   for (i = num; i < PIPE_MAX_SAMPLERS; i++) {
      pstip->state.samplers[i] = NULL;
   }

   pstip->num_samplers = num;
   /* pass-through */
   pstip->driver_bind_sampler_states(pstip->pipe, num, sampler);
}

static void* pstip_create_fs_state	(	struct pipe_context *	pipe,
		const struct pipe_shader_state *	fs
	)			[static]

This function overrides the driver's create_fs_state() function and will typically be called by the state tracker.

Definition at line 616 of file draw_pipe_pstipple.c.

References CALLOC_STRUCT, pstip_stage::driver_create_fs_state, pstip_fragment_shader::driver_fs, pstip_stage::pipe, pstip_stage_from_pipe(), and pstip_fragment_shader::state.

{
   struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
   struct pstip_fragment_shader *aafs = CALLOC_STRUCT(pstip_fragment_shader);

   if (aafs) {
      aafs->state = *fs;

      /* pass-through */
      aafs->driver_fs = pstip->driver_create_fs_state(pstip->pipe, fs);
   }

   return aafs;
}

static boolean pstip_create_sampler

(

struct pstip_stage *

pstip

)

[static]

Create the sampler CSO that'll be used for stippling.

Definition at line 445 of file draw_pipe_pstipple.c.

References pipe_context::create_sampler_state, FALSE, pipe_sampler_state::mag_img_filter, pipe_sampler_state::max_lod, pipe_sampler_state::min_img_filter, pipe_sampler_state::min_lod, pipe_sampler_state::min_mip_filter, pipe_sampler_state::normalized_coords, pstip_stage::pipe, PIPE_TEX_FILTER_NEAREST, PIPE_TEX_MIPFILTER_NONE, PIPE_TEX_WRAP_REPEAT, pstip_stage::sampler_cso, TRUE, pipe_sampler_state::wrap_r, pipe_sampler_state::wrap_s, and pipe_sampler_state::wrap_t.

{
   struct pipe_sampler_state sampler;
   struct pipe_context *pipe = pstip->pipe;

   memset(&sampler, 0, sizeof(sampler));
   sampler.wrap_s = PIPE_TEX_WRAP_REPEAT;
   sampler.wrap_t = PIPE_TEX_WRAP_REPEAT;
   sampler.wrap_r = PIPE_TEX_WRAP_REPEAT;
   sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
   sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
   sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
   sampler.normalized_coords = 1;
   sampler.min_lod = 0.0f;
   sampler.max_lod = 0.0f;

   pstip->sampler_cso = pipe->create_sampler_state(pipe, &sampler);
   if (pstip->sampler_cso == NULL)
      return FALSE;
   
   return TRUE;
}

static boolean pstip_create_texture

(

struct pstip_stage *

pstip

)

[static]

Create the texture map we'll use for stippling.

Definition at line 418 of file draw_pipe_pstipple.c.

References pipe_texture::block, pipe_texture::depth, FALSE, pipe_texture::format, pipe_texture::height, pipe_texture::last_level, pf_get_block(), pstip_stage::pipe, PIPE_FORMAT_A8_UNORM, PIPE_TEXTURE_2D, pipe_context::screen, pipe_texture::target, pstip_stage::texture, pipe_screen::texture_create, TRUE, and pipe_texture::width.

{
   struct pipe_context *pipe = pstip->pipe;
   struct pipe_screen *screen = pipe->screen;
   struct pipe_texture texTemp;

   memset(&texTemp, 0, sizeof(texTemp));
   texTemp.target = PIPE_TEXTURE_2D;
   texTemp.format = PIPE_FORMAT_A8_UNORM; /* XXX verify supported by driver! */
   texTemp.last_level = 0;
   texTemp.width[0] = 32;
   texTemp.height[0] = 32;
   texTemp.depth[0] = 1;
   pf_get_block(texTemp.format, &texTemp.block);

   pstip->texture = screen->texture_create(screen, &texTemp);
   if (pstip->texture == NULL)
      return FALSE;

   return TRUE;
}

static void pstip_delete_fs_state	(	struct pipe_context *	pipe,
		void *	fs
	)			[static]

Definition at line 647 of file draw_pipe_pstipple.c.

References pstip_stage::driver_delete_fs_state, pstip_fragment_shader::driver_fs, FREE, pstip_stage::pipe, and pstip_stage_from_pipe().

{
   struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
   struct pstip_fragment_shader *aafs = (struct pstip_fragment_shader *) fs;
   /* pass-through */
   pstip->driver_delete_fs_state(pstip->pipe, aafs->driver_fs);
   FREE(aafs);
}

static void pstip_destroy

(

struct draw_stage *

stage

)

[static]

Definition at line 565 of file draw_pipe_pstipple.c.

References pipe_context::delete_sampler_state, draw_free_temp_verts(), FREE, pstip_stage::pipe, PIPE_MAX_SAMPLERS, pipe_texture_reference(), pipe_texture_release(), pstip_stage(), pstip_stage::sampler_cso, pstip_stage::state, pstip_stage::texture, and pstip_stage::textures.

{
   struct pstip_stage *pstip = pstip_stage(stage);
   uint i;

   for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
      pipe_texture_reference(&pstip->state.textures[i], NULL);
   }

   pstip->pipe->delete_sampler_state(pstip->pipe, pstip->sampler_cso);

   pipe_texture_release(&pstip->texture);

   draw_free_temp_verts( stage );
   FREE( stage );
}

static void pstip_first_tri	(	struct draw_stage *	stage,
		struct prim_header *	header
	)			[static]

Definition at line 496 of file draw_pipe_pstipple.c.

References assert, bind_pstip_fragment_shader(), draw_stage::draw, draw, draw_pipe_passthrough_tri(), pstip_stage::driver_bind_sampler_states, pstip_stage::driver_set_sampler_textures, FALSE, pstip_stage::fs, MAX2, pstip_stage::num_samplers, pstip_stage::num_textures, pstip_stage::pipe, PIPE_MAX_SAMPLERS, pipe_texture_reference(), pipe_rasterizer_state::poly_stipple_enable, pstip_stage(), draw_context::rasterizer, pstip_stage::sampler_cso, pstip_fragment_shader::sampler_unit, pstip_stage::samplers, pstip_stage::state, draw_context::suspend_flushing, pstip_stage::texture, pstip_stage::textures, draw_stage::tri, and TRUE.

{
   struct pstip_stage *pstip = pstip_stage(stage);
   struct pipe_context *pipe = pstip->pipe;
   struct draw_context *draw = stage->draw;
   uint num_samplers;

   assert(stage->draw->rasterizer->poly_stipple_enable);

   /* bind our fragprog */
   if (!bind_pstip_fragment_shader(pstip)) {
      stage->tri = draw_pipe_passthrough_tri;
      stage->tri(stage, header);
      return;
   }
      

   /* how many samplers? */
   /* we'll use sampler/texture[pstip->sampler_unit] for the stipple */
   num_samplers = MAX2(pstip->num_textures, pstip->num_samplers);
   num_samplers = MAX2(num_samplers, pstip->fs->sampler_unit + 1);

   /* plug in our sampler, texture */
   pstip->state.samplers[pstip->fs->sampler_unit] = pstip->sampler_cso;
   pipe_texture_reference(&pstip->state.textures[pstip->fs->sampler_unit],
                          pstip->texture);

   assert(num_samplers <= PIPE_MAX_SAMPLERS);

   draw->suspend_flushing = TRUE;
   pstip->driver_bind_sampler_states(pipe, num_samplers, pstip->state.samplers);
   pstip->driver_set_sampler_textures(pipe, num_samplers, pstip->state.textures);
   draw->suspend_flushing = FALSE;

   /* now really draw first triangle */
   stage->tri = draw_pipe_passthrough_tri;
   stage->tri(stage, header);
}

static void pstip_flush	(	struct draw_stage *	stage,
		unsigned	flags
	)			[static]

Definition at line 537 of file draw_pipe_pstipple.c.

References draw_stage::draw, draw, pstip_stage::driver_bind_fs_state, pstip_stage::driver_bind_sampler_states, pstip_fragment_shader::driver_fs, pstip_stage::driver_set_sampler_textures, FALSE, draw_stage::flush, pstip_stage::fs, draw_stage::next, pstip_stage::num_samplers, pstip_stage::num_textures, pstip_stage::pipe, pstip_first_tri(), pstip_stage(), pstip_stage::samplers, pstip_stage::state, draw_context::suspend_flushing, pstip_stage::textures, draw_stage::tri, and TRUE.

{
   struct draw_context *draw = stage->draw;
   struct pstip_stage *pstip = pstip_stage(stage);
   struct pipe_context *pipe = pstip->pipe;

   stage->tri = pstip_first_tri;
   stage->next->flush( stage->next, flags );

   /* restore original frag shader, texture, sampler state */
   draw->suspend_flushing = TRUE;
   pstip->driver_bind_fs_state(pipe, pstip->fs->driver_fs);
   pstip->driver_bind_sampler_states(pipe, pstip->num_samplers,
                                     pstip->state.samplers);
   pstip->driver_set_sampler_textures(pipe, pstip->num_textures,
                                      pstip->state.textures);
   draw->suspend_flushing = FALSE;
}

static void pstip_reset_stipple_counter

(

struct draw_stage *

stage

)

[static]

Definition at line 558 of file draw_pipe_pstipple.c.

References draw_stage::next, and draw_stage::reset_stipple_counter.

{
   stage->next->reset_stipple_counter( stage->next );
}

static void pstip_set_polygon_stipple	(	struct pipe_context *	pipe,
		const struct pipe_poly_stipple *	stipple
	)			[static]

Definition at line 699 of file draw_pipe_pstipple.c.

References pstip_stage::driver_set_polygon_stipple, pstip_stage::pipe, pstip_stage_from_pipe(), pstip_update_texture(), pstip_stage::state, and pstip_stage::stipple.

{
   struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);

   /* save current */
   pstip->state.stipple = stipple;

   /* pass-through */
   pstip->driver_set_polygon_stipple(pstip->pipe, stipple);

   pstip_update_texture(pstip);
}

static void pstip_set_sampler_textures	(	struct pipe_context *	pipe,
		unsigned	num,
		struct pipe_texture **	texture
	)			[static]

Definition at line 677 of file draw_pipe_pstipple.c.

References pstip_stage::driver_set_sampler_textures, pstip_stage::num_textures, pstip_stage::pipe, PIPE_MAX_SAMPLERS, pipe_texture_reference(), pstip_stage_from_pipe(), pstip_stage::state, and pstip_stage::textures.

{
   struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
   uint i;

   /* save current */
   for (i = 0; i < num; i++) {
      pipe_texture_reference(&pstip->state.textures[i], texture[i]);
   }
   for (; i < PIPE_MAX_SAMPLERS; i++) {
      pipe_texture_reference(&pstip->state.textures[i], NULL);
   }

   pstip->num_textures = num;

   /* pass-through */
   pstip->driver_set_sampler_textures(pstip->pipe, num, texture);
}

static struct pstip_stage* pstip_stage

(

struct draw_stage *

stage

)

[static, read]

Definition at line 489 of file draw_pipe_pstipple.c.

{
   return (struct pstip_stage *) stage;
}

static struct pstip_stage* pstip_stage_from_pipe

(

struct pipe_context *

pipe

)

[static, read]

Definition at line 604 of file draw_pipe_pstipple.c.

References pipe_context::draw, draw, draw_context::pipeline, and draw_context::pstipple.

{
   struct draw_context *draw = (struct draw_context *) pipe->draw;
   return pstip_stage(draw->pipeline.pstipple);
}

static void pstip_transform_decl	(	struct tgsi_transform_context *	ctx,
		struct tgsi_full_declaration *	decl
	)			[static]

TGSI declaration transform callback.

Look for a free sampler, a free input attrib, and two free temp regs.

Definition at line 130 of file draw_pipe_pstipple.c.

References tgsi_full_declaration::Declaration, tgsi_full_declaration::DeclarationRange, tgsi_transform_context::emit_declaration, tgsi_declaration::File, tgsi_declaration_range::First, tgsi_declaration_range::Last, MAX2, pstip_transform_context::maxInput, pstip_transform_context::samplersUsed, tgsi_full_declaration::Semantic, tgsi_declaration_semantic::SemanticName, pstip_transform_context::tempsUsed, TGSI_FILE_INPUT, TGSI_FILE_SAMPLER, TGSI_FILE_TEMPORARY, TGSI_SEMANTIC_POSITION, and pstip_transform_context::wincoordInput.

{
   struct pstip_transform_context *pctx = (struct pstip_transform_context *) ctx;

   if (decl->Declaration.File == TGSI_FILE_SAMPLER) {
      uint i;
      for (i = decl->DeclarationRange.First;
           i <= decl->DeclarationRange.Last; i++) {
         pctx->samplersUsed |= 1 << i;
      }
   }
   else if (decl->Declaration.File == TGSI_FILE_INPUT) {
      pctx->maxInput = MAX2(pctx->maxInput, (int) decl->DeclarationRange.Last);
      if (decl->Semantic.SemanticName == TGSI_SEMANTIC_POSITION)
         pctx->wincoordInput = (int) decl->DeclarationRange.First;
   }
   else if (decl->Declaration.File == TGSI_FILE_TEMPORARY) {
      uint i;
      for (i = decl->DeclarationRange.First;
           i <= decl->DeclarationRange.Last; i++) {
         pctx->tempsUsed |= (1 << i);
      }
   }

   ctx->emit_declaration(ctx, decl);
}

static void pstip_transform_immed	(	struct tgsi_transform_context *	ctx,
		struct tgsi_full_immediate *	immed
	)			[static]

Definition at line 160 of file draw_pipe_pstipple.c.

References pstip_transform_context::numImmed.

{
   struct pstip_transform_context *pctx = (struct pstip_transform_context *) ctx;
   pctx->numImmed++;
}

static void pstip_transform_inst	(	struct tgsi_transform_context *	ctx,
		struct tgsi_full_instruction *	inst
	)			[static]

TGSI instruction transform callback.

Replace writes to result.color w/ a temp reg. Upon END instruction, insert texture sampling code for antialiasing.

Definition at line 189 of file draw_pipe_pstipple.c.

References assert, tgsi_full_declaration::Declaration, tgsi_full_declaration::DeclarationRange, tgsi_full_dst_register::DstRegister, tgsi_transform_context::emit_declaration, tgsi_transform_context::emit_immediate, tgsi_transform_context::emit_instruction, FALSE, tgsi_src_register::File, tgsi_dst_register::File, tgsi_declaration::File, tgsi_declaration_range::First, pstip_transform_context::firstInstruction, free_bit(), pstip_transform_context::freeSampler, tgsi_full_instruction::FullDstRegisters, tgsi_full_instruction::FullSrcRegisters, tgsi_full_immediate::Immediate, tgsi_src_register::Index, tgsi_dst_register::Index, tgsi_full_instruction::Instruction, tgsi_full_instruction::InstructionExtTexture, tgsi_declaration::Interpolate, tgsi_declaration_range::Last, pstip_transform_context::maxInput, tgsi_src_register::Negate, tgsi_instruction::NumDstRegs, pstip_transform_context::numImmed, tgsi_instruction::NumSrcRegs, tgsi_instruction::Opcode, PIPE_MAX_SAMPLERS, tgsi_full_immediate::Pointer, pstip_transform_context::samplersUsed, tgsi_full_declaration::Semantic, tgsi_declaration::Semantic, tgsi_declaration_semantic::SemanticIndex, tgsi_declaration_semantic::SemanticName, tgsi_immediate::Size, tgsi_full_src_register::SrcRegister, pstip_transform_context::tempsUsed, pstip_transform_context::texTemp, tgsi_instruction_ext_texture::Texture, tgsi_default_full_declaration(), tgsi_default_full_immediate(), tgsi_default_full_instruction(), TGSI_FILE_IMMEDIATE, TGSI_FILE_INPUT, TGSI_FILE_SAMPLER, TGSI_FILE_TEMPORARY, TGSI_INTERPOLATE_LINEAR, TGSI_OPCODE_KIL, TGSI_OPCODE_MUL, TGSI_OPCODE_TEX, TGSI_SEMANTIC_POSITION, TGSI_TEXTURE_2D, tgsi_full_immediate::u, and pstip_transform_context::wincoordInput.

{
   struct pstip_transform_context *pctx = (struct pstip_transform_context *) ctx;

   if (pctx->firstInstruction) {
      /* emit our new declarations before the first instruction */

      struct tgsi_full_declaration decl;
      struct tgsi_full_instruction newInst;
      uint i;
      int wincoordInput;

      /* find free sampler */
      pctx->freeSampler = free_bit(pctx->samplersUsed);
      if (pctx->freeSampler >= PIPE_MAX_SAMPLERS)
         pctx->freeSampler = PIPE_MAX_SAMPLERS - 1;

      if (pctx->wincoordInput < 0)
         wincoordInput = pctx->maxInput + 1;
      else
         wincoordInput = pctx->wincoordInput;

      /* find one free temp reg */
      for (i = 0; i < 32; i++) {
         if ((pctx->tempsUsed & (1 << i)) == 0) {
            /* found a free temp */
            if (pctx->texTemp < 0)
               pctx->texTemp  = i;
            else
               break;
         }
      }
      assert(pctx->texTemp >= 0);

      if (pctx->wincoordInput < 0) {
         /* declare new position input reg */
         decl = tgsi_default_full_declaration();
         decl.Declaration.File = TGSI_FILE_INPUT;
         decl.Declaration.Interpolate = TGSI_INTERPOLATE_LINEAR; /* XXX? */
         decl.Declaration.Semantic = 1;
         decl.Semantic.SemanticName = TGSI_SEMANTIC_POSITION;
         decl.Semantic.SemanticIndex = 0;
         decl.DeclarationRange.First = 
            decl.DeclarationRange.Last = wincoordInput;
         ctx->emit_declaration(ctx, &decl);
      }

      /* declare new sampler */
      decl = tgsi_default_full_declaration();
      decl.Declaration.File = TGSI_FILE_SAMPLER;
      decl.DeclarationRange.First = 
      decl.DeclarationRange.Last = pctx->freeSampler;
      ctx->emit_declaration(ctx, &decl);

      /* declare new temp regs */
      decl = tgsi_default_full_declaration();
      decl.Declaration.File = TGSI_FILE_TEMPORARY;
      decl.DeclarationRange.First = 
      decl.DeclarationRange.Last = pctx->texTemp;
      ctx->emit_declaration(ctx, &decl);

      /* emit immediate = {1/32, 1/32, 1, 1}
       * The index/position of this immediate will be pctx->numImmed
       */
      {
         static const float value[4] = { 1.0/32, 1.0/32, 1.0, 1.0 };
         struct tgsi_full_immediate immed;
         uint size = 4;
         immed = tgsi_default_full_immediate();
         immed.Immediate.Size = 1 + size; /* one for the token itself */
         immed.u.Pointer = (void *) value;
         ctx->emit_immediate(ctx, &immed);
      }

      pctx->firstInstruction = FALSE;


      /* 
       * Insert new MUL/TEX/KILP instructions at start of program
       * Take gl_FragCoord, divide by 32 (stipple size), sample the
       * texture and kill fragment if needed.
       *
       * We'd like to use non-normalized texcoords to index into a RECT
       * texture, but we can only use GL_REPEAT wrap mode with normalized
       * texcoords.  Darn.
       */

      /* MUL texTemp, INPUT[wincoord], 1/32; */
      newInst = tgsi_default_full_instruction();
      newInst.Instruction.Opcode = TGSI_OPCODE_MUL;
      newInst.Instruction.NumDstRegs = 1;
      newInst.FullDstRegisters[0].DstRegister.File = TGSI_FILE_TEMPORARY;
      newInst.FullDstRegisters[0].DstRegister.Index = pctx->texTemp;
      newInst.Instruction.NumSrcRegs = 2;
      newInst.FullSrcRegisters[0].SrcRegister.File = TGSI_FILE_INPUT;
      newInst.FullSrcRegisters[0].SrcRegister.Index = wincoordInput;
      newInst.FullSrcRegisters[1].SrcRegister.File = TGSI_FILE_IMMEDIATE;
      newInst.FullSrcRegisters[1].SrcRegister.Index = pctx->numImmed;
      ctx->emit_instruction(ctx, &newInst);

      /* TEX texTemp, texTemp, sampler; */
      newInst = tgsi_default_full_instruction();
      newInst.Instruction.Opcode = TGSI_OPCODE_TEX;
      newInst.Instruction.NumDstRegs = 1;
      newInst.FullDstRegisters[0].DstRegister.File = TGSI_FILE_TEMPORARY;
      newInst.FullDstRegisters[0].DstRegister.Index = pctx->texTemp;
      newInst.Instruction.NumSrcRegs = 2;
      newInst.InstructionExtTexture.Texture = TGSI_TEXTURE_2D;
      newInst.FullSrcRegisters[0].SrcRegister.File = TGSI_FILE_TEMPORARY;
      newInst.FullSrcRegisters[0].SrcRegister.Index = pctx->texTemp;
      newInst.FullSrcRegisters[1].SrcRegister.File = TGSI_FILE_SAMPLER;
      newInst.FullSrcRegisters[1].SrcRegister.Index = pctx->freeSampler;
      ctx->emit_instruction(ctx, &newInst);

      /* KIL -texTemp;   # if -texTemp < 0, KILL fragment */
      newInst = tgsi_default_full_instruction();
      newInst.Instruction.Opcode = TGSI_OPCODE_KIL;
      newInst.Instruction.NumDstRegs = 0;
      newInst.Instruction.NumSrcRegs = 1;
      newInst.FullSrcRegisters[0].SrcRegister.File = TGSI_FILE_TEMPORARY;
      newInst.FullSrcRegisters[0].SrcRegister.Index = pctx->texTemp;
      newInst.FullSrcRegisters[0].SrcRegister.Negate = 1;
      ctx->emit_instruction(ctx, &newInst);
   }

   /* emit this instruction */
   ctx->emit_instruction(ctx, inst);
}

static void pstip_update_texture

(

struct pstip_stage *

pstip

)

[static]

Load texture image with current stipple pattern.

Definition at line 370 of file draw_pipe_pstipple.c.

References pipe_context::flush, pipe_screen::get_tex_surface, pstip_stage::pipe, PIPE_BUFFER_USAGE_CPU_WRITE, PIPE_FLUSH_TEXTURE_CACHE, pipe_context::screen, pstip_stage::state, pipe_poly_stipple::stipple, pstip_stage::stipple, pipe_surface::stride, pipe_screen::surface_map, pipe_screen::surface_unmap, pipe_screen::tex_surface_release, and pstip_stage::texture.

{
   static const uint bit31 = 1 << 31;
   struct pipe_context *pipe = pstip->pipe;
   struct pipe_screen *screen = pipe->screen;
   struct pipe_surface *surface;
   const uint *stipple = pstip->state.stipple->stipple;
   uint i, j;
   ubyte *data;

   /* XXX: want to avoid flushing just because we use stipple: 
    */
   pipe->flush( pipe, PIPE_FLUSH_TEXTURE_CACHE, NULL );

   surface = screen->get_tex_surface(screen, pstip->texture, 0, 0, 0,
                                     PIPE_BUFFER_USAGE_CPU_WRITE);
   data = screen->surface_map(screen, surface,
                              PIPE_BUFFER_USAGE_CPU_WRITE);

   /*
    * Load alpha texture.
    * Note: 0 means keep the fragment, 255 means kill it.
    * We'll negate the texel value and use KILP which kills if value
    * is negative.
    */
   for (i = 0; i < 32; i++) {
      for (j = 0; j < 32; j++) {
         if (stipple[i] & (bit31 >> j)) {
            /* fragment "on" */
            data[i * surface->stride + j] = 0;
         }
         else {
            /* fragment "off" */
            data[i * surface->stride + j] = 255;
         }
      }
   }

   /* unmap */
   screen->surface_unmap(screen, surface);
   screen->tex_surface_release(screen, &surface);
}

---