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>
32 #include "main/glheader.h"
33 #include "main/macros.h"
34 #include "main/enums.h"
35 #include "program/program.h"
37 #include "intel_batchbuffer.h"
39 #include "brw_defines.h"
40 #include "brw_context.h"
44 static void release_tmps( struct brw_clip_compile
*c
)
46 c
->last_tmp
= c
->first_tmp
;
50 void brw_clip_tri_alloc_regs( struct brw_clip_compile
*c
,
53 struct brw_context
*brw
= c
->func
.brw
;
56 /* Register usage is static, precompute here:
58 c
->reg
.R0
= retype(brw_vec8_grf(i
, 0), BRW_REGISTER_TYPE_UD
); i
++;
60 if (c
->key
.nr_userclip
) {
61 c
->reg
.fixed_planes
= brw_vec4_grf(i
, 0);
62 i
+= (6 + c
->key
.nr_userclip
+ 1) / 2;
64 c
->prog_data
.curb_read_length
= (6 + c
->key
.nr_userclip
+ 1) / 2;
67 c
->prog_data
.curb_read_length
= 0;
70 /* Payload vertices plus space for more generated vertices:
72 for (j
= 0; j
< nr_verts
; j
++) {
73 c
->reg
.vertex
[j
] = brw_vec4_grf(i
, 0);
77 if (c
->vue_map
.num_slots
% 2) {
78 /* The VUE has an odd number of slots so the last register is only half
79 * used. Fill the second half with zero.
81 for (j
= 0; j
< 3; j
++) {
82 GLuint delta
= brw_vue_slot_to_offset(c
->vue_map
.num_slots
);
84 brw_MOV(&c
->func
, byte_offset(c
->reg
.vertex
[j
], delta
), brw_imm_f(0));
88 c
->reg
.t
= brw_vec1_grf(i
, 0);
89 c
->reg
.loopcount
= retype(brw_vec1_grf(i
, 1), BRW_REGISTER_TYPE_D
);
90 c
->reg
.nr_verts
= retype(brw_vec1_grf(i
, 2), BRW_REGISTER_TYPE_UD
);
91 c
->reg
.planemask
= retype(brw_vec1_grf(i
, 3), BRW_REGISTER_TYPE_UD
);
92 c
->reg
.plane_equation
= brw_vec4_grf(i
, 4);
95 c
->reg
.dpPrev
= brw_vec1_grf(i
, 0); /* fixme - dp4 will clobber r.1,2,3 */
96 c
->reg
.dp
= brw_vec1_grf(i
, 4);
99 c
->reg
.inlist
= brw_uw16_reg(BRW_GENERAL_REGISTER_FILE
, i
, 0);
102 c
->reg
.outlist
= brw_uw16_reg(BRW_GENERAL_REGISTER_FILE
, i
, 0);
105 c
->reg
.freelist
= brw_uw16_reg(BRW_GENERAL_REGISTER_FILE
, i
, 0);
108 if (!c
->key
.nr_userclip
) {
109 c
->reg
.fixed_planes
= brw_vec8_grf(i
, 0);
113 if (c
->key
.do_unfilled
) {
114 c
->reg
.dir
= brw_vec4_grf(i
, 0);
115 c
->reg
.offset
= brw_vec4_grf(i
, 4);
117 c
->reg
.tmp0
= brw_vec4_grf(i
, 0);
118 c
->reg
.tmp1
= brw_vec4_grf(i
, 4);
122 c
->reg
.vertex_src_mask
= retype(brw_vec1_grf(i
, 0), BRW_REGISTER_TYPE_UD
);
123 c
->reg
.clipdistance_offset
= retype(brw_vec1_grf(i
, 1), BRW_REGISTER_TYPE_W
);
127 c
->reg
.ff_sync
= retype(brw_vec1_grf(i
, 0), BRW_REGISTER_TYPE_UD
);
134 c
->prog_data
.urb_read_length
= c
->nr_regs
; /* ? */
135 c
->prog_data
.total_grf
= i
;
140 void brw_clip_tri_init_vertices( struct brw_clip_compile
*c
)
142 struct brw_compile
*p
= &c
->func
;
143 struct brw_reg tmp0
= c
->reg
.loopcount
; /* handy temporary */
145 /* Initial list of indices for incoming vertexes:
147 brw_AND(p
, tmp0
, get_element_ud(c
->reg
.R0
, 2), brw_imm_ud(PRIM_MASK
));
149 vec1(brw_null_reg()),
152 brw_imm_ud(_3DPRIM_TRISTRIP_REVERSE
));
154 /* XXX: Is there an easier way to do this? Need to reverse every
155 * second tristrip element: Can ignore sometimes?
157 brw_IF(p
, BRW_EXECUTE_1
);
159 brw_MOV(p
, get_element(c
->reg
.inlist
, 0), brw_address(c
->reg
.vertex
[1]) );
160 brw_MOV(p
, get_element(c
->reg
.inlist
, 1), brw_address(c
->reg
.vertex
[0]) );
161 if (c
->need_direction
)
162 brw_MOV(p
, c
->reg
.dir
, brw_imm_f(-1));
166 brw_MOV(p
, get_element(c
->reg
.inlist
, 0), brw_address(c
->reg
.vertex
[0]) );
167 brw_MOV(p
, get_element(c
->reg
.inlist
, 1), brw_address(c
->reg
.vertex
[1]) );
168 if (c
->need_direction
)
169 brw_MOV(p
, c
->reg
.dir
, brw_imm_f(1));
173 brw_MOV(p
, get_element(c
->reg
.inlist
, 2), brw_address(c
->reg
.vertex
[2]) );
174 brw_MOV(p
, brw_vec8_grf(c
->reg
.outlist
.nr
, 0), brw_imm_f(0));
175 brw_MOV(p
, c
->reg
.nr_verts
, brw_imm_ud(3));
180 void brw_clip_tri_flat_shade( struct brw_clip_compile
*c
)
182 struct brw_compile
*p
= &c
->func
;
183 struct brw_reg tmp0
= c
->reg
.loopcount
; /* handy temporary */
185 brw_AND(p
, tmp0
, get_element_ud(c
->reg
.R0
, 2), brw_imm_ud(PRIM_MASK
));
187 vec1(brw_null_reg()),
190 brw_imm_ud(_3DPRIM_POLYGON
));
192 brw_IF(p
, BRW_EXECUTE_1
);
194 brw_clip_copy_flatshaded_attributes(c
, 1, 0);
195 brw_clip_copy_flatshaded_attributes(c
, 2, 0);
199 if (c
->key
.pv_first
) {
201 vec1(brw_null_reg()),
204 brw_imm_ud(_3DPRIM_TRIFAN
));
205 brw_IF(p
, BRW_EXECUTE_1
);
207 brw_clip_copy_flatshaded_attributes(c
, 0, 1);
208 brw_clip_copy_flatshaded_attributes(c
, 2, 1);
212 brw_clip_copy_flatshaded_attributes(c
, 1, 0);
213 brw_clip_copy_flatshaded_attributes(c
, 2, 0);
218 brw_clip_copy_flatshaded_attributes(c
, 0, 2);
219 brw_clip_copy_flatshaded_attributes(c
, 1, 2);
227 load_vertex_pos(struct brw_clip_compile
*c
, struct brw_indirect vtx
,
229 GLuint hpos_offset
, GLuint clip_offset
)
231 struct brw_compile
*p
= &c
->func
;
235 * dst = (vertex_src_mask & 1) ? src.hpos : src.clipvertex;
238 brw_set_conditionalmod(p
, BRW_CONDITIONAL_NZ
);
239 brw_AND(p
, vec1(brw_null_reg()), c
->reg
.vertex_src_mask
, brw_imm_ud(1));
240 brw_IF(p
, BRW_EXECUTE_1
);
242 brw_MOV(p
, dst
, deref_4f(vtx
, clip_offset
));
246 brw_MOV(p
, dst
, deref_4f(vtx
, hpos_offset
));
252 /* Use mesa's clipping algorithms, translated to GEN4 assembly.
254 void brw_clip_tri( struct brw_clip_compile
*c
)
256 struct brw_compile
*p
= &c
->func
;
257 struct brw_indirect vtx
= brw_indirect(0, 0);
258 struct brw_indirect vtxPrev
= brw_indirect(1, 0);
259 struct brw_indirect vtxOut
= brw_indirect(2, 0);
260 struct brw_indirect plane_ptr
= brw_indirect(3, 0);
261 struct brw_indirect inlist_ptr
= brw_indirect(4, 0);
262 struct brw_indirect outlist_ptr
= brw_indirect(5, 0);
263 struct brw_indirect freelist_ptr
= brw_indirect(6, 0);
264 GLuint hpos_offset
= brw_varying_to_offset(&c
->vue_map
, VARYING_SLOT_POS
);
265 GLuint clipvert_offset
= brw_clip_have_varying(c
, VARYING_SLOT_CLIP_VERTEX
)
266 ? brw_varying_to_offset(&c
->vue_map
, VARYING_SLOT_CLIP_VERTEX
)
268 GLint clipdist0_offset
= c
->key
.nr_userclip
269 ? brw_varying_to_offset(&c
->vue_map
, VARYING_SLOT_CLIP_DIST0
)
272 brw_MOV(p
, get_addr_reg(vtxPrev
), brw_address(c
->reg
.vertex
[2]) );
273 brw_MOV(p
, get_addr_reg(plane_ptr
), brw_clip_plane0_address(c
));
274 brw_MOV(p
, get_addr_reg(inlist_ptr
), brw_address(c
->reg
.inlist
));
275 brw_MOV(p
, get_addr_reg(outlist_ptr
), brw_address(c
->reg
.outlist
));
277 brw_MOV(p
, get_addr_reg(freelist_ptr
), brw_address(c
->reg
.vertex
[3]) );
279 /* Set the initial vertex source mask: The first 6 planes are the bounds
280 * of the view volume; the next 6 planes are the user clipping planes.
282 brw_MOV(p
, c
->reg
.vertex_src_mask
, brw_imm_ud(0xfc0));
284 /* Set the initial clipdistance offset to be 6 floats before gl_ClipDistance[0].
285 * We'll increment 6 times before we start hitting actual user clipping. */
286 brw_MOV(p
, c
->reg
.clipdistance_offset
, brw_imm_d(clipdist0_offset
- 6*sizeof(float)));
288 brw_DO(p
, BRW_EXECUTE_1
);
290 /* if (planemask & 1)
292 brw_set_conditionalmod(p
, BRW_CONDITIONAL_NZ
);
293 brw_AND(p
, vec1(brw_null_reg()), c
->reg
.planemask
, brw_imm_ud(1));
295 brw_IF(p
, BRW_EXECUTE_1
);
297 /* vtxOut = freelist_ptr++
299 brw_MOV(p
, get_addr_reg(vtxOut
), get_addr_reg(freelist_ptr
) );
300 brw_ADD(p
, get_addr_reg(freelist_ptr
), get_addr_reg(freelist_ptr
), brw_imm_uw(c
->nr_regs
* REG_SIZE
));
302 if (c
->key
.nr_userclip
)
303 brw_MOV(p
, c
->reg
.plane_equation
, deref_4f(plane_ptr
, 0));
305 brw_MOV(p
, c
->reg
.plane_equation
, deref_4b(plane_ptr
, 0));
307 brw_MOV(p
, c
->reg
.loopcount
, c
->reg
.nr_verts
);
308 brw_MOV(p
, c
->reg
.nr_verts
, brw_imm_ud(0));
310 brw_DO(p
, BRW_EXECUTE_1
);
314 brw_MOV(p
, get_addr_reg(vtx
), deref_1uw(inlist_ptr
, 0));
316 load_vertex_pos(c
, vtxPrev
, vec4(c
->reg
.dpPrev
), hpos_offset
, clipvert_offset
);
317 /* IS_NEGATIVE(prev) */
318 brw_set_conditionalmod(p
, BRW_CONDITIONAL_L
);
319 brw_DP4(p
, vec4(c
->reg
.dpPrev
), vec4(c
->reg
.dpPrev
), c
->reg
.plane_equation
);
320 brw_IF(p
, BRW_EXECUTE_1
);
322 load_vertex_pos(c
, vtx
, vec4(c
->reg
.dp
), hpos_offset
, clipvert_offset
);
325 brw_set_conditionalmod(p
, BRW_CONDITIONAL_GE
);
326 brw_DP4(p
, vec4(c
->reg
.dp
), vec4(c
->reg
.dp
), c
->reg
.plane_equation
);
327 brw_IF(p
, BRW_EXECUTE_1
);
332 brw_ADD(p
, c
->reg
.t
, c
->reg
.dpPrev
, negate(c
->reg
.dp
));
333 brw_math_invert(p
, c
->reg
.t
, c
->reg
.t
);
334 brw_MUL(p
, c
->reg
.t
, c
->reg
.t
, c
->reg
.dpPrev
);
336 /* If (vtxOut == 0) vtxOut = vtxPrev
338 brw_CMP(p
, vec1(brw_null_reg()), BRW_CONDITIONAL_EQ
, get_addr_reg(vtxOut
), brw_imm_uw(0) );
339 brw_MOV(p
, get_addr_reg(vtxOut
), get_addr_reg(vtxPrev
) );
340 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
342 brw_clip_interp_vertex(c
, vtxOut
, vtxPrev
, vtx
, c
->reg
.t
, false);
344 /* *outlist_ptr++ = vtxOut;
348 brw_MOV(p
, deref_1uw(outlist_ptr
, 0), get_addr_reg(vtxOut
));
349 brw_ADD(p
, get_addr_reg(outlist_ptr
), get_addr_reg(outlist_ptr
), brw_imm_uw(sizeof(short)));
350 brw_ADD(p
, c
->reg
.nr_verts
, c
->reg
.nr_verts
, brw_imm_ud(1));
351 brw_MOV(p
, get_addr_reg(vtxOut
), brw_imm_uw(0) );
358 /* *outlist_ptr++ = vtxPrev;
361 brw_MOV(p
, deref_1uw(outlist_ptr
, 0), get_addr_reg(vtxPrev
));
362 brw_ADD(p
, get_addr_reg(outlist_ptr
), get_addr_reg(outlist_ptr
), brw_imm_uw(sizeof(short)));
363 brw_ADD(p
, c
->reg
.nr_verts
, c
->reg
.nr_verts
, brw_imm_ud(1));
365 load_vertex_pos(c
, vtx
, vec4(c
->reg
.dp
), hpos_offset
, clipvert_offset
);
368 brw_set_conditionalmod(p
, BRW_CONDITIONAL_L
);
369 brw_DP4(p
, vec4(c
->reg
.dp
), vec4(c
->reg
.dp
), c
->reg
.plane_equation
);
370 brw_IF(p
, BRW_EXECUTE_1
);
372 /* Going out of bounds. Avoid division by zero as we
373 * know dp != dpPrev from DIFFERENT_SIGNS, above.
375 brw_ADD(p
, c
->reg
.t
, c
->reg
.dp
, negate(c
->reg
.dpPrev
));
376 brw_math_invert(p
, c
->reg
.t
, c
->reg
.t
);
377 brw_MUL(p
, c
->reg
.t
, c
->reg
.t
, c
->reg
.dp
);
379 /* If (vtxOut == 0) vtxOut = vtx
381 brw_CMP(p
, vec1(brw_null_reg()), BRW_CONDITIONAL_EQ
, get_addr_reg(vtxOut
), brw_imm_uw(0) );
382 brw_MOV(p
, get_addr_reg(vtxOut
), get_addr_reg(vtx
) );
383 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
385 brw_clip_interp_vertex(c
, vtxOut
, vtx
, vtxPrev
, c
->reg
.t
, true);
387 /* *outlist_ptr++ = vtxOut;
391 brw_MOV(p
, deref_1uw(outlist_ptr
, 0), get_addr_reg(vtxOut
));
392 brw_ADD(p
, get_addr_reg(outlist_ptr
), get_addr_reg(outlist_ptr
), brw_imm_uw(sizeof(short)));
393 brw_ADD(p
, c
->reg
.nr_verts
, c
->reg
.nr_verts
, brw_imm_ud(1));
394 brw_MOV(p
, get_addr_reg(vtxOut
), brw_imm_uw(0) );
403 brw_MOV(p
, get_addr_reg(vtxPrev
), get_addr_reg(vtx
));
404 brw_ADD(p
, get_addr_reg(inlist_ptr
), get_addr_reg(inlist_ptr
), brw_imm_uw(sizeof(short)));
406 /* while (--loopcount != 0)
408 brw_set_conditionalmod(p
, BRW_CONDITIONAL_NZ
);
409 brw_ADD(p
, c
->reg
.loopcount
, c
->reg
.loopcount
, brw_imm_d(-1));
413 /* vtxPrev = *(outlist_ptr-1) OR: outlist[nr_verts-1]
415 * inlist_ptr = &inlist[0]
416 * outlist_ptr = &outlist[0]
418 brw_ADD(p
, get_addr_reg(outlist_ptr
), get_addr_reg(outlist_ptr
), brw_imm_w(-2));
419 brw_MOV(p
, get_addr_reg(vtxPrev
), deref_1uw(outlist_ptr
, 0));
420 brw_MOV(p
, brw_vec8_grf(c
->reg
.inlist
.nr
, 0), brw_vec8_grf(c
->reg
.outlist
.nr
, 0));
421 brw_MOV(p
, get_addr_reg(inlist_ptr
), brw_address(c
->reg
.inlist
));
422 brw_MOV(p
, get_addr_reg(outlist_ptr
), brw_address(c
->reg
.outlist
));
428 brw_ADD(p
, get_addr_reg(plane_ptr
), get_addr_reg(plane_ptr
), brw_clip_plane_stride(c
));
433 vec1(brw_null_reg()),
438 /* && (planemask>>=1) != 0
440 brw_set_conditionalmod(p
, BRW_CONDITIONAL_NZ
);
441 brw_SHR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud(1));
442 brw_SHR(p
, c
->reg
.vertex_src_mask
, c
->reg
.vertex_src_mask
, brw_imm_ud(1));
443 brw_ADD(p
, c
->reg
.clipdistance_offset
, c
->reg
.clipdistance_offset
, brw_imm_w(sizeof(float)));
450 void brw_clip_tri_emit_polygon(struct brw_clip_compile
*c
)
452 struct brw_compile
*p
= &c
->func
;
454 /* for (loopcount = nr_verts-2; loopcount > 0; loopcount--)
456 brw_set_conditionalmod(p
, BRW_CONDITIONAL_G
);
462 brw_IF(p
, BRW_EXECUTE_1
);
464 struct brw_indirect v0
= brw_indirect(0, 0);
465 struct brw_indirect vptr
= brw_indirect(1, 0);
467 brw_MOV(p
, get_addr_reg(vptr
), brw_address(c
->reg
.inlist
));
468 brw_MOV(p
, get_addr_reg(v0
), deref_1uw(vptr
, 0));
470 brw_clip_emit_vue(c
, v0
, 1, 0,
471 ((_3DPRIM_TRIFAN
<< URB_WRITE_PRIM_TYPE_SHIFT
)
472 | URB_WRITE_PRIM_START
));
474 brw_ADD(p
, get_addr_reg(vptr
), get_addr_reg(vptr
), brw_imm_uw(2));
475 brw_MOV(p
, get_addr_reg(v0
), deref_1uw(vptr
, 0));
477 brw_DO(p
, BRW_EXECUTE_1
);
479 brw_clip_emit_vue(c
, v0
, 1, 0,
480 (_3DPRIM_TRIFAN
<< URB_WRITE_PRIM_TYPE_SHIFT
));
482 brw_ADD(p
, get_addr_reg(vptr
), get_addr_reg(vptr
), brw_imm_uw(2));
483 brw_MOV(p
, get_addr_reg(v0
), deref_1uw(vptr
, 0));
485 brw_set_conditionalmod(p
, BRW_CONDITIONAL_NZ
);
486 brw_ADD(p
, c
->reg
.loopcount
, c
->reg
.loopcount
, brw_imm_d(-1));
490 brw_clip_emit_vue(c
, v0
, 0, 1,
491 ((_3DPRIM_TRIFAN
<< URB_WRITE_PRIM_TYPE_SHIFT
)
492 | URB_WRITE_PRIM_END
));
497 static void do_clip_tri( struct brw_clip_compile
*c
)
499 brw_clip_init_planes(c
);
505 static void maybe_do_clip_tri( struct brw_clip_compile
*c
)
507 struct brw_compile
*p
= &c
->func
;
509 brw_CMP(p
, vec1(brw_null_reg()), BRW_CONDITIONAL_NZ
, c
->reg
.planemask
, brw_imm_ud(0));
510 brw_IF(p
, BRW_EXECUTE_1
);
517 static void brw_clip_test( struct brw_clip_compile
*c
)
519 struct brw_reg t
= retype(get_tmp(c
), BRW_REGISTER_TYPE_UD
);
520 struct brw_reg t1
= retype(get_tmp(c
), BRW_REGISTER_TYPE_UD
);
521 struct brw_reg t2
= retype(get_tmp(c
), BRW_REGISTER_TYPE_UD
);
522 struct brw_reg t3
= retype(get_tmp(c
), BRW_REGISTER_TYPE_UD
);
524 struct brw_reg v0
= get_tmp(c
);
525 struct brw_reg v1
= get_tmp(c
);
526 struct brw_reg v2
= get_tmp(c
);
528 struct brw_indirect vt0
= brw_indirect(0, 0);
529 struct brw_indirect vt1
= brw_indirect(1, 0);
530 struct brw_indirect vt2
= brw_indirect(2, 0);
532 struct brw_compile
*p
= &c
->func
;
533 struct brw_reg tmp0
= c
->reg
.loopcount
; /* handy temporary */
535 GLuint hpos_offset
= brw_varying_to_offset(&c
->vue_map
,
538 brw_MOV(p
, get_addr_reg(vt0
), brw_address(c
->reg
.vertex
[0]));
539 brw_MOV(p
, get_addr_reg(vt1
), brw_address(c
->reg
.vertex
[1]));
540 brw_MOV(p
, get_addr_reg(vt2
), brw_address(c
->reg
.vertex
[2]));
541 brw_MOV(p
, v0
, deref_4f(vt0
, hpos_offset
));
542 brw_MOV(p
, v1
, deref_4f(vt1
, hpos_offset
));
543 brw_MOV(p
, v2
, deref_4f(vt2
, hpos_offset
));
544 brw_AND(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud(~0x3f));
546 /* test nearz, xmin, ymin plane */
547 /* clip.xyz < -clip.w */
548 brw_CMP(p
, t1
, BRW_CONDITIONAL_L
, v0
, negate(get_element(v0
, 3)));
549 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
550 brw_CMP(p
, t2
, BRW_CONDITIONAL_L
, v1
, negate(get_element(v1
, 3)));
551 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
552 brw_CMP(p
, t3
, BRW_CONDITIONAL_L
, v2
, negate(get_element(v2
, 3)));
553 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
555 /* All vertices are outside of a plane, rejected */
556 brw_AND(p
, t
, t1
, t2
);
557 brw_AND(p
, t
, t
, t3
);
558 brw_OR(p
, tmp0
, get_element(t
, 0), get_element(t
, 1));
559 brw_OR(p
, tmp0
, tmp0
, get_element(t
, 2));
560 brw_set_conditionalmod(p
, BRW_CONDITIONAL_NZ
);
561 brw_AND(p
, brw_null_reg(), tmp0
, brw_imm_ud(0x1));
562 brw_IF(p
, BRW_EXECUTE_1
);
564 brw_clip_kill_thread(c
);
567 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
569 /* some vertices are inside a plane, some are outside,need to clip */
570 brw_XOR(p
, t
, t1
, t2
);
571 brw_XOR(p
, t1
, t2
, t3
);
573 brw_AND(p
, t
, t
, brw_imm_ud(0x1));
574 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
575 get_element(t
, 0), brw_imm_ud(0));
576 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<5)));
577 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
578 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
579 get_element(t
, 1), brw_imm_ud(0));
580 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<3)));
581 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
582 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
583 get_element(t
, 2), brw_imm_ud(0));
584 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<1)));
585 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
587 /* test farz, xmax, ymax plane */
588 /* clip.xyz > clip.w */
589 brw_CMP(p
, t1
, BRW_CONDITIONAL_G
, v0
, get_element(v0
, 3));
590 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
591 brw_CMP(p
, t2
, BRW_CONDITIONAL_G
, v1
, get_element(v1
, 3));
592 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
593 brw_CMP(p
, t3
, BRW_CONDITIONAL_G
, v2
, get_element(v2
, 3));
594 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
596 /* All vertices are outside of a plane, rejected */
597 brw_AND(p
, t
, t1
, t2
);
598 brw_AND(p
, t
, t
, t3
);
599 brw_OR(p
, tmp0
, get_element(t
, 0), get_element(t
, 1));
600 brw_OR(p
, tmp0
, tmp0
, get_element(t
, 2));
601 brw_set_conditionalmod(p
, BRW_CONDITIONAL_NZ
);
602 brw_AND(p
, brw_null_reg(), tmp0
, brw_imm_ud(0x1));
603 brw_IF(p
, BRW_EXECUTE_1
);
605 brw_clip_kill_thread(c
);
608 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
610 /* some vertices are inside a plane, some are outside,need to clip */
611 brw_XOR(p
, t
, t1
, t2
);
612 brw_XOR(p
, t1
, t2
, t3
);
614 brw_AND(p
, t
, t
, brw_imm_ud(0x1));
615 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
616 get_element(t
, 0), brw_imm_ud(0));
617 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<4)));
618 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
619 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
620 get_element(t
, 1), brw_imm_ud(0));
621 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<2)));
622 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
623 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
624 get_element(t
, 2), brw_imm_ud(0));
625 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<0)));
626 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
632 void brw_emit_tri_clip( struct brw_clip_compile
*c
)
634 struct brw_compile
*p
= &c
->func
;
635 struct brw_context
*brw
= p
->brw
;
636 brw_clip_tri_alloc_regs(c
, 3 + c
->key
.nr_userclip
+ 6);
637 brw_clip_tri_init_vertices(c
);
638 brw_clip_init_clipmask(c
);
639 brw_clip_init_ff_sync(c
);
641 /* if -ve rhw workaround bit is set,
643 if (brw
->has_negative_rhw_bug
) {
644 brw_set_conditionalmod(p
, BRW_CONDITIONAL_NZ
);
645 brw_AND(p
, brw_null_reg(), get_element_ud(c
->reg
.R0
, 2),
647 brw_IF(p
, BRW_EXECUTE_1
);
653 /* Can't push into do_clip_tri because with polygon (or quad)
654 * flatshading, need to apply the flatshade here because we don't
655 * respect the PV when converting to trifan for emit:
657 if (c
->has_flat_shading
)
658 brw_clip_tri_flat_shade(c
);
660 if ((c
->key
.clip_mode
== BRW_CLIPMODE_NORMAL
) ||
661 (c
->key
.clip_mode
== BRW_CLIPMODE_KERNEL_CLIP
))
664 maybe_do_clip_tri(c
);
666 brw_clip_tri_emit_polygon(c
);
668 /* Send an empty message to kill the thread:
670 brw_clip_kill_thread(c
);