projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge remote branch 'origin/master' into radeon-rewrite
[mesa.git] / src / mesa / drivers / dri / i965 / brw_sf_emit.c
1 /*
2 Copyright (C) Intel Corp. 2006. All Rights Reserved.
3 Intel funded Tungsten Graphics (http://www.tungstengraphics.com) 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 <keith@tungstengraphics.com>
30 */
31
32
33 #include "main/glheader.h"
34 #include "main/macros.h"
35 #include "main/enums.h"
36
37 #include "intel_batchbuffer.h"
38
39 #include "brw_defines.h"
40 #include "brw_context.h"
41 #include "brw_eu.h"
42 #include "brw_util.h"
43 #include "brw_sf.h"
44
45
46 static struct brw_reg get_vert_attr(struct brw_sf_compile *c,
47 struct brw_reg vert,
48 GLuint attr)
49 {
50 GLuint off = c->attr_to_idx[attr] / 2;
51 GLuint sub = c->attr_to_idx[attr] % 2;
52
53 return brw_vec4_grf(vert.nr + off, sub * 4);
54 }
55
56 static GLboolean have_attr(struct brw_sf_compile *c,
57 GLuint attr)
58 {
59 return (c->key.attrs & (1<<attr)) ? 1 : 0;
60 }
61
62 /***********************************************************************
63 * Twoside lighting
64 */
65 static void copy_bfc( struct brw_sf_compile *c,
66 struct brw_reg vert )
67 {
68 struct brw_compile *p = &c->func;
69 GLuint i;
70
71 for (i = 0; i < 2; i++) {
72 if (have_attr(c, VERT_RESULT_COL0+i) &&
73 have_attr(c, VERT_RESULT_BFC0+i))
74 brw_MOV(p,
75 get_vert_attr(c, vert, VERT_RESULT_COL0+i),
76 get_vert_attr(c, vert, VERT_RESULT_BFC0+i));
77 }
78 }
79
80
81 static void do_twoside_color( struct brw_sf_compile *c )
82 {
83 struct brw_compile *p = &c->func;
84 struct brw_instruction *if_insn;
85 GLuint backface_conditional = c->key.frontface_ccw ? BRW_CONDITIONAL_G : BRW_CONDITIONAL_L;
86
87 /* Already done in clip program:
88 */
89 if (c->key.primitive == SF_UNFILLED_TRIS)
90 return;
91
92 /* XXX: What happens if BFC isn't present? This could only happen
93 * for user-supplied vertex programs, as t_vp_build.c always does
94 * the right thing.
95 */
96 if (!(have_attr(c, VERT_RESULT_COL0) && have_attr(c, VERT_RESULT_BFC0)) &&
97 !(have_attr(c, VERT_RESULT_COL1) && have_attr(c, VERT_RESULT_BFC1)))
98 return;
99
100 /* Need to use BRW_EXECUTE_4 and also do an 4-wide compare in order
101 * to get all channels active inside the IF. In the clipping code
102 * we run with NoMask, so it's not an option and we can use
103 * BRW_EXECUTE_1 for all comparisions.
104 */
105 brw_push_insn_state(p);
106 brw_CMP(p, vec4(brw_null_reg()), backface_conditional, c->det, brw_imm_f(0));
107 if_insn = brw_IF(p, BRW_EXECUTE_4);
108 {
109 switch (c->nr_verts) {
110 case 3: copy_bfc(c, c->vert[2]);
111 case 2: copy_bfc(c, c->vert[1]);
112 case 1: copy_bfc(c, c->vert[0]);
113 }
114 }
115 brw_ENDIF(p, if_insn);
116 brw_pop_insn_state(p);
117 }
118
119
120
121 /***********************************************************************
122 * Flat shading
123 */
124
125 #define VERT_RESULT_COLOR_BITS ((1<<VERT_RESULT_COL0) | \
126 (1<<VERT_RESULT_COL1))
127
128 static void copy_colors( struct brw_sf_compile *c,
129 struct brw_reg dst,
130 struct brw_reg src)
131 {
132 struct brw_compile *p = &c->func;
133 GLuint i;
134
135 for (i = VERT_RESULT_COL0; i <= VERT_RESULT_COL1; i++) {
136 if (have_attr(c,i))
137 brw_MOV(p,
138 get_vert_attr(c, dst, i),
139 get_vert_attr(c, src, i));
140 }
141 }
142
143
144
145 /* Need to use a computed jump to copy flatshaded attributes as the
146 * vertices are ordered according to y-coordinate before reaching this
147 * point, so the PV could be anywhere.
148 */
149 static void do_flatshade_triangle( struct brw_sf_compile *c )
150 {
151 struct brw_compile *p = &c->func;
152 struct brw_reg ip = brw_ip_reg();
153 GLuint nr = brw_count_bits(c->key.attrs & VERT_RESULT_COLOR_BITS);
154 if (!nr)
155 return;
156
157 /* Already done in clip program:
158 */
159 if (c->key.primitive == SF_UNFILLED_TRIS)
160 return;
161
162 brw_push_insn_state(p);
163
164 brw_MUL(p, c->pv, c->pv, brw_imm_ud(nr*2+1));
165 brw_JMPI(p, ip, ip, c->pv);
166
167 copy_colors(c, c->vert[1], c->vert[0]);
168 copy_colors(c, c->vert[2], c->vert[0]);
169 brw_JMPI(p, ip, ip, brw_imm_ud(nr*4+1));
170
171 copy_colors(c, c->vert[0], c->vert[1]);
172 copy_colors(c, c->vert[2], c->vert[1]);
173 brw_JMPI(p, ip, ip, brw_imm_ud(nr*2));
174
175 copy_colors(c, c->vert[0], c->vert[2]);
176 copy_colors(c, c->vert[1], c->vert[2]);
177
178 brw_pop_insn_state(p);
179 }
180
181
182 static void do_flatshade_line( struct brw_sf_compile *c )
183 {
184 struct brw_compile *p = &c->func;
185 struct brw_reg ip = brw_ip_reg();
186 GLuint nr = brw_count_bits(c->key.attrs & VERT_RESULT_COLOR_BITS);
187
188 if (!nr)
189 return;
190
191 /* Already done in clip program:
192 */
193 if (c->key.primitive == SF_UNFILLED_TRIS)
194 return;
195
196 brw_push_insn_state(p);
197
198 brw_MUL(p, c->pv, c->pv, brw_imm_ud(nr+1));
199 brw_JMPI(p, ip, ip, c->pv);
200 copy_colors(c, c->vert[1], c->vert[0]);
201
202 brw_JMPI(p, ip, ip, brw_imm_ud(nr));
203 copy_colors(c, c->vert[0], c->vert[1]);
204
205 brw_pop_insn_state(p);
206 }
207
208
209
210 /***********************************************************************
211 * Triangle setup.
212 */
213
214
215 static void alloc_regs( struct brw_sf_compile *c )
216 {
217 GLuint reg, i;
218
219 /* Values computed by fixed function unit:
220 */
221 c->pv = retype(brw_vec1_grf(1, 1), BRW_REGISTER_TYPE_UD);
222 c->det = brw_vec1_grf(1, 2);
223 c->dx0 = brw_vec1_grf(1, 3);
224 c->dx2 = brw_vec1_grf(1, 4);
225 c->dy0 = brw_vec1_grf(1, 5);
226 c->dy2 = brw_vec1_grf(1, 6);
227
228 /* z and 1/w passed in seperately:
229 */
230 c->z[0] = brw_vec1_grf(2, 0);
231 c->inv_w[0] = brw_vec1_grf(2, 1);
232 c->z[1] = brw_vec1_grf(2, 2);
233 c->inv_w[1] = brw_vec1_grf(2, 3);
234 c->z[2] = brw_vec1_grf(2, 4);
235 c->inv_w[2] = brw_vec1_grf(2, 5);
236
237 /* The vertices:
238 */
239 reg = 3;
240 for (i = 0; i < c->nr_verts; i++) {
241 c->vert[i] = brw_vec8_grf(reg, 0);
242 reg += c->nr_attr_regs;
243 }
244
245 /* Temporaries, allocated after last vertex reg.
246 */
247 c->inv_det = brw_vec1_grf(reg, 0); reg++;
248 c->a1_sub_a0 = brw_vec8_grf(reg, 0); reg++;
249 c->a2_sub_a0 = brw_vec8_grf(reg, 0); reg++;
250 c->tmp = brw_vec8_grf(reg, 0); reg++;
251
252 /* Note grf allocation:
253 */
254 c->prog_data.total_grf = reg;
255
256
257 /* Outputs of this program - interpolation coefficients for
258 * rasterization:
259 */
260 c->m1Cx = brw_vec8_reg(BRW_MESSAGE_REGISTER_FILE, 1, 0);
261 c->m2Cy = brw_vec8_reg(BRW_MESSAGE_REGISTER_FILE, 2, 0);
262 c->m3C0 = brw_vec8_reg(BRW_MESSAGE_REGISTER_FILE, 3, 0);
263 }
264
265
266 static void copy_z_inv_w( struct brw_sf_compile *c )
267 {
268 struct brw_compile *p = &c->func;
269 GLuint i;
270
271 brw_push_insn_state(p);
272
273 /* Copy both scalars with a single MOV:
274 */
275 for (i = 0; i < c->nr_verts; i++)
276 brw_MOV(p, vec2(suboffset(c->vert[i], 2)), vec2(c->z[i]));
277
278 brw_pop_insn_state(p);
279 }
280
281
282 static void invert_det( struct brw_sf_compile *c)
283 {
284 /* Looks like we invert all 8 elements just to get 1/det in
285 * position 2 !?!
286 */
287 brw_math(&c->func,
288 c->inv_det,
289 BRW_MATH_FUNCTION_INV,
290 BRW_MATH_SATURATE_NONE,
291 0,
292 c->det,
293 BRW_MATH_DATA_SCALAR,
294 BRW_MATH_PRECISION_FULL);
295
296 }
297
298 #define NON_PERPECTIVE_ATTRS (FRAG_BIT_WPOS | \
299 FRAG_BIT_COL0 | \
300 FRAG_BIT_COL1)
301
302 static GLboolean calculate_masks( struct brw_sf_compile *c,
303 GLuint reg,
304 GLushort *pc,
305 GLushort *pc_persp,
306 GLushort *pc_linear)
307 {
308 GLboolean is_last_attr = (reg == c->nr_setup_regs - 1);
309 GLuint persp_mask = c->key.attrs & ~NON_PERPECTIVE_ATTRS;
310 GLuint linear_mask;
311
312 if (c->key.do_flat_shading)
313 linear_mask = c->key.attrs & ~(FRAG_BIT_COL0|FRAG_BIT_COL1);
314 else
315 linear_mask = c->key.attrs;
316
317 *pc_persp = 0;
318 *pc_linear = 0;
319 *pc = 0xf;
320
321 if (persp_mask & (1 << c->idx_to_attr[reg*2]))
322 *pc_persp = 0xf;
323
324 if (linear_mask & (1 << c->idx_to_attr[reg*2]))
325 *pc_linear = 0xf;
326
327 /* Maybe only processs one attribute on the final round:
328 */
329 if (reg*2+1 < c->nr_setup_attrs) {
330 *pc |= 0xf0;
331
332 if (persp_mask & (1 << c->idx_to_attr[reg*2+1]))
333 *pc_persp |= 0xf0;
334
335 if (linear_mask & (1 << c->idx_to_attr[reg*2+1]))
336 *pc_linear |= 0xf0;
337 }
338
339 return is_last_attr;
340 }
341
342
343
344 void brw_emit_tri_setup( struct brw_sf_compile *c, GLboolean allocate)
345 {
346 struct brw_compile *p = &c->func;
347 GLuint i;
348
349 c->nr_verts = 3;
350
351 if (allocate)
352 alloc_regs(c);
353
354 invert_det(c);
355 copy_z_inv_w(c);
356
357 if (c->key.do_twoside_color)
358 do_twoside_color(c);
359
360 if (c->key.do_flat_shading)
361 do_flatshade_triangle(c);
362
363
364 for (i = 0; i < c->nr_setup_regs; i++)
365 {
366 /* Pair of incoming attributes:
367 */
368 struct brw_reg a0 = offset(c->vert[0], i);
369 struct brw_reg a1 = offset(c->vert[1], i);
370 struct brw_reg a2 = offset(c->vert[2], i);
371 GLushort pc, pc_persp, pc_linear;
372 GLboolean last = calculate_masks(c, i, &pc, &pc_persp, &pc_linear);
373
374 if (pc_persp)
375 {
376 brw_set_predicate_control_flag_value(p, pc_persp);
377 brw_MUL(p, a0, a0, c->inv_w[0]);
378 brw_MUL(p, a1, a1, c->inv_w[1]);
379 brw_MUL(p, a2, a2, c->inv_w[2]);
380 }
381
382
383 /* Calculate coefficients for interpolated values:
384 */
385 if (pc_linear)
386 {
387 brw_set_predicate_control_flag_value(p, pc_linear);
388
389 brw_ADD(p, c->a1_sub_a0, a1, negate(a0));
390 brw_ADD(p, c->a2_sub_a0, a2, negate(a0));
391
392 /* calculate dA/dx
393 */
394 brw_MUL(p, brw_null_reg(), c->a1_sub_a0, c->dy2);
395 brw_MAC(p, c->tmp, c->a2_sub_a0, negate(c->dy0));
396 brw_MUL(p, c->m1Cx, c->tmp, c->inv_det);
397
398 /* calculate dA/dy
399 */
400 brw_MUL(p, brw_null_reg(), c->a2_sub_a0, c->dx0);
401 brw_MAC(p, c->tmp, c->a1_sub_a0, negate(c->dx2));
402 brw_MUL(p, c->m2Cy, c->tmp, c->inv_det);
403 }
404
405 {
406 brw_set_predicate_control_flag_value(p, pc);
407 /* start point for interpolation
408 */
409 brw_MOV(p, c->m3C0, a0);
410
411 /* Copy m0..m3 to URB. m0 is implicitly copied from r0 in
412 * the send instruction:
413 */
414 brw_urb_WRITE(p,
415 brw_null_reg(),
416 0,
417 brw_vec8_grf(0, 0), /* r0, will be copied to m0 */
418 0, /* allocate */
419 1, /* used */
420 4, /* msg len */
421 0, /* response len */
422 last, /* eot */
423 last, /* writes complete */
424 i*4, /* offset */
425 BRW_URB_SWIZZLE_TRANSPOSE); /* XXX: Swizzle control "SF to windower" */
426 }
427 }
428 }
429
430
431
432 void brw_emit_line_setup( struct brw_sf_compile *c, GLboolean allocate)
433 {
434 struct brw_compile *p = &c->func;
435 GLuint i;
436
437
438 c->nr_verts = 2;
439
440 if (allocate)
441 alloc_regs(c);
442
443 invert_det(c);
444 copy_z_inv_w(c);
445
446 if (c->key.do_flat_shading)
447 do_flatshade_line(c);
448
449 for (i = 0; i < c->nr_setup_regs; i++)
450 {
451 /* Pair of incoming attributes:
452 */
453 struct brw_reg a0 = offset(c->vert[0], i);
454 struct brw_reg a1 = offset(c->vert[1], i);
455 GLushort pc, pc_persp, pc_linear;
456 GLboolean last = calculate_masks(c, i, &pc, &pc_persp, &pc_linear);
457
458 if (pc_persp)
459 {
460 brw_set_predicate_control_flag_value(p, pc_persp);
461 brw_MUL(p, a0, a0, c->inv_w[0]);
462 brw_MUL(p, a1, a1, c->inv_w[1]);
463 }
464
465 /* Calculate coefficients for position, color:
466 */
467 if (pc_linear) {
468 brw_set_predicate_control_flag_value(p, pc_linear);
469
470 brw_ADD(p, c->a1_sub_a0, a1, negate(a0));
471
472 brw_MUL(p, c->tmp, c->a1_sub_a0, c->dx0);
473 brw_MUL(p, c->m1Cx, c->tmp, c->inv_det);
474
475 brw_MUL(p, c->tmp, c->a1_sub_a0, c->dy0);
476 brw_MUL(p, c->m2Cy, c->tmp, c->inv_det);
477 }
478
479 {
480 brw_set_predicate_control_flag_value(p, pc);
481
482 /* start point for interpolation
483 */
484 brw_MOV(p, c->m3C0, a0);
485
486 /* Copy m0..m3 to URB.
487 */
488 brw_urb_WRITE(p,
489 brw_null_reg(),
490 0,
491 brw_vec8_grf(0, 0),
492 0, /* allocate */
493 1, /* used */
494 4, /* msg len */
495 0, /* response len */
496 last, /* eot */
497 last, /* writes complete */
498 i*4, /* urb destination offset */
499 BRW_URB_SWIZZLE_TRANSPOSE);
500 }
501 }
502 }
503
504 void brw_emit_point_sprite_setup( struct brw_sf_compile *c, GLboolean allocate)
505 {
506 struct brw_compile *p = &c->func;
507 GLuint i;
508
509 c->nr_verts = 1;
510
511 if (allocate)
512 alloc_regs(c);
513
514 copy_z_inv_w(c);
515 for (i = 0; i < c->nr_setup_regs; i++)
516 {
517 struct brw_sf_point_tex *tex = &c->point_attrs[c->idx_to_attr[2*i]];
518 struct brw_reg a0 = offset(c->vert[0], i);
519 GLushort pc, pc_persp, pc_linear;
520 GLboolean last = calculate_masks(c, i, &pc, &pc_persp, &pc_linear);
521
522 if (pc_persp)
523 {
524 if (!tex->CoordReplace) {
525 brw_set_predicate_control_flag_value(p, pc_persp);
526 brw_MUL(p, a0, a0, c->inv_w[0]);
527 }
528 }
529
530 if (tex->CoordReplace) {
531 /* Caculate 1.0/PointWidth */
532 brw_math(&c->func,
533 c->tmp,
534 BRW_MATH_FUNCTION_INV,
535 BRW_MATH_SATURATE_NONE,
536 0,
537 c->dx0,
538 BRW_MATH_DATA_SCALAR,
539 BRW_MATH_PRECISION_FULL);
540
541 if (c->key.SpriteOrigin == GL_LOWER_LEFT) {
542 brw_MUL(p, c->m1Cx, c->tmp, c->inv_w[0]);
543 brw_MOV(p, vec1(suboffset(c->m1Cx, 1)), brw_imm_f(0.0));
544 brw_MUL(p, c->m2Cy, c->tmp, negate(c->inv_w[0]));
545 brw_MOV(p, vec1(suboffset(c->m2Cy, 0)), brw_imm_f(0.0));
546 } else {
547 brw_MUL(p, c->m1Cx, c->tmp, c->inv_w[0]);
548 brw_MOV(p, vec1(suboffset(c->m1Cx, 1)), brw_imm_f(0.0));
549 brw_MUL(p, c->m2Cy, c->tmp, c->inv_w[0]);
550 brw_MOV(p, vec1(suboffset(c->m2Cy, 0)), brw_imm_f(0.0));
551 }
552 } else {
553 brw_MOV(p, c->m1Cx, brw_imm_ud(0));
554 brw_MOV(p, c->m2Cy, brw_imm_ud(0));
555 }
556
557 {
558 brw_set_predicate_control_flag_value(p, pc);
559 if (tex->CoordReplace) {
560 if (c->key.SpriteOrigin == GL_LOWER_LEFT) {
561 brw_MUL(p, c->m3C0, c->inv_w[0], brw_imm_f(1.0));
562 brw_MOV(p, vec1(suboffset(c->m3C0, 0)), brw_imm_f(0.0));
563 }
564 else
565 brw_MOV(p, c->m3C0, brw_imm_f(0.0));
566 } else {
567 brw_MOV(p, c->m3C0, a0); /* constant value */
568 }
569
570 /* Copy m0..m3 to URB.
571 */
572 brw_urb_WRITE(p,
573 brw_null_reg(),
574 0,
575 brw_vec8_grf(0, 0),
576 0, /* allocate */
577 1, /* used */
578 4, /* msg len */
579 0, /* response len */
580 last, /* eot */
581 last, /* writes complete */
582 i*4, /* urb destination offset */
583 BRW_URB_SWIZZLE_TRANSPOSE);
584 }
585 }
586 }
587
588 /* Points setup - several simplifications as all attributes are
589 * constant across the face of the point (point sprites excluded!)
590 */
591 void brw_emit_point_setup( struct brw_sf_compile *c, GLboolean allocate)
592 {
593 struct brw_compile *p = &c->func;
594 GLuint i;
595
596 c->nr_verts = 1;
597
598 if (allocate)
599 alloc_regs(c);
600
601 copy_z_inv_w(c);
602
603 brw_MOV(p, c->m1Cx, brw_imm_ud(0)); /* zero - move out of loop */
604 brw_MOV(p, c->m2Cy, brw_imm_ud(0)); /* zero - move out of loop */
605
606 for (i = 0; i < c->nr_setup_regs; i++)
607 {
608 struct brw_reg a0 = offset(c->vert[0], i);
609 GLushort pc, pc_persp, pc_linear;
610 GLboolean last = calculate_masks(c, i, &pc, &pc_persp, &pc_linear);
611
612 if (pc_persp)
613 {
614 /* This seems odd as the values are all constant, but the
615 * fragment shader will be expecting it:
616 */
617 brw_set_predicate_control_flag_value(p, pc_persp);
618 brw_MUL(p, a0, a0, c->inv_w[0]);
619 }
620
621
622 /* The delta values are always zero, just send the starting
623 * coordinate. Again, this is to fit in with the interpolation
624 * code in the fragment shader.
625 */
626 {
627 brw_set_predicate_control_flag_value(p, pc);
628
629 brw_MOV(p, c->m3C0, a0); /* constant value */
630
631 /* Copy m0..m3 to URB.
632 */
633 brw_urb_WRITE(p,
634 brw_null_reg(),
635 0,
636 brw_vec8_grf(0, 0),
637 0, /* allocate */
638 1, /* used */
639 4, /* msg len */
640 0, /* response len */
641 last, /* eot */
642 last, /* writes complete */
643 i*4, /* urb destination offset */
644 BRW_URB_SWIZZLE_TRANSPOSE);
645 }
646 }
647 }
648
649 void brw_emit_anyprim_setup( struct brw_sf_compile *c )
650 {
651 struct brw_compile *p = &c->func;
652 struct brw_reg ip = brw_ip_reg();
653 struct brw_reg payload_prim = brw_uw1_reg(BRW_GENERAL_REGISTER_FILE, 1, 0);
654 struct brw_reg payload_attr = get_element_ud(brw_vec1_reg(BRW_GENERAL_REGISTER_FILE, 1, 0), 0);
655 struct brw_reg primmask;
656 struct brw_instruction *jmp;
657 struct brw_reg v1_null_ud = vec1(retype(brw_null_reg(), BRW_REGISTER_TYPE_UD));
658
659 GLuint saveflag;
660
661 c->nr_verts = 3;
662 alloc_regs(c);
663
664 primmask = retype(get_element(c->tmp, 0), BRW_REGISTER_TYPE_UD);
665
666 brw_MOV(p, primmask, brw_imm_ud(1));
667 brw_SHL(p, primmask, primmask, payload_prim);
668
669 brw_set_conditionalmod(p, BRW_CONDITIONAL_Z);
670 brw_AND(p, v1_null_ud, primmask, brw_imm_ud((1<<_3DPRIM_TRILIST) |
671 (1<<_3DPRIM_TRISTRIP) |
672 (1<<_3DPRIM_TRIFAN) |
673 (1<<_3DPRIM_TRISTRIP_REVERSE) |
674 (1<<_3DPRIM_POLYGON) |
675 (1<<_3DPRIM_RECTLIST) |
676 (1<<_3DPRIM_TRIFAN_NOSTIPPLE)));
677 jmp = brw_JMPI(p, ip, ip, brw_imm_w(0));
678 {
679 saveflag = p->flag_value;
680 brw_push_insn_state(p);
681 brw_emit_tri_setup( c, GL_FALSE );
682 brw_pop_insn_state(p);
683 p->flag_value = saveflag;
684 /* note - thread killed in subroutine, so must
685 * restore the flag which is changed when building
686 * the subroutine. fix #13240
687 */
688 }
689 brw_land_fwd_jump(p, jmp);
690
691 brw_set_conditionalmod(p, BRW_CONDITIONAL_Z);
692 brw_AND(p, v1_null_ud, primmask, brw_imm_ud((1<<_3DPRIM_LINELIST) |
693 (1<<_3DPRIM_LINESTRIP) |
694 (1<<_3DPRIM_LINELOOP) |
695 (1<<_3DPRIM_LINESTRIP_CONT) |
696 (1<<_3DPRIM_LINESTRIP_BF) |
697 (1<<_3DPRIM_LINESTRIP_CONT_BF)));
698 jmp = brw_JMPI(p, ip, ip, brw_imm_w(0));
699 {
700 saveflag = p->flag_value;
701 brw_push_insn_state(p);
702 brw_emit_line_setup( c, GL_FALSE );
703 brw_pop_insn_state(p);
704 p->flag_value = saveflag;
705 /* note - thread killed in subroutine */
706 }
707 brw_land_fwd_jump(p, jmp);
708
709 brw_set_conditionalmod(p, BRW_CONDITIONAL_Z);
710 brw_AND(p, v1_null_ud, payload_attr, brw_imm_ud(1<<BRW_SPRITE_POINT_ENABLE));
711 jmp = brw_JMPI(p, ip, ip, brw_imm_w(0));
712 {
713 saveflag = p->flag_value;
714 brw_push_insn_state(p);
715 brw_emit_point_sprite_setup( c, GL_FALSE );
716 brw_pop_insn_state(p);
717 p->flag_value = saveflag;
718 }
719 brw_land_fwd_jump(p, jmp);
720
721 brw_emit_point_setup( c, GL_FALSE );
722 }
723
724
725
726