llvmpipe: initialize llvmpipe->dirty with LP_NEW_SCISSOR
[mesa.git] / src / gallium / drivers / llvmpipe / lp_setup_line.c
1 /**************************************************************************
2 *
3 * Copyright 2007 VMware, Inc.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * 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, sub license, 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 portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 /*
29 * Binning code for lines
30 */
31
32 #include "util/u_math.h"
33 #include "util/u_memory.h"
34 #include "lp_perf.h"
35 #include "lp_setup_context.h"
36 #include "lp_rast.h"
37 #include "lp_state_fs.h"
38 #include "lp_state_setup.h"
39 #include "lp_context.h"
40 #include "draw/draw_context.h"
41
42 #define NUM_CHANNELS 4
43
44 struct lp_line_info {
45
46 float dx;
47 float dy;
48 float oneoverarea;
49 boolean frontfacing;
50
51 const float (*v1)[4];
52 const float (*v2)[4];
53
54 float (*a0)[4];
55 float (*dadx)[4];
56 float (*dady)[4];
57 };
58
59
60 /**
61 * Compute a0 for a constant-valued coefficient (GL_FLAT shading).
62 */
63 static void constant_coef( struct lp_setup_context *setup,
64 struct lp_line_info *info,
65 unsigned slot,
66 const float value,
67 unsigned i )
68 {
69 info->a0[slot][i] = value;
70 info->dadx[slot][i] = 0.0f;
71 info->dady[slot][i] = 0.0f;
72 }
73
74
75 /**
76 * Compute a0, dadx and dady for a linearly interpolated coefficient,
77 * for a triangle.
78 */
79 static void linear_coef( struct lp_setup_context *setup,
80 struct lp_line_info *info,
81 unsigned slot,
82 unsigned vert_attr,
83 unsigned i)
84 {
85 float a1 = info->v1[vert_attr][i];
86 float a2 = info->v2[vert_attr][i];
87
88 float da21 = a1 - a2;
89 float dadx = da21 * info->dx * info->oneoverarea;
90 float dady = da21 * info->dy * info->oneoverarea;
91
92 info->dadx[slot][i] = dadx;
93 info->dady[slot][i] = dady;
94
95 info->a0[slot][i] = (a1 -
96 (dadx * (info->v1[0][0] - setup->pixel_offset) +
97 dady * (info->v1[0][1] - setup->pixel_offset)));
98 }
99
100
101 /**
102 * Compute a0, dadx and dady for a perspective-corrected interpolant,
103 * for a triangle.
104 * We basically multiply the vertex value by 1/w before computing
105 * the plane coefficients (a0, dadx, dady).
106 * Later, when we compute the value at a particular fragment position we'll
107 * divide the interpolated value by the interpolated W at that fragment.
108 */
109 static void perspective_coef( struct lp_setup_context *setup,
110 struct lp_line_info *info,
111 unsigned slot,
112 unsigned vert_attr,
113 unsigned i)
114 {
115 /* premultiply by 1/w (v[0][3] is always 1/w):
116 */
117 float a1 = info->v1[vert_attr][i] * info->v1[0][3];
118 float a2 = info->v2[vert_attr][i] * info->v2[0][3];
119
120 float da21 = a1 - a2;
121 float dadx = da21 * info->dx * info->oneoverarea;
122 float dady = da21 * info->dy * info->oneoverarea;
123
124 info->dadx[slot][i] = dadx;
125 info->dady[slot][i] = dady;
126
127 info->a0[slot][i] = (a1 -
128 (dadx * (info->v1[0][0] - setup->pixel_offset) +
129 dady * (info->v1[0][1] - setup->pixel_offset)));
130 }
131
132 static void
133 setup_fragcoord_coef( struct lp_setup_context *setup,
134 struct lp_line_info *info,
135 unsigned slot,
136 unsigned usage_mask)
137 {
138 /*X*/
139 if (usage_mask & TGSI_WRITEMASK_X) {
140 info->a0[slot][0] = 0.0;
141 info->dadx[slot][0] = 1.0;
142 info->dady[slot][0] = 0.0;
143 }
144
145 /*Y*/
146 if (usage_mask & TGSI_WRITEMASK_Y) {
147 info->a0[slot][1] = 0.0;
148 info->dadx[slot][1] = 0.0;
149 info->dady[slot][1] = 1.0;
150 }
151
152 /*Z*/
153 if (usage_mask & TGSI_WRITEMASK_Z) {
154 linear_coef(setup, info, slot, 0, 2);
155 }
156
157 /*W*/
158 if (usage_mask & TGSI_WRITEMASK_W) {
159 linear_coef(setup, info, slot, 0, 3);
160 }
161 }
162
163 /**
164 * Compute the tri->coef[] array dadx, dady, a0 values.
165 */
166 static void setup_line_coefficients( struct lp_setup_context *setup,
167 struct lp_line_info *info)
168 {
169 const struct lp_setup_variant_key *key = &setup->setup.variant->key;
170 unsigned fragcoord_usage_mask = TGSI_WRITEMASK_XYZ;
171 unsigned slot;
172
173 /* setup interpolation for all the remaining attributes:
174 */
175 for (slot = 0; slot < key->num_inputs; slot++) {
176 unsigned vert_attr = key->inputs[slot].src_index;
177 unsigned usage_mask = key->inputs[slot].usage_mask;
178 unsigned i;
179
180 switch (key->inputs[slot].interp) {
181 case LP_INTERP_CONSTANT:
182 if (key->flatshade_first) {
183 for (i = 0; i < NUM_CHANNELS; i++)
184 if (usage_mask & (1 << i))
185 constant_coef(setup, info, slot+1, info->v1[vert_attr][i], i);
186 }
187 else {
188 for (i = 0; i < NUM_CHANNELS; i++)
189 if (usage_mask & (1 << i))
190 constant_coef(setup, info, slot+1, info->v2[vert_attr][i], i);
191 }
192 break;
193
194 case LP_INTERP_LINEAR:
195 for (i = 0; i < NUM_CHANNELS; i++)
196 if (usage_mask & (1 << i))
197 linear_coef(setup, info, slot+1, vert_attr, i);
198 break;
199
200 case LP_INTERP_PERSPECTIVE:
201 for (i = 0; i < NUM_CHANNELS; i++)
202 if (usage_mask & (1 << i))
203 perspective_coef(setup, info, slot+1, vert_attr, i);
204 fragcoord_usage_mask |= TGSI_WRITEMASK_W;
205 break;
206
207 case LP_INTERP_POSITION:
208 /*
209 * The generated pixel interpolators will pick up the coeffs from
210 * slot 0, so all need to ensure that the usage mask is covers all
211 * usages.
212 */
213 fragcoord_usage_mask |= usage_mask;
214 break;
215
216 case LP_INTERP_FACING:
217 for (i = 0; i < NUM_CHANNELS; i++)
218 if (usage_mask & (1 << i))
219 constant_coef(setup, info, slot+1,
220 info->frontfacing ? 1.0f : -1.0f, i);
221 break;
222
223 default:
224 assert(0);
225 }
226 }
227
228 /* The internal position input is in slot zero:
229 */
230 setup_fragcoord_coef(setup, info, 0,
231 fragcoord_usage_mask);
232 }
233
234
235
236 static inline int subpixel_snap( float a )
237 {
238 return util_iround(FIXED_ONE * a);
239 }
240
241
242 /**
243 * Print line vertex attribs (for debug).
244 */
245 static void
246 print_line(struct lp_setup_context *setup,
247 const float (*v1)[4],
248 const float (*v2)[4])
249 {
250 const struct lp_setup_variant_key *key = &setup->setup.variant->key;
251 uint i;
252
253 debug_printf("llvmpipe line\n");
254 for (i = 0; i < 1 + key->num_inputs; i++) {
255 debug_printf(" v1[%d]: %f %f %f %f\n", i,
256 v1[i][0], v1[i][1], v1[i][2], v1[i][3]);
257 }
258 for (i = 0; i < 1 + key->num_inputs; i++) {
259 debug_printf(" v2[%d]: %f %f %f %f\n", i,
260 v2[i][0], v2[i][1], v2[i][2], v2[i][3]);
261 }
262 }
263
264
265 static inline boolean sign(float x){
266 return x >= 0;
267 }
268
269
270 /* Used on positive floats only:
271 */
272 static inline float fracf(float f)
273 {
274 return f - floorf(f);
275 }
276
277
278
279 static boolean
280 try_setup_line( struct lp_setup_context *setup,
281 const float (*v1)[4],
282 const float (*v2)[4])
283 {
284 struct llvmpipe_context *lp_context = (struct llvmpipe_context *)setup->pipe;
285 struct lp_scene *scene = setup->scene;
286 const struct lp_setup_variant_key *key = &setup->setup.variant->key;
287 struct lp_rast_triangle *line;
288 struct lp_rast_plane *plane;
289 struct lp_line_info info;
290 float width = MAX2(1.0, setup->line_width);
291 const struct u_rect *scissor;
292 struct u_rect bbox, bboxpos;
293 boolean s_planes[4];
294 unsigned tri_bytes;
295 int x[4];
296 int y[4];
297 int i;
298 int nr_planes = 4;
299 unsigned viewport_index = 0;
300 unsigned layer = 0;
301
302 /* linewidth should be interpreted as integer */
303 int fixed_width = util_iround(width) * FIXED_ONE;
304
305 float x_offset=0;
306 float y_offset=0;
307 float x_offset_end=0;
308 float y_offset_end=0;
309
310 float x1diff;
311 float y1diff;
312 float x2diff;
313 float y2diff;
314 float dx, dy;
315 float area;
316 const float (*pv)[4];
317
318 boolean draw_start;
319 boolean draw_end;
320 boolean will_draw_start;
321 boolean will_draw_end;
322
323 if (0)
324 print_line(setup, v1, v2);
325
326 if (setup->flatshade_first) {
327 pv = v1;
328 }
329 else {
330 pv = v2;
331 }
332 if (setup->viewport_index_slot > 0) {
333 unsigned *udata = (unsigned*)pv[setup->viewport_index_slot];
334 viewport_index = lp_clamp_viewport_idx(*udata);
335 }
336 if (setup->layer_slot > 0) {
337 layer = *(unsigned*)pv[setup->layer_slot];
338 layer = MIN2(layer, scene->fb_max_layer);
339 }
340
341 dx = v1[0][0] - v2[0][0];
342 dy = v1[0][1] - v2[0][1];
343 area = (dx * dx + dy * dy);
344 if (area == 0) {
345 LP_COUNT(nr_culled_tris);
346 return TRUE;
347 }
348
349 info.oneoverarea = 1.0f / area;
350 info.dx = dx;
351 info.dy = dy;
352 info.v1 = v1;
353 info.v2 = v2;
354
355
356 /* X-MAJOR LINE */
357 if (fabsf(dx) >= fabsf(dy)) {
358 float dydx = dy / dx;
359
360 x1diff = v1[0][0] - (float) floor(v1[0][0]) - 0.5;
361 y1diff = v1[0][1] - (float) floor(v1[0][1]) - 0.5;
362 x2diff = v2[0][0] - (float) floor(v2[0][0]) - 0.5;
363 y2diff = v2[0][1] - (float) floor(v2[0][1]) - 0.5;
364
365 if (y2diff==-0.5 && dy<0){
366 y2diff = 0.5;
367 }
368
369 /*
370 * Diamond exit rule test for starting point
371 */
372 if (fabsf(x1diff) + fabsf(y1diff) < 0.5) {
373 draw_start = TRUE;
374 }
375 else if (sign(x1diff) == sign(-dx)) {
376 draw_start = FALSE;
377 }
378 else if (sign(-y1diff) != sign(dy)) {
379 draw_start = TRUE;
380 }
381 else {
382 /* do intersection test */
383 float yintersect = fracf(v1[0][1]) + x1diff * dydx;
384 draw_start = (yintersect < 1.0 && yintersect > 0.0);
385 }
386
387
388 /*
389 * Diamond exit rule test for ending point
390 */
391 if (fabsf(x2diff) + fabsf(y2diff) < 0.5) {
392 draw_end = FALSE;
393 }
394 else if (sign(x2diff) != sign(-dx)) {
395 draw_end = FALSE;
396 }
397 else if (sign(-y2diff) == sign(dy)) {
398 draw_end = TRUE;
399 }
400 else {
401 /* do intersection test */
402 float yintersect = fracf(v2[0][1]) + x2diff * dydx;
403 draw_end = (yintersect < 1.0 && yintersect > 0.0);
404 }
405
406 /* Are we already drawing start/end?
407 */
408 will_draw_start = sign(-x1diff) != sign(dx);
409 will_draw_end = (sign(x2diff) == sign(-dx)) || x2diff==0;
410
411 if (dx < 0) {
412 /* if v2 is to the right of v1, swap pointers */
413 const float (*temp)[4] = v1;
414 v1 = v2;
415 v2 = temp;
416 dx = -dx;
417 dy = -dy;
418 /* Otherwise shift planes appropriately */
419 if (will_draw_start != draw_start) {
420 x_offset_end = - x1diff - 0.5;
421 y_offset_end = x_offset_end * dydx;
422
423 }
424 if (will_draw_end != draw_end) {
425 x_offset = - x2diff - 0.5;
426 y_offset = x_offset * dydx;
427 }
428
429 }
430 else{
431 /* Otherwise shift planes appropriately */
432 if (will_draw_start != draw_start) {
433 x_offset = - x1diff + 0.5;
434 y_offset = x_offset * dydx;
435 }
436 if (will_draw_end != draw_end) {
437 x_offset_end = - x2diff + 0.5;
438 y_offset_end = x_offset_end * dydx;
439 }
440 }
441
442 /* x/y positions in fixed point */
443 x[0] = subpixel_snap(v1[0][0] + x_offset - setup->pixel_offset);
444 x[1] = subpixel_snap(v2[0][0] + x_offset_end - setup->pixel_offset);
445 x[2] = subpixel_snap(v2[0][0] + x_offset_end - setup->pixel_offset);
446 x[3] = subpixel_snap(v1[0][0] + x_offset - setup->pixel_offset);
447
448 y[0] = subpixel_snap(v1[0][1] + y_offset - setup->pixel_offset) - fixed_width/2;
449 y[1] = subpixel_snap(v2[0][1] + y_offset_end - setup->pixel_offset) - fixed_width/2;
450 y[2] = subpixel_snap(v2[0][1] + y_offset_end - setup->pixel_offset) + fixed_width/2;
451 y[3] = subpixel_snap(v1[0][1] + y_offset - setup->pixel_offset) + fixed_width/2;
452
453 }
454 else {
455 const float dxdy = dx / dy;
456
457 /* Y-MAJOR LINE */
458 x1diff = v1[0][0] - (float) floor(v1[0][0]) - 0.5;
459 y1diff = v1[0][1] - (float) floor(v1[0][1]) - 0.5;
460 x2diff = v2[0][0] - (float) floor(v2[0][0]) - 0.5;
461 y2diff = v2[0][1] - (float) floor(v2[0][1]) - 0.5;
462
463 if (x2diff==-0.5 && dx<0) {
464 x2diff = 0.5;
465 }
466
467 /*
468 * Diamond exit rule test for starting point
469 */
470 if (fabsf(x1diff) + fabsf(y1diff) < 0.5) {
471 draw_start = TRUE;
472 }
473 else if (sign(-y1diff) == sign(dy)) {
474 draw_start = FALSE;
475 }
476 else if (sign(x1diff) != sign(-dx)) {
477 draw_start = TRUE;
478 }
479 else {
480 /* do intersection test */
481 float xintersect = fracf(v1[0][0]) + y1diff * dxdy;
482 draw_start = (xintersect < 1.0 && xintersect > 0.0);
483 }
484
485 /*
486 * Diamond exit rule test for ending point
487 */
488 if (fabsf(x2diff) + fabsf(y2diff) < 0.5) {
489 draw_end = FALSE;
490 }
491 else if (sign(-y2diff) != sign(dy) ) {
492 draw_end = FALSE;
493 }
494 else if (sign(x2diff) == sign(-dx) ) {
495 draw_end = TRUE;
496 }
497 else {
498 /* do intersection test */
499 float xintersect = fracf(v2[0][0]) + y2diff * dxdy;
500 draw_end = (xintersect < 1.0 && xintersect >= 0.0);
501 }
502
503 /* Are we already drawing start/end?
504 */
505 will_draw_start = sign(y1diff) == sign(dy);
506 will_draw_end = (sign(-y2diff) == sign(dy)) || y2diff==0;
507
508 if (dy > 0) {
509 /* if v2 is on top of v1, swap pointers */
510 const float (*temp)[4] = v1;
511 v1 = v2;
512 v2 = temp;
513 dx = -dx;
514 dy = -dy;
515
516 /* Otherwise shift planes appropriately */
517 if (will_draw_start != draw_start) {
518 y_offset_end = - y1diff + 0.5;
519 x_offset_end = y_offset_end * dxdy;
520 }
521 if (will_draw_end != draw_end) {
522 y_offset = - y2diff + 0.5;
523 x_offset = y_offset * dxdy;
524 }
525 }
526 else {
527 /* Otherwise shift planes appropriately */
528 if (will_draw_start != draw_start) {
529 y_offset = - y1diff - 0.5;
530 x_offset = y_offset * dxdy;
531
532 }
533 if (will_draw_end != draw_end) {
534 y_offset_end = - y2diff - 0.5;
535 x_offset_end = y_offset_end * dxdy;
536 }
537 }
538
539 /* x/y positions in fixed point */
540 x[0] = subpixel_snap(v1[0][0] + x_offset - setup->pixel_offset) - fixed_width/2;
541 x[1] = subpixel_snap(v2[0][0] + x_offset_end - setup->pixel_offset) - fixed_width/2;
542 x[2] = subpixel_snap(v2[0][0] + x_offset_end - setup->pixel_offset) + fixed_width/2;
543 x[3] = subpixel_snap(v1[0][0] + x_offset - setup->pixel_offset) + fixed_width/2;
544
545 y[0] = subpixel_snap(v1[0][1] + y_offset - setup->pixel_offset);
546 y[1] = subpixel_snap(v2[0][1] + y_offset_end - setup->pixel_offset);
547 y[2] = subpixel_snap(v2[0][1] + y_offset_end - setup->pixel_offset);
548 y[3] = subpixel_snap(v1[0][1] + y_offset - setup->pixel_offset);
549 }
550
551 /* Bounding rectangle (in pixels) */
552 {
553 /* Yes this is necessary to accurately calculate bounding boxes
554 * with the two fill-conventions we support. GL (normally) ends
555 * up needing a bottom-left fill convention, which requires
556 * slightly different rounding.
557 */
558 int adj = (setup->bottom_edge_rule != 0) ? 1 : 0;
559
560 bbox.x0 = (MIN4(x[0], x[1], x[2], x[3]) + (FIXED_ONE-1)) >> FIXED_ORDER;
561 bbox.x1 = (MAX4(x[0], x[1], x[2], x[3]) + (FIXED_ONE-1)) >> FIXED_ORDER;
562 bbox.y0 = (MIN4(y[0], y[1], y[2], y[3]) + (FIXED_ONE-1) + adj) >> FIXED_ORDER;
563 bbox.y1 = (MAX4(y[0], y[1], y[2], y[3]) + (FIXED_ONE-1) + adj) >> FIXED_ORDER;
564
565 /* Inclusive coordinates:
566 */
567 bbox.x1--;
568 bbox.y1--;
569 }
570
571 if (bbox.x1 < bbox.x0 ||
572 bbox.y1 < bbox.y0) {
573 if (0) debug_printf("empty bounding box\n");
574 LP_COUNT(nr_culled_tris);
575 return TRUE;
576 }
577
578 if (!u_rect_test_intersection(&setup->draw_regions[viewport_index], &bbox)) {
579 if (0) debug_printf("offscreen\n");
580 LP_COUNT(nr_culled_tris);
581 return TRUE;
582 }
583
584 bboxpos = bbox;
585
586 /* Can safely discard negative regions:
587 */
588 bboxpos.x0 = MAX2(bboxpos.x0, 0);
589 bboxpos.y0 = MAX2(bboxpos.y0, 0);
590
591 nr_planes = 4;
592 /*
593 * Determine how many scissor planes we need, that is drop scissor
594 * edges if the bounding box of the tri is fully inside that edge.
595 */
596 if (setup->scissor_test) {
597 /* why not just use draw_regions */
598 scissor = &setup->scissors[viewport_index];
599 scissor_planes_needed(s_planes, &bboxpos, scissor);
600 nr_planes += s_planes[0] + s_planes[1] + s_planes[2] + s_planes[3];
601 }
602
603 line = lp_setup_alloc_triangle(scene,
604 key->num_inputs,
605 nr_planes,
606 &tri_bytes);
607 if (!line)
608 return FALSE;
609
610 #ifdef DEBUG
611 line->v[0][0] = v1[0][0];
612 line->v[1][0] = v2[0][0];
613 line->v[0][1] = v1[0][1];
614 line->v[1][1] = v2[0][1];
615 #endif
616
617 LP_COUNT(nr_tris);
618
619 if (lp_context->active_statistics_queries &&
620 !llvmpipe_rasterization_disabled(lp_context)) {
621 lp_context->pipeline_statistics.c_primitives++;
622 }
623
624 /* calculate the deltas */
625 plane = GET_PLANES(line);
626 plane[0].dcdy = x[0] - x[1];
627 plane[1].dcdy = x[1] - x[2];
628 plane[2].dcdy = x[2] - x[3];
629 plane[3].dcdy = x[3] - x[0];
630
631 plane[0].dcdx = y[0] - y[1];
632 plane[1].dcdx = y[1] - y[2];
633 plane[2].dcdx = y[2] - y[3];
634 plane[3].dcdx = y[3] - y[0];
635
636 if (draw_will_inject_frontface(lp_context->draw) &&
637 setup->face_slot > 0) {
638 line->inputs.frontfacing = v1[setup->face_slot][0];
639 } else {
640 line->inputs.frontfacing = TRUE;
641 }
642
643 /* Setup parameter interpolants:
644 */
645 info.a0 = GET_A0(&line->inputs);
646 info.dadx = GET_DADX(&line->inputs);
647 info.dady = GET_DADY(&line->inputs);
648 info.frontfacing = line->inputs.frontfacing;
649 setup_line_coefficients(setup, &info);
650
651 line->inputs.disable = FALSE;
652 line->inputs.opaque = FALSE;
653 line->inputs.layer = layer;
654 line->inputs.viewport_index = viewport_index;
655
656 /*
657 * XXX: this code is mostly identical to the one in lp_setup_tri, except it
658 * uses 4 planes instead of 3. Could share the code (including the sse
659 * assembly, in fact we'd get the 4th plane for free).
660 * The only difference apart from storing the 4th plane would be some
661 * different shuffle for calculating dcdx/dcdy.
662 */
663 for (i = 0; i < 4; i++) {
664
665 /* half-edge constants, will be iterated over the whole render
666 * target.
667 */
668 plane[i].c = IMUL64(plane[i].dcdx, x[i]) - IMUL64(plane[i].dcdy, y[i]);
669
670 /* correct for top-left vs. bottom-left fill convention.
671 */
672 if (plane[i].dcdx < 0) {
673 /* both fill conventions want this - adjust for left edges */
674 plane[i].c++;
675 }
676 else if (plane[i].dcdx == 0) {
677 if (setup->pixel_offset == 0) {
678 /* correct for top-left fill convention:
679 */
680 if (plane[i].dcdy > 0) plane[i].c++;
681 }
682 else {
683 /* correct for bottom-left fill convention:
684 */
685 if (plane[i].dcdy < 0) plane[i].c++;
686 }
687 }
688
689 plane[i].dcdx *= FIXED_ONE;
690 plane[i].dcdy *= FIXED_ONE;
691
692 /* find trivial reject offsets for each edge for a single-pixel
693 * sized block. These will be scaled up at each recursive level to
694 * match the active blocksize. Scaling in this way works best if
695 * the blocks are square.
696 */
697 plane[i].eo = 0;
698 if (plane[i].dcdx < 0) plane[i].eo -= plane[i].dcdx;
699 if (plane[i].dcdy > 0) plane[i].eo += plane[i].dcdy;
700 }
701
702
703 /*
704 * When rasterizing scissored tris, use the intersection of the
705 * triangle bounding box and the scissor rect to generate the
706 * scissor planes.
707 *
708 * This permits us to cut off the triangle "tails" that are present
709 * in the intermediate recursive levels caused when two of the
710 * triangles edges don't diverge quickly enough to trivially reject
711 * exterior blocks from the triangle.
712 *
713 * It's not really clear if it's worth worrying about these tails,
714 * but since we generate the planes for each scissored tri, it's
715 * free to trim them in this case.
716 *
717 * Note that otherwise, the scissor planes only vary in 'C' value,
718 * and even then only on state-changes. Could alternatively store
719 * these planes elsewhere.
720 * (Or only store the c value together with a bit indicating which
721 * scissor edge this is, so rasterization would treat them differently
722 * (easier to evaluate) to ordinary planes.)
723 */
724 if (nr_planes > 4) {
725 struct lp_rast_plane *plane_s = &plane[4];
726
727 if (s_planes[0]) {
728 plane_s->dcdx = -1 << 8;
729 plane_s->dcdy = 0;
730 plane_s->c = (1-scissor->x0) << 8;
731 plane_s->eo = 1 << 8;
732 plane_s++;
733 }
734 if (s_planes[1]) {
735 plane_s->dcdx = 1 << 8;
736 plane_s->dcdy = 0;
737 plane_s->c = (scissor->x1+1) << 8;
738 plane_s->eo = 0 << 8;
739 plane_s++;
740 }
741 if (s_planes[2]) {
742 plane_s->dcdx = 0;
743 plane_s->dcdy = 1 << 8;
744 plane_s->c = (1-scissor->y0) << 8;
745 plane_s->eo = 1 << 8;
746 plane_s++;
747 }
748 if (s_planes[3]) {
749 plane_s->dcdx = 0;
750 plane_s->dcdy = -1 << 8;
751 plane_s->c = (scissor->y1+1) << 8;
752 plane_s->eo = 0;
753 plane_s++;
754 }
755 assert(plane_s == &plane[nr_planes]);
756 }
757
758 return lp_setup_bin_triangle(setup, line, &bbox, &bboxpos, nr_planes, viewport_index);
759 }
760
761
762 static void lp_setup_line( struct lp_setup_context *setup,
763 const float (*v0)[4],
764 const float (*v1)[4] )
765 {
766 if (!try_setup_line( setup, v0, v1 ))
767 {
768 if (!lp_setup_flush_and_restart(setup))
769 return;
770
771 if (!try_setup_line( setup, v0, v1 ))
772 return;
773 }
774 }
775
776
777 void lp_setup_choose_line( struct lp_setup_context *setup )
778 {
779 setup->line = lp_setup_line;
780 }
781
782