2 Copyright (C) Intel Corp. 2006. All Rights Reserved.
3 Intel funded Tungsten Graphics 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 <keithw@vmware.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 * Loads the clip distance for a vertex into `dst`, and ends with
228 * a comparison of it to zero with the condition `cond`.
230 * - If using a fixed plane, the distance is dot(hpos, plane).
231 * - If using a user clip plane, the distance is directly available in the vertex.
234 load_clip_distance(struct brw_clip_compile
*c
, struct brw_indirect vtx
,
235 struct brw_reg dst
, GLuint hpos_offset
, int cond
)
237 struct brw_compile
*p
= &c
->func
;
238 const struct brw_context
*brw
= p
->brw
;
241 brw_AND(p
, vec1(brw_null_reg()), c
->reg
.vertex_src_mask
, brw_imm_ud(1));
242 brw_inst_set_cond_modifier(brw
, brw_last_inst
, BRW_CONDITIONAL_NZ
);
243 brw_IF(p
, BRW_EXECUTE_1
);
245 struct brw_indirect temp_ptr
= brw_indirect(7, 0);
246 brw_ADD(p
, get_addr_reg(temp_ptr
), get_addr_reg(vtx
), c
->reg
.clipdistance_offset
);
247 brw_MOV(p
, vec1(dst
), deref_1f(temp_ptr
, 0));
251 brw_MOV(p
, dst
, deref_4f(vtx
, hpos_offset
));
252 brw_DP4(p
, dst
, dst
, c
->reg
.plane_equation
);
256 brw_CMP(p
, brw_null_reg(), cond
, vec1(dst
), brw_imm_f(0.0f
));
260 /* Use mesa's clipping algorithms, translated to GEN4 assembly.
262 void brw_clip_tri( struct brw_clip_compile
*c
)
264 struct brw_compile
*p
= &c
->func
;
265 const struct brw_context
*brw
= p
->brw
;
266 struct brw_indirect vtx
= brw_indirect(0, 0);
267 struct brw_indirect vtxPrev
= brw_indirect(1, 0);
268 struct brw_indirect vtxOut
= brw_indirect(2, 0);
269 struct brw_indirect plane_ptr
= brw_indirect(3, 0);
270 struct brw_indirect inlist_ptr
= brw_indirect(4, 0);
271 struct brw_indirect outlist_ptr
= brw_indirect(5, 0);
272 struct brw_indirect freelist_ptr
= brw_indirect(6, 0);
273 GLuint hpos_offset
= brw_varying_to_offset(&c
->vue_map
, VARYING_SLOT_POS
);
274 GLint clipdist0_offset
= c
->key
.nr_userclip
275 ? brw_varying_to_offset(&c
->vue_map
, VARYING_SLOT_CLIP_DIST0
)
278 brw_MOV(p
, get_addr_reg(vtxPrev
), brw_address(c
->reg
.vertex
[2]) );
279 brw_MOV(p
, get_addr_reg(plane_ptr
), brw_clip_plane0_address(c
));
280 brw_MOV(p
, get_addr_reg(inlist_ptr
), brw_address(c
->reg
.inlist
));
281 brw_MOV(p
, get_addr_reg(outlist_ptr
), brw_address(c
->reg
.outlist
));
283 brw_MOV(p
, get_addr_reg(freelist_ptr
), brw_address(c
->reg
.vertex
[3]) );
285 /* Set the initial vertex source mask: The first 6 planes are the bounds
286 * of the view volume; the next 8 planes are the user clipping planes.
288 brw_MOV(p
, c
->reg
.vertex_src_mask
, brw_imm_ud(0x3fc0));
290 /* Set the initial clipdistance offset to be 6 floats before gl_ClipDistance[0].
291 * We'll increment 6 times before we start hitting actual user clipping. */
292 brw_MOV(p
, c
->reg
.clipdistance_offset
, brw_imm_d(clipdist0_offset
- 6*sizeof(float)));
294 brw_DO(p
, BRW_EXECUTE_1
);
296 /* if (planemask & 1)
298 brw_AND(p
, vec1(brw_null_reg()), c
->reg
.planemask
, brw_imm_ud(1));
299 brw_inst_set_cond_modifier(brw
, brw_last_inst
, BRW_CONDITIONAL_NZ
);
301 brw_IF(p
, BRW_EXECUTE_1
);
303 /* vtxOut = freelist_ptr++
305 brw_MOV(p
, get_addr_reg(vtxOut
), get_addr_reg(freelist_ptr
) );
306 brw_ADD(p
, get_addr_reg(freelist_ptr
), get_addr_reg(freelist_ptr
), brw_imm_uw(c
->nr_regs
* REG_SIZE
));
308 if (c
->key
.nr_userclip
)
309 brw_MOV(p
, c
->reg
.plane_equation
, deref_4f(plane_ptr
, 0));
311 brw_MOV(p
, c
->reg
.plane_equation
, deref_4b(plane_ptr
, 0));
313 brw_MOV(p
, c
->reg
.loopcount
, c
->reg
.nr_verts
);
314 brw_MOV(p
, c
->reg
.nr_verts
, brw_imm_ud(0));
316 brw_DO(p
, BRW_EXECUTE_1
);
320 brw_MOV(p
, get_addr_reg(vtx
), deref_1uw(inlist_ptr
, 0));
322 load_clip_distance(c
, vtxPrev
, c
->reg
.dpPrev
, hpos_offset
, BRW_CONDITIONAL_L
);
323 /* IS_NEGATIVE(prev) */
324 brw_IF(p
, BRW_EXECUTE_1
);
326 load_clip_distance(c
, vtx
, c
->reg
.dp
, hpos_offset
, BRW_CONDITIONAL_GE
);
329 brw_IF(p
, BRW_EXECUTE_1
);
334 brw_ADD(p
, c
->reg
.t
, c
->reg
.dpPrev
, negate(c
->reg
.dp
));
335 brw_math_invert(p
, c
->reg
.t
, c
->reg
.t
);
336 brw_MUL(p
, c
->reg
.t
, c
->reg
.t
, c
->reg
.dpPrev
);
338 /* If (vtxOut == 0) vtxOut = vtxPrev
340 brw_CMP(p
, vec1(brw_null_reg()), BRW_CONDITIONAL_EQ
, get_addr_reg(vtxOut
), brw_imm_uw(0) );
341 brw_MOV(p
, get_addr_reg(vtxOut
), get_addr_reg(vtxPrev
));
342 brw_inst_set_pred_control(brw
, brw_last_inst
,
343 BRW_PREDICATE_NORMAL
);
345 brw_clip_interp_vertex(c
, vtxOut
, vtxPrev
, vtx
, c
->reg
.t
, false);
347 /* *outlist_ptr++ = vtxOut;
351 brw_MOV(p
, deref_1uw(outlist_ptr
, 0), get_addr_reg(vtxOut
));
352 brw_ADD(p
, get_addr_reg(outlist_ptr
), get_addr_reg(outlist_ptr
), brw_imm_uw(sizeof(short)));
353 brw_ADD(p
, c
->reg
.nr_verts
, c
->reg
.nr_verts
, brw_imm_ud(1));
354 brw_MOV(p
, get_addr_reg(vtxOut
), brw_imm_uw(0) );
361 /* *outlist_ptr++ = vtxPrev;
364 brw_MOV(p
, deref_1uw(outlist_ptr
, 0), get_addr_reg(vtxPrev
));
365 brw_ADD(p
, get_addr_reg(outlist_ptr
), get_addr_reg(outlist_ptr
), brw_imm_uw(sizeof(short)));
366 brw_ADD(p
, c
->reg
.nr_verts
, c
->reg
.nr_verts
, brw_imm_ud(1));
368 load_clip_distance(c
, vtx
, c
->reg
.dp
, hpos_offset
, BRW_CONDITIONAL_L
);
371 brw_IF(p
, BRW_EXECUTE_1
);
373 /* Going out of bounds. Avoid division by zero as we
374 * know dp != dpPrev from DIFFERENT_SIGNS, above.
376 brw_ADD(p
, c
->reg
.t
, c
->reg
.dp
, negate(c
->reg
.dpPrev
));
377 brw_math_invert(p
, c
->reg
.t
, c
->reg
.t
);
378 brw_MUL(p
, c
->reg
.t
, c
->reg
.t
, c
->reg
.dp
);
380 /* If (vtxOut == 0) vtxOut = vtx
382 brw_CMP(p
, vec1(brw_null_reg()), BRW_CONDITIONAL_EQ
, get_addr_reg(vtxOut
), brw_imm_uw(0) );
383 brw_MOV(p
, get_addr_reg(vtxOut
), get_addr_reg(vtx
));
384 brw_inst_set_pred_control(brw
, brw_last_inst
,
385 BRW_PREDICATE_NORMAL
);
387 brw_clip_interp_vertex(c
, vtxOut
, vtx
, vtxPrev
, c
->reg
.t
, true);
389 /* *outlist_ptr++ = vtxOut;
393 brw_MOV(p
, deref_1uw(outlist_ptr
, 0), get_addr_reg(vtxOut
));
394 brw_ADD(p
, get_addr_reg(outlist_ptr
), get_addr_reg(outlist_ptr
), brw_imm_uw(sizeof(short)));
395 brw_ADD(p
, c
->reg
.nr_verts
, c
->reg
.nr_verts
, brw_imm_ud(1));
396 brw_MOV(p
, get_addr_reg(vtxOut
), brw_imm_uw(0) );
405 brw_MOV(p
, get_addr_reg(vtxPrev
), get_addr_reg(vtx
));
406 brw_ADD(p
, get_addr_reg(inlist_ptr
), get_addr_reg(inlist_ptr
), brw_imm_uw(sizeof(short)));
408 /* while (--loopcount != 0)
410 brw_ADD(p
, c
->reg
.loopcount
, c
->reg
.loopcount
, brw_imm_d(-1));
411 brw_inst_set_cond_modifier(brw
, brw_last_inst
, BRW_CONDITIONAL_NZ
);
414 brw_inst_set_pred_control(brw
, brw_last_inst
, BRW_PREDICATE_NORMAL
);
416 /* vtxPrev = *(outlist_ptr-1) OR: outlist[nr_verts-1]
418 * inlist_ptr = &inlist[0]
419 * outlist_ptr = &outlist[0]
421 brw_ADD(p
, get_addr_reg(outlist_ptr
), get_addr_reg(outlist_ptr
), brw_imm_w(-2));
422 brw_MOV(p
, get_addr_reg(vtxPrev
), deref_1uw(outlist_ptr
, 0));
423 brw_MOV(p
, brw_vec8_grf(c
->reg
.inlist
.nr
, 0), brw_vec8_grf(c
->reg
.outlist
.nr
, 0));
424 brw_MOV(p
, get_addr_reg(inlist_ptr
), brw_address(c
->reg
.inlist
));
425 brw_MOV(p
, get_addr_reg(outlist_ptr
), brw_address(c
->reg
.outlist
));
431 brw_ADD(p
, get_addr_reg(plane_ptr
), get_addr_reg(plane_ptr
), brw_clip_plane_stride(c
));
436 vec1(brw_null_reg()),
440 brw_set_default_predicate_control(p
, BRW_PREDICATE_NORMAL
);
442 /* && (planemask>>=1) != 0
444 brw_SHR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud(1));
445 brw_inst_set_cond_modifier(brw
, brw_last_inst
, BRW_CONDITIONAL_NZ
);
446 brw_SHR(p
, c
->reg
.vertex_src_mask
, c
->reg
.vertex_src_mask
, brw_imm_ud(1));
447 brw_ADD(p
, c
->reg
.clipdistance_offset
, c
->reg
.clipdistance_offset
, brw_imm_w(sizeof(float)));
450 brw_set_default_predicate_control(p
, BRW_PREDICATE_NONE
);
455 void brw_clip_tri_emit_polygon(struct brw_clip_compile
*c
)
457 struct brw_compile
*p
= &c
->func
;
458 const struct brw_context
*brw
= p
->brw
;
460 /* for (loopcount = nr_verts-2; loopcount > 0; loopcount--)
466 brw_inst_set_cond_modifier(brw
, brw_last_inst
, BRW_CONDITIONAL_G
);
468 brw_IF(p
, BRW_EXECUTE_1
);
470 struct brw_indirect v0
= brw_indirect(0, 0);
471 struct brw_indirect vptr
= brw_indirect(1, 0);
473 brw_MOV(p
, get_addr_reg(vptr
), brw_address(c
->reg
.inlist
));
474 brw_MOV(p
, get_addr_reg(v0
), deref_1uw(vptr
, 0));
476 brw_clip_emit_vue(c
, v0
, BRW_URB_WRITE_ALLOCATE_COMPLETE
,
477 ((_3DPRIM_TRIFAN
<< URB_WRITE_PRIM_TYPE_SHIFT
)
478 | URB_WRITE_PRIM_START
));
480 brw_ADD(p
, get_addr_reg(vptr
), get_addr_reg(vptr
), brw_imm_uw(2));
481 brw_MOV(p
, get_addr_reg(v0
), deref_1uw(vptr
, 0));
483 brw_DO(p
, BRW_EXECUTE_1
);
485 brw_clip_emit_vue(c
, v0
, BRW_URB_WRITE_ALLOCATE_COMPLETE
,
486 (_3DPRIM_TRIFAN
<< URB_WRITE_PRIM_TYPE_SHIFT
));
488 brw_ADD(p
, get_addr_reg(vptr
), get_addr_reg(vptr
), brw_imm_uw(2));
489 brw_MOV(p
, get_addr_reg(v0
), deref_1uw(vptr
, 0));
491 brw_ADD(p
, c
->reg
.loopcount
, c
->reg
.loopcount
, brw_imm_d(-1));
492 brw_inst_set_cond_modifier(brw
, brw_last_inst
, BRW_CONDITIONAL_NZ
);
495 brw_inst_set_pred_control(brw
, brw_last_inst
, BRW_PREDICATE_NORMAL
);
497 brw_clip_emit_vue(c
, v0
, BRW_URB_WRITE_EOT_COMPLETE
,
498 ((_3DPRIM_TRIFAN
<< URB_WRITE_PRIM_TYPE_SHIFT
)
499 | URB_WRITE_PRIM_END
));
504 static void do_clip_tri( struct brw_clip_compile
*c
)
506 brw_clip_init_planes(c
);
512 static void maybe_do_clip_tri( struct brw_clip_compile
*c
)
514 struct brw_compile
*p
= &c
->func
;
516 brw_CMP(p
, vec1(brw_null_reg()), BRW_CONDITIONAL_NZ
, c
->reg
.planemask
, brw_imm_ud(0));
517 brw_IF(p
, BRW_EXECUTE_1
);
524 static void brw_clip_test( struct brw_clip_compile
*c
)
526 struct brw_reg t
= retype(get_tmp(c
), BRW_REGISTER_TYPE_UD
);
527 struct brw_reg t1
= retype(get_tmp(c
), BRW_REGISTER_TYPE_UD
);
528 struct brw_reg t2
= retype(get_tmp(c
), BRW_REGISTER_TYPE_UD
);
529 struct brw_reg t3
= retype(get_tmp(c
), BRW_REGISTER_TYPE_UD
);
531 struct brw_reg v0
= get_tmp(c
);
532 struct brw_reg v1
= get_tmp(c
);
533 struct brw_reg v2
= get_tmp(c
);
535 struct brw_indirect vt0
= brw_indirect(0, 0);
536 struct brw_indirect vt1
= brw_indirect(1, 0);
537 struct brw_indirect vt2
= brw_indirect(2, 0);
539 struct brw_compile
*p
= &c
->func
;
540 const struct brw_context
*brw
= p
->brw
;
541 struct brw_reg tmp0
= c
->reg
.loopcount
; /* handy temporary */
543 GLuint hpos_offset
= brw_varying_to_offset(&c
->vue_map
,
546 brw_MOV(p
, get_addr_reg(vt0
), brw_address(c
->reg
.vertex
[0]));
547 brw_MOV(p
, get_addr_reg(vt1
), brw_address(c
->reg
.vertex
[1]));
548 brw_MOV(p
, get_addr_reg(vt2
), brw_address(c
->reg
.vertex
[2]));
549 brw_MOV(p
, v0
, deref_4f(vt0
, hpos_offset
));
550 brw_MOV(p
, v1
, deref_4f(vt1
, hpos_offset
));
551 brw_MOV(p
, v2
, deref_4f(vt2
, hpos_offset
));
552 brw_AND(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud(~0x3f));
554 /* test nearz, xmin, ymin plane */
555 /* clip.xyz < -clip.w */
556 brw_CMP(p
, t1
, BRW_CONDITIONAL_L
, v0
, negate(get_element(v0
, 3)));
557 brw_CMP(p
, t2
, BRW_CONDITIONAL_L
, v1
, negate(get_element(v1
, 3)));
558 brw_CMP(p
, t3
, BRW_CONDITIONAL_L
, v2
, negate(get_element(v2
, 3)));
560 /* All vertices are outside of a plane, rejected */
561 brw_AND(p
, t
, t1
, t2
);
562 brw_AND(p
, t
, t
, t3
);
563 brw_OR(p
, tmp0
, get_element(t
, 0), get_element(t
, 1));
564 brw_OR(p
, tmp0
, tmp0
, get_element(t
, 2));
565 brw_AND(p
, brw_null_reg(), tmp0
, brw_imm_ud(0x1));
566 brw_inst_set_cond_modifier(brw
, brw_last_inst
, BRW_CONDITIONAL_NZ
);
567 brw_IF(p
, BRW_EXECUTE_1
);
569 brw_clip_kill_thread(c
);
572 brw_set_default_predicate_control(p
, BRW_PREDICATE_NONE
);
574 /* some vertices are inside a plane, some are outside,need to clip */
575 brw_XOR(p
, t
, t1
, t2
);
576 brw_XOR(p
, t1
, t2
, t3
);
578 brw_AND(p
, t
, t
, brw_imm_ud(0x1));
579 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
580 get_element(t
, 0), brw_imm_ud(0));
581 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<5)));
582 brw_inst_set_pred_control(brw
, brw_last_inst
, BRW_PREDICATE_NORMAL
);
583 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
584 get_element(t
, 1), brw_imm_ud(0));
585 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<3)));
586 brw_inst_set_pred_control(brw
, brw_last_inst
, BRW_PREDICATE_NORMAL
);
587 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
588 get_element(t
, 2), brw_imm_ud(0));
589 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<1)));
590 brw_inst_set_pred_control(brw
, brw_last_inst
, BRW_PREDICATE_NORMAL
);
592 /* test farz, xmax, ymax plane */
593 /* clip.xyz > clip.w */
594 brw_CMP(p
, t1
, BRW_CONDITIONAL_G
, v0
, get_element(v0
, 3));
595 brw_CMP(p
, t2
, BRW_CONDITIONAL_G
, v1
, get_element(v1
, 3));
596 brw_CMP(p
, t3
, BRW_CONDITIONAL_G
, v2
, get_element(v2
, 3));
598 /* All vertices are outside of a plane, rejected */
599 brw_AND(p
, t
, t1
, t2
);
600 brw_AND(p
, t
, t
, t3
);
601 brw_OR(p
, tmp0
, get_element(t
, 0), get_element(t
, 1));
602 brw_OR(p
, tmp0
, tmp0
, get_element(t
, 2));
603 brw_AND(p
, brw_null_reg(), tmp0
, brw_imm_ud(0x1));
604 brw_inst_set_cond_modifier(brw
, brw_last_inst
, BRW_CONDITIONAL_NZ
);
605 brw_IF(p
, BRW_EXECUTE_1
);
607 brw_clip_kill_thread(c
);
610 brw_set_default_predicate_control(p
, BRW_PREDICATE_NONE
);
612 /* some vertices are inside a plane, some are outside,need to clip */
613 brw_XOR(p
, t
, t1
, t2
);
614 brw_XOR(p
, t1
, t2
, t3
);
616 brw_AND(p
, t
, t
, brw_imm_ud(0x1));
617 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
618 get_element(t
, 0), brw_imm_ud(0));
619 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<4)));
620 brw_inst_set_pred_control(brw
, brw_last_inst
, BRW_PREDICATE_NORMAL
);
621 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
622 get_element(t
, 1), brw_imm_ud(0));
623 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<2)));
624 brw_inst_set_pred_control(brw
, brw_last_inst
, BRW_PREDICATE_NORMAL
);
625 brw_CMP(p
, brw_null_reg(), BRW_CONDITIONAL_NZ
,
626 get_element(t
, 2), brw_imm_ud(0));
627 brw_OR(p
, c
->reg
.planemask
, c
->reg
.planemask
, brw_imm_ud((1<<0)));
628 brw_inst_set_pred_control(brw
, brw_last_inst
, BRW_PREDICATE_NORMAL
);
634 void brw_emit_tri_clip( struct brw_clip_compile
*c
)
636 struct brw_compile
*p
= &c
->func
;
637 struct brw_context
*brw
= p
->brw
;
638 brw_clip_tri_alloc_regs(c
, 3 + c
->key
.nr_userclip
+ 6);
639 brw_clip_tri_init_vertices(c
);
640 brw_clip_init_clipmask(c
);
641 brw_clip_init_ff_sync(c
);
643 /* if -ve rhw workaround bit is set,
645 if (brw
->has_negative_rhw_bug
) {
646 brw_AND(p
, brw_null_reg(), get_element_ud(c
->reg
.R0
, 2),
648 brw_inst_set_cond_modifier(brw
, brw_last_inst
, BRW_CONDITIONAL_NZ
);
649 brw_IF(p
, BRW_EXECUTE_1
);
655 /* Can't push into do_clip_tri because with polygon (or quad)
656 * flatshading, need to apply the flatshade here because we don't
657 * respect the PV when converting to trifan for emit:
659 if (c
->has_flat_shading
)
660 brw_clip_tri_flat_shade(c
);
662 if ((c
->key
.clip_mode
== BRW_CLIPMODE_NORMAL
) ||
663 (c
->key
.clip_mode
== BRW_CLIPMODE_KERNEL_CLIP
))
666 maybe_do_clip_tri(c
);
668 brw_clip_tri_emit_polygon(c
);
670 /* Send an empty message to kill the thread:
672 brw_clip_kill_thread(c
);