draw_pipe_clip.c File Reference

Include dependency graph for draw_pipe_clip.c:

Go to the source code of this file.

Data Structures
struct	clipper
Defines
#define	IS_NEGATIVE(X)   ((X) < 0.0)
	Clipping stage.
#define	DIFFERENT_SIGNS(x, y)   ((x) * (y) <= 0.0F && (x) - (y) != 0.0F)
#define	MAX_CLIPPED_VERTICES   ((2 * (6 + PIPE_MAX_CLIP_PLANES))+1)
#define	LINTERP(T, OUT, IN)   ((OUT) + (T) * ((IN) - (OUT)))
Functions
static struct clipper *	clipper_stage (struct draw_stage *stage)
static void	interp_attr (float *fdst, float t, const float *fin, const float *fout)
static void	copy_colors (struct draw_stage *stage, struct vertex_header *dst, const struct vertex_header *src)
static void	interp (const struct clipper *clip, struct vertex_header *dst, float t, const struct vertex_header *out, const struct vertex_header *in)
static void	emit_poly (struct draw_stage *stage, struct vertex_header **inlist, unsigned n, const struct prim_header *origPrim)
static float	dot4 (const float *a, const float *b)
static void	do_clip_tri (struct draw_stage *stage, struct prim_header *header, unsigned clipmask)
static void	do_clip_line (struct draw_stage *stage, struct prim_header *header, unsigned clipmask)
static void	clip_point (struct draw_stage *stage, struct prim_header *header)
static void	clip_line (struct draw_stage *stage, struct prim_header *header)
static void	clip_tri (struct draw_stage *stage, struct prim_header *header)
static void	clip_init_state (struct draw_stage *stage)
static void	clip_first_tri (struct draw_stage *stage, struct prim_header *header)
static void	clip_first_line (struct draw_stage *stage, struct prim_header *header)
static void	clip_flush (struct draw_stage *stage, unsigned flags)
static void	clip_reset_stipple_counter (struct draw_stage *stage)
static void	clip_destroy (struct draw_stage *stage)
struct draw_stage *	draw_clip_stage (struct draw_context *draw)
	Allocate a new clipper stage.

---

Define Documentation

#define DIFFERENT_SIGNS	(	x,
		y		)	((x) * (y) <= 0.0F && (x) - (y) != 0.0F)

Definition at line 49 of file draw_pipe_clip.c.

#define IS_NEGATIVE

(

X

)

((X) < 0.0)

Clipping stage.

Author:

Keith Whitwell <keith@tungstengraphics.com>

Definition at line 45 of file draw_pipe_clip.c.

#define LINTERP	(	T,
		OUT,
		IN		)	((OUT) + (T) * ((IN) - (OUT)))

Definition at line 79 of file draw_pipe_clip.c.

#define MAX_CLIPPED_VERTICES   ((2 * (6 + PIPE_MAX_CLIP_PLANES))+1)

Definition at line 53 of file draw_pipe_clip.c.

---

Function Documentation

static void clip_destroy

(

struct draw_stage *

stage

)

[static]

Definition at line 478 of file draw_pipe_clip.c.

References draw_free_temp_verts(), and FREE.

{
   draw_free_temp_verts( stage );
   FREE( stage );
}

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

Definition at line 455 of file draw_pipe_clip.c.

References clip_init_state(), and draw_stage::line.

{
   clip_init_state( stage );
   stage->line( stage, header );
}

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

Definition at line 448 of file draw_pipe_clip.c.

References clip_init_state(), and draw_stage::tri.

{
   clip_init_state( stage );
   stage->tri( stage, header );
}

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

Definition at line 463 of file draw_pipe_clip.c.

References clip_first_line(), clip_first_tri(), draw_stage::flush, draw_stage::line, draw_stage::next, and draw_stage::tri.

{
   stage->tri = clip_first_tri;
   stage->line = clip_first_line;
   stage->next->flush( stage->next, flags );
}

static void clip_init_state

(

struct draw_stage *

stage

)

[static]

Definition at line 423 of file draw_pipe_clip.c.

References clip_line(), clip_tri(), clipper_stage(), clipper::color_attribs, draw_stage::draw, FALSE, clipper::flat, pipe_rasterizer_state::flatshade, draw_vertex_shader::info, draw_stage::line, clipper::num_color_attribs, tgsi_shader_info::num_outputs, tgsi_shader_info::output_semantic_name, draw_context::rasterizer, TGSI_SEMANTIC_BCOLOR, TGSI_SEMANTIC_COLOR, draw_stage::tri, TRUE, draw_context::vertex_shader, and draw_context::vs.

{
   struct clipper *clipper = clipper_stage( stage );

   clipper->flat = stage->draw->rasterizer->flatshade ? TRUE : FALSE;

   if (clipper->flat) {
      const struct draw_vertex_shader *vs = stage->draw->vs.vertex_shader;
      uint i;

      clipper->num_color_attribs = 0;
      for (i = 0; i < vs->info.num_outputs; i++) {
         if (vs->info.output_semantic_name[i] == TGSI_SEMANTIC_COLOR ||
             vs->info.output_semantic_name[i] == TGSI_SEMANTIC_BCOLOR) {
            clipper->color_attribs[clipper->num_color_attribs++] = i;
         }
      }
   }
   
   stage->tri = clip_tri;
   stage->line = clip_line;
}

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

Definition at line 382 of file draw_pipe_clip.c.

References vertex_header::clipmask, do_clip_line(), draw_stage::line, draw_stage::next, and prim_header::v.

{
   unsigned clipmask = (header->v[0]->clipmask | 
                        header->v[1]->clipmask);
   
   if (clipmask == 0) {
      /* no clipping needed */
      stage->next->line( stage->next, header );
   }
   else if ((header->v[0]->clipmask &
             header->v[1]->clipmask) == 0) {
      do_clip_line(stage, header, clipmask);
   }
   /* else, totally clipped */
}

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

Definition at line 373 of file draw_pipe_clip.c.

References vertex_header::clipmask, draw_stage::next, draw_stage::point, and prim_header::v.

{
   if (header->v[0]->clipmask == 0) 
      stage->next->point( stage->next, header );
}

static void clip_reset_stipple_counter

(

struct draw_stage *

stage

)

[static]

Definition at line 472 of file draw_pipe_clip.c.

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

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

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

Definition at line 401 of file draw_pipe_clip.c.

References vertex_header::clipmask, do_clip_tri(), draw_stage::next, draw_stage::tri, and prim_header::v.

{
   unsigned clipmask = (header->v[0]->clipmask | 
                        header->v[1]->clipmask | 
                        header->v[2]->clipmask);
   
   if (clipmask == 0) {
      /* no clipping needed */
      stage->next->tri( stage->next, header );
   }
   else if ((header->v[0]->clipmask & 
             header->v[1]->clipmask & 
             header->v[2]->clipmask) == 0) {
      do_clip_tri(stage, header, clipmask);
   }
}

static struct clipper* clipper_stage

(

struct draw_stage *

stage

)

[static, read]

Definition at line 73 of file draw_pipe_clip.c.

{
   return (struct clipper *)stage;
}

static void copy_colors	(	struct draw_stage *	stage,
		struct vertex_header *	dst,
		const struct vertex_header *	src
	)			[static]

Definition at line 95 of file draw_pipe_clip.c.

References clipper_stage(), clipper::color_attribs, COPY_4FV, vertex_header::data, and clipper::num_color_attribs.

{
   const struct clipper *clipper = clipper_stage(stage);
   uint i;
   for (i = 0; i < clipper->num_color_attribs; i++) {
      const uint attr = clipper->color_attribs[i];
      COPY_4FV(dst->data[attr], src->data[attr]);
   }
}

static void do_clip_line	(	struct draw_stage *	stage,
		struct prim_header *	header,
		unsigned	clipmask
	)			[static]

Definition at line 313 of file draw_pipe_clip.c.

References vertex_header::clip, vertex_header::clipmask, clipper_stage(), copy_colors(), dot4(), clipper::flat, interp(), draw_stage::line, MAX2, draw_stage::next, clipper::plane, draw_stage::tmp, and prim_header::v.

{
   const struct clipper *clipper = clipper_stage( stage );
   struct vertex_header *v0 = header->v[0];
   struct vertex_header *v1 = header->v[1];
   const float *pos0 = v0->clip;
   const float *pos1 = v1->clip;
   float t0 = 0.0F;
   float t1 = 0.0F;
   struct prim_header newprim;

   while (clipmask) {
      const unsigned plane_idx = ffs(clipmask)-1;
      const float *plane = clipper->plane[plane_idx];
      const float dp0 = dot4( pos0, plane );
      const float dp1 = dot4( pos1, plane );

      if (dp1 < 0.0F) {
         float t = dp1 / (dp1 - dp0);
         t1 = MAX2(t1, t);
      } 

      if (dp0 < 0.0F) {
         float t = dp0 / (dp0 - dp1);
         t0 = MAX2(t0, t);
      }

      if (t0 + t1 >= 1.0F)
         return; /* discard */

      clipmask &= ~(1 << plane_idx);  /* turn off this plane's bit */
   }

   if (v0->clipmask) {
      interp( clipper, stage->tmp[0], t0, v0, v1 );

      if (clipper->flat)
         copy_colors(stage, stage->tmp[0], v0);

      newprim.v[0] = stage->tmp[0];
   }
   else {
      newprim.v[0] = v0;
   }

   if (v1->clipmask) {
      interp( clipper, stage->tmp[1], t1, v1, v0 );
      newprim.v[1] = stage->tmp[1];
   }
   else {
      newprim.v[1] = v1;
   }

   stage->next->line( stage->next, &newprim );
}

static void do_clip_tri	(	struct draw_stage *	stage,
		struct prim_header *	header,
		unsigned	clipmask
	)			[static]

Definition at line 216 of file draw_pipe_clip.c.

References vertex_header::clip, clipper_stage(), copy_colors(), DIFFERENT_SIGNS, dot4(), dup_vert(), vertex_header::edgeflag, emit_poly(), clipper::flat, interp(), IS_NEGATIVE, MAX_CLIPPED_VERTICES, clipper::plane, clipper::stage, draw_stage::tmp, and prim_header::v.

{
   struct clipper *clipper = clipper_stage( stage );
   struct vertex_header *a[MAX_CLIPPED_VERTICES];
   struct vertex_header *b[MAX_CLIPPED_VERTICES];
   struct vertex_header **inlist = a;
   struct vertex_header **outlist = b;
   unsigned tmpnr = 0;
   unsigned n = 3;
   unsigned i;

   inlist[0] = header->v[0];
   inlist[1] = header->v[1];
   inlist[2] = header->v[2];

   while (clipmask && n >= 3) {
      const unsigned plane_idx = ffs(clipmask)-1;
      const float *plane = clipper->plane[plane_idx];
      struct vertex_header *vert_prev = inlist[0];
      float dp_prev = dot4( vert_prev->clip, plane );
      unsigned outcount = 0;

      clipmask &= ~(1<<plane_idx);

      inlist[n] = inlist[0]; /* prevent rotation of vertices */

      for (i = 1; i <= n; i++) {
         struct vertex_header *vert = inlist[i];

         float dp = dot4( vert->clip, plane );

         if (!IS_NEGATIVE(dp_prev)) {
            outlist[outcount++] = vert_prev;
         }

         if (DIFFERENT_SIGNS(dp, dp_prev)) {
            struct vertex_header *new_vert = clipper->stage.tmp[tmpnr++];
            outlist[outcount++] = new_vert;

            if (IS_NEGATIVE(dp)) {
               /* Going out of bounds.  Avoid division by zero as we
                * know dp != dp_prev from DIFFERENT_SIGNS, above.
                */
               float t = dp / (dp - dp_prev);
               interp( clipper, new_vert, t, vert, vert_prev );
               
               /* Force edgeflag true in this case:
                */
               new_vert->edgeflag = 1;
            } else {
               /* Coming back in.
                */
               float t = dp_prev / (dp_prev - dp);
               interp( clipper, new_vert, t, vert_prev, vert );

               /* Copy starting vert's edgeflag:
                */
               new_vert->edgeflag = vert_prev->edgeflag;
            }
         }

         vert_prev = vert;
         dp_prev = dp;
      }

      {
         struct vertex_header **tmp = inlist;
         inlist = outlist;
         outlist = tmp;
         n = outcount;
      }
   }

   /* If flat-shading, copy color to new provoking vertex.
    */
   if (clipper->flat && inlist[0] != header->v[2]) {
      if (1) {
         inlist[0] = dup_vert(stage, inlist[0], tmpnr++);
      }

      copy_colors(stage, inlist[0], header->v[2]);
   }



   /* Emit the polygon as triangles to the setup stage:
    */
   if (n >= 3)
      emit_poly( stage, inlist, n, header );
}

static float dot4	(	const float *	a,
		const float *	b
	)			[static]

Definition at line 204 of file draw_pipe_clip.c.

{
   return (a[0]*b[0] +
           a[1]*b[1] +
           a[2]*b[2] +
           a[3]*b[3]);
}

struct draw_stage* draw_clip_stage

(

struct draw_context *

draw

)

[read]

Allocate a new clipper stage.

Returns:

pointer to new stage object

Definition at line 489 of file draw_pipe_clip.c.

References CALLOC_STRUCT, clip_destroy(), clip_first_line(), clip_first_tri(), clip_flush(), clip_point(), clip_reset_stipple_counter(), draw_stage::destroy, draw_stage::draw, draw_alloc_temp_verts(), draw_stage::flush, draw_stage::line, MAX_CLIPPED_VERTICES, draw_context::plane, clipper::plane, draw_stage::point, draw_stage::reset_stipple_counter, clipper::stage, and draw_stage::tri.

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

   if (!draw_alloc_temp_verts( &clipper->stage, MAX_CLIPPED_VERTICES+1 ))
      goto fail;

   clipper->stage.draw = draw;
   clipper->stage.point = clip_point;
   clipper->stage.line = clip_first_line;
   clipper->stage.tri = clip_first_tri;
   clipper->stage.flush = clip_flush;
   clipper->stage.reset_stipple_counter = clip_reset_stipple_counter;
   clipper->stage.destroy = clip_destroy;

   clipper->plane = draw->plane;

   return &clipper->stage;

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

   return NULL;
}

static void emit_poly	(	struct draw_stage *	stage,
		struct vertex_header **	inlist,
		unsigned	n,
		const struct prim_header *	origPrim
	)			[static]

Definition at line 159 of file draw_pipe_clip.c.

References vertex_header::data, debug_printf(), prim_header::det, draw_stage::draw, DRAW_PIPE_EDGE_FLAG_0, DRAW_PIPE_EDGE_FLAG_1, DRAW_PIPE_EDGE_FLAG_2, DRAW_PIPE_RESET_STIPPLE, prim_header::flags, draw_vertex_shader::info, draw_stage::next, tgsi_shader_info::num_outputs, prim_header::pad, draw_stage::tri, prim_header::v, draw_context::vertex_shader, and draw_context::vs.

{
   struct prim_header header;
   unsigned i;

   const ushort edge_first  = DRAW_PIPE_EDGE_FLAG_2;
   const ushort edge_middle = DRAW_PIPE_EDGE_FLAG_0;
   const ushort edge_last   = DRAW_PIPE_EDGE_FLAG_1;

   /* later stages may need the determinant, but only the sign matters */
   header.det = origPrim->det;
   header.flags = DRAW_PIPE_RESET_STIPPLE | edge_first | edge_middle;
   header.pad = 0;

   for (i = 2; i < n; i++, header.flags = edge_middle) {
      header.v[0] = inlist[i-1];
      header.v[1] = inlist[i];
      header.v[2] = inlist[0];  /* keep in v[2] for flatshading */

      if (i == n-1)
        header.flags |= edge_last;

      if (0) {
         const struct draw_vertex_shader *vs = stage->draw->vs.vertex_shader;
         uint j, k;
         debug_printf("Clipped tri:\n");
         for (j = 0; j < 3; j++) {
            for (k = 0; k < vs->info.num_outputs; k++) {
               debug_printf("  Vert %d: Attr %d:  %f %f %f %f\n", j, k,
                            header.v[j]->data[k][0],
                            header.v[j]->data[k][1],
                            header.v[j]->data[k][2],
                            header.v[j]->data[k][3]);
            }
         }
      }

      stage->next->tri( stage->next, &header );
   }
}

static void interp	(	const struct clipper *	clip,
		struct vertex_header *	dst,
		float	t,
		const struct vertex_header *	out,
		const struct vertex_header *	in
	)			[static]

Definition at line 111 of file draw_pipe_clip.c.

References vertex_header::clip, vertex_header::clipmask, vertex_header::data, draw_stage::draw, vertex_header::edgeflag, interp_attr(), draw_context::num_vs_outputs, vertex_header::pad, draw_context::position_output, pipe_viewport_state::scale, clipper::stage, pipe_viewport_state::translate, UNDEFINED_VERTEX_ID, vertex_header::vertex_id, draw_context::viewport, and draw_context::vs.

{
   const unsigned nr_attrs = clip->stage.draw->vs.num_vs_outputs;
   const unsigned pos_attr = clip->stage.draw->vs.position_output;
   unsigned j;

   /* Vertex header.
    */
   {
      dst->clipmask = 0;
      dst->edgeflag = 0;        /* will get overwritten later */
      dst->pad = 0;
      dst->vertex_id = UNDEFINED_VERTEX_ID;
   }

   /* Clip coordinates:  interpolate normally
    */
   {
      interp_attr(dst->clip, t, in->clip, out->clip);
   }

   /* Do the projective divide and insert window coordinates:
    */
   {
      const float *pos = dst->clip;
      const float *scale = clip->stage.draw->viewport.scale;
      const float *trans = clip->stage.draw->viewport.translate;
      const float oow = 1.0f / pos[3];

      dst->data[pos_attr][0] = pos[0] * oow * scale[0] + trans[0];
      dst->data[pos_attr][1] = pos[1] * oow * scale[1] + trans[1];
      dst->data[pos_attr][2] = pos[2] * oow * scale[2] + trans[2];
      dst->data[pos_attr][3] = oow;
   }

   /* Other attributes
    */
   for (j = 0; j < nr_attrs; j++) {
      if (j != pos_attr)
         interp_attr(dst->data[j], t, in->data[j], out->data[j]);
   }
}

static void interp_attr	(	float *	fdst,
		float	t,
		const float *	fin,
		const float *	fout
	)			[static]

Definition at line 84 of file draw_pipe_clip.c.

References LINTERP.

{  
   fdst[0] = LINTERP( t, fout[0], fin[0] );
   fdst[1] = LINTERP( t, fout[1], fin[1] );
   fdst[2] = LINTERP( t, fout[2], fin[2] );
   fdst[3] = LINTERP( t, fout[3], fin[3] );
}

---