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 struct u_rect bbox; 292 unsigned tri_bytes; 293 int x[4]; 294 int y[4]; 295 int i; 296 int nr_planes = 4; 297 unsigned viewport_index = 0; 298 unsigned layer = 0; 299 300 /* linewidth should be interpreted as integer */ 301 int fixed_width = util_iround(width) * FIXED_ONE; 302 303 float x_offset=0; 304 float y_offset=0; 305 float x_offset_end=0; 306 float y_offset_end=0; 307 308 float x1diff; 309 float y1diff; 310 float x2diff; 311 float y2diff; 312 float dx, dy; 313 float area; 314 const float (*pv)[4]; 315 316 boolean draw_start; 317 boolean draw_end; 318 boolean will_draw_start; 319 boolean will_draw_end; 320 321 if (0) 322 print_line(setup, v1, v2); 323 324 if (setup->flatshade_first) { 325 pv = v1; 326 } 327 else { 328 pv = v2; 329 } 330 if (setup->viewport_index_slot > 0) { 331 unsigned *udata = (unsigned*)pv[setup->viewport_index_slot]; 332 viewport_index = lp_clamp_viewport_idx(*udata); 333 } 334 if (setup->layer_slot > 0) { 335 layer = *(unsigned*)pv[setup->layer_slot]; 336 layer = MIN2(layer, scene->fb_max_layer); 337 } 338 339 dx = v1[0][0] - v2[0][0]; 340 dy = v1[0][1] - v2[0][1]; 341 area = (dx * dx + dy * dy); 342 if (area == 0) { 343 LP_COUNT(nr_culled_tris); 344 return TRUE; 345 } 346 347 info.oneoverarea = 1.0f / area; 348 info.dx = dx; 349 info.dy = dy; 350 info.v1 = v1; 351 info.v2 = v2; 352 353 354 /* X-MAJOR LINE */ 355 if (fabsf(dx) >= fabsf(dy)) { 356 float dydx = dy / dx; 357 358 x1diff = v1[0][0] - (float) floor(v1[0][0]) - 0.5; 359 y1diff = v1[0][1] - (float) floor(v1[0][1]) - 0.5; 360 x2diff = v2[0][0] - (float) floor(v2[0][0]) - 0.5; 361 y2diff = v2[0][1] - (float) floor(v2[0][1]) - 0.5; 362 363 if (y2diff==-0.5 && dy<0){ 364 y2diff = 0.5; 365 } 366 367 /* 368 * Diamond exit rule test for starting point 369 */ 370 if (fabsf(x1diff) + fabsf(y1diff) < 0.5) { 371 draw_start = TRUE; 372 } 373 else if (sign(x1diff) == sign(-dx)) { 374 draw_start = FALSE; 375 } 376 else if (sign(-y1diff) != sign(dy)) { 377 draw_start = TRUE; 378 } 379 else { 380 /* do intersection test */ 381 float yintersect = fracf(v1[0][1]) + x1diff * dydx; 382 draw_start = (yintersect < 1.0 && yintersect > 0.0); 383 } 384 385 386 /* 387 * Diamond exit rule test for ending point 388 */ 389 if (fabsf(x2diff) + fabsf(y2diff) < 0.5) { 390 draw_end = FALSE; 391 } 392 else if (sign(x2diff) != sign(-dx)) { 393 draw_end = FALSE; 394 } 395 else if (sign(-y2diff) == sign(dy)) { 396 draw_end = TRUE; 397 } 398 else { 399 /* do intersection test */ 400 float yintersect = fracf(v2[0][1]) + x2diff * dydx; 401 draw_end = (yintersect < 1.0 && yintersect > 0.0); 402 } 403 404 /* Are we already drawing start/end? 405 */ 406 will_draw_start = sign(-x1diff) != sign(dx); 407 will_draw_end = (sign(x2diff) == sign(-dx)) || x2diff==0; 408 409 if (dx < 0) { 410 /* if v2 is to the right of v1, swap pointers */ 411 const float (*temp)[4] = v1; 412 v1 = v2; 413 v2 = temp; 414 dx = -dx; 415 dy = -dy; 416 /* Otherwise shift planes appropriately */ 417 if (will_draw_start != draw_start) { 418 x_offset_end = - x1diff - 0.5; 419 y_offset_end = x_offset_end * dydx; 420 421 } 422 if (will_draw_end != draw_end) { 423 x_offset = - x2diff - 0.5; 424 y_offset = x_offset * dydx; 425 } 426 427 } 428 else{ 429 /* Otherwise shift planes appropriately */ 430 if (will_draw_start != draw_start) { 431 x_offset = - x1diff + 0.5; 432 y_offset = x_offset * dydx; 433 } 434 if (will_draw_end != draw_end) { 435 x_offset_end = - x2diff + 0.5; 436 y_offset_end = x_offset_end * dydx; 437 } 438 } 439 440 /* x/y positions in fixed point */ 441 x[0] = subpixel_snap(v1[0][0] + x_offset - setup->pixel_offset); 442 x[1] = subpixel_snap(v2[0][0] + x_offset_end - setup->pixel_offset); 443 x[2] = subpixel_snap(v2[0][0] + x_offset_end - setup->pixel_offset); 444 x[3] = subpixel_snap(v1[0][0] + x_offset - setup->pixel_offset); 445 446 y[0] = subpixel_snap(v1[0][1] + y_offset - setup->pixel_offset) - fixed_width/2; 447 y[1] = subpixel_snap(v2[0][1] + y_offset_end - setup->pixel_offset) - fixed_width/2; 448 y[2] = subpixel_snap(v2[0][1] + y_offset_end - setup->pixel_offset) + fixed_width/2; 449 y[3] = subpixel_snap(v1[0][1] + y_offset - setup->pixel_offset) + fixed_width/2; 450 451 } 452 else { 453 const float dxdy = dx / dy; 454 455 /* Y-MAJOR LINE */ 456 x1diff = v1[0][0] - (float) floor(v1[0][0]) - 0.5; 457 y1diff = v1[0][1] - (float) floor(v1[0][1]) - 0.5; 458 x2diff = v2[0][0] - (float) floor(v2[0][0]) - 0.5; 459 y2diff = v2[0][1] - (float) floor(v2[0][1]) - 0.5; 460 461 if (x2diff==-0.5 && dx<0) { 462 x2diff = 0.5; 463 } 464 465 /* 466 * Diamond exit rule test for starting point 467 */ 468 if (fabsf(x1diff) + fabsf(y1diff) < 0.5) { 469 draw_start = TRUE; 470 } 471 else if (sign(-y1diff) == sign(dy)) { 472 draw_start = FALSE; 473 } 474 else if (sign(x1diff) != sign(-dx)) { 475 draw_start = TRUE; 476 } 477 else { 478 /* do intersection test */ 479 float xintersect = fracf(v1[0][0]) + y1diff * dxdy; 480 draw_start = (xintersect < 1.0 && xintersect > 0.0); 481 } 482 483 /* 484 * Diamond exit rule test for ending point 485 */ 486 if (fabsf(x2diff) + fabsf(y2diff) < 0.5) { 487 draw_end = FALSE; 488 } 489 else if (sign(-y2diff) != sign(dy) ) { 490 draw_end = FALSE; 491 } 492 else if (sign(x2diff) == sign(-dx) ) { 493 draw_end = TRUE; 494 } 495 else { 496 /* do intersection test */ 497 float xintersect = fracf(v2[0][0]) + y2diff * dxdy; 498 draw_end = (xintersect < 1.0 && xintersect >= 0.0); 499 } 500 501 /* Are we already drawing start/end? 502 */ 503 will_draw_start = sign(y1diff) == sign(dy); 504 will_draw_end = (sign(-y2diff) == sign(dy)) || y2diff==0; 505 506 if (dy > 0) { 507 /* if v2 is on top of v1, swap pointers */ 508 const float (*temp)[4] = v1; 509 v1 = v2; 510 v2 = temp; 511 dx = -dx; 512 dy = -dy; 513 514 /* Otherwise shift planes appropriately */ 515 if (will_draw_start != draw_start) { 516 y_offset_end = - y1diff + 0.5; 517 x_offset_end = y_offset_end * dxdy; 518 } 519 if (will_draw_end != draw_end) { 520 y_offset = - y2diff + 0.5; 521 x_offset = y_offset * dxdy; 522 } 523 } 524 else { 525 /* Otherwise shift planes appropriately */ 526 if (will_draw_start != draw_start) { 527 y_offset = - y1diff - 0.5; 528 x_offset = y_offset * dxdy; 529 530 } 531 if (will_draw_end != draw_end) { 532 y_offset_end = - y2diff - 0.5; 533 x_offset_end = y_offset_end * dxdy; 534 } 535 } 536 537 /* x/y positions in fixed point */ 538 x[0] = subpixel_snap(v1[0][0] + x_offset - setup->pixel_offset) - fixed_width/2; 539 x[1] = subpixel_snap(v2[0][0] + x_offset_end - setup->pixel_offset) - fixed_width/2; 540 x[2] = subpixel_snap(v2[0][0] + x_offset_end - setup->pixel_offset) + fixed_width/2; 541 x[3] = subpixel_snap(v1[0][0] + x_offset - setup->pixel_offset) + fixed_width/2; 542 543 y[0] = subpixel_snap(v1[0][1] + y_offset - setup->pixel_offset); 544 y[1] = subpixel_snap(v2[0][1] + y_offset_end - setup->pixel_offset); 545 y[2] = subpixel_snap(v2[0][1] + y_offset_end - setup->pixel_offset); 546 y[3] = subpixel_snap(v1[0][1] + y_offset - setup->pixel_offset); 547 } 548 549 /* Bounding rectangle (in pixels) */ 550 { 551 /* Yes this is necessary to accurately calculate bounding boxes 552 * with the two fill-conventions we support. GL (normally) ends 553 * up needing a bottom-left fill convention, which requires 554 * slightly different rounding. 555 */ 556 int adj = (setup->bottom_edge_rule != 0) ? 1 : 0; 557 558 bbox.x0 = (MIN4(x[0], x[1], x[2], x[3]) + (FIXED_ONE-1)) >> FIXED_ORDER; 559 bbox.x1 = (MAX4(x[0], x[1], x[2], x[3]) + (FIXED_ONE-1)) >> FIXED_ORDER; 560 bbox.y0 = (MIN4(y[0], y[1], y[2], y[3]) + (FIXED_ONE-1) + adj) >> FIXED_ORDER; 561 bbox.y1 = (MAX4(y[0], y[1], y[2], y[3]) + (FIXED_ONE-1) + adj) >> FIXED_ORDER; 562 563 /* Inclusive coordinates: 564 */ 565 bbox.x1--; 566 bbox.y1--; 567 } 568 569 if (bbox.x1 < bbox.x0 || 570 bbox.y1 < bbox.y0) { 571 if (0) debug_printf("empty bounding box\n"); 572 LP_COUNT(nr_culled_tris); 573 return TRUE; 574 } 575 576 if (!u_rect_test_intersection(&setup->draw_regions[viewport_index], &bbox)) { 577 if (0) debug_printf("offscreen\n"); 578 LP_COUNT(nr_culled_tris); 579 return TRUE; 580 } 581 582 /* Can safely discard negative regions: 583 */ 584 bbox.x0 = MAX2(bbox.x0, 0); 585 bbox.y0 = MAX2(bbox.y0, 0); 586 587 nr_planes = 4; 588 /* 589 * Determine how many scissor planes we need, that is drop scissor 590 * edges if the bounding box of the tri is fully inside that edge. 591 */ 592 if (setup->scissor_test) { 593 /* why not just use draw_regions */ 594 boolean s_planes[4]; 595 scissor_planes_needed(s_planes, &bbox, &setup->scissors[viewport_index]); 596 nr_planes += s_planes[0] + s_planes[1] + s_planes[2] + s_planes[3]; 597 } 598 599 line = lp_setup_alloc_triangle(scene, 600 key->num_inputs, 601 nr_planes, 602 &tri_bytes); 603 if (!line) 604 return FALSE; 605 606 #ifdef DEBUG 607 line->v[0][0] = v1[0][0]; 608 line->v[1][0] = v2[0][0]; 609 line->v[0][1] = v1[0][1]; 610 line->v[1][1] = v2[0][1]; 611 #endif 612 613 LP_COUNT(nr_tris); 614 615 if (lp_context->active_statistics_queries && 616 !llvmpipe_rasterization_disabled(lp_context)) { 617 lp_context->pipeline_statistics.c_primitives++; 618 } 619 620 /* calculate the deltas */ 621 plane = GET_PLANES(line); 622 plane[0].dcdy = x[0] - x[1]; 623 plane[1].dcdy = x[1] - x[2]; 624 plane[2].dcdy = x[2] - x[3]; 625 plane[3].dcdy = x[3] - x[0]; 626 627 plane[0].dcdx = y[0] - y[1]; 628 plane[1].dcdx = y[1] - y[2]; 629 plane[2].dcdx = y[2] - y[3]; 630 plane[3].dcdx = y[3] - y[0]; 631 632 if (draw_will_inject_frontface(lp_context->draw) && 633 setup->face_slot > 0) { 634 line->inputs.frontfacing = v1[setup->face_slot][0]; 635 } else { 636 line->inputs.frontfacing = TRUE; 637 } 638 639 /* Setup parameter interpolants: 640 */ 641 info.a0 = GET_A0(&line->inputs); 642 info.dadx = GET_DADX(&line->inputs); 643 info.dady = GET_DADY(&line->inputs); 644 info.frontfacing = line->inputs.frontfacing; 645 setup_line_coefficients(setup, &info); 646 647 line->inputs.disable = FALSE; 648 line->inputs.opaque = FALSE; 649 line->inputs.layer = layer; 650 line->inputs.viewport_index = viewport_index; 651 652 /* 653 * XXX: this code is mostly identical to the one in lp_setup_tri, except it 654 * uses 4 planes instead of 3. Could share the code (including the sse 655 * assembly, in fact we'd get the 4th plane for free). 656 * The only difference apart from storing the 4th plane would be some 657 * different shuffle for calculating dcdx/dcdy. 658 */ 659 for (i = 0; i < 4; i++) { 660 661 /* half-edge constants, will be iterated over the whole render 662 * target. 663 */ 664 plane[i].c = IMUL64(plane[i].dcdx, x[i]) - IMUL64(plane[i].dcdy, y[i]); 665 666 /* correct for top-left vs. bottom-left fill convention. 667 */ 668 if (plane[i].dcdx < 0) { 669 /* both fill conventions want this - adjust for left edges */ 670 plane[i].c++; 671 } 672 else if (plane[i].dcdx == 0) { 673 if (setup->pixel_offset == 0) { 674 /* correct for top-left fill convention: 675 */ 676 if (plane[i].dcdy > 0) plane[i].c++; 677 } 678 else { 679 /* correct for bottom-left fill convention: 680 */ 681 if (plane[i].dcdy < 0) plane[i].c++; 682 } 683 } 684 685 plane[i].dcdx *= FIXED_ONE; 686 plane[i].dcdy *= FIXED_ONE; 687 688 /* find trivial reject offsets for each edge for a single-pixel 689 * sized block. These will be scaled up at each recursive level to 690 * match the active blocksize. Scaling in this way works best if 691 * the blocks are square. 692 */ 693 plane[i].eo = 0; 694 if (plane[i].dcdx < 0) plane[i].eo -= plane[i].dcdx; 695 if (plane[i].dcdy > 0) plane[i].eo += plane[i].dcdy; 696 } 697 698 699 /* 700 * When rasterizing scissored tris, use the intersection of the 701 * triangle bounding box and the scissor rect to generate the 702 * scissor planes. 703 * 704 * This permits us to cut off the triangle "tails" that are present 705 * in the intermediate recursive levels caused when two of the 706 * triangles edges don't diverge quickly enough to trivially reject 707 * exterior blocks from the triangle. 708 * 709 * It's not really clear if it's worth worrying about these tails, 710 * but since we generate the planes for each scissored tri, it's 711 * free to trim them in this case. 712 * 713 * Note that otherwise, the scissor planes only vary in 'C' value, 714 * and even then only on state-changes. Could alternatively store 715 * these planes elsewhere. 716 * (Or only store the c value together with a bit indicating which 717 * scissor edge this is, so rasterization would treat them differently 718 * (easier to evaluate) to ordinary planes.) 719 */ 720 if (nr_planes > 4) { 721 /* why not just use draw_regions */ 722 const struct u_rect *scissor = &setup->scissors[viewport_index]; 723 struct lp_rast_plane *plane_s = &plane[4]; 724 boolean s_planes[4]; 725 scissor_planes_needed(s_planes, &bbox, scissor); 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, 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 783
