2 Copyright (C) Intel Corp. 2006. All Rights Reserved.
3 Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
4 develop this 3D driver.
6 Permission is hereby granted, free of charge, to any person obtaining
7 a copy of this software and associated documentation files (the
8 "Software"), to deal in the Software without restriction, including
9 without limitation the rights to use, copy, modify, merge, publish,
10 distribute, sublicense, and/or sell copies of the Software, and to
11 permit persons to whom the Software is furnished to do so, subject to
12 the following conditions:
14 The above copyright notice and this permission notice (including the
15 next paragraph) shall be included in all copies or substantial
16 portions of the Software.
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
22 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
23 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
24 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **********************************************************************/
29 * Keith Whitwell <keith@tungstengraphics.com>
36 #include "shader/program.h"
37 #include "intel_batchbuffer.h"
39 #include "brw_defines.h"
40 #include "brw_context.h"
45 static struct brw_reg
get_tmp( struct brw_clip_compile
*c
)
47 struct brw_reg tmp
= brw_vec4_grf(c
->last_tmp
, 0);
49 if (++c
->last_tmp
> c
->prog_data
.total_grf
)
50 c
->prog_data
.total_grf
= c
->last_tmp
;
55 static void release_tmps( struct brw_clip_compile
*c
)
57 c
->last_tmp
= c
->first_tmp
;
61 void brw_clip_tri_alloc_regs( struct brw_clip_compile
*c
,
66 /* Register usage is static, precompute here:
68 c
->reg
.R0
= retype(brw_vec8_grf(i
, 0), BRW_REGISTER_TYPE_UD
); i
++;
70 if (c
->key
.nr_userclip
) {
71 c
->reg
.fixed_planes
= brw_vec4_grf(i
, 0);
72 i
+= (6 + c
->key
.nr_userclip
+ 1) / 2;
74 c
->prog_data
.curb_read_length
= (6 + c
->key
.nr_userclip
+ 1) / 2;
77 c
->prog_data
.curb_read_length
= 0;
80 /* Payload vertices plus space for more generated vertices:
82 for (j
= 0; j
< nr_verts
; j
++) {
83 c
->reg
.vertex
[j
] = brw_vec4_grf(i
, 0);
87 if (c
->nr_attrs
& 1) {
88 for (j
= 0; j
< 3; j
++) {
89 GLuint delta
= c
->nr_attrs
*16 + 32;
90 brw_MOV(&c
->func
, byte_offset(c
->reg
.vertex
[j
], delta
), brw_imm_f(0));
94 c
->reg
.t
= brw_vec1_grf(i
, 0);
95 c
->reg
.loopcount
= retype(brw_vec1_grf(i
, 1), BRW_REGISTER_TYPE_D
);
96 c
->reg
.nr_verts
= retype(brw_vec1_grf(i
, 2), BRW_REGISTER_TYPE_UD
);
97 c
->reg
.planemask
= retype(brw_vec1_grf(i
, 3), BRW_REGISTER_TYPE_UD
);
98 c
->reg
.plane_equation
= brw_vec4_grf(i
, 4);
101 c
->reg
.dpPrev
= brw_vec1_grf(i
, 0); /* fixme - dp4 will clobber r.1,2,3 */
102 c
->reg
.dp
= brw_vec1_grf(i
, 4);
105 c
->reg
.inlist
= brw_uw16_reg(BRW_GENERAL_REGISTER_FILE
, i
, 0);
108 c
->reg
.outlist
= brw_uw16_reg(BRW_GENERAL_REGISTER_FILE
, i
, 0);
111 c
->reg
.freelist
= brw_uw16_reg(BRW_GENERAL_REGISTER_FILE
, i
, 0);
114 if (!c
->key
.nr_userclip
) {
115 c
->reg
.fixed_planes
= brw_vec8_grf(i
, 0);
119 if (c
->key
.do_unfilled
) {
120 c
->reg
.dir
= brw_vec4_grf(i
, 0);
121 c
->reg
.offset
= brw_vec4_grf(i
, 4);
123 c
->reg
.tmp0
= brw_vec4_grf(i
, 0);
124 c
->reg
.tmp1
= brw_vec4_grf(i
, 4);
131 c
->prog_data
.urb_read_length
= c
->nr_regs
; /* ? */
132 c
->prog_data
.total_grf
= i
;
137 void brw_clip_tri_init_vertices( struct brw_clip_compile
*c
)
139 struct brw_compile
*p
= &c
->func
;
140 struct brw_reg tmp0
= c
->reg
.loopcount
; /* handy temporary */
141 struct brw_instruction
*is_rev
;
143 /* Initial list of indices for incoming vertexes:
145 brw_AND(p
, tmp0
, get_element_ud(c
->reg
.R0
, 2), brw_imm_ud(PRIM_MASK
));
147 vec1(brw_null_reg()),
150 brw_imm_ud(_3DPRIM_TRISTRIP_REVERSE
));
152 /* XXX: Is there an easier way to do this? Need to reverse every
153 * second tristrip element: Can ignore sometimes?
155 is_rev
= brw_IF(p
, BRW_EXECUTE_1
);
157 brw_MOV(p
, get_element(c
->reg
.inlist
, 0), brw_address(c
->reg
.vertex
[1]) );
158 brw_MOV(p
, get_element(c
->reg
.inlist
, 1), brw_address(c
->reg
.vertex
[0]) );
159 if (c
->need_direction
)
160 brw_MOV(p
, c
->reg
.dir
, brw_imm_f(-1));
162 is_rev
= brw_ELSE(p
, is_rev
);
164 brw_MOV(p
, get_element(c
->reg
.inlist
, 0), brw_address(c
->reg
.vertex
[0]) );
165 brw_MOV(p
, get_element(c
->reg
.inlist
, 1), brw_address(c
->reg
.vertex
[1]) );
166 if (c
->need_direction
)
167 brw_MOV(p
, c
->reg
.dir
, brw_imm_f(1));
169 brw_ENDIF(p
, is_rev
);
171 brw_MOV(p
, get_element(c
->reg
.inlist
, 2), brw_address(c
->reg
.vertex
[2]) );
172 brw_MOV(p
, brw_vec8_grf(c
->reg
.outlist
.nr
, 0), brw_imm_f(0));
173 brw_MOV(p
, c
->reg
.nr_verts
, brw_imm_ud(3));
178 void brw_clip_tri_flat_shade( struct brw_clip_compile
*c
)
180 struct brw_compile
*p
= &c
->func
;
181 struct brw_instruction
*is_poly
;
182 struct brw_reg tmp0
= c
->reg
.loopcount
; /* handy temporary */
184 brw_AND(p
, tmp0
, get_element_ud(c
->reg
.R0
, 2), brw_imm_ud(PRIM_MASK
));
186 vec1(brw_null_reg()),
189 brw_imm_ud(_3DPRIM_POLYGON
));
191 is_poly
= brw_IF(p
, BRW_EXECUTE_1
);
193 brw_clip_copy_colors(c
, 1, 0);
194 brw_clip_copy_colors(c
, 2, 0);
196 is_poly
= brw_ELSE(p
, is_poly
);
198 brw_clip_copy_colors(c
, 0, 2);
199 brw_clip_copy_colors(c
, 1, 2);
201 brw_ENDIF(p
, is_poly
);
206 /* Use mesa's clipping algorithms, translated to GEN4 assembly.
208 void brw_clip_tri( struct brw_clip_compile
*c
)
210 struct brw_compile
*p
= &c
->func
;
211 struct brw_indirect vtx
= brw_indirect(0, 0);
212 struct brw_indirect vtxPrev
= brw_indirect(1, 0);
213 struct brw_indirect vtxOut
= brw_indirect(2, 0);
214 struct brw_indirect plane_ptr
= brw_indirect(3, 0);
215 struct brw_indirect inlist_ptr
= brw_indirect(4, 0);
216 struct brw_indirect outlist_ptr
= brw_indirect(5, 0);
217 struct brw_indirect freelist_ptr
= brw_indirect(6, 0);
218 struct brw_instruction
*plane_loop
;
219 struct brw_instruction
*plane_active
;
220 struct brw_instruction
*vertex_loop
;
221 struct brw_instruction
*next_test
;
222 struct brw_instruction
*prev_test
;
224 brw_MOV(p
, get_addr_reg(vtxPrev
), brw_address(c
->reg
.vertex
[2]) );
225 brw_MOV(p
, get_addr_reg(plane_ptr
), brw_clip_plane0_address(c
));
226 brw_MOV(p
, get_addr_reg(inlist_ptr
), brw_address(c
->reg
.inlist
));
227 brw_MOV(p
, get_addr_reg(outlist_ptr
), brw_address(c
->reg
.outlist
));
229 brw_MOV(p
, get_addr_reg(freelist_ptr
), brw_address(c
->reg
.vertex
[3]) );
231 plane_loop
= brw_DO(p
, BRW_EXECUTE_1
);
233 /* if (planemask & 1)
235 brw_set_conditionalmod(p
, BRW_CONDITIONAL_NZ
);
236 brw_AND(p
, vec1(brw_null_reg()), c
->reg
.planemask
, brw_imm_ud(1));
238 plane_active
= brw_IF(p
, BRW_EXECUTE_1
);
240 /* vtxOut = freelist_ptr++
242 brw_MOV(p
, get_addr_reg(vtxOut
), get_addr_reg(freelist_ptr
) );
243 brw_ADD(p
, get_addr_reg(freelist_ptr
), get_addr_reg(freelist_ptr
), brw_imm_uw(c
->nr_regs
* REG_SIZE
));
245 if (c
->key
.nr_userclip
)
246 brw_MOV(p
, c
->reg
.plane_equation
, deref_4f(plane_ptr
, 0));
248 brw_MOV(p
, c
->reg
.plane_equation
, deref_4b(plane_ptr
, 0));
250 brw_MOV(p
, c
->reg
.loopcount
, c
->reg
.nr_verts
);
251 brw_MOV(p
, c
->reg
.nr_verts
, brw_imm_ud(0));
253 vertex_loop
= brw_DO(p
, BRW_EXECUTE_1
);
257 brw_MOV(p
, get_addr_reg(vtx
), deref_1uw(inlist_ptr
, 0));
259 /* IS_NEGATIVE(prev) */
260 brw_set_conditionalmod(p
, BRW_CONDITIONAL_L
);
261 brw_DP4(p
, vec4(c
->reg
.dpPrev
), deref_4f(vtxPrev
, c
->offset
[VERT_RESULT_HPOS
]), c
->reg
.plane_equation
);
262 prev_test
= brw_IF(p
, BRW_EXECUTE_1
);
266 brw_set_conditionalmod(p
, BRW_CONDITIONAL_GE
);
267 brw_DP4(p
, vec4(c
->reg
.dp
), deref_4f(vtx
, c
->offset
[VERT_RESULT_HPOS
]), c
->reg
.plane_equation
);
268 next_test
= brw_IF(p
, BRW_EXECUTE_1
);
273 brw_ADD(p
, c
->reg
.t
, c
->reg
.dpPrev
, negate(c
->reg
.dp
));
274 brw_math_invert(p
, c
->reg
.t
, c
->reg
.t
);
275 brw_MUL(p
, c
->reg
.t
, c
->reg
.t
, c
->reg
.dpPrev
);
277 /* If (vtxOut == 0) vtxOut = vtxPrev
279 brw_CMP(p
, vec1(brw_null_reg()), BRW_CONDITIONAL_EQ
, get_addr_reg(vtxOut
), brw_imm_uw(0) );
280 brw_MOV(p
, get_addr_reg(vtxOut
), get_addr_reg(vtxPrev
) );
281 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
283 brw_clip_interp_vertex(c
, vtxOut
, vtxPrev
, vtx
, c
->reg
.t
, GL_FALSE
);
285 /* *outlist_ptr++ = vtxOut;
289 brw_MOV(p
, deref_1uw(outlist_ptr
, 0), get_addr_reg(vtxOut
));
290 brw_ADD(p
, get_addr_reg(outlist_ptr
), get_addr_reg(outlist_ptr
), brw_imm_uw(sizeof(short)));
291 brw_ADD(p
, c
->reg
.nr_verts
, c
->reg
.nr_verts
, brw_imm_ud(1));
292 brw_MOV(p
, get_addr_reg(vtxOut
), brw_imm_uw(0) );
294 brw_ENDIF(p
, next_test
);
297 prev_test
= brw_ELSE(p
, prev_test
);
299 /* *outlist_ptr++ = vtxPrev;
302 brw_MOV(p
, deref_1uw(outlist_ptr
, 0), get_addr_reg(vtxPrev
));
303 brw_ADD(p
, get_addr_reg(outlist_ptr
), get_addr_reg(outlist_ptr
), brw_imm_uw(sizeof(short)));
304 brw_ADD(p
, c
->reg
.nr_verts
, c
->reg
.nr_verts
, brw_imm_ud(1));
308 brw_set_conditionalmod(p
, BRW_CONDITIONAL_L
);
309 brw_DP4(p
, vec4(c
->reg
.dp
), deref_4f(vtx
, c
->offset
[VERT_RESULT_HPOS
]), c
->reg
.plane_equation
);
310 next_test
= brw_IF(p
, BRW_EXECUTE_1
);
312 /* Going out of bounds. Avoid division by zero as we
313 * know dp != dpPrev from DIFFERENT_SIGNS, above.
315 brw_ADD(p
, c
->reg
.t
, c
->reg
.dp
, negate(c
->reg
.dpPrev
));
316 brw_math_invert(p
, c
->reg
.t
, c
->reg
.t
);
317 brw_MUL(p
, c
->reg
.t
, c
->reg
.t
, c
->reg
.dp
);
319 /* If (vtxOut == 0) vtxOut = vtx
321 brw_CMP(p
, vec1(brw_null_reg()), BRW_CONDITIONAL_EQ
, get_addr_reg(vtxOut
), brw_imm_uw(0) );
322 brw_MOV(p
, get_addr_reg(vtxOut
), get_addr_reg(vtx
) );
323 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
325 brw_clip_interp_vertex(c
, vtxOut
, vtx
, vtxPrev
, c
->reg
.t
, GL_TRUE
);
327 /* *outlist_ptr++ = vtxOut;
331 brw_MOV(p
, deref_1uw(outlist_ptr
, 0), get_addr_reg(vtxOut
));
332 brw_ADD(p
, get_addr_reg(outlist_ptr
), get_addr_reg(outlist_ptr
), brw_imm_uw(sizeof(short)));
333 brw_ADD(p
, c
->reg
.nr_verts
, c
->reg
.nr_verts
, brw_imm_ud(1));
334 brw_MOV(p
, get_addr_reg(vtxOut
), brw_imm_uw(0) );
336 brw_ENDIF(p
, next_test
);
338 brw_ENDIF(p
, prev_test
);
343 brw_MOV(p
, get_addr_reg(vtxPrev
), get_addr_reg(vtx
));
344 brw_ADD(p
, get_addr_reg(inlist_ptr
), get_addr_reg(inlist_ptr
), brw_imm_uw(sizeof(short)));
346 /* while (--loopcount != 0)
348 brw_set_conditionalmod(p
, BRW_CONDITIONAL_NZ
);
349 brw_ADD(p
, c
->reg
.loopcount
, c
->reg
.loopcount
, brw_imm_d(-1));
351 brw_WHILE(p
, vertex_loop
);
353 /* vtxPrev = *(outlist_ptr-1) OR: outlist[nr_verts-1]
355 * inlist_ptr = &inlist[0]
356 * outlist_ptr = &outlist[0]
358 brw_ADD(p
, get_addr_reg(outlist_ptr
), get_addr_reg(outlist_ptr
), brw_imm_w(-2));
359 brw_MOV(p
, get_addr_reg(vtxPrev
), deref_1uw(outlist_ptr
, 0));
360 brw_MOV(p
, brw_vec8_grf(c
->reg
.inlist
.nr
, 0), brw_vec8_grf(c
->reg
.outlist
.nr
, 0));
361 brw_MOV(p
, get_addr_reg(inlist_ptr
), brw_address(c
->reg
.inlist
));
362 brw_MOV(p
, get_addr_reg(outlist_ptr
), brw_address(c
->reg
.outlist
));
364 brw_ENDIF(p
, plane_active
);
368 brw_ADD(p
, get_addr_reg(plane_ptr
), get_addr_reg(plane_ptr
), brw_clip_plane_stride(c
));
373 vec1(brw_null_reg()),
378 /* && (planemask>>=1) != 0
380 brw_set_conditionalmod(p
, BRW_CONDITIONAL_NZ
);
381 brw_SHR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud(1));
383 brw_WHILE(p
, plane_loop
);
388 void brw_clip_tri_emit_polygon(struct brw_clip_compile
*c
)
390 struct brw_compile
*p
= &c
->func
;
391 struct brw_instruction
*loop
, *if_insn
;
393 /* for (loopcount = nr_verts-2; loopcount > 0; loopcount--)
395 brw_set_conditionalmod(p
, BRW_CONDITIONAL_G
);
401 if_insn
= brw_IF(p
, BRW_EXECUTE_1
);
403 struct brw_indirect v0
= brw_indirect(0, 0);
404 struct brw_indirect vptr
= brw_indirect(1, 0);
406 brw_MOV(p
, get_addr_reg(vptr
), brw_address(c
->reg
.inlist
));
407 brw_MOV(p
, get_addr_reg(v0
), deref_1uw(vptr
, 0));
409 brw_clip_emit_vue(c
, v0
, 1, 0, ((_3DPRIM_TRIFAN
<< 2) | R02_PRIM_START
));
411 brw_ADD(p
, get_addr_reg(vptr
), get_addr_reg(vptr
), brw_imm_uw(2));
412 brw_MOV(p
, get_addr_reg(v0
), deref_1uw(vptr
, 0));
414 loop
= brw_DO(p
, BRW_EXECUTE_1
);
416 brw_clip_emit_vue(c
, v0
, 1, 0, (_3DPRIM_TRIFAN
<< 2));
418 brw_ADD(p
, get_addr_reg(vptr
), get_addr_reg(vptr
), brw_imm_uw(2));
419 brw_MOV(p
, get_addr_reg(v0
), deref_1uw(vptr
, 0));
421 brw_set_conditionalmod(p
, BRW_CONDITIONAL_NZ
);
422 brw_ADD(p
, c
->reg
.loopcount
, c
->reg
.loopcount
, brw_imm_d(-1));
426 brw_clip_emit_vue(c
, v0
, 0, 1, ((_3DPRIM_TRIFAN
<< 2) | R02_PRIM_END
));
428 brw_ENDIF(p
, if_insn
);
431 static void do_clip_tri( struct brw_clip_compile
*c
)
433 brw_clip_init_planes(c
);
439 static void maybe_do_clip_tri( struct brw_clip_compile
*c
)
441 struct brw_compile
*p
= &c
->func
;
442 struct brw_instruction
*do_clip
;
444 brw_CMP(p
, vec1(brw_null_reg()), BRW_CONDITIONAL_NZ
, c
->reg
.planemask
, brw_imm_ud(0));
445 do_clip
= brw_IF(p
, BRW_EXECUTE_1
);
449 brw_ENDIF(p
, do_clip
);
452 static void brw_clip_test( struct brw_clip_compile
*c
)
454 struct brw_reg t
= retype(get_tmp(c
), BRW_REGISTER_TYPE_UD
);
455 struct brw_reg t1
= retype(get_tmp(c
), BRW_REGISTER_TYPE_UD
);
456 struct brw_reg t2
= retype(get_tmp(c
), BRW_REGISTER_TYPE_UD
);
457 struct brw_reg t3
= retype(get_tmp(c
), BRW_REGISTER_TYPE_UD
);
459 struct brw_reg v0
= get_tmp(c
);
460 struct brw_reg v1
= get_tmp(c
);
461 struct brw_reg v2
= get_tmp(c
);
463 struct brw_indirect vt0
= brw_indirect(0, 0);
464 struct brw_indirect vt1
= brw_indirect(1, 0);
465 struct brw_indirect vt2
= brw_indirect(2, 0);
467 struct brw_compile
*p
= &c
->func
;
469 brw_MOV(p
, get_addr_reg(vt0
), brw_address(c
->reg
.vertex
[0]));
470 brw_MOV(p
, get_addr_reg(vt1
), brw_address(c
->reg
.vertex
[1]));
471 brw_MOV(p
, get_addr_reg(vt2
), brw_address(c
->reg
.vertex
[2]));
472 brw_MOV(p
, v0
, deref_4f(vt0
, c
->offset
[VERT_RESULT_HPOS
]));
473 brw_MOV(p
, v1
, deref_4f(vt1
, c
->offset
[VERT_RESULT_HPOS
]));
474 brw_MOV(p
, v2
, deref_4f(vt2
, c
->offset
[VERT_RESULT_HPOS
]));
476 /* test nearz, xmin, ymin plane */
477 brw_CMP(p
, t1
, BRW_CONDITIONAL_LE
, negate(v0
), get_element(v0
, 3));
478 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
479 brw_CMP(p
, t2
, BRW_CONDITIONAL_LE
, negate(v1
), get_element(v1
, 3));
480 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
481 brw_CMP(p
, t3
, BRW_CONDITIONAL_LE
, negate(v2
), get_element(v2
, 3));
482 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
483 brw_XOR(p
, t
, t1
, t2
);
484 brw_XOR(p
, t1
, t2
, t3
);
487 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
488 get_element(t
, 0), brw_imm_ud(0));
489 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<5)));
490 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
491 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
492 get_element(t
, 1), brw_imm_ud(0));
493 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<3)));
494 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
495 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
496 get_element(t
, 2), brw_imm_ud(0));
497 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<1)));
498 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
500 /* test farz, xmax, ymax plane */
501 brw_CMP(p
, t1
, BRW_CONDITIONAL_L
, v0
, get_element(v0
, 3));
502 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
503 brw_CMP(p
, t2
, BRW_CONDITIONAL_L
, v1
, get_element(v1
, 3));
504 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
505 brw_CMP(p
, t3
, BRW_CONDITIONAL_L
, v2
, get_element(v2
, 3));
506 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
508 brw_XOR(p
, t
, t1
, t2
);
509 brw_XOR(p
, t1
, t2
, t3
);
512 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
513 get_element(t
, 0), brw_imm_ud(0));
514 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<4)));
515 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
516 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
517 get_element(t
, 1), brw_imm_ud(0));
518 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<2)));
519 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
520 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
521 get_element(t
, 2), brw_imm_ud(0));
522 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<0)));
523 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
529 void brw_emit_tri_clip( struct brw_clip_compile
*c
)
531 struct brw_instruction
*neg_rhw
;
532 struct brw_compile
*p
= &c
->func
;
533 brw_clip_tri_alloc_regs(c
, 3 + c
->key
.nr_userclip
+ 6);
534 brw_clip_tri_init_vertices(c
);
535 brw_clip_init_clipmask(c
);
537 /* if -ve rhw workaround bit is set,
539 if (!BRW_IS_IGD(p
->brw
)) {
540 brw_set_conditionalmod(p
, BRW_CONDITIONAL_NZ
);
541 brw_AND(p
, brw_null_reg(), get_element_ud(c
->reg
.R0
, 2),
543 neg_rhw
= brw_IF(p
, BRW_EXECUTE_1
);
547 brw_ENDIF(p
, neg_rhw
);
549 /* Can't push into do_clip_tri because with polygon (or quad)
550 * flatshading, need to apply the flatshade here because we don't
551 * respect the PV when converting to trifan for emit:
553 if (c
->key
.do_flat_shading
)
554 brw_clip_tri_flat_shade(c
);
556 if (c
->key
.clip_mode
== BRW_CLIPMODE_NORMAL
)
559 maybe_do_clip_tri(c
);
561 brw_clip_tri_emit_polygon(c
);
563 /* Send an empty message to kill the thread:
565 brw_clip_kill_thread(c
);