brw_clip.h File Reference

Include dependency graph for brw_clip.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	brw_clip_prog_key
struct	brw_clip_compile
Defines
#define	MAX_VERTS   (3+6+6)
#define	CLIP_LINE   0
#define	CLIP_POINT   1
#define	CLIP_FILL   2
#define	CLIP_CULL   3
#define	PRIM_MASK   (0x1f)
#define	ATTR_SIZE   (4*4)
Functions
void	brw_emit_unfilled_clip (struct brw_clip_compile *c)
void	brw_emit_tri_clip (struct brw_clip_compile *c)
void	brw_emit_line_clip (struct brw_clip_compile *c)
void	brw_emit_point_clip (struct brw_clip_compile *c)
void	brw_clip_tri_init_vertices (struct brw_clip_compile *c)
void	brw_clip_tri_flat_shade (struct brw_clip_compile *c)
void	brw_clip_tri (struct brw_clip_compile *c)
void	brw_clip_tri_emit_polygon (struct brw_clip_compile *c)
void	brw_clip_tri_alloc_regs (struct brw_clip_compile *c, unsigned nr_verts)
void	brw_clip_interp_vertex (struct brw_clip_compile *c, struct brw_indirect dest_ptr, struct brw_indirect v0_ptr, struct brw_indirect v1_ptr, struct brw_reg t0, boolean force_edgeflag)
void	brw_clip_init_planes (struct brw_clip_compile *c)
void	brw_clip_emit_vue (struct brw_clip_compile *c, struct brw_indirect vert, boolean allocate, boolean eot, unsigned header)
void	brw_clip_kill_thread (struct brw_clip_compile *c)
struct brw_reg	brw_clip_plane_stride (struct brw_clip_compile *c)
struct brw_reg	brw_clip_plane0_address (struct brw_clip_compile *c)
void	brw_clip_copy_colors (struct brw_clip_compile *c, unsigned to, unsigned from)
void	brw_clip_init_clipmask (struct brw_clip_compile *c)

---

Define Documentation

#define ATTR_SIZE   (4*4)

Definition at line 122 of file brw_clip.h.

#define CLIP_CULL   3

Definition at line 69 of file brw_clip.h.

#define CLIP_FILL   2

Definition at line 68 of file brw_clip.h.

#define CLIP_LINE   0

Definition at line 66 of file brw_clip.h.

#define CLIP_POINT   1

Definition at line 67 of file brw_clip.h.

#define MAX_VERTS   (3+6+6)

Definition at line 39 of file brw_clip.h.

#define PRIM_MASK   (0x1f)

Definition at line 72 of file brw_clip.h.

---

Function Documentation

void brw_clip_copy_colors	(	struct brw_clip_compile *	c,
		unsigned	to,
		unsigned	from
	)

Definition at line 297 of file brw_clip_util.c.

References brw_MOV(), byte_offset(), brw_clip_compile::func, brw_clip_compile::offset, brw_clip_compile::reg, and brw_clip_compile::vertex.

{
#if 0
   struct brw_compile *p = &c->func;

   if (c->offset[VERT_RESULT_COL0])
      brw_MOV(p,
              byte_offset(c->reg.vertex[to], c->offset[VERT_RESULT_COL0]),
              byte_offset(c->reg.vertex[from], c->offset[VERT_RESULT_COL0]));

   if (c->offset[VERT_RESULT_COL1])
      brw_MOV(p,
              byte_offset(c->reg.vertex[to], c->offset[VERT_RESULT_COL1]),
              byte_offset(c->reg.vertex[from], c->offset[VERT_RESULT_COL1]));

   if (c->offset[VERT_RESULT_BFC0])
      brw_MOV(p,
              byte_offset(c->reg.vertex[to], c->offset[VERT_RESULT_BFC0]),
              byte_offset(c->reg.vertex[from], c->offset[VERT_RESULT_BFC0]));

   if (c->offset[VERT_RESULT_BFC1])
      brw_MOV(p,
              byte_offset(c->reg.vertex[to], c->offset[VERT_RESULT_BFC1]),
              byte_offset(c->reg.vertex[from], c->offset[VERT_RESULT_BFC1]));
#else
         #warning "disabled"
#endif
}

void brw_clip_emit_vue	(	struct brw_clip_compile *	c,
		struct brw_indirect	vert,
		boolean	allocate,
		boolean	eot,
		unsigned	header
	)

Definition at line 198 of file brw_clip_util.c.

References assert, brw_copy_from_indirect(), brw_imm_ud(), brw_message_reg(), brw_MOV(), brw_null_reg(), BRW_REGISTER_TYPE_UD, BRW_URB_SWIZZLE_NONE, brw_urb_WRITE(), brw_clip_compile::func, get_element_ud(), brw_clip_compile::last_mrf, MAX_MRF, brw_clip_compile::nr_regs, brw_clip_compile::R0, brw_clip_compile::reg, and retype().

{
   struct brw_compile *p = &c->func;
   unsigned start = c->last_mrf;

   assert(!(allocate && eot));

   /* Cycle through mrf regs - probably futile as we have to wait for
    * the allocation response anyway.  Also, the order this function
    * is invoked doesn't correspond to the order the instructions will
    * be executed, so it won't have any effect in many cases.
    */
#if 0
   if (start + c->nr_regs + 1 >= MAX_MRF)
      start = 0;

   c->last_mrf = start + c->nr_regs + 1;
#endif

   /* Copy the vertex from vertn into m1..mN+1:
    */
   brw_copy_from_indirect(p, brw_message_reg(start+1), vert, c->nr_regs);

   /* Overwrite PrimType and PrimStart in the message header, for
    * each vertex in turn:
    */
   brw_MOV(p, get_element_ud(c->reg.R0, 2), brw_imm_ud(header));


   /* Send each vertex as a seperate write to the urb.  This
    * is different to the concept in brw_sf_emit.c, where
    * subsequent writes are used to build up a single urb
    * entry.  Each of these writes instantiates a seperate
    * urb entry - (I think... what about 'allocate'?)
    */
   brw_urb_WRITE(p,
                 allocate ? c->reg.R0 : retype(brw_null_reg(), BRW_REGISTER_TYPE_UD),
                 start,
                 c->reg.R0,
                 allocate,
                 1,             /* used */
                 c->nr_regs + 1, /* msg length */
                 allocate ? 1 : 0, /* response_length */
                 eot,           /* eot */
                 1,             /* writes_complete */
                 0,             /* urb offset */
                 BRW_URB_SWIZZLE_NONE);
}

void brw_clip_init_clipmask

(

struct brw_clip_compile *

c

)

Definition at line 329 of file brw_clip_util.c.

References brw_AND(), brw_imm_ud(), brw_OR(), BRW_REGISTER_TYPE_UD, brw_SHR(), brw_clip_compile::func, get_element_ud(), get_tmp(), brw_clip_compile::key, brw_clip_prog_key::nr_userclip, brw_clip_compile::planemask, brw_clip_compile::R0, brw_clip_compile::reg, release_tmp(), retype(), and vec1().

{
   struct brw_compile *p = &c->func;
   struct brw_reg incoming = get_element_ud(c->reg.R0, 2);

   /* Shift so that lowest outcode bit is rightmost:
    */
   brw_SHR(p, c->reg.planemask, incoming, brw_imm_ud(26));

   if (c->key.nr_userclip) {
      struct brw_reg tmp = retype(vec1(get_tmp(c)), BRW_REGISTER_TYPE_UD);

      /* Rearrange userclip outcodes so that they come directly after
       * the fixed plane bits.
       */
      brw_AND(p, tmp, incoming, brw_imm_ud(0x3f<<14));
      brw_SHR(p, tmp, tmp, brw_imm_ud(8));
      brw_OR(p, c->reg.planemask, c->reg.planemask, tmp);

      release_tmp(c, tmp);
   }
}

void brw_clip_init_planes

(

struct brw_clip_compile *

c

)

Definition at line 66 of file brw_clip_util.c.

References brw_MOV(), brw_clip_compile::fixed_planes, brw_clip_compile::func, get_element_ud(), brw_clip_compile::key, make_plane_ud(), brw_clip_prog_key::nr_userclip, and brw_clip_compile::reg.

{
   struct brw_compile *p = &c->func;

   if (!c->key.nr_userclip) {
      brw_MOV(p, get_element_ud(c->reg.fixed_planes, 0), make_plane_ud( 0,    0, 0xff, 1));
      brw_MOV(p, get_element_ud(c->reg.fixed_planes, 1), make_plane_ud( 0,    0,    1, 1));
      brw_MOV(p, get_element_ud(c->reg.fixed_planes, 2), make_plane_ud( 0, 0xff,    0, 1));
      brw_MOV(p, get_element_ud(c->reg.fixed_planes, 3), make_plane_ud( 0,    1,    0, 1));
      brw_MOV(p, get_element_ud(c->reg.fixed_planes, 4), make_plane_ud(0xff,  0,    0, 1));
      brw_MOV(p, get_element_ud(c->reg.fixed_planes, 5), make_plane_ud( 1,    0,    0, 1));
   }
}

void brw_clip_interp_vertex	(	struct brw_clip_compile *	c,
		struct brw_indirect	dest_ptr,
		struct brw_indirect	v0_ptr,
		struct brw_indirect	v1_ptr,
		struct brw_reg	t0,
		boolean	force_edgeflag
	)

Definition at line 128 of file brw_clip_util.c.

References brw_ADD(), brw_clip_project_vertex(), brw_copy_indirect_to_indirect(), brw_imm_f(), brw_MAC(), brw_MOV(), brw_MUL(), brw_null_reg(), deref_4f(), brw_clip_compile::func, get_tmp(), negate(), brw_clip_compile::nr_attrs, brw_clip_compile::offset, release_tmp(), and vec4().

{
#if 0
   struct brw_compile *p = &c->func;
   struct brw_reg tmp = get_tmp(c);
   unsigned i;

   /* Just copy the vertex header:
    */
   brw_copy_indirect_to_indirect(p, dest_ptr, v0_ptr, 1);

   /* Iterate over each attribute (could be done in pairs?)
    */
   for (i = 0; i < c->nr_attrs; i++) {
      unsigned delta = i*16 + 32;

      if (delta == c->offset[VERT_RESULT_EDGE]) {
         if (force_edgeflag)
            brw_MOV(p, deref_4f(dest_ptr, delta), brw_imm_f(1));
         else
            brw_MOV(p, deref_4f(dest_ptr, delta), deref_4f(v0_ptr, delta));
      }
      else {
         /* Interpolate:
          *
          *        New = attr0 + t*attr1 - t*attr0
          */
         brw_MUL(p,
                 vec4(brw_null_reg()),
                 deref_4f(v1_ptr, delta),
                 t0);

         brw_MAC(p,
                 tmp,
                 negate(deref_4f(v0_ptr, delta)),
                 t0);

         brw_ADD(p,
                 deref_4f(dest_ptr, delta),
                 deref_4f(v0_ptr, delta),
                 tmp);
      }
   }

   if (i & 1) {
      unsigned delta = i*16 + 32;
      brw_MOV(p, deref_4f(dest_ptr, delta), brw_imm_f(0));
   }

   release_tmp(c, tmp);

   /* Recreate the projected (NDC) coordinate in the new vertex
    * header:
    */
   brw_clip_project_vertex(c, dest_ptr );
#else
         #warning "disabled"
#endif
}

void brw_clip_kill_thread

(

struct brw_clip_compile *

c

)

Definition at line 253 of file brw_clip_util.c.

References brw_null_reg(), BRW_REGISTER_TYPE_UD, BRW_URB_SWIZZLE_NONE, brw_urb_WRITE(), brw_clip_compile::func, brw_clip_compile::R0, brw_clip_compile::reg, and retype().

{
   struct brw_compile *p = &c->func;

   /* Send an empty message to kill the thread and release any
    * allocated urb entry:
    */
   brw_urb_WRITE(p,
                 retype(brw_null_reg(), BRW_REGISTER_TYPE_UD),
                 0,
                 c->reg.R0,
                 0,             /* allocate */
                 0,             /* used */
                 0,             /* msg len */
                 0,             /* response len */
                 1,             /* eot */
                 1,             /* writes complete */
                 0,
                 BRW_URB_SWIZZLE_NONE);
}

struct brw_reg brw_clip_plane0_address

(

struct brw_clip_compile *

c

)

[read]

Definition at line 277 of file brw_clip_util.c.

References brw_address().

{
   return brw_address(c->reg.fixed_planes);
}

struct brw_reg brw_clip_plane_stride

(

struct brw_clip_compile *

c

)

[read]

Definition at line 283 of file brw_clip_util.c.

References brw_imm_uw().

{
   if (c->key.nr_userclip) {
      return brw_imm_uw(16);
   }
   else {
      return brw_imm_uw(4);
   }
}

void brw_clip_tri

(

struct brw_clip_compile *

c

)

Definition at line 201 of file brw_clip_tri.c.

References brw_ADD(), brw_address(), brw_AND(), brw_clip_interp_vertex(), brw_clip_plane0_address(), brw_clip_plane_stride(), brw_CMP(), BRW_CONDITIONAL_EQ, BRW_CONDITIONAL_GE, BRW_CONDITIONAL_L, BRW_CONDITIONAL_NZ, brw_DO(), brw_DP4(), brw_ELSE(), brw_ENDIF(), BRW_EXECUTE_1, brw_IF(), brw_imm_d(), brw_imm_ud(), brw_imm_uw(), brw_imm_w(), brw_indirect(), brw_math_invert(), brw_MOV(), brw_MUL(), brw_null_reg(), BRW_PREDICATE_NONE, brw_set_conditionalmod(), brw_set_predicate_control(), brw_SHR(), brw_vec8_grf(), brw_WHILE(), deref_1uw(), deref_4b(), deref_4f(), brw_clip_compile::dp, brw_clip_compile::dpPrev, FALSE, brw_clip_compile::func, get_addr_reg(), brw_clip_compile::inlist, brw_clip_compile::key, brw_clip_compile::loopcount, negate(), brw_reg::nr, brw_clip_compile::nr_regs, brw_clip_prog_key::nr_userclip, brw_clip_compile::nr_verts, brw_clip_compile::offset, brw_clip_compile::outlist, brw_clip_compile::plane_equation, brw_clip_compile::planemask, brw_clip_compile::reg, REG_SIZE, brw_clip_compile::t, TRUE, vec1(), vec4(), and brw_clip_compile::vertex.

{
#if 0
   struct brw_compile *p = &c->func;
   struct brw_indirect vtx = brw_indirect(0, 0);
   struct brw_indirect vtxPrev = brw_indirect(1, 0);
   struct brw_indirect vtxOut = brw_indirect(2, 0);
   struct brw_indirect plane_ptr = brw_indirect(3, 0);
   struct brw_indirect inlist_ptr = brw_indirect(4, 0);
   struct brw_indirect outlist_ptr = brw_indirect(5, 0);
   struct brw_indirect freelist_ptr = brw_indirect(6, 0);
   struct brw_instruction *plane_loop;
   struct brw_instruction *plane_active;
   struct brw_instruction *vertex_loop;
   struct brw_instruction *next_test;
   struct brw_instruction *prev_test;

   brw_MOV(p, get_addr_reg(vtxPrev),     brw_address(c->reg.vertex[2]) );
   brw_MOV(p, get_addr_reg(plane_ptr),   brw_clip_plane0_address(c));
   brw_MOV(p, get_addr_reg(inlist_ptr),  brw_address(c->reg.inlist));
   brw_MOV(p, get_addr_reg(outlist_ptr), brw_address(c->reg.outlist));

   brw_MOV(p, get_addr_reg(freelist_ptr), brw_address(c->reg.vertex[3]) );

   plane_loop = brw_DO(p, BRW_EXECUTE_1);
   {
      /* if (planemask & 1)
       */
      brw_set_conditionalmod(p, BRW_CONDITIONAL_NZ);
      brw_AND(p, vec1(brw_null_reg()), c->reg.planemask, brw_imm_ud(1));

      plane_active = brw_IF(p, BRW_EXECUTE_1);
      {
         /* vtxOut = freelist_ptr++
          */
         brw_MOV(p, get_addr_reg(vtxOut),       get_addr_reg(freelist_ptr) );
         brw_ADD(p, get_addr_reg(freelist_ptr), get_addr_reg(freelist_ptr), brw_imm_uw(c->nr_regs * REG_SIZE));

         if (c->key.nr_userclip)
            brw_MOV(p, c->reg.plane_equation, deref_4f(plane_ptr, 0));
         else
            brw_MOV(p, c->reg.plane_equation, deref_4b(plane_ptr, 0));

         brw_MOV(p, c->reg.loopcount, c->reg.nr_verts);
         brw_MOV(p, c->reg.nr_verts, brw_imm_ud(0));

         vertex_loop = brw_DO(p, BRW_EXECUTE_1);
         {
            /* vtx = *input_ptr;
             */
            brw_MOV(p, get_addr_reg(vtx), deref_1uw(inlist_ptr, 0));

            /* IS_NEGATIVE(prev) */
            brw_set_conditionalmod(p, BRW_CONDITIONAL_L);
            brw_DP4(p, vec4(c->reg.dpPrev), deref_4f(vtxPrev, c->offset[VERT_RESULT_HPOS]), c->reg.plane_equation);
            prev_test = brw_IF(p, BRW_EXECUTE_1);
            {
               /* IS_POSITIVE(next)
                */
               brw_set_conditionalmod(p, BRW_CONDITIONAL_GE);
               brw_DP4(p, vec4(c->reg.dp), deref_4f(vtx, c->offset[VERT_RESULT_HPOS]), c->reg.plane_equation);
               next_test = brw_IF(p, BRW_EXECUTE_1);
               {

                  /* Coming back in.
                   */
                  brw_ADD(p, c->reg.t, c->reg.dpPrev, negate(c->reg.dp));
                  brw_math_invert(p, c->reg.t, c->reg.t);
                  brw_MUL(p, c->reg.t, c->reg.t, c->reg.dpPrev);

                  /* If (vtxOut == 0) vtxOut = vtxPrev
                   */
                  brw_CMP(p, vec1(brw_null_reg()), BRW_CONDITIONAL_EQ, get_addr_reg(vtxOut), brw_imm_uw(0) );
                  brw_MOV(p, get_addr_reg(vtxOut), get_addr_reg(vtxPrev) );
                  brw_set_predicate_control(p, BRW_PREDICATE_NONE);

                  brw_clip_interp_vertex(c, vtxOut, vtxPrev, vtx, c->reg.t, FALSE);

                  /* *outlist_ptr++ = vtxOut;
                   * nr_verts++;
                   * vtxOut = 0;
                   */
                  brw_MOV(p, deref_1uw(outlist_ptr, 0), get_addr_reg(vtxOut));
                  brw_ADD(p, get_addr_reg(outlist_ptr), get_addr_reg(outlist_ptr), brw_imm_uw(sizeof(short)));
                  brw_ADD(p, c->reg.nr_verts, c->reg.nr_verts, brw_imm_ud(1));
                  brw_MOV(p, get_addr_reg(vtxOut), brw_imm_uw(0) );
               }
               brw_ENDIF(p, next_test);

            }
            prev_test = brw_ELSE(p, prev_test);
            {
               /* *outlist_ptr++ = vtxPrev;
                * nr_verts++;
                */
               brw_MOV(p, deref_1uw(outlist_ptr, 0), get_addr_reg(vtxPrev));
               brw_ADD(p, get_addr_reg(outlist_ptr), get_addr_reg(outlist_ptr), brw_imm_uw(sizeof(short)));
               brw_ADD(p, c->reg.nr_verts, c->reg.nr_verts, brw_imm_ud(1));

               /* IS_NEGATIVE(next)
                */
               brw_set_conditionalmod(p, BRW_CONDITIONAL_L);
               brw_DP4(p, vec4(c->reg.dp), deref_4f(vtx, c->offset[VERT_RESULT_HPOS]), c->reg.plane_equation);
               next_test = brw_IF(p, BRW_EXECUTE_1);
               {
                  /* Going out of bounds.  Avoid division by zero as we
                   * know dp != dpPrev from DIFFERENT_SIGNS, above.
                   */
                  brw_ADD(p, c->reg.t, c->reg.dp, negate(c->reg.dpPrev));
                  brw_math_invert(p, c->reg.t, c->reg.t);
                  brw_MUL(p, c->reg.t, c->reg.t, c->reg.dp);

                  /* If (vtxOut == 0) vtxOut = vtx
                   */
                  brw_CMP(p, vec1(brw_null_reg()), BRW_CONDITIONAL_EQ, get_addr_reg(vtxOut), brw_imm_uw(0) );
                  brw_MOV(p, get_addr_reg(vtxOut), get_addr_reg(vtx) );
                  brw_set_predicate_control(p, BRW_PREDICATE_NONE);

                  brw_clip_interp_vertex(c, vtxOut, vtx, vtxPrev, c->reg.t, TRUE);

                  /* *outlist_ptr++ = vtxOut;
                   * nr_verts++;
                   * vtxOut = 0;
                   */
                  brw_MOV(p, deref_1uw(outlist_ptr, 0), get_addr_reg(vtxOut));
                  brw_ADD(p, get_addr_reg(outlist_ptr), get_addr_reg(outlist_ptr), brw_imm_uw(sizeof(short)));
                  brw_ADD(p, c->reg.nr_verts, c->reg.nr_verts, brw_imm_ud(1));
                  brw_MOV(p, get_addr_reg(vtxOut), brw_imm_uw(0) );
               }
               brw_ENDIF(p, next_test);
            }
            brw_ENDIF(p, prev_test);

            /* vtxPrev = vtx;
             * inlist_ptr++;
             */
            brw_MOV(p, get_addr_reg(vtxPrev), get_addr_reg(vtx));
            brw_ADD(p, get_addr_reg(inlist_ptr), get_addr_reg(inlist_ptr), brw_imm_uw(sizeof(short)));

            /* while (--loopcount != 0)
             */
            brw_set_conditionalmod(p, BRW_CONDITIONAL_NZ);
            brw_ADD(p, c->reg.loopcount, c->reg.loopcount, brw_imm_d(-1));
         }
         brw_WHILE(p, vertex_loop);

         /* vtxPrev = *(outlist_ptr-1)  OR: outlist[nr_verts-1]
          * inlist = outlist
          * inlist_ptr = &inlist[0]
          * outlist_ptr = &outlist[0]
          */
         brw_ADD(p, get_addr_reg(outlist_ptr), get_addr_reg(outlist_ptr), brw_imm_w(-2));
         brw_MOV(p, get_addr_reg(vtxPrev), deref_1uw(outlist_ptr, 0));
         brw_MOV(p, brw_vec8_grf(c->reg.inlist.nr, 0), brw_vec8_grf(c->reg.outlist.nr, 0));
         brw_MOV(p, get_addr_reg(inlist_ptr), brw_address(c->reg.inlist));
         brw_MOV(p, get_addr_reg(outlist_ptr), brw_address(c->reg.outlist));
      }
      brw_ENDIF(p, plane_active);

      /* plane_ptr++;
       */
      brw_ADD(p, get_addr_reg(plane_ptr), get_addr_reg(plane_ptr), brw_clip_plane_stride(c));

      /* nr_verts >= 3
       */
      brw_CMP(p,
              vec1(brw_null_reg()),
              BRW_CONDITIONAL_GE,
              c->reg.nr_verts,
              brw_imm_ud(3));

      /* && (planemask>>=1) != 0
       */
      brw_set_conditionalmod(p, BRW_CONDITIONAL_NZ);
      brw_SHR(p, c->reg.planemask, c->reg.planemask, brw_imm_ud(1));
   }
   brw_WHILE(p, plane_loop);
#else
         #warning "disabled"
#endif
}

void brw_clip_tri_alloc_regs	(	struct brw_clip_compile *	c,
		unsigned	nr_verts
	)

Definition at line 54 of file brw_clip_tri.c.

References BRW_GENERAL_REGISTER_FILE, brw_imm_f(), brw_MOV(), BRW_REGISTER_TYPE_UD, brw_uw16_reg(), brw_vec1_grf(), brw_vec4_grf(), brw_vec8_grf(), byte_offset(), brw_clip_prog_data::curb_read_length, brw_clip_compile::dir, brw_clip_prog_key::do_unfilled, brw_clip_compile::dp, brw_clip_compile::dpPrev, brw_clip_compile::first_tmp, brw_clip_compile::fixed_planes, brw_clip_compile::freelist, brw_clip_compile::func, brw_clip_compile::inlist, brw_clip_compile::key, brw_clip_compile::last_tmp, brw_clip_compile::loopcount, brw_clip_compile::nr_attrs, brw_clip_compile::nr_regs, brw_clip_prog_key::nr_userclip, brw_clip_compile::nr_verts, brw_clip_compile::offset, brw_clip_compile::outlist, brw_clip_compile::plane_equation, brw_clip_compile::planemask, brw_clip_compile::prog_data, brw_clip_compile::R0, brw_clip_compile::reg, retype(), brw_clip_compile::t, brw_clip_compile::tmp1, brw_clip_prog_data::total_grf, brw_clip_prog_data::urb_read_length, and brw_clip_compile::vertex.

{
   unsigned i = 0,j;

   /* Register usage is static, precompute here:
    */
   c->reg.R0 = retype(brw_vec8_grf(i, 0), BRW_REGISTER_TYPE_UD); i++;

   if (c->key.nr_userclip) {
      c->reg.fixed_planes = brw_vec4_grf(i, 0);
      i += (6 + c->key.nr_userclip + 1) / 2;

      c->prog_data.curb_read_length = (6 + c->key.nr_userclip + 1) / 2;
   }
   else
      c->prog_data.curb_read_length = 0;


   /* Payload vertices plus space for more generated vertices:
    */
   for (j = 0; j < nr_verts; j++) {
      c->reg.vertex[j] = brw_vec4_grf(i, 0);
      i += c->nr_regs;
   }

   if (c->nr_attrs & 1) {
      for (j = 0; j < 3; j++) {
         unsigned delta = c->nr_attrs*16 + 32;
         brw_MOV(&c->func, byte_offset(c->reg.vertex[j], delta), brw_imm_f(0));
      }
   }

   c->reg.t          = brw_vec1_grf(i, 0);
   c->reg.loopcount  = retype(brw_vec1_grf(i, 1), BRW_REGISTER_TYPE_UD);
   c->reg.nr_verts   = retype(brw_vec1_grf(i, 2), BRW_REGISTER_TYPE_UD);
   c->reg.planemask  = retype(brw_vec1_grf(i, 3), BRW_REGISTER_TYPE_UD);
   c->reg.plane_equation = brw_vec4_grf(i, 4);
   i++;

   c->reg.dpPrev     = brw_vec1_grf(i, 0); /* fixme - dp4 will clobber r.1,2,3 */
   c->reg.dp         = brw_vec1_grf(i, 4);
   i++;

   c->reg.inlist     = brw_uw16_reg(BRW_GENERAL_REGISTER_FILE, i, 0);
   i++;

   c->reg.outlist    = brw_uw16_reg(BRW_GENERAL_REGISTER_FILE, i, 0);
   i++;

   c->reg.freelist   = brw_uw16_reg(BRW_GENERAL_REGISTER_FILE, i, 0);
   i++;

   if (!c->key.nr_userclip) {
      c->reg.fixed_planes = brw_vec8_grf(i, 0);
      i++;
   }

   if (c->key.do_unfilled) {
      c->reg.dir     = brw_vec4_grf(i, 0);
      c->reg.offset  = brw_vec4_grf(i, 4);
      i++;
      c->reg.tmp0    = brw_vec4_grf(i, 0);
      c->reg.tmp1    = brw_vec4_grf(i, 4);
      i++;
   }

   c->first_tmp = i;
   c->last_tmp = i;

   c->prog_data.urb_read_length = c->nr_regs; /* ? */
   c->prog_data.total_grf = i;
}

void brw_clip_tri_emit_polygon

(

struct brw_clip_compile *

c

)

Definition at line 385 of file brw_clip_tri.c.

References _3DPRIM_TRIFAN, brw_ADD(), brw_address(), brw_clip_emit_vue(), BRW_CONDITIONAL_G, BRW_CONDITIONAL_NZ, brw_DO(), brw_ENDIF(), BRW_EXECUTE_1, brw_IF(), brw_imm_d(), brw_imm_uw(), brw_indirect(), brw_MOV(), brw_set_conditionalmod(), brw_WHILE(), deref_1uw(), brw_clip_compile::func, get_addr_reg(), brw_clip_compile::inlist, brw_clip_compile::loopcount, brw_clip_compile::nr_verts, R02_PRIM_END, R02_PRIM_START, and brw_clip_compile::reg.

{
   struct brw_compile *p = &c->func;
   struct brw_instruction *loop, *if_insn;

   /* for (loopcount = nr_verts-2; loopcount > 0; loopcount--)
    */
   brw_set_conditionalmod(p, BRW_CONDITIONAL_G);
   brw_ADD(p,
           c->reg.loopcount,
           c->reg.nr_verts,
           brw_imm_d(-2));

   if_insn = brw_IF(p, BRW_EXECUTE_1);
   {
      struct brw_indirect v0 = brw_indirect(0, 0);
      struct brw_indirect vptr = brw_indirect(1, 0);

      brw_MOV(p, get_addr_reg(vptr), brw_address(c->reg.inlist));
      brw_MOV(p, get_addr_reg(v0), deref_1uw(vptr, 0));

      brw_clip_emit_vue(c, v0, 1, 0, ((_3DPRIM_TRIFAN << 2) | R02_PRIM_START));

      brw_ADD(p, get_addr_reg(vptr), get_addr_reg(vptr), brw_imm_uw(2));
      brw_MOV(p, get_addr_reg(v0), deref_1uw(vptr, 0));

      loop = brw_DO(p, BRW_EXECUTE_1);
      {
         brw_clip_emit_vue(c, v0, 1, 0, (_3DPRIM_TRIFAN << 2));

         brw_ADD(p, get_addr_reg(vptr), get_addr_reg(vptr), brw_imm_uw(2));
         brw_MOV(p, get_addr_reg(v0), deref_1uw(vptr, 0));

         brw_set_conditionalmod(p, BRW_CONDITIONAL_NZ);
         brw_ADD(p, c->reg.loopcount, c->reg.loopcount, brw_imm_d(-1));
      }
      brw_WHILE(p, loop);

      brw_clip_emit_vue(c, v0, 0, 1, ((_3DPRIM_TRIFAN << 2) | R02_PRIM_END));
   }
   brw_ENDIF(p, if_insn);
}

void brw_clip_tri_flat_shade

(

struct brw_clip_compile *

c

)

Definition at line 171 of file brw_clip_tri.c.

References _3DPRIM_POLYGON, brw_AND(), brw_clip_copy_colors(), brw_CMP(), BRW_CONDITIONAL_EQ, brw_ELSE(), brw_ENDIF(), BRW_EXECUTE_1, brw_IF(), brw_imm_ud(), brw_null_reg(), brw_clip_compile::func, get_element_ud(), brw_clip_compile::loopcount, PRIM_MASK, brw_clip_compile::R0, brw_clip_compile::reg, and vec1().

{
   struct brw_compile *p = &c->func;
   struct brw_instruction *is_poly;
   struct brw_reg tmp0 = c->reg.loopcount; /* handy temporary */

   brw_AND(p, tmp0, get_element_ud(c->reg.R0, 2), brw_imm_ud(PRIM_MASK));
   brw_CMP(p,
           vec1(brw_null_reg()),
           BRW_CONDITIONAL_EQ,
           tmp0,
           brw_imm_ud(_3DPRIM_POLYGON));

   is_poly = brw_IF(p, BRW_EXECUTE_1);
   {
      brw_clip_copy_colors(c, 1, 0);
      brw_clip_copy_colors(c, 2, 0);
   }
   is_poly = brw_ELSE(p, is_poly);
   {
      brw_clip_copy_colors(c, 0, 2);
      brw_clip_copy_colors(c, 1, 2);
   }
   brw_ENDIF(p, is_poly);
}

void brw_clip_tri_init_vertices

(

struct brw_clip_compile *

c

)

Definition at line 130 of file brw_clip_tri.c.

References _3DPRIM_TRISTRIP_REVERSE, brw_address(), brw_AND(), brw_CMP(), BRW_CONDITIONAL_EQ, brw_ELSE(), brw_ENDIF(), BRW_EXECUTE_1, brw_IF(), brw_imm_f(), brw_imm_ud(), brw_MOV(), brw_null_reg(), brw_vec8_grf(), brw_clip_compile::dir, brw_clip_compile::func, get_element(), get_element_ud(), brw_clip_compile::inlist, brw_clip_compile::loopcount, brw_clip_compile::need_direction, brw_reg::nr, brw_clip_compile::nr_verts, brw_clip_compile::outlist, PRIM_MASK, brw_clip_compile::R0, brw_clip_compile::reg, vec1(), and brw_clip_compile::vertex.

{
   struct brw_compile *p = &c->func;
   struct brw_reg tmp0 = c->reg.loopcount; /* handy temporary */
   struct brw_instruction *is_rev;

   /* Initial list of indices for incoming vertexes:
    */
   brw_AND(p, tmp0, get_element_ud(c->reg.R0, 2), brw_imm_ud(PRIM_MASK));
   brw_CMP(p,
           vec1(brw_null_reg()),
           BRW_CONDITIONAL_EQ,
           tmp0,
           brw_imm_ud(_3DPRIM_TRISTRIP_REVERSE));

   /* XXX: Is there an easier way to do this?  Need to reverse every
    * second tristrip element:  Can ignore sometimes?
    */
   is_rev = brw_IF(p, BRW_EXECUTE_1);
   {
      brw_MOV(p, get_element(c->reg.inlist, 0),  brw_address(c->reg.vertex[1]) );
      brw_MOV(p, get_element(c->reg.inlist, 1),  brw_address(c->reg.vertex[0]) );
      if (c->need_direction)
         brw_MOV(p, c->reg.dir, brw_imm_f(-1));
   }
   is_rev = brw_ELSE(p, is_rev);
   {
      brw_MOV(p, get_element(c->reg.inlist, 0),  brw_address(c->reg.vertex[0]) );
      brw_MOV(p, get_element(c->reg.inlist, 1),  brw_address(c->reg.vertex[1]) );
      if (c->need_direction)
         brw_MOV(p, c->reg.dir, brw_imm_f(1));
   }
   brw_ENDIF(p, is_rev);

   brw_MOV(p, get_element(c->reg.inlist, 2),  brw_address(c->reg.vertex[2]) );
   brw_MOV(p, brw_vec8_grf(c->reg.outlist.nr, 0), brw_imm_f(0));
   brw_MOV(p, c->reg.nr_verts, brw_imm_ud(3));
}

void brw_emit_line_clip

(

struct brw_clip_compile *

c

)

Definition at line 237 of file brw_clip_line.c.

References brw_clip_copy_colors(), brw_clip_line_alloc_regs(), clip_and_emit_line(), brw_clip_prog_key::do_flat_shading, and brw_clip_compile::key.

{
   brw_clip_line_alloc_regs(c);

   if (c->key.do_flat_shading)
      brw_clip_copy_colors(c, 0, 1);

   clip_and_emit_line(c);
}

void brw_emit_point_clip

(

struct brw_clip_compile *

c

)

Definition at line 41 of file brw_clip_point.c.

References brw_clip_kill_thread(), and brw_clip_tri_alloc_regs().

{
   /* Send an empty message to kill the thread:
    */
   brw_clip_tri_alloc_regs(c, 0);
   brw_clip_kill_thread(c);
}

void brw_emit_tri_clip

(

struct brw_clip_compile *

c

)

Definition at line 530 of file brw_clip_tri.c.

References brw_AND(), brw_clip_init_clipmask(), brw_clip_kill_thread(), brw_clip_test(), brw_clip_tri_alloc_regs(), brw_clip_tri_emit_polygon(), brw_clip_tri_flat_shade(), brw_clip_tri_init_vertices(), BRW_CLIPMODE_NORMAL, BRW_CONDITIONAL_NZ, brw_ENDIF(), BRW_EXECUTE_1, brw_IF(), brw_imm_ud(), brw_null_reg(), brw_set_conditionalmod(), brw_clip_prog_key::clip_mode, do_clip_tri(), brw_clip_prog_key::do_flat_shading, brw_clip_compile::func, get_element_ud(), brw_clip_compile::key, maybe_do_clip_tri(), brw_clip_prog_key::nr_userclip, brw_clip_compile::R0, and brw_clip_compile::reg.

{
   struct brw_instruction *neg_rhw;
   struct brw_compile *p = &c->func;
   brw_clip_tri_alloc_regs(c, 3 + c->key.nr_userclip + 6);
   brw_clip_tri_init_vertices(c);
   brw_clip_init_clipmask(c);

   /* if -ve rhw workaround bit is set,
      do cliptest */
   brw_set_conditionalmod(p, BRW_CONDITIONAL_NZ);
   brw_AND(p, brw_null_reg(), get_element_ud(c->reg.R0, 2),
           brw_imm_ud(1<<20));
   neg_rhw = brw_IF(p, BRW_EXECUTE_1);
   {
       brw_clip_test(c);
   }
   brw_ENDIF(p, neg_rhw);

   /* Can't push into do_clip_tri because with polygon (or quad)
    * flatshading, need to apply the flatshade here because we don't
    * respect the PV when converting to trifan for emit:
    */
   if (c->key.do_flat_shading)
      brw_clip_tri_flat_shade(c);

   if (c->key.clip_mode == BRW_CLIPMODE_NORMAL)
      do_clip_tri(c);
   else
      maybe_do_clip_tri(c);

   brw_clip_tri_emit_polygon(c);

   /* Send an empty message to kill the thread:
    */
   brw_clip_kill_thread(c);
}

void brw_emit_unfilled_clip

(

struct brw_clip_compile *

c

)

Definition at line 414 of file brw_clip_unfilled.c.

References assert, brw_clip_init_clipmask(), brw_clip_init_planes(), brw_clip_kill_thread(), brw_clip_tri(), brw_clip_tri_alloc_regs(), brw_clip_tri_flat_shade(), brw_clip_tri_init_vertices(), brw_CMP(), BRW_CONDITIONAL_NZ, brw_ENDIF(), BRW_EXECUTE_1, brw_IF(), brw_imm_ud(), brw_null_reg(), check_nr_verts(), CLIP_CULL, compute_offset(), compute_tri_direction(), copy_bfc(), brw_clip_prog_key::copy_bfc_ccw, brw_clip_prog_key::copy_bfc_cw, cull_direction(), brw_clip_prog_key::do_flat_shading, emit_unfilled_primitives(), brw_clip_prog_key::fill_ccw, brw_clip_prog_key::fill_cw, brw_clip_compile::func, brw_clip_compile::key, merge_edgeflags(), brw_clip_compile::need_direction, brw_clip_prog_key::nr_userclip, brw_clip_compile::offset, brw_clip_prog_key::offset_ccw, brw_clip_prog_key::offset_cw, brw_clip_compile::planemask, brw_clip_compile::reg, and vec1().

{
   struct brw_compile *p = &c->func;
   struct brw_instruction *do_clip;
   

   c->need_direction = ((c->key.offset_ccw || c->key.offset_cw) ||
                        (c->key.fill_ccw != c->key.fill_cw) ||
                        c->key.fill_ccw == CLIP_CULL ||
                        c->key.fill_cw == CLIP_CULL ||
                        c->key.copy_bfc_cw ||
                        c->key.copy_bfc_ccw);

   brw_clip_tri_alloc_regs(c, 3 + c->key.nr_userclip + 6);
   brw_clip_tri_init_vertices(c);

   assert(c->offset[VERT_RESULT_EDGE]);

   if (c->key.fill_ccw == CLIP_CULL &&
       c->key.fill_cw == CLIP_CULL) {
      brw_clip_kill_thread(c);
      return;
   }

   merge_edgeflags(c);

   /* Need to use the inlist indirection here: 
    */
   if (c->need_direction) 
      compute_tri_direction(c);
   
   if (c->key.fill_ccw == CLIP_CULL ||
       c->key.fill_cw == CLIP_CULL)
      cull_direction(c);

   if (c->key.offset_ccw ||
       c->key.offset_cw)
      compute_offset(c);

   if (c->key.copy_bfc_ccw ||
       c->key.copy_bfc_cw)
      copy_bfc(c);

   /* Need to do this whether we clip or not:
    */
   if (c->key.do_flat_shading)
      brw_clip_tri_flat_shade(c);
   
   brw_clip_init_clipmask(c);
   brw_CMP(p, vec1(brw_null_reg()), BRW_CONDITIONAL_NZ, c->reg.planemask, brw_imm_ud(0));
   do_clip = brw_IF(p, BRW_EXECUTE_1);
   {
      brw_clip_init_planes(c);
      brw_clip_tri(c);
      check_nr_verts(c);
   }
   brw_ENDIF(p, do_clip);
   
   emit_unfilled_primitives(c);
   brw_clip_kill_thread(c);
}

---