• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  Copyright (C) Intel Corp.  2006.  All Rights Reserved.
3  Intel funded Tungsten Graphics to
4  develop this 3D driver.
5 
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:
13 
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.
17 
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.
25 
26  **********************************************************************/
27  /*
28   * Authors:
29   *   Keith Whitwell <keithw@vmware.com>
30   */
31 
32 #include "main/macros.h"
33 #include "main/enums.h"
34 #include "program/program.h"
35 
36 #include "brw_clip.h"
37 
release_tmps(struct brw_clip_compile * c)38 static void release_tmps( struct brw_clip_compile *c )
39 {
40    c->last_tmp = c->first_tmp;
41 }
42 
43 
brw_clip_tri_alloc_regs(struct brw_clip_compile * c,GLuint nr_verts)44 void brw_clip_tri_alloc_regs( struct brw_clip_compile *c,
45 			      GLuint nr_verts )
46 {
47    const struct gen_device_info *devinfo = c->func.devinfo;
48    GLuint i = 0,j;
49 
50    /* Register usage is static, precompute here:
51     */
52    c->reg.R0 = retype(brw_vec8_grf(i, 0), BRW_REGISTER_TYPE_UD); i++;
53 
54    if (c->key.nr_userclip) {
55       c->reg.fixed_planes = brw_vec4_grf(i, 0);
56       i += (6 + c->key.nr_userclip + 1) / 2;
57 
58       c->prog_data.curb_read_length = (6 + c->key.nr_userclip + 1) / 2;
59    }
60    else
61       c->prog_data.curb_read_length = 0;
62 
63 
64    /* Payload vertices plus space for more generated vertices:
65     */
66    for (j = 0; j < nr_verts; j++) {
67       c->reg.vertex[j] = brw_vec4_grf(i, 0);
68       i += c->nr_regs;
69    }
70 
71    if (c->vue_map.num_slots % 2) {
72       /* The VUE has an odd number of slots so the last register is only half
73        * used.  Fill the second half with zero.
74        */
75       for (j = 0; j < 3; j++) {
76 	 GLuint delta = brw_vue_slot_to_offset(c->vue_map.num_slots);
77 
78 	 brw_MOV(&c->func, byte_offset(c->reg.vertex[j], delta), brw_imm_f(0));
79       }
80    }
81 
82    c->reg.t          = brw_vec1_grf(i, 0);
83    c->reg.loopcount  = retype(brw_vec1_grf(i, 1), BRW_REGISTER_TYPE_D);
84    c->reg.nr_verts   = retype(brw_vec1_grf(i, 2), BRW_REGISTER_TYPE_UD);
85    c->reg.planemask  = retype(brw_vec1_grf(i, 3), BRW_REGISTER_TYPE_UD);
86    c->reg.plane_equation = brw_vec4_grf(i, 4);
87    i++;
88 
89    c->reg.dpPrev     = brw_vec1_grf(i, 0); /* fixme - dp4 will clobber r.1,2,3 */
90    c->reg.dp         = brw_vec1_grf(i, 4);
91    i++;
92 
93    c->reg.inlist     = brw_uw16_reg(BRW_GENERAL_REGISTER_FILE, i, 0);
94    i++;
95 
96    c->reg.outlist    = brw_uw16_reg(BRW_GENERAL_REGISTER_FILE, i, 0);
97    i++;
98 
99    c->reg.freelist   = brw_uw16_reg(BRW_GENERAL_REGISTER_FILE, i, 0);
100    i++;
101 
102    if (!c->key.nr_userclip) {
103       c->reg.fixed_planes = brw_vec8_grf(i, 0);
104       i++;
105    }
106 
107    if (c->key.do_unfilled) {
108       c->reg.dir     = brw_vec4_grf(i, 0);
109       c->reg.offset  = brw_vec4_grf(i, 4);
110       i++;
111       c->reg.tmp0    = brw_vec4_grf(i, 0);
112       c->reg.tmp1    = brw_vec4_grf(i, 4);
113       i++;
114    }
115 
116    c->reg.vertex_src_mask = retype(brw_vec1_grf(i, 0), BRW_REGISTER_TYPE_UD);
117    c->reg.clipdistance_offset = retype(brw_vec1_grf(i, 1), BRW_REGISTER_TYPE_W);
118    i++;
119 
120    if (devinfo->gen == 5) {
121       c->reg.ff_sync = retype(brw_vec1_grf(i, 0), BRW_REGISTER_TYPE_UD);
122       i++;
123    }
124 
125    c->first_tmp = i;
126    c->last_tmp = i;
127 
128    c->prog_data.urb_read_length = c->nr_regs; /* ? */
129    c->prog_data.total_grf = i;
130 }
131 
132 
133 
brw_clip_tri_init_vertices(struct brw_clip_compile * c)134 void brw_clip_tri_init_vertices( struct brw_clip_compile *c )
135 {
136    struct brw_codegen *p = &c->func;
137    struct brw_reg tmp0 = c->reg.loopcount; /* handy temporary */
138 
139    /* Initial list of indices for incoming vertexes:
140     */
141    brw_AND(p, tmp0, get_element_ud(c->reg.R0, 2), brw_imm_ud(PRIM_MASK));
142    brw_CMP(p,
143 	   vec1(brw_null_reg()),
144 	   BRW_CONDITIONAL_EQ,
145 	   tmp0,
146 	   brw_imm_ud(_3DPRIM_TRISTRIP_REVERSE));
147 
148    /* XXX: Is there an easier way to do this?  Need to reverse every
149     * second tristrip element:  Can ignore sometimes?
150     */
151    brw_IF(p, BRW_EXECUTE_1);
152    {
153       brw_MOV(p, get_element(c->reg.inlist, 0),  brw_address(c->reg.vertex[1]) );
154       brw_MOV(p, get_element(c->reg.inlist, 1),  brw_address(c->reg.vertex[0]) );
155       if (c->need_direction)
156 	 brw_MOV(p, c->reg.dir, brw_imm_f(-1));
157    }
158    brw_ELSE(p);
159    {
160       brw_MOV(p, get_element(c->reg.inlist, 0),  brw_address(c->reg.vertex[0]) );
161       brw_MOV(p, get_element(c->reg.inlist, 1),  brw_address(c->reg.vertex[1]) );
162       if (c->need_direction)
163 	 brw_MOV(p, c->reg.dir, brw_imm_f(1));
164    }
165    brw_ENDIF(p);
166 
167    brw_MOV(p, get_element(c->reg.inlist, 2),  brw_address(c->reg.vertex[2]) );
168    brw_MOV(p, brw_vec8_grf(c->reg.outlist.nr, 0), brw_imm_f(0));
169    brw_MOV(p, c->reg.nr_verts, brw_imm_ud(3));
170 }
171 
172 
173 
brw_clip_tri_flat_shade(struct brw_clip_compile * c)174 void brw_clip_tri_flat_shade( struct brw_clip_compile *c )
175 {
176    struct brw_codegen *p = &c->func;
177    struct brw_reg tmp0 = c->reg.loopcount; /* handy temporary */
178 
179    brw_AND(p, tmp0, get_element_ud(c->reg.R0, 2), brw_imm_ud(PRIM_MASK));
180    brw_CMP(p,
181 	   vec1(brw_null_reg()),
182 	   BRW_CONDITIONAL_EQ,
183 	   tmp0,
184 	   brw_imm_ud(_3DPRIM_POLYGON));
185 
186    brw_IF(p, BRW_EXECUTE_1);
187    {
188       brw_clip_copy_flatshaded_attributes(c, 1, 0);
189       brw_clip_copy_flatshaded_attributes(c, 2, 0);
190    }
191    brw_ELSE(p);
192    {
193       if (c->key.pv_first) {
194 	 brw_CMP(p,
195 		 vec1(brw_null_reg()),
196 		 BRW_CONDITIONAL_EQ,
197 		 tmp0,
198 		 brw_imm_ud(_3DPRIM_TRIFAN));
199 	 brw_IF(p, BRW_EXECUTE_1);
200 	 {
201 	    brw_clip_copy_flatshaded_attributes(c, 0, 1);
202 	    brw_clip_copy_flatshaded_attributes(c, 2, 1);
203 	 }
204 	 brw_ELSE(p);
205 	 {
206 	    brw_clip_copy_flatshaded_attributes(c, 1, 0);
207 	    brw_clip_copy_flatshaded_attributes(c, 2, 0);
208 	 }
209 	 brw_ENDIF(p);
210       }
211       else {
212          brw_clip_copy_flatshaded_attributes(c, 0, 2);
213          brw_clip_copy_flatshaded_attributes(c, 1, 2);
214       }
215    }
216    brw_ENDIF(p);
217 }
218 
219 
220 /**
221  * Loads the clip distance for a vertex into `dst`, and ends with
222  * a comparison of it to zero with the condition `cond`.
223  *
224  * - If using a fixed plane, the distance is dot(hpos, plane).
225  * - If using a user clip plane, the distance is directly available in the vertex.
226  */
227 static inline void
load_clip_distance(struct brw_clip_compile * c,struct brw_indirect vtx,struct brw_reg dst,GLuint hpos_offset,int cond)228 load_clip_distance(struct brw_clip_compile *c, struct brw_indirect vtx,
229                 struct brw_reg dst, GLuint hpos_offset, int cond)
230 {
231    struct brw_codegen *p = &c->func;
232 
233    dst = vec4(dst);
234    brw_AND(p, vec1(brw_null_reg()), c->reg.vertex_src_mask, brw_imm_ud(1));
235    brw_inst_set_cond_modifier(p->devinfo, brw_last_inst, BRW_CONDITIONAL_NZ);
236    brw_IF(p, BRW_EXECUTE_1);
237    {
238       struct brw_indirect temp_ptr = brw_indirect(7, 0);
239       brw_ADD(p, get_addr_reg(temp_ptr), get_addr_reg(vtx), c->reg.clipdistance_offset);
240       brw_MOV(p, vec1(dst), deref_1f(temp_ptr, 0));
241    }
242    brw_ELSE(p);
243    {
244       brw_MOV(p, dst, deref_4f(vtx, hpos_offset));
245       brw_DP4(p, dst, dst, c->reg.plane_equation);
246    }
247    brw_ENDIF(p);
248 
249    brw_CMP(p, brw_null_reg(), cond, vec1(dst), brw_imm_f(0.0f));
250 }
251 
252 
253 /* Use mesa's clipping algorithms, translated to GEN4 assembly.
254  */
brw_clip_tri(struct brw_clip_compile * c)255 void brw_clip_tri( struct brw_clip_compile *c )
256 {
257    struct brw_codegen *p = &c->func;
258    struct brw_indirect vtx = brw_indirect(0, 0);
259    struct brw_indirect vtxPrev = brw_indirect(1, 0);
260    struct brw_indirect vtxOut = brw_indirect(2, 0);
261    struct brw_indirect plane_ptr = brw_indirect(3, 0);
262    struct brw_indirect inlist_ptr = brw_indirect(4, 0);
263    struct brw_indirect outlist_ptr = brw_indirect(5, 0);
264    struct brw_indirect freelist_ptr = brw_indirect(6, 0);
265    GLuint hpos_offset = brw_varying_to_offset(&c->vue_map, VARYING_SLOT_POS);
266    GLint clipdist0_offset = c->key.nr_userclip
267       ? brw_varying_to_offset(&c->vue_map, VARYING_SLOT_CLIP_DIST0)
268       : 0;
269 
270    brw_MOV(p, get_addr_reg(vtxPrev),     brw_address(c->reg.vertex[2]) );
271    brw_MOV(p, get_addr_reg(plane_ptr),   brw_clip_plane0_address(c));
272    brw_MOV(p, get_addr_reg(inlist_ptr),  brw_address(c->reg.inlist));
273    brw_MOV(p, get_addr_reg(outlist_ptr), brw_address(c->reg.outlist));
274 
275    brw_MOV(p, get_addr_reg(freelist_ptr), brw_address(c->reg.vertex[3]) );
276 
277    /* Set the initial vertex source mask: The first 6 planes are the bounds
278     * of the view volume; the next 8 planes are the user clipping planes.
279     */
280    brw_MOV(p, c->reg.vertex_src_mask, brw_imm_ud(0x3fc0));
281 
282    /* Set the initial clipdistance offset to be 6 floats before gl_ClipDistance[0].
283     * We'll increment 6 times before we start hitting actual user clipping. */
284    brw_MOV(p, c->reg.clipdistance_offset, brw_imm_d(clipdist0_offset - 6*sizeof(float)));
285 
286    brw_DO(p, BRW_EXECUTE_1);
287    {
288       /* if (planemask & 1)
289        */
290       brw_AND(p, vec1(brw_null_reg()), c->reg.planemask, brw_imm_ud(1));
291       brw_inst_set_cond_modifier(p->devinfo, brw_last_inst, BRW_CONDITIONAL_NZ);
292 
293       brw_IF(p, BRW_EXECUTE_1);
294       {
295 	 /* vtxOut = freelist_ptr++
296 	  */
297 	 brw_MOV(p, get_addr_reg(vtxOut),       get_addr_reg(freelist_ptr) );
298 	 brw_ADD(p, get_addr_reg(freelist_ptr), get_addr_reg(freelist_ptr), brw_imm_uw(c->nr_regs * REG_SIZE));
299 
300 	 if (c->key.nr_userclip)
301 	    brw_MOV(p, c->reg.plane_equation, deref_4f(plane_ptr, 0));
302 	 else
303 	    brw_MOV(p, c->reg.plane_equation, deref_4b(plane_ptr, 0));
304 
305 	 brw_MOV(p, c->reg.loopcount, c->reg.nr_verts);
306 	 brw_MOV(p, c->reg.nr_verts, brw_imm_ud(0));
307 
308 	 brw_DO(p, BRW_EXECUTE_1);
309 	 {
310 	    /* vtx = *input_ptr;
311 	     */
312 	    brw_MOV(p, get_addr_reg(vtx), deref_1uw(inlist_ptr, 0));
313 
314             load_clip_distance(c, vtxPrev, c->reg.dpPrev, hpos_offset, BRW_CONDITIONAL_L);
315 	    /* (prev < 0.0f) */
316 	    brw_IF(p, BRW_EXECUTE_1);
317 	    {
318                load_clip_distance(c, vtx, c->reg.dp, hpos_offset, BRW_CONDITIONAL_GE);
319 	       /* IS_POSITIVE(next)
320 		*/
321 	       brw_IF(p, BRW_EXECUTE_1);
322 	       {
323 
324 		  /* Coming back in.
325 		   */
326 		  brw_ADD(p, c->reg.t, c->reg.dpPrev, negate(c->reg.dp));
327 		  brw_math_invert(p, c->reg.t, c->reg.t);
328 		  brw_MUL(p, c->reg.t, c->reg.t, c->reg.dpPrev);
329 
330 		  /* If (vtxOut == 0) vtxOut = vtxPrev
331 		   */
332 		  brw_CMP(p, vec1(brw_null_reg()), BRW_CONDITIONAL_EQ, get_addr_reg(vtxOut), brw_imm_uw(0) );
333                   brw_MOV(p, get_addr_reg(vtxOut), get_addr_reg(vtxPrev));
334                   brw_inst_set_pred_control(p->devinfo, brw_last_inst,
335                                             BRW_PREDICATE_NORMAL);
336 
337 		  brw_clip_interp_vertex(c, vtxOut, vtxPrev, vtx, c->reg.t, false);
338 
339 		  /* *outlist_ptr++ = vtxOut;
340 		   * nr_verts++;
341 		   * vtxOut = 0;
342 		   */
343 		  brw_MOV(p, deref_1uw(outlist_ptr, 0), get_addr_reg(vtxOut));
344 		  brw_ADD(p, get_addr_reg(outlist_ptr), get_addr_reg(outlist_ptr), brw_imm_uw(sizeof(short)));
345 		  brw_ADD(p, c->reg.nr_verts, c->reg.nr_verts, brw_imm_ud(1));
346 		  brw_MOV(p, get_addr_reg(vtxOut), brw_imm_uw(0) );
347 	       }
348 	       brw_ENDIF(p);
349 
350 	    }
351 	    brw_ELSE(p);
352 	    {
353 	       /* *outlist_ptr++ = vtxPrev;
354 		* nr_verts++;
355 		*/
356 	       brw_MOV(p, deref_1uw(outlist_ptr, 0), get_addr_reg(vtxPrev));
357 	       brw_ADD(p, get_addr_reg(outlist_ptr), get_addr_reg(outlist_ptr), brw_imm_uw(sizeof(short)));
358 	       brw_ADD(p, c->reg.nr_verts, c->reg.nr_verts, brw_imm_ud(1));
359 
360                load_clip_distance(c, vtx, c->reg.dp, hpos_offset, BRW_CONDITIONAL_L);
361 	       /* (next < 0.0f)
362 		*/
363 	       brw_IF(p, BRW_EXECUTE_1);
364 	       {
365 		  /* Going out of bounds.  Avoid division by zero as we
366 		   * know dp != dpPrev from DIFFERENT_SIGNS, above.
367 		   */
368 		  brw_ADD(p, c->reg.t, c->reg.dp, negate(c->reg.dpPrev));
369 		  brw_math_invert(p, c->reg.t, c->reg.t);
370 		  brw_MUL(p, c->reg.t, c->reg.t, c->reg.dp);
371 
372 		  /* If (vtxOut == 0) vtxOut = vtx
373 		   */
374 		  brw_CMP(p, vec1(brw_null_reg()), BRW_CONDITIONAL_EQ, get_addr_reg(vtxOut), brw_imm_uw(0) );
375                   brw_MOV(p, get_addr_reg(vtxOut), get_addr_reg(vtx));
376                   brw_inst_set_pred_control(p->devinfo, brw_last_inst,
377                                             BRW_PREDICATE_NORMAL);
378 
379 		  brw_clip_interp_vertex(c, vtxOut, vtx, vtxPrev, c->reg.t, true);
380 
381 		  /* *outlist_ptr++ = vtxOut;
382 		   * nr_verts++;
383 		   * vtxOut = 0;
384 		   */
385 		  brw_MOV(p, deref_1uw(outlist_ptr, 0), get_addr_reg(vtxOut));
386 		  brw_ADD(p, get_addr_reg(outlist_ptr), get_addr_reg(outlist_ptr), brw_imm_uw(sizeof(short)));
387 		  brw_ADD(p, c->reg.nr_verts, c->reg.nr_verts, brw_imm_ud(1));
388 		  brw_MOV(p, get_addr_reg(vtxOut), brw_imm_uw(0) );
389 	       }
390 	       brw_ENDIF(p);
391 	    }
392 	    brw_ENDIF(p);
393 
394 	    /* vtxPrev = vtx;
395 	     * inlist_ptr++;
396 	     */
397 	    brw_MOV(p, get_addr_reg(vtxPrev), get_addr_reg(vtx));
398 	    brw_ADD(p, get_addr_reg(inlist_ptr), get_addr_reg(inlist_ptr), brw_imm_uw(sizeof(short)));
399 
400 	    /* while (--loopcount != 0)
401 	     */
402 	    brw_ADD(p, c->reg.loopcount, c->reg.loopcount, brw_imm_d(-1));
403             brw_inst_set_cond_modifier(p->devinfo, brw_last_inst, BRW_CONDITIONAL_NZ);
404 	 }
405 	 brw_WHILE(p);
406          brw_inst_set_pred_control(p->devinfo, brw_last_inst, BRW_PREDICATE_NORMAL);
407 
408 	 /* vtxPrev = *(outlist_ptr-1)  OR: outlist[nr_verts-1]
409 	  * inlist = outlist
410 	  * inlist_ptr = &inlist[0]
411 	  * outlist_ptr = &outlist[0]
412 	  */
413 	 brw_ADD(p, get_addr_reg(outlist_ptr), get_addr_reg(outlist_ptr), brw_imm_w(-2));
414 	 brw_MOV(p, get_addr_reg(vtxPrev), deref_1uw(outlist_ptr, 0));
415 	 brw_MOV(p, brw_vec8_grf(c->reg.inlist.nr, 0), brw_vec8_grf(c->reg.outlist.nr, 0));
416 	 brw_MOV(p, get_addr_reg(inlist_ptr), brw_address(c->reg.inlist));
417 	 brw_MOV(p, get_addr_reg(outlist_ptr), brw_address(c->reg.outlist));
418       }
419       brw_ENDIF(p);
420 
421       /* plane_ptr++;
422        */
423       brw_ADD(p, get_addr_reg(plane_ptr), get_addr_reg(plane_ptr), brw_clip_plane_stride(c));
424 
425       /* nr_verts >= 3
426        */
427       brw_CMP(p,
428 	      vec1(brw_null_reg()),
429 	      BRW_CONDITIONAL_GE,
430 	      c->reg.nr_verts,
431 	      brw_imm_ud(3));
432       brw_set_default_predicate_control(p, BRW_PREDICATE_NORMAL);
433 
434       /* && (planemask>>=1) != 0
435        */
436       brw_SHR(p, c->reg.planemask, c->reg.planemask, brw_imm_ud(1));
437       brw_inst_set_cond_modifier(p->devinfo, brw_last_inst, BRW_CONDITIONAL_NZ);
438       brw_SHR(p, c->reg.vertex_src_mask, c->reg.vertex_src_mask, brw_imm_ud(1));
439       brw_ADD(p, c->reg.clipdistance_offset, c->reg.clipdistance_offset, brw_imm_w(sizeof(float)));
440    }
441    brw_WHILE(p);
442    brw_set_default_predicate_control(p, BRW_PREDICATE_NONE);
443 }
444 
445 
446 
brw_clip_tri_emit_polygon(struct brw_clip_compile * c)447 void brw_clip_tri_emit_polygon(struct brw_clip_compile *c)
448 {
449    struct brw_codegen *p = &c->func;
450 
451    /* for (loopcount = nr_verts-2; loopcount > 0; loopcount--)
452     */
453    brw_ADD(p,
454 	   c->reg.loopcount,
455 	   c->reg.nr_verts,
456 	   brw_imm_d(-2));
457    brw_inst_set_cond_modifier(p->devinfo, brw_last_inst, BRW_CONDITIONAL_G);
458 
459    brw_IF(p, BRW_EXECUTE_1);
460    {
461       struct brw_indirect v0 = brw_indirect(0, 0);
462       struct brw_indirect vptr = brw_indirect(1, 0);
463 
464       brw_MOV(p, get_addr_reg(vptr), brw_address(c->reg.inlist));
465       brw_MOV(p, get_addr_reg(v0), deref_1uw(vptr, 0));
466 
467       brw_clip_emit_vue(c, v0, BRW_URB_WRITE_ALLOCATE_COMPLETE,
468                         ((_3DPRIM_TRIFAN << URB_WRITE_PRIM_TYPE_SHIFT)
469                          | URB_WRITE_PRIM_START));
470 
471       brw_ADD(p, get_addr_reg(vptr), get_addr_reg(vptr), brw_imm_uw(2));
472       brw_MOV(p, get_addr_reg(v0), deref_1uw(vptr, 0));
473 
474       brw_DO(p, BRW_EXECUTE_1);
475       {
476 	 brw_clip_emit_vue(c, v0, BRW_URB_WRITE_ALLOCATE_COMPLETE,
477                            (_3DPRIM_TRIFAN << URB_WRITE_PRIM_TYPE_SHIFT));
478 
479 	 brw_ADD(p, get_addr_reg(vptr), get_addr_reg(vptr), brw_imm_uw(2));
480 	 brw_MOV(p, get_addr_reg(v0), deref_1uw(vptr, 0));
481 
482 	 brw_ADD(p, c->reg.loopcount, c->reg.loopcount, brw_imm_d(-1));
483          brw_inst_set_cond_modifier(p->devinfo, brw_last_inst, BRW_CONDITIONAL_NZ);
484       }
485       brw_WHILE(p);
486       brw_inst_set_pred_control(p->devinfo, brw_last_inst, BRW_PREDICATE_NORMAL);
487 
488       brw_clip_emit_vue(c, v0, BRW_URB_WRITE_EOT_COMPLETE,
489                         ((_3DPRIM_TRIFAN << URB_WRITE_PRIM_TYPE_SHIFT)
490                          | URB_WRITE_PRIM_END));
491    }
492    brw_ENDIF(p);
493 }
494 
do_clip_tri(struct brw_clip_compile * c)495 static void do_clip_tri( struct brw_clip_compile *c )
496 {
497    brw_clip_init_planes(c);
498 
499    brw_clip_tri(c);
500 }
501 
502 
maybe_do_clip_tri(struct brw_clip_compile * c)503 static void maybe_do_clip_tri( struct brw_clip_compile *c )
504 {
505    struct brw_codegen *p = &c->func;
506 
507    brw_CMP(p, vec1(brw_null_reg()), BRW_CONDITIONAL_NZ, c->reg.planemask, brw_imm_ud(0));
508    brw_IF(p, BRW_EXECUTE_1);
509    {
510       do_clip_tri(c);
511    }
512    brw_ENDIF(p);
513 }
514 
brw_clip_test(struct brw_clip_compile * c)515 static void brw_clip_test( struct brw_clip_compile *c )
516 {
517     struct brw_reg t = retype(get_tmp(c), BRW_REGISTER_TYPE_UD);
518     struct brw_reg t1 = retype(get_tmp(c), BRW_REGISTER_TYPE_UD);
519     struct brw_reg t2 = retype(get_tmp(c), BRW_REGISTER_TYPE_UD);
520     struct brw_reg t3 = retype(get_tmp(c), BRW_REGISTER_TYPE_UD);
521 
522     struct brw_reg v0 = get_tmp(c);
523     struct brw_reg v1 = get_tmp(c);
524     struct brw_reg v2 = get_tmp(c);
525 
526     struct brw_indirect vt0 = brw_indirect(0, 0);
527     struct brw_indirect vt1 = brw_indirect(1, 0);
528     struct brw_indirect vt2 = brw_indirect(2, 0);
529 
530     struct brw_codegen *p = &c->func;
531     struct brw_reg tmp0 = c->reg.loopcount; /* handy temporary */
532 
533     GLuint hpos_offset = brw_varying_to_offset(&c->vue_map,
534                                                    VARYING_SLOT_POS);
535 
536     brw_MOV(p, get_addr_reg(vt0), brw_address(c->reg.vertex[0]));
537     brw_MOV(p, get_addr_reg(vt1), brw_address(c->reg.vertex[1]));
538     brw_MOV(p, get_addr_reg(vt2), brw_address(c->reg.vertex[2]));
539     brw_MOV(p, v0, deref_4f(vt0, hpos_offset));
540     brw_MOV(p, v1, deref_4f(vt1, hpos_offset));
541     brw_MOV(p, v2, deref_4f(vt2, hpos_offset));
542     brw_AND(p, c->reg.planemask, c->reg.planemask, brw_imm_ud(~0x3f));
543 
544     /* test nearz, xmin, ymin plane */
545     /* clip.xyz < -clip.w */
546     brw_CMP(p, t1, BRW_CONDITIONAL_L, v0, negate(get_element(v0, 3)));
547     brw_CMP(p, t2, BRW_CONDITIONAL_L, v1, negate(get_element(v1, 3)));
548     brw_CMP(p, t3, BRW_CONDITIONAL_L, v2, negate(get_element(v2, 3)));
549 
550     /* All vertices are outside of a plane, rejected */
551     brw_AND(p, t, t1, t2);
552     brw_AND(p, t, t, t3);
553     brw_OR(p, tmp0, get_element(t, 0), get_element(t, 1));
554     brw_OR(p, tmp0, tmp0, get_element(t, 2));
555     brw_AND(p, brw_null_reg(), tmp0, brw_imm_ud(0x1));
556     brw_inst_set_cond_modifier(p->devinfo, brw_last_inst, BRW_CONDITIONAL_NZ);
557     brw_IF(p, BRW_EXECUTE_1);
558     {
559         brw_clip_kill_thread(c);
560     }
561     brw_ENDIF(p);
562     brw_set_default_predicate_control(p, BRW_PREDICATE_NONE);
563 
564     /* some vertices are inside a plane, some are outside,need to clip */
565     brw_XOR(p, t, t1, t2);
566     brw_XOR(p, t1, t2, t3);
567     brw_OR(p, t, t, t1);
568     brw_AND(p, t, t, brw_imm_ud(0x1));
569     brw_CMP(p, brw_null_reg(), BRW_CONDITIONAL_NZ,
570             get_element(t, 0), brw_imm_ud(0));
571     brw_OR(p, c->reg.planemask, c->reg.planemask, brw_imm_ud((1<<5)));
572     brw_inst_set_pred_control(p->devinfo, brw_last_inst, BRW_PREDICATE_NORMAL);
573     brw_CMP(p, brw_null_reg(), BRW_CONDITIONAL_NZ,
574             get_element(t, 1), brw_imm_ud(0));
575     brw_OR(p, c->reg.planemask, c->reg.planemask, brw_imm_ud((1<<3)));
576     brw_inst_set_pred_control(p->devinfo, brw_last_inst, BRW_PREDICATE_NORMAL);
577     brw_CMP(p, brw_null_reg(), BRW_CONDITIONAL_NZ,
578             get_element(t, 2), brw_imm_ud(0));
579     brw_OR(p, c->reg.planemask, c->reg.planemask, brw_imm_ud((1<<1)));
580     brw_inst_set_pred_control(p->devinfo, brw_last_inst, BRW_PREDICATE_NORMAL);
581 
582     /* test farz, xmax, ymax plane */
583     /* clip.xyz > clip.w */
584     brw_CMP(p, t1, BRW_CONDITIONAL_G, v0, get_element(v0, 3));
585     brw_CMP(p, t2, BRW_CONDITIONAL_G, v1, get_element(v1, 3));
586     brw_CMP(p, t3, BRW_CONDITIONAL_G, v2, get_element(v2, 3));
587 
588     /* All vertices are outside of a plane, rejected */
589     brw_AND(p, t, t1, t2);
590     brw_AND(p, t, t, t3);
591     brw_OR(p, tmp0, get_element(t, 0), get_element(t, 1));
592     brw_OR(p, tmp0, tmp0, get_element(t, 2));
593     brw_AND(p, brw_null_reg(), tmp0, brw_imm_ud(0x1));
594     brw_inst_set_cond_modifier(p->devinfo, brw_last_inst, BRW_CONDITIONAL_NZ);
595     brw_IF(p, BRW_EXECUTE_1);
596     {
597         brw_clip_kill_thread(c);
598     }
599     brw_ENDIF(p);
600     brw_set_default_predicate_control(p, BRW_PREDICATE_NONE);
601 
602     /* some vertices are inside a plane, some are outside,need to clip */
603     brw_XOR(p, t, t1, t2);
604     brw_XOR(p, t1, t2, t3);
605     brw_OR(p, t, t, t1);
606     brw_AND(p, t, t, brw_imm_ud(0x1));
607     brw_CMP(p, brw_null_reg(), BRW_CONDITIONAL_NZ,
608             get_element(t, 0), brw_imm_ud(0));
609     brw_OR(p, c->reg.planemask, c->reg.planemask, brw_imm_ud((1<<4)));
610     brw_inst_set_pred_control(p->devinfo, brw_last_inst, BRW_PREDICATE_NORMAL);
611     brw_CMP(p, brw_null_reg(), BRW_CONDITIONAL_NZ,
612             get_element(t, 1), brw_imm_ud(0));
613     brw_OR(p, c->reg.planemask, c->reg.planemask, brw_imm_ud((1<<2)));
614     brw_inst_set_pred_control(p->devinfo, brw_last_inst, BRW_PREDICATE_NORMAL);
615     brw_CMP(p, brw_null_reg(), BRW_CONDITIONAL_NZ,
616             get_element(t, 2), brw_imm_ud(0));
617     brw_OR(p, c->reg.planemask, c->reg.planemask, brw_imm_ud((1<<0)));
618     brw_inst_set_pred_control(p->devinfo, brw_last_inst, BRW_PREDICATE_NORMAL);
619 
620     release_tmps(c);
621 }
622 
623 
brw_emit_tri_clip(struct brw_clip_compile * c)624 void brw_emit_tri_clip( struct brw_clip_compile *c )
625 {
626    struct brw_codegen *p = &c->func;
627    brw_clip_tri_alloc_regs(c, 3 + c->key.nr_userclip + 6);
628    brw_clip_tri_init_vertices(c);
629    brw_clip_init_clipmask(c);
630    brw_clip_init_ff_sync(c);
631 
632    /* if -ve rhw workaround bit is set,
633       do cliptest */
634    if (p->devinfo->has_negative_rhw_bug) {
635       brw_AND(p, brw_null_reg(), get_element_ud(c->reg.R0, 2),
636               brw_imm_ud(1<<20));
637       brw_inst_set_cond_modifier(p->devinfo, brw_last_inst, BRW_CONDITIONAL_NZ);
638       brw_IF(p, BRW_EXECUTE_1);
639       {
640          brw_clip_test(c);
641       }
642       brw_ENDIF(p);
643    }
644    /* Can't push into do_clip_tri because with polygon (or quad)
645     * flatshading, need to apply the flatshade here because we don't
646     * respect the PV when converting to trifan for emit:
647     */
648    if (c->key.contains_flat_varying)
649       brw_clip_tri_flat_shade(c);
650 
651    if ((c->key.clip_mode == BRW_CLIP_MODE_NORMAL) ||
652        (c->key.clip_mode == BRW_CLIP_MODE_KERNEL_CLIP))
653       do_clip_tri(c);
654    else
655       maybe_do_clip_tri(c);
656 
657    brw_clip_tri_emit_polygon(c);
658 
659    /* Send an empty message to kill the thread:
660     */
661    brw_clip_kill_thread(c);
662 }
663