spu_tri.c File Reference

Include dependency graph for spu_tri.c:

Go to the source code of this file.

Data Structures
union	float4
struct	vertex_header
	Basic vertex info. More...
struct	edge
	Triangle edge info. More...
struct	interp_coef
struct	setup_stage
	Triangle setup info (derived from draw_stage). More...
Defines
#define	CEILF(X)   ((float) (int) ((X) + 0.99999))
#define	QUAD_TOP_LEFT   0
#define	QUAD_TOP_RIGHT   1
#define	QUAD_BOTTOM_LEFT   2
#define	QUAD_BOTTOM_RIGHT   3
#define	MASK_TOP_LEFT   (1 << QUAD_TOP_LEFT)
#define	MASK_TOP_RIGHT   (1 << QUAD_TOP_RIGHT)
#define	MASK_BOTTOM_LEFT   (1 << QUAD_BOTTOM_LEFT)
#define	MASK_BOTTOM_RIGHT   (1 << QUAD_BOTTOM_RIGHT)
#define	MASK_ALL   0xf
#define	DEBUG_VERTS   0
Typedefs
typedef vector unsigned int	mask_t
	Triangle rendering within a tile.
Functions
static void	eval_coeff (uint slot, float x, float y, vector float result[4])
	Evaluate attribute coefficients (plane equations) to compute attribute values for the four fragments in a quad.
static vector float	eval_z (float x, float y)
static void	emit_quad (int x, int y, mask_t mask)
	Emit a quad (pass to next stage).
static int	block (int x)
	Given an X or Y coordinate, return the block/quad coordinate that it belongs to.
static mask_t	calculate_mask (int x)
	Compute mask which indicates which pixels in the 2x2 quad are actually inside the triangle's bounds.
static void	flush_spans (void)
	Render a horizontal span of quads.
static boolean	setup_sort_vertices (const struct vertex_header *v0, const struct vertex_header *v1, const struct vertex_header *v2)
static void	const_coeff (uint slot)
	Compute a0 for a constant-valued coefficient (GL_FLAT shading).
static void	tri_linear_coeff (uint slot, uint firstComp, uint lastComp)
	Compute a0, dadx and dady for a linearly interpolated coefficient, for a triangle.
static void	tri_linear_coeff4 (uint slot)
	As above, but interp setup all four vector components.
static void	setup_tri_coefficients (void)
	Compute the setup.coef[] array dadx, dady, a0 values.
static void	setup_tri_edges (void)
static void	subtriangle (struct edge *eleft, struct edge *eright, unsigned lines)
	Render the upper or lower half of a triangle.
boolean	tri_draw (const float *v0, const float *v1, const float *v2, uint tx, uint ty)
	Draw triangle into tile at (tx, ty) (tile coords) The tile data should have already been fetched.
Variables
static struct setup_stage	setup

---

Define Documentation

#define CEILF

(

X

)

((float) (int) ((X) + 0.99999))

Definition at line 64 of file spu_tri.c.

#define DEBUG_VERTS   0

Definition at line 78 of file spu_tri.c.

#define MASK_ALL   0xf

Definition at line 75 of file spu_tri.c.

#define MASK_BOTTOM_LEFT   (1 << QUAD_BOTTOM_LEFT)

Definition at line 73 of file spu_tri.c.

#define MASK_BOTTOM_RIGHT   (1 << QUAD_BOTTOM_RIGHT)

Definition at line 74 of file spu_tri.c.

#define MASK_TOP_LEFT   (1 << QUAD_TOP_LEFT)

Definition at line 71 of file spu_tri.c.

#define MASK_TOP_RIGHT   (1 << QUAD_TOP_RIGHT)

Definition at line 72 of file spu_tri.c.

#define QUAD_BOTTOM_LEFT   2

Definition at line 69 of file spu_tri.c.

#define QUAD_BOTTOM_RIGHT   3

Definition at line 70 of file spu_tri.c.

#define QUAD_TOP_LEFT   0

Definition at line 67 of file spu_tri.c.

#define QUAD_TOP_RIGHT   1

Definition at line 68 of file spu_tri.c.

---

Typedef Documentation

typedef vector unsigned int mask_t

Triangle rendering within a tile.

Masks are uint[4] vectors with each element being 0 or 0xffffffff

Definition at line 44 of file spu_tri.c.

---

Function Documentation

static int block

(

int

x

)

[static]

Given an X or Y coordinate, return the block/quad coordinate that it belongs to.

Definition at line 383 of file spu_tri.c.

{

static mask_t calculate_mask

(

int

x

)

[static]

Compute mask which indicates which pixels in the 2x2 quad are actually inside the triangle's bounds.

The mask is a uint4 vector and each element will be 0 or 0xffffffff.

Definition at line 394 of file spu_tri.c.

{
   /* This is a little tricky.
    * Use & instead of && to avoid branches.
    * Use negation to convert true/false to ~0/0 values.
    */
   mask_t mask;
   mask = spu_insert(-((x   >= setup.span.left[0]) & (x   < setup.span.right[0])), mask, 0);
   mask = spu_insert(-((x+1 >= setup.span.left[0]) & (x+1 < setup.span.right[0])), mask, 1);
   mask = spu_insert(-((x   >= setup.span.left[1]) & (x   < setup.span.right[1])), mask, 2);

static void const_coeff

(

uint

slot

)

[static]

Compute a0 for a constant-valued coefficient (GL_FLAT shading).

The value value comes from vertex->data[slot]. The result will be put into setup.coef[slot].a0.

Parameters:

slot

which attribute slot

Definition at line 622 of file spu_tri.c.

{
   setup.coef[slot].dadx.v = (vector float) {0.0, 0.0, 0.0, 0.0};

static void emit_quad	(	int	x,
		int	y,
		mask_t	mask
	)			[static]

Emit a quad (pass to next stage).

No clipping is done. Note: about 1/5 to 1/7 of the time, mask is zero and this function should be skipped. But adding the test for that slows things down overall.

< modified locally, but not put back yet

< modified locally, but not put back yet

Definition at line 261 of file spu_tri.c.

{
   /* If any bits in mask are set... */
   if (spu_extract(spu_orx(mask), 0)) {
      const int ix = x - setup.cliprect_minx;
      const int iy = y - setup.cliprect_miny;
      vector float colors[4];

      spu.cur_ctile_status = TILE_STATUS_DIRTY;
      spu.cur_ztile_status = TILE_STATUS_DIRTY;

      if (spu.texture[0].start) {
         /* texture mapping */
         const uint unit = 0;
         vector float texcoords[4];
         eval_coeff(2, (float) x, (float) y, texcoords);

         if (spu_extract(mask, 0))
            colors[0] = spu.sample_texture[unit](unit, texcoords[0]);
         if (spu_extract(mask, 1))
            colors[1] = spu.sample_texture[unit](unit, texcoords[1]);
         if (spu_extract(mask, 2))
            colors[2] = spu.sample_texture[unit](unit, texcoords[2]);
         if (spu_extract(mask, 3))
            colors[3] = spu.sample_texture[unit](unit, texcoords[3]);


         if (spu.texture[1].start) {
            /* multi-texture mapping */
            const uint unit = 1;
            vector float colors1[4];

            eval_coeff(2, (float) x, (float) y, texcoords);

            if (spu_extract(mask, 0))
               colors1[0] = spu.sample_texture[unit](unit, texcoords[0]);
            if (spu_extract(mask, 1))
               colors1[1] = spu.sample_texture[unit](unit, texcoords[1]);
            if (spu_extract(mask, 2))
               colors1[2] = spu.sample_texture[unit](unit, texcoords[2]);
            if (spu_extract(mask, 3))
               colors1[3] = spu.sample_texture[unit](unit, texcoords[3]);

            /* hack: modulate first texture by second */
            colors[0] = spu_mul(colors[0], colors1[0]);
            colors[1] = spu_mul(colors[1], colors1[1]);
            colors[2] = spu_mul(colors[2], colors1[2]);
            colors[3] = spu_mul(colors[3], colors1[3]);
         }

      }
      else {
         /* simple shading */
#if 0
         eval_coeff(1, (float) x, (float) y, colors);

#else
         /* XXX new fragment program code */

         if (spu.fragment_program) {
            vector float inputs[4*4], outputs[2*4];

            /* setup inputs */
            eval_coeff(1, (float) x, (float) y, inputs);

            /* Execute the current fragment program */
            spu.fragment_program(inputs, outputs, spu.constants);

            /* Copy outputs */
            colors[0] = outputs[0*4+0];
            colors[1] = outputs[0*4+1];
            colors[2] = outputs[0*4+2];
            colors[3] = outputs[0*4+3];

            if (0 && spu.init.id==0 && y == 48) {
               printf("colors[0] = %f %f %f %f\n",
                      spu_extract(colors[0], 0),
                      spu_extract(colors[0], 1),
                      spu_extract(colors[0], 2),
                      spu_extract(colors[0], 3));
               printf("colors[1] = %f %f %f %f\n",
                      spu_extract(colors[1], 0),
                      spu_extract(colors[1], 1),
                      spu_extract(colors[1], 2),
                      spu_extract(colors[1], 3));
            }

         }
#endif
      }


      {
         /* Convert fragment data from AoS to SoA format.
          * I.e. (RGBA,RGBA,RGBA,RGBA) -> (RRRR,GGGG,BBBB,AAAA)
          * This is temporary!
          */
         vector float soa_frag[4];
         _transpose_matrix4x4(soa_frag, colors);

         float4 fragZ;

         fragZ.v = eval_z((float) x, (float) y);

         /* Do all per-fragment/quad operations here, including:
          *  alpha test, z test, stencil test, blend and framebuffer writing.
          */
         spu.fragment_ops(ix, iy, &spu.ctile, &spu.ztile,
                          fragZ.v,
                          soa_frag[0], soa_frag[1],
                          soa_frag[2], soa_frag[3],
                          mask);
      }

static void eval_coeff	(	uint	slot,
		float	x,
		float	y,
		vector float	result[4]
	)			[static]

Evaluate attribute coefficients (plane equations) to compute attribute values for the four fragments in a quad.

Eg: four colors will be computed (in AoS format).

Definition at line 211 of file spu_tri.c.

     : four colors will be computed (in AoS format).
 */
static INLINE void
eval_coeff(uint slot, float x, float y, vector float result[4])
{
   switch (spu.vertex_info.interp_mode[slot]) {
   case INTERP_CONSTANT:
      result[QUAD_TOP_LEFT] =
      result[QUAD_TOP_RIGHT] =
      result[QUAD_BOTTOM_LEFT] =
      result[QUAD_BOTTOM_RIGHT] = setup.coef[slot].a0.v;
      break;

   case INTERP_LINEAR:
      /* fall-through, for now */
   default:
      {
         register vector float dadx = setup.coef[slot].dadx.v;
         register vector float dady = setup.coef[slot].dady.v;
         register vector float topLeft
            = spu_add(setup.coef[slot].a0.v,
                      spu_add(spu_mul(spu_splats(x), dadx),
                              spu_mul(spu_splats(y), dady)));

         result[QUAD_TOP_LEFT] = topLeft;
         result[QUAD_TOP_RIGHT] = spu_add(topLeft, dadx);
         result[QUAD_BOTTOM_LEFT] = spu_add(topLeft, dady);
         result[QUAD_BOTTOM_RIGHT] = spu_add(spu_add(topLeft, dadx), dady);

static vector float eval_z	(	float	x,
		float	y
	)			[static]

Definition at line 242 of file spu_tri.c.

References interp_coef::a0, setup_stage::coef, interp_coef::dadx, interp_coef::dady, and float4::f.

{
   const uint slot = 0;
   const float dzdx = setup.coef[slot].dadx.f[2];
   const float dzdy = setup.coef[slot].dady.f[2];
   const float topLeft = setup.coef[slot].a0.f[2] + x * dzdx + y * dzdy;
   const vector float topLeftv = spu_splats(topLeft);

static void flush_spans

(

void

)

[static]

Render a horizontal span of quads.

< mfc_get() called but not yet arrived

< in local store, but not changed

< modified locally, but not put back yet

< defined in FB, but not in local store

< mfc_get() called but not yet arrived

< in local store, but not changed

< modified locally, but not put back yet

< defined in FB, but not in local store

Definition at line 412 of file spu_tri.c.

{
   int minleft, maxright;
   int x;

   switch (setup.span.y_flags) {
   case 0x3:
      /* both odd and even lines written (both quad rows) */
      minleft = MIN2(setup.span.left[0], setup.span.left[1]);
      maxright = MAX2(setup.span.right[0], setup.span.right[1]);
      break;

   case 0x1:
      /* only even line written (quad top row) */
      minleft = setup.span.left[0];
      maxright = setup.span.right[0];
      break;

   case 0x2:
      /* only odd line written (quad bottom row) */
      minleft = setup.span.left[1];
      maxright = setup.span.right[1];
      break;

   default:
      return;
   }


   /* OK, we're very likely to need the tile data now.
    * clear or finish waiting if needed.
    */
   if (spu.cur_ctile_status == TILE_STATUS_GETTING) {
      /* wait for mfc_get() to complete */
      //printf("SPU: %u: waiting for ctile\n", spu.init.id);
      wait_on_mask(1 << TAG_READ_TILE_COLOR);
      spu.cur_ctile_status = TILE_STATUS_CLEAN;
   }
   else if (spu.cur_ctile_status == TILE_STATUS_CLEAR) {
      //printf("SPU %u: clearing C tile %u, %u\n", spu.init.id, setup.tx, setup.ty);
      clear_c_tile(&spu.ctile);
      spu.cur_ctile_status = TILE_STATUS_DIRTY;
   }
   ASSERT(spu.cur_ctile_status != TILE_STATUS_DEFINED);

   if (spu.read_depth) {
      if (spu.cur_ztile_status == TILE_STATUS_GETTING) {
         /* wait for mfc_get() to complete */
         //printf("SPU: %u: waiting for ztile\n", spu.init.id);
         wait_on_mask(1 << TAG_READ_TILE_Z);
         spu.cur_ztile_status = TILE_STATUS_CLEAN;
      }
      else if (spu.cur_ztile_status == TILE_STATUS_CLEAR) {
         //printf("SPU %u: clearing Z tile %u, %u\n", spu.init.id, setup.tx, setup.ty);
         clear_z_tile(&spu.ztile);
         spu.cur_ztile_status = TILE_STATUS_DIRTY;
      }
      ASSERT(spu.cur_ztile_status != TILE_STATUS_DEFINED);
   }

   /* XXX this loop could be moved into the above switch cases and
    * calculate_mask() could be simplified a bit...
    */
   for (x = block(minleft); x <= block(maxright); x += 2) {
#if 1
      emit_quad( x, setup.span.y, calculate_mask( x ) );
#endif
   }

   setup.span.y = 0;
   setup.span.y_flags = 0;

static boolean setup_sort_vertices	(	const struct vertex_header *	v0,
		const struct vertex_header *	v1,
		const struct vertex_header *	v2
	)			[static]

Definition at line 500 of file spu_tri.c.

References setup_stage::cliprect_maxx, setup_stage::cliprect_maxy, setup_stage::cliprect_minx, setup_stage::cliprect_miny, vertex_header::data, edge::dx, edge::dy, setup_stage::ebot, setup_stage::emaj, setup_stage::etop, FALSE, setup_stage::oneoverarea, PIPE_WINDING_CW, TRUE, setup_stage::vmax, setup_stage::vmid, setup_stage::vmin, and setup_stage::vprovoke.

{

#if DEBUG_VERTS
   fprintf(stderr, "Triangle:\n");
   print_vertex(v0);
   print_vertex(v1);
   print_vertex(v2);
#endif

   setup.vprovoke = v2;

   /* determine bottom to top order of vertices */
   {
      float y0 = spu_extract(v0->data[0], 1);
      float y1 = spu_extract(v1->data[0], 1);
      float y2 = spu_extract(v2->data[0], 1);
      if (y0 <= y1) {
         if (y1 <= y2) {
            /* y0<=y1<=y2 */
            setup.vmin = v0;   
            setup.vmid = v1;   
            setup.vmax = v2;
         }
         else if (y2 <= y0) {
            /* y2<=y0<=y1 */
            setup.vmin = v2;   
            setup.vmid = v0;   
            setup.vmax = v1;   
         }
         else {
            /* y0<=y2<=y1 */
            setup.vmin = v0;   
            setup.vmid = v2;   
            setup.vmax = v1;  
         }
      }
      else {
         if (y0 <= y2) {
            /* y1<=y0<=y2 */
            setup.vmin = v1;   
            setup.vmid = v0;   
            setup.vmax = v2;  
         }
         else if (y2 <= y1) {
            /* y2<=y1<=y0 */
            setup.vmin = v2;   
            setup.vmid = v1;   
            setup.vmax = v0;  
         }
         else {
            /* y1<=y2<=y0 */
            setup.vmin = v1;   
            setup.vmid = v2;   
            setup.vmax = v0;
         }
      }
   }

   /* Check if triangle is completely outside the tile bounds */
   if (spu_extract(setup.vmin->data[0], 1) > setup.cliprect_maxy)
      return FALSE;
   if (spu_extract(setup.vmax->data[0], 1) < setup.cliprect_miny)
      return FALSE;
   if (spu_extract(setup.vmin->data[0], 0) < setup.cliprect_minx &&
       spu_extract(setup.vmid->data[0], 0) < setup.cliprect_minx &&
       spu_extract(setup.vmax->data[0], 0) < setup.cliprect_minx)
      return FALSE;
   if (spu_extract(setup.vmin->data[0], 0) > setup.cliprect_maxx &&
       spu_extract(setup.vmid->data[0], 0) > setup.cliprect_maxx &&
       spu_extract(setup.vmax->data[0], 0) > setup.cliprect_maxx)
      return FALSE;

   setup.ebot.dx = spu_extract(setup.vmid->data[0], 0) - spu_extract(setup.vmin->data[0], 0);
   setup.ebot.dy = spu_extract(setup.vmid->data[0], 1) - spu_extract(setup.vmin->data[0], 1);
   setup.emaj.dx = spu_extract(setup.vmax->data[0], 0) - spu_extract(setup.vmin->data[0], 0);
   setup.emaj.dy = spu_extract(setup.vmax->data[0], 1) - spu_extract(setup.vmin->data[0], 1);
   setup.etop.dx = spu_extract(setup.vmax->data[0], 0) - spu_extract(setup.vmid->data[0], 0);
   setup.etop.dy = spu_extract(setup.vmax->data[0], 1) - spu_extract(setup.vmid->data[0], 1);

   /*
    * Compute triangle's area.  Use 1/area to compute partial
    * derivatives of attributes later.
    *
    * The area will be the same as prim->det, but the sign may be
    * different depending on how the vertices get sorted above.
    *
    * To determine whether the primitive is front or back facing we
    * use the prim->det value because its sign is correct.
    */
   {
      const float area = (setup.emaj.dx * setup.ebot.dy - 
                            setup.ebot.dx * setup.emaj.dy);

      setup.oneoverarea = 1.0f / area;
      /*
      _mesa_printf("%s one-over-area %f  area %f  det %f\n",
                   __FUNCTION__, setup.oneoverarea, area, prim->det );
      */
   }

#if 0
   /* We need to know if this is a front or back-facing triangle for:
    *  - the GLSL gl_FrontFacing fragment attribute (bool)
    *  - two-sided stencil test
    */
   setup.quad.facing = (prim->det > 0.0) ^ (setup.softpipe->rasterizer->front_winding == PIPE_WINDING_CW);
#endif

static void setup_tri_coefficients

(

void

)

[static]

Compute the setup.coef[] array dadx, dady, a0 values.

Must be called after setup.vmin,vmid,vmax,vprovoke are initialized.

Definition at line 759 of file spu_tri.c.

{
#if 1
   uint i;

   for (i = 0; i < spu.vertex_info.num_attribs; i++) {
      switch (spu.vertex_info.interp_mode[i]) {
      case INTERP_NONE:
         break;
      case INTERP_POS:
         /*tri_linear_coeff(i, 2, 3);*/
         /* XXX interp W if PERSPECTIVE... */
         tri_linear_coeff4(i);
         break;
      case INTERP_CONSTANT:
         const_coeff(i);
         break;
      case INTERP_LINEAR:
         tri_linear_coeff4(i);
         break;
      case INTERP_PERSPECTIVE:
         tri_linear_coeff4(i);  /* temporary */
         break;
      default:
         ASSERT(0);
      }
   }
#else
   ASSERT(spu.vertex_info.interp_mode[0] == INTERP_POS);
   ASSERT(spu.vertex_info.interp_mode[1] == INTERP_LINEAR ||

static void setup_tri_edges

(

void

)

[static]

Definition at line 795 of file spu_tri.c.

{
   float vmin_x = spu_extract(setup.vmin->data[0], 0) + 0.5f;
   float vmid_x = spu_extract(setup.vmid->data[0], 0) + 0.5f;

   float vmin_y = spu_extract(setup.vmin->data[0], 1) - 0.5f;
   float vmid_y = spu_extract(setup.vmid->data[0], 1) - 0.5f;
   float vmax_y = spu_extract(setup.vmax->data[0], 1) - 0.5f;

   setup.emaj.sy = CEILF(vmin_y);
   setup.emaj.lines = (int) CEILF(vmax_y - setup.emaj.sy);
   setup.emaj.dxdy = setup.emaj.dx / setup.emaj.dy;
   setup.emaj.sx = vmin_x + (setup.emaj.sy - vmin_y) * setup.emaj.dxdy;

   setup.etop.sy = CEILF(vmid_y);
   setup.etop.lines = (int) CEILF(vmax_y - setup.etop.sy);
   setup.etop.dxdy = setup.etop.dx / setup.etop.dy;
   setup.etop.sx = vmid_x + (setup.etop.sy - vmid_y) * setup.etop.dxdy;

static void subtriangle	(	struct edge *	eleft,
		struct edge *	eright,
		unsigned	lines
	)			[static]

Render the upper or lower half of a triangle.

Scissoring/cliprect is applied here too.

Definition at line 825 of file spu_tri.c.

References ASSERT, block(), setup_stage::cliprect_maxx, setup_stage::cliprect_maxy, setup_stage::cliprect_minx, setup_stage::cliprect_miny, edge::dxdy, flush_spans(), setup_stage::left, setup_stage::right, setup_stage::span, edge::sx, edge::sy, setup_stage::y, and setup_stage::y_flags.

{
   const int minx = setup.cliprect_minx;
   const int maxx = setup.cliprect_maxx;
   const int miny = setup.cliprect_miny;
   const int maxy = setup.cliprect_maxy;
   int y, start_y, finish_y;
   int sy = (int)eleft->sy;

   ASSERT((int)eleft->sy == (int) eright->sy);

   /* clip top/bottom */
   start_y = sy;
   finish_y = sy + lines;

   if (start_y < miny)
      start_y = miny;

   if (finish_y > maxy)
      finish_y = maxy;

   start_y -= sy;
   finish_y -= sy;

   /*
   _mesa_printf("%s %d %d\n", __FUNCTION__, start_y, finish_y);  
   */

   for (y = start_y; y < finish_y; y++) {

      /* avoid accumulating adds as floats don't have the precision to
       * accurately iterate large triangle edges that way.  luckily we
       * can just multiply these days.
       *
       * this is all drowned out by the attribute interpolation anyway.
       */
      int left = (int)(eleft->sx + y * eleft->dxdy);
      int right = (int)(eright->sx + y * eright->dxdy);

      /* clip left/right */
      if (left < minx)
         left = minx;
      if (right > maxx)
         right = maxx;

      if (left < right) {
         int _y = sy + y;
         if (block(_y) != setup.span.y) {
            flush_spans();
            setup.span.y = block(_y);
         }

         setup.span.left[_y&1] = left;
         setup.span.right[_y&1] = right;
         setup.span.y_flags |= 1<<(_y&1);
      }
   }


   /* save the values so that emaj can be restarted:
    */

boolean tri_draw	(	const float *	v0,
		const float *	v1,
		const float *	v2,
		uint	tx,
		uint	ty
	)

Draw triangle into tile at (tx, ty) (tile coords) The tile data should have already been fetched.

Definition at line 900 of file spu_tri.c.

{
   setup.tx = tx;
   setup.ty = ty;

   /* set clipping bounds to tile bounds */
   setup.cliprect_minx = tx * TILE_SIZE;
   setup.cliprect_miny = ty * TILE_SIZE;
   setup.cliprect_maxx = (tx + 1) * TILE_SIZE;
   setup.cliprect_maxy = (ty + 1) * TILE_SIZE;

   if (!setup_sort_vertices((struct vertex_header *) v0,
                            (struct vertex_header *) v1,
                            (struct vertex_header *) v2)) {
      return FALSE; /* totally clipped */
   }

   setup_tri_coefficients();
   setup_tri_edges();

   setup.span.y = 0;
   setup.span.y_flags = 0;
   setup.span.right[0] = 0;
   setup.span.right[1] = 0;
   /*   setup.span.z_mode = tri_z_mode( setup.ctx ); */

   /*   init_constant_attribs( setup ); */
      
   if (setup.oneoverarea < 0.0) {
      /* emaj on left:
       */
      subtriangle( &setup.emaj, &setup.ebot, setup.ebot.lines );
      subtriangle( &setup.emaj, &setup.etop, setup.etop.lines );
   }
   else {
      /* emaj on right:
       */
      subtriangle( &setup.ebot, &setup.emaj, setup.ebot.lines );
      subtriangle( &setup.etop, &setup.emaj, setup.etop.lines );
   }

static void tri_linear_coeff	(	uint	slot,
		uint	firstComp,
		uint	lastComp
	)			[static]

Compute a0, dadx and dady for a linearly interpolated coefficient, for a triangle.

Definition at line 635 of file spu_tri.c.

{
   uint i;
   const float *vmin_d = (float *) &setup.vmin->data[slot];
   const float *vmid_d = (float *) &setup.vmid->data[slot];
   const float *vmax_d = (float *) &setup.vmax->data[slot];
   const float x = spu_extract(setup.vmin->data[0], 0) - 0.5f;
   const float y = spu_extract(setup.vmin->data[0], 1) - 0.5f;

   for (i = firstComp; i < lastComp; i++) {
      float botda = vmid_d[i] - vmin_d[i];
      float majda = vmax_d[i] - vmin_d[i];
      float a = setup.ebot.dy * majda - botda * setup.emaj.dy;
      float b = setup.emaj.dx * botda - majda * setup.ebot.dx;
   
      ASSERT(slot < PIPE_MAX_SHADER_INPUTS);

      setup.coef[slot].dadx.f[i] = a * setup.oneoverarea;
      setup.coef[slot].dady.f[i] = b * setup.oneoverarea;

      /* calculate a0 as the value which would be sampled for the
       * fragment at (0,0), taking into account that we want to sample at
       * pixel centers, in other words (0.5, 0.5).
       *
       * this is neat but unfortunately not a good way to do things for
       * triangles with very large values of dadx or dady as it will
       * result in the subtraction and re-addition from a0 of a very
       * large number, which means we'll end up loosing a lot of the
       * fractional bits and precision from a0.  the way to fix this is
       * to define a0 as the sample at a pixel center somewhere near vmin
       * instead - i'll switch to this later.
       */
      setup.coef[slot].a0.f[i] = (vmin_d[i] - 
                                 (setup.coef[slot].dadx.f[i] * x + 
                                  setup.coef[slot].dady.f[i] * y));
   }

   /*
   _mesa_printf("attr[%d].%c: %f dx:%f dy:%f\n",
                slot, "xyzw"[i], 
                setup.coef[slot].a0[i],
                setup.coef[slot].dadx.f[i],

static void tri_linear_coeff4

(

uint

slot

)

[static]

As above, but interp setup all four vector components.

Definition at line 686 of file spu_tri.c.

{
   const vector float vmin_d = setup.vmin->data[slot];
   const vector float vmid_d = setup.vmid->data[slot];
   const vector float vmax_d = setup.vmax->data[slot];
   const vector float xxxx = spu_splats(spu_extract(setup.vmin->data[0], 0) - 0.5f);
   const vector float yyyy = spu_splats(spu_extract(setup.vmin->data[0], 1) - 0.5f);

   vector float botda = vmid_d - vmin_d;
   vector float majda = vmax_d - vmin_d;

   vector float a = spu_sub(spu_mul(spu_splats(setup.ebot.dy), majda),
                            spu_mul(botda, spu_splats(setup.emaj.dy)));
   vector float b = spu_sub(spu_mul(spu_splats(setup.emaj.dx), botda),
                            spu_mul(majda, spu_splats(setup.ebot.dx)));

   setup.coef[slot].dadx.v = spu_mul(a, spu_splats(setup.oneoverarea));
   setup.coef[slot].dady.v = spu_mul(b, spu_splats(setup.oneoverarea));

   vector float tempx = spu_mul(setup.coef[slot].dadx.v, xxxx);
   vector float tempy = spu_mul(setup.coef[slot].dady.v, yyyy);

---

Variable Documentation

struct setup_stage setup [static]

Definition at line 146 of file spu_tri.c.

---