projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
dri: drop MINIGLX_SOURCES (2)
[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 & BITFIELD64_BIT(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 (BITFIELD64_BIT(VERT_RESULT_COL0) | \
126 BITFIELD64_BIT(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 intel_context *intel = &p->brw->intel;
153 struct brw_reg ip = brw_ip_reg();
154 GLuint nr = brw_count_bits(c->key.attrs & VERT_RESULT_COLOR_BITS);
155 GLuint jmpi = 1;
156
157 if (!nr)
158 return;
159
160 /* Already done in clip program:
161 */
162 if (c->key.primitive == SF_UNFILLED_TRIS)
163 return;
164
165 if (intel->is_ironlake)
166 jmpi = 2;
167
168 brw_push_insn_state(p);
169
170 brw_MUL(p, c->pv, c->pv, brw_imm_d(jmpi*(nr*2+1)));
171 brw_JMPI(p, ip, ip, c->pv);
172
173 copy_colors(c, c->vert[1], c->vert[0]);
174 copy_colors(c, c->vert[2], c->vert[0]);
175 brw_JMPI(p, ip, ip, brw_imm_d(jmpi*(nr*4+1)));
176
177 copy_colors(c, c->vert[0], c->vert[1]);
178 copy_colors(c, c->vert[2], c->vert[1]);
179 brw_JMPI(p, ip, ip, brw_imm_d(jmpi*nr*2));
180
181 copy_colors(c, c->vert[0], c->vert[2]);
182 copy_colors(c, c->vert[1], c->vert[2]);
183
184 brw_pop_insn_state(p);
185 }
186
187
188 static void do_flatshade_line( struct brw_sf_compile *c )
189 {
190 struct brw_compile *p = &c->func;
191 struct intel_context *intel = &p->brw->intel;
192 struct brw_reg ip = brw_ip_reg();
193 GLuint nr = brw_count_bits(c->key.attrs & VERT_RESULT_COLOR_BITS);
194 GLuint jmpi = 1;
195
196 if (!nr)
197 return;
198
199 /* Already done in clip program:
200 */
201 if (c->key.primitive == SF_UNFILLED_TRIS)
202 return;
203
204 if (intel->is_ironlake)
205 jmpi = 2;
206
207 brw_push_insn_state(p);
208
209 brw_MUL(p, c->pv, c->pv, brw_imm_d(jmpi*(nr+1)));
210 brw_JMPI(p, ip, ip, c->pv);
211 copy_colors(c, c->vert[1], c->vert[0]);
212
213 brw_JMPI(p, ip, ip, brw_imm_ud(jmpi*nr));
214 copy_colors(c, c->vert[0], c->vert[1]);
215
216 brw_pop_insn_state(p);
217 }
218
219
220
221 /***********************************************************************
222 * Triangle setup.
223 */
224
225
226 static void alloc_regs( struct brw_sf_compile *c )
227 {
228 GLuint reg, i;
229
230 /* Values computed by fixed function unit:
231 */
232 c->pv = retype(brw_vec1_grf(1, 1), BRW_REGISTER_TYPE_D);
233 c->det = brw_vec1_grf(1, 2);
234 c->dx0 = brw_vec1_grf(1, 3);
235 c->dx2 = brw_vec1_grf(1, 4);
236 c->dy0 = brw_vec1_grf(1, 5);
237 c->dy2 = brw_vec1_grf(1, 6);
238
239 /* z and 1/w passed in seperately:
240 */
241 c->z[0] = brw_vec1_grf(2, 0);
242 c->inv_w[0] = brw_vec1_grf(2, 1);
243 c->z[1] = brw_vec1_grf(2, 2);
244 c->inv_w[1] = brw_vec1_grf(2, 3);
245 c->z[2] = brw_vec1_grf(2, 4);
246 c->inv_w[2] = brw_vec1_grf(2, 5);
247
248 /* The vertices:
249 */
250 reg = 3;
251 for (i = 0; i < c->nr_verts; i++) {
252 c->vert[i] = brw_vec8_grf(reg, 0);
253 reg += c->nr_attr_regs;
254 }
255
256 /* Temporaries, allocated after last vertex reg.
257 */
258 c->inv_det = brw_vec1_grf(reg, 0); reg++;
259 c->a1_sub_a0 = brw_vec8_grf(reg, 0); reg++;
260 c->a2_sub_a0 = brw_vec8_grf(reg, 0); reg++;
261 c->tmp = brw_vec8_grf(reg, 0); reg++;
262
263 /* Note grf allocation:
264 */
265 c->prog_data.total_grf = reg;
266
267
268 /* Outputs of this program - interpolation coefficients for
269 * rasterization:
270 */
271 c->m1Cx = brw_vec8_reg(BRW_MESSAGE_REGISTER_FILE, 1, 0);
272 c->m2Cy = brw_vec8_reg(BRW_MESSAGE_REGISTER_FILE, 2, 0);
273 c->m3C0 = brw_vec8_reg(BRW_MESSAGE_REGISTER_FILE, 3, 0);
274 }
275
276
277 static void copy_z_inv_w( struct brw_sf_compile *c )
278 {
279 struct brw_compile *p = &c->func;
280 GLuint i;
281
282 brw_push_insn_state(p);
283
284 /* Copy both scalars with a single MOV:
285 */
286 for (i = 0; i < c->nr_verts; i++)
287 brw_MOV(p, vec2(suboffset(c->vert[i], 2)), vec2(c->z[i]));
288
289 brw_pop_insn_state(p);
290 }
291
292
293 static void invert_det( struct brw_sf_compile *c)
294 {
295 /* Looks like we invert all 8 elements just to get 1/det in
296 * position 2 !?!
297 */
298 brw_math(&c->func,
299 c->inv_det,
300 BRW_MATH_FUNCTION_INV,
301 BRW_MATH_SATURATE_NONE,
302 0,
303 c->det,
304 BRW_MATH_DATA_SCALAR,
305 BRW_MATH_PRECISION_FULL);
306
307 }
308
309
310 static GLboolean calculate_masks( struct brw_sf_compile *c,
311 GLuint reg,
312 GLushort *pc,
313 GLushort *pc_persp,
314 GLushort *pc_linear)
315 {
316 GLboolean is_last_attr = (reg == c->nr_setup_regs - 1);
317 GLbitfield64 persp_mask;
318 GLbitfield64 linear_mask;
319
320 if (c->key.do_flat_shading || c->key.linear_color)
321 persp_mask = c->key.attrs & ~(FRAG_BIT_WPOS |
322 FRAG_BIT_COL0 |
323 FRAG_BIT_COL1);
324 else
325 persp_mask = c->key.attrs & ~(FRAG_BIT_WPOS);
326
327 if (c->key.do_flat_shading)
328 linear_mask = c->key.attrs & ~(FRAG_BIT_COL0|FRAG_BIT_COL1);
329 else
330 linear_mask = c->key.attrs;
331
332 *pc_persp = 0;
333 *pc_linear = 0;
334 *pc = 0xf;
335
336 if (persp_mask & BITFIELD64_BIT(c->idx_to_attr[reg*2]))
337 *pc_persp = 0xf;
338
339 if (linear_mask & BITFIELD64_BIT(c->idx_to_attr[reg*2]))
340 *pc_linear = 0xf;
341
342 /* Maybe only processs one attribute on the final round:
343 */
344 if (reg*2+1 < c->nr_setup_attrs) {
345 *pc |= 0xf0;
346
347 if (persp_mask & BITFIELD64_BIT(c->idx_to_attr[reg*2+1]))
348 *pc_persp |= 0xf0;
349
350 if (linear_mask & BITFIELD64_BIT(c->idx_to_attr[reg*2+1]))
351 *pc_linear |= 0xf0;
352 }
353
354 return is_last_attr;
355 }
356
357
358
359 void brw_emit_tri_setup( struct brw_sf_compile *c, GLboolean allocate)
360 {
361 struct brw_compile *p = &c->func;
362 GLuint i;
363
364 c->nr_verts = 3;
365
366 if (allocate)
367 alloc_regs(c);
368
369 invert_det(c);
370 copy_z_inv_w(c);
371
372 if (c->key.do_twoside_color)
373 do_twoside_color(c);
374
375 if (c->key.do_flat_shading)
376 do_flatshade_triangle(c);
377
378
379 for (i = 0; i < c->nr_setup_regs; i++)
380 {
381 /* Pair of incoming attributes:
382 */
383 struct brw_reg a0 = offset(c->vert[0], i);
384 struct brw_reg a1 = offset(c->vert[1], i);
385 struct brw_reg a2 = offset(c->vert[2], i);
386 GLushort pc, pc_persp, pc_linear;
387 GLboolean last = calculate_masks(c, i, &pc, &pc_persp, &pc_linear);
388
389 if (pc_persp)
390 {
391 brw_set_predicate_control_flag_value(p, pc_persp);
392 brw_MUL(p, a0, a0, c->inv_w[0]);
393 brw_MUL(p, a1, a1, c->inv_w[1]);
394 brw_MUL(p, a2, a2, c->inv_w[2]);
395 }
396
397
398 /* Calculate coefficients for interpolated values:
399 */
400 if (pc_linear)
401 {
402 brw_set_predicate_control_flag_value(p, pc_linear);
403
404 brw_ADD(p, c->a1_sub_a0, a1, negate(a0));
405 brw_ADD(p, c->a2_sub_a0, a2, negate(a0));
406
407 /* calculate dA/dx
408 */
409 brw_MUL(p, brw_null_reg(), c->a1_sub_a0, c->dy2);
410 brw_MAC(p, c->tmp, c->a2_sub_a0, negate(c->dy0));
411 brw_MUL(p, c->m1Cx, c->tmp, c->inv_det);
412
413 /* calculate dA/dy
414 */
415 brw_MUL(p, brw_null_reg(), c->a2_sub_a0, c->dx0);
416 brw_MAC(p, c->tmp, c->a1_sub_a0, negate(c->dx2));
417 brw_MUL(p, c->m2Cy, c->tmp, c->inv_det);
418 }
419
420 {
421 brw_set_predicate_control_flag_value(p, pc);
422 /* start point for interpolation
423 */
424 brw_MOV(p, c->m3C0, a0);
425
426 /* Copy m0..m3 to URB. m0 is implicitly copied from r0 in
427 * the send instruction:
428 */
429 brw_urb_WRITE(p,
430 brw_null_reg(),
431 0,
432 brw_vec8_grf(0, 0), /* r0, will be copied to m0 */
433 0, /* allocate */
434 1, /* used */
435 4, /* msg len */
436 0, /* response len */
437 last, /* eot */
438 last, /* writes complete */
439 i*4, /* offset */
440 BRW_URB_SWIZZLE_TRANSPOSE); /* XXX: Swizzle control "SF to windower" */
441 }
442 }
443 }
444
445
446
447 void brw_emit_line_setup( struct brw_sf_compile *c, GLboolean allocate)
448 {
449 struct brw_compile *p = &c->func;
450 GLuint i;
451
452
453 c->nr_verts = 2;
454
455 if (allocate)
456 alloc_regs(c);
457
458 invert_det(c);
459 copy_z_inv_w(c);
460
461 if (c->key.do_flat_shading)
462 do_flatshade_line(c);
463
464 for (i = 0; i < c->nr_setup_regs; i++)
465 {
466 /* Pair of incoming attributes:
467 */
468 struct brw_reg a0 = offset(c->vert[0], i);
469 struct brw_reg a1 = offset(c->vert[1], i);
470 GLushort pc, pc_persp, pc_linear;
471 GLboolean last = calculate_masks(c, i, &pc, &pc_persp, &pc_linear);
472
473 if (pc_persp)
474 {
475 brw_set_predicate_control_flag_value(p, pc_persp);
476 brw_MUL(p, a0, a0, c->inv_w[0]);
477 brw_MUL(p, a1, a1, c->inv_w[1]);
478 }
479
480 /* Calculate coefficients for position, color:
481 */
482 if (pc_linear) {
483 brw_set_predicate_control_flag_value(p, pc_linear);
484
485 brw_ADD(p, c->a1_sub_a0, a1, negate(a0));
486
487 brw_MUL(p, c->tmp, c->a1_sub_a0, c->dx0);
488 brw_MUL(p, c->m1Cx, c->tmp, c->inv_det);
489
490 brw_MUL(p, c->tmp, c->a1_sub_a0, c->dy0);
491 brw_MUL(p, c->m2Cy, c->tmp, c->inv_det);
492 }
493
494 {
495 brw_set_predicate_control_flag_value(p, pc);
496
497 /* start point for interpolation
498 */
499 brw_MOV(p, c->m3C0, a0);
500
501 /* Copy m0..m3 to URB.
502 */
503 brw_urb_WRITE(p,
504 brw_null_reg(),
505 0,
506 brw_vec8_grf(0, 0),
507 0, /* allocate */
508 1, /* used */
509 4, /* msg len */
510 0, /* response len */
511 last, /* eot */
512 last, /* writes complete */
513 i*4, /* urb destination offset */
514 BRW_URB_SWIZZLE_TRANSPOSE);
515 }
516 }
517 }
518
519 void brw_emit_point_sprite_setup( struct brw_sf_compile *c, GLboolean allocate)
520 {
521 struct brw_compile *p = &c->func;
522 GLuint i;
523
524 c->nr_verts = 1;
525
526 if (allocate)
527 alloc_regs(c);
528
529 copy_z_inv_w(c);
530 for (i = 0; i < c->nr_setup_regs; i++)
531 {
532 struct brw_sf_point_tex *tex = &c->point_attrs[c->idx_to_attr[2*i]];
533 struct brw_reg a0 = offset(c->vert[0], i);
534 GLushort pc, pc_persp, pc_linear;
535 GLboolean last = calculate_masks(c, i, &pc, &pc_persp, &pc_linear);
536
537 if (pc_persp)
538 {
539 if (!tex->CoordReplace) {
540 brw_set_predicate_control_flag_value(p, pc_persp);
541 brw_MUL(p, a0, a0, c->inv_w[0]);
542 }
543 }
544
545 if (tex->CoordReplace) {
546 /* Caculate 1.0/PointWidth */
547 brw_math(&c->func,
548 c->tmp,
549 BRW_MATH_FUNCTION_INV,
550 BRW_MATH_SATURATE_NONE,
551 0,
552 c->dx0,
553 BRW_MATH_DATA_SCALAR,
554 BRW_MATH_PRECISION_FULL);
555
556 if (c->key.sprite_origin_lower_left) {
557 brw_MUL(p, c->m1Cx, c->tmp, c->inv_w[0]);
558 brw_MOV(p, vec1(suboffset(c->m1Cx, 1)), brw_imm_f(0.0));
559 brw_MUL(p, c->m2Cy, c->tmp, negate(c->inv_w[0]));
560 brw_MOV(p, vec1(suboffset(c->m2Cy, 0)), brw_imm_f(0.0));
561 } else {
562 brw_MUL(p, c->m1Cx, c->tmp, c->inv_w[0]);
563 brw_MOV(p, vec1(suboffset(c->m1Cx, 1)), brw_imm_f(0.0));
564 brw_MUL(p, c->m2Cy, c->tmp, c->inv_w[0]);
565 brw_MOV(p, vec1(suboffset(c->m2Cy, 0)), brw_imm_f(0.0));
566 }
567 } else {
568 brw_MOV(p, c->m1Cx, brw_imm_ud(0));
569 brw_MOV(p, c->m2Cy, brw_imm_ud(0));
570 }
571
572 {
573 brw_set_predicate_control_flag_value(p, pc);
574 if (tex->CoordReplace) {
575 if (c->key.sprite_origin_lower_left) {
576 brw_MUL(p, c->m3C0, c->inv_w[0], brw_imm_f(1.0));
577 brw_MOV(p, vec1(suboffset(c->m3C0, 0)), brw_imm_f(0.0));
578 }
579 else
580 brw_MOV(p, c->m3C0, brw_imm_f(0.0));
581 } else {
582 brw_MOV(p, c->m3C0, a0); /* constant value */
583 }
584
585 /* Copy m0..m3 to URB.
586 */
587 brw_urb_WRITE(p,
588 brw_null_reg(),
589 0,
590 brw_vec8_grf(0, 0),
591 0, /* allocate */
592 1, /* used */
593 4, /* msg len */
594 0, /* response len */
595 last, /* eot */
596 last, /* writes complete */
597 i*4, /* urb destination offset */
598 BRW_URB_SWIZZLE_TRANSPOSE);
599 }
600 }
601 }
602
603 /* Points setup - several simplifications as all attributes are
604 * constant across the face of the point (point sprites excluded!)
605 */
606 void brw_emit_point_setup( struct brw_sf_compile *c, GLboolean allocate)
607 {
608 struct brw_compile *p = &c->func;
609 GLuint i;
610
611 c->nr_verts = 1;
612
613 if (allocate)
614 alloc_regs(c);
615
616 copy_z_inv_w(c);
617
618 brw_MOV(p, c->m1Cx, brw_imm_ud(0)); /* zero - move out of loop */
619 brw_MOV(p, c->m2Cy, brw_imm_ud(0)); /* zero - move out of loop */
620
621 for (i = 0; i < c->nr_setup_regs; i++)
622 {
623 struct brw_reg a0 = offset(c->vert[0], i);
624 GLushort pc, pc_persp, pc_linear;
625 GLboolean last = calculate_masks(c, i, &pc, &pc_persp, &pc_linear);
626
627 if (pc_persp)
628 {
629 /* This seems odd as the values are all constant, but the
630 * fragment shader will be expecting it:
631 */
632 brw_set_predicate_control_flag_value(p, pc_persp);
633 brw_MUL(p, a0, a0, c->inv_w[0]);
634 }
635
636
637 /* The delta values are always zero, just send the starting
638 * coordinate. Again, this is to fit in with the interpolation
639 * code in the fragment shader.
640 */
641 {
642 brw_set_predicate_control_flag_value(p, pc);
643
644 brw_MOV(p, c->m3C0, a0); /* constant value */
645
646 /* Copy m0..m3 to URB.
647 */
648 brw_urb_WRITE(p,
649 brw_null_reg(),
650 0,
651 brw_vec8_grf(0, 0),
652 0, /* allocate */
653 1, /* used */
654 4, /* msg len */
655 0, /* response len */
656 last, /* eot */
657 last, /* writes complete */
658 i*4, /* urb destination offset */
659 BRW_URB_SWIZZLE_TRANSPOSE);
660 }
661 }
662 }
663
664 void brw_emit_anyprim_setup( struct brw_sf_compile *c )
665 {
666 struct brw_compile *p = &c->func;
667 struct brw_reg ip = brw_ip_reg();
668 struct brw_reg payload_prim = brw_uw1_reg(BRW_GENERAL_REGISTER_FILE, 1, 0);
669 struct brw_reg payload_attr = get_element_ud(brw_vec1_reg(BRW_GENERAL_REGISTER_FILE, 1, 0), 0);
670 struct brw_reg primmask;
671 struct brw_instruction *jmp;
672 struct brw_reg v1_null_ud = vec1(retype(brw_null_reg(), BRW_REGISTER_TYPE_UD));
673
674 GLuint saveflag;
675
676 c->nr_verts = 3;
677 alloc_regs(c);
678
679 primmask = retype(get_element(c->tmp, 0), BRW_REGISTER_TYPE_UD);
680
681 brw_MOV(p, primmask, brw_imm_ud(1));
682 brw_SHL(p, primmask, primmask, payload_prim);
683
684 brw_set_conditionalmod(p, BRW_CONDITIONAL_Z);
685 brw_AND(p, v1_null_ud, primmask, brw_imm_ud((1<<_3DPRIM_TRILIST) |
686 (1<<_3DPRIM_TRISTRIP) |
687 (1<<_3DPRIM_TRIFAN) |
688 (1<<_3DPRIM_TRISTRIP_REVERSE) |
689 (1<<_3DPRIM_POLYGON) |
690 (1<<_3DPRIM_RECTLIST) |
691 (1<<_3DPRIM_TRIFAN_NOSTIPPLE)));
692 jmp = brw_JMPI(p, ip, ip, brw_imm_d(0));
693 {
694 saveflag = p->flag_value;
695 brw_push_insn_state(p);
696 brw_emit_tri_setup( c, GL_FALSE );
697 brw_pop_insn_state(p);
698 p->flag_value = saveflag;
699 /* note - thread killed in subroutine, so must
700 * restore the flag which is changed when building
701 * the subroutine. fix #13240
702 */
703 }
704 brw_land_fwd_jump(p, jmp);
705
706 brw_set_conditionalmod(p, BRW_CONDITIONAL_Z);
707 brw_AND(p, v1_null_ud, primmask, brw_imm_ud((1<<_3DPRIM_LINELIST) |
708 (1<<_3DPRIM_LINESTRIP) |
709 (1<<_3DPRIM_LINELOOP) |
710 (1<<_3DPRIM_LINESTRIP_CONT) |
711 (1<<_3DPRIM_LINESTRIP_BF) |
712 (1<<_3DPRIM_LINESTRIP_CONT_BF)));
713 jmp = brw_JMPI(p, ip, ip, brw_imm_d(0));
714 {
715 saveflag = p->flag_value;
716 brw_push_insn_state(p);
717 brw_emit_line_setup( c, GL_FALSE );
718 brw_pop_insn_state(p);
719 p->flag_value = saveflag;
720 /* note - thread killed in subroutine */
721 }
722 brw_land_fwd_jump(p, jmp);
723
724 brw_set_conditionalmod(p, BRW_CONDITIONAL_Z);
725 brw_AND(p, v1_null_ud, payload_attr, brw_imm_ud(1<<BRW_SPRITE_POINT_ENABLE));
726 jmp = brw_JMPI(p, ip, ip, brw_imm_d(0));
727 {
728 saveflag = p->flag_value;
729 brw_push_insn_state(p);
730 brw_emit_point_sprite_setup( c, GL_FALSE );
731 brw_pop_insn_state(p);
732 p->flag_value = saveflag;
733 }
734 brw_land_fwd_jump(p, jmp);
735
736 brw_emit_point_setup( c, GL_FALSE );
737 }
738
739
740
741