projects / mesa.git / blob
? search:


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