lp_setup_tri.c revision 22e6dc387039e79f6d1435ae8b7422a6514d5d10
1/************************************************************************** 2 * 3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. 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 TUNGSTEN GRAPHICS 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 triangles 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 38#define NUM_CHANNELS 4 39 40 41/** 42 * Compute a0 for a constant-valued coefficient (GL_FLAT shading). 43 */ 44static void constant_coef( struct lp_setup_context *setup, 45 struct lp_rast_triangle *tri, 46 unsigned slot, 47 const float value, 48 unsigned i ) 49{ 50 tri->inputs.a0[slot][i] = value; 51 tri->inputs.dadx[slot][i] = 0.0f; 52 tri->inputs.dady[slot][i] = 0.0f; 53} 54 55 56/** 57 * Compute a0, dadx and dady for a linearly interpolated coefficient, 58 * for a triangle. 59 */ 60static void linear_coef( struct lp_setup_context *setup, 61 struct lp_rast_triangle *tri, 62 float oneoverarea, 63 unsigned slot, 64 const float (*v1)[4], 65 const float (*v2)[4], 66 const float (*v3)[4], 67 unsigned vert_attr, 68 unsigned i) 69{ 70 float a1 = v1[vert_attr][i]; 71 float a2 = v2[vert_attr][i]; 72 float a3 = v3[vert_attr][i]; 73 74 float da12 = a1 - a2; 75 float da31 = a3 - a1; 76 float dadx = (da12 * tri->dy31 - tri->dy12 * da31) * oneoverarea; 77 float dady = (da31 * tri->dx12 - tri->dx31 * da12) * oneoverarea; 78 79 tri->inputs.dadx[slot][i] = dadx; 80 tri->inputs.dady[slot][i] = dady; 81 82 /* calculate a0 as the value which would be sampled for the 83 * fragment at (0,0), taking into account that we want to sample at 84 * pixel centers, in other words (0.5, 0.5). 85 * 86 * this is neat but unfortunately not a good way to do things for 87 * triangles with very large values of dadx or dady as it will 88 * result in the subtraction and re-addition from a0 of a very 89 * large number, which means we'll end up loosing a lot of the 90 * fractional bits and precision from a0. the way to fix this is 91 * to define a0 as the sample at a pixel center somewhere near vmin 92 * instead - i'll switch to this later. 93 */ 94 tri->inputs.a0[slot][i] = (a1 - 95 (dadx * (v1[0][0] - setup->pixel_offset) + 96 dady * (v1[0][1] - setup->pixel_offset))); 97} 98 99 100/** 101 * Compute a0, dadx and dady for a perspective-corrected interpolant, 102 * for a triangle. 103 * We basically multiply the vertex value by 1/w before computing 104 * the plane coefficients (a0, dadx, dady). 105 * Later, when we compute the value at a particular fragment position we'll 106 * divide the interpolated value by the interpolated W at that fragment. 107 */ 108static void perspective_coef( struct lp_setup_context *setup, 109 struct lp_rast_triangle *tri, 110 float oneoverarea, 111 unsigned slot, 112 const float (*v1)[4], 113 const float (*v2)[4], 114 const float (*v3)[4], 115 unsigned vert_attr, 116 unsigned i) 117{ 118 /* premultiply by 1/w (v[0][3] is always 1/w): 119 */ 120 float a1 = v1[vert_attr][i] * v1[0][3]; 121 float a2 = v2[vert_attr][i] * v2[0][3]; 122 float a3 = v3[vert_attr][i] * v3[0][3]; 123 float da12 = a1 - a2; 124 float da31 = a3 - a1; 125 float dadx = (da12 * tri->dy31 - tri->dy12 * da31) * oneoverarea; 126 float dady = (da31 * tri->dx12 - tri->dx31 * da12) * oneoverarea; 127 128 tri->inputs.dadx[slot][i] = dadx; 129 tri->inputs.dady[slot][i] = dady; 130 tri->inputs.a0[slot][i] = (a1 - 131 (dadx * (v1[0][0] - setup->pixel_offset) + 132 dady * (v1[0][1] - setup->pixel_offset))); 133} 134 135 136/** 137 * Special coefficient setup for gl_FragCoord. 138 * X and Y are trivial 139 * Z and W are copied from position_coef which should have already been computed. 140 * We could do a bit less work if we'd examine gl_FragCoord's swizzle mask. 141 */ 142static void 143setup_fragcoord_coef(struct lp_setup_context *setup, 144 struct lp_rast_triangle *tri, 145 float oneoverarea, 146 unsigned slot, 147 const float (*v1)[4], 148 const float (*v2)[4], 149 const float (*v3)[4]) 150{ 151 /*X*/ 152 tri->inputs.a0[slot][0] = 0.0; 153 tri->inputs.dadx[slot][0] = 1.0; 154 tri->inputs.dady[slot][0] = 0.0; 155 /*Y*/ 156 tri->inputs.a0[slot][1] = 0.0; 157 tri->inputs.dadx[slot][1] = 0.0; 158 tri->inputs.dady[slot][1] = 1.0; 159 /*Z*/ 160 linear_coef(setup, tri, oneoverarea, slot, v1, v2, v3, 0, 2); 161 /*W*/ 162 linear_coef(setup, tri, oneoverarea, slot, v1, v2, v3, 0, 3); 163} 164 165 166static void setup_facing_coef( struct lp_setup_context *setup, 167 struct lp_rast_triangle *tri, 168 unsigned slot, 169 boolean frontface ) 170{ 171 constant_coef( setup, tri, slot, 1.0f - frontface, 0 ); 172 constant_coef( setup, tri, slot, 0.0f, 1 ); /* wasted */ 173 constant_coef( setup, tri, slot, 0.0f, 2 ); /* wasted */ 174 constant_coef( setup, tri, slot, 0.0f, 3 ); /* wasted */ 175} 176 177 178/** 179 * Compute the tri->coef[] array dadx, dady, a0 values. 180 */ 181static void setup_tri_coefficients( struct lp_setup_context *setup, 182 struct lp_rast_triangle *tri, 183 float oneoverarea, 184 const float (*v1)[4], 185 const float (*v2)[4], 186 const float (*v3)[4], 187 boolean frontface) 188{ 189 unsigned slot; 190 191 /* The internal position input is in slot zero: 192 */ 193 setup_fragcoord_coef(setup, tri, oneoverarea, 0, v1, v2, v3); 194 195 /* setup interpolation for all the remaining attributes: 196 */ 197 for (slot = 0; slot < setup->fs.nr_inputs; slot++) { 198 unsigned vert_attr = setup->fs.input[slot].src_index; 199 unsigned i; 200 201 switch (setup->fs.input[slot].interp) { 202 case LP_INTERP_CONSTANT: 203 for (i = 0; i < NUM_CHANNELS; i++) 204 constant_coef(setup, tri, slot+1, v3[vert_attr][i], i); 205 break; 206 207 case LP_INTERP_LINEAR: 208 for (i = 0; i < NUM_CHANNELS; i++) 209 linear_coef(setup, tri, oneoverarea, slot+1, v1, v2, v3, vert_attr, i); 210 break; 211 212 case LP_INTERP_PERSPECTIVE: 213 for (i = 0; i < NUM_CHANNELS; i++) 214 perspective_coef(setup, tri, oneoverarea, slot+1, v1, v2, v3, vert_attr, i); 215 break; 216 217 case LP_INTERP_POSITION: 218 /* XXX: fix me - duplicates the values in slot zero. 219 */ 220 setup_fragcoord_coef(setup, tri, oneoverarea, slot+1, v1, v2, v3); 221 break; 222 223 case LP_INTERP_FACING: 224 setup_facing_coef(setup, tri, slot+1, frontface); 225 break; 226 227 default: 228 assert(0); 229 } 230 } 231} 232 233 234 235static INLINE int subpixel_snap( float a ) 236{ 237 return util_iround(FIXED_ONE * a - (FIXED_ONE / 2)); 238} 239 240 241 242/** 243 * Alloc space for a new triangle plus the input.a0/dadx/dady arrays 244 * immediately after it. 245 * The memory is allocated from the per-scene pool, not per-tile. 246 * \param tri_size returns number of bytes allocated 247 * \param nr_inputs number of fragment shader inputs 248 * \return pointer to triangle space 249 */ 250static INLINE struct lp_rast_triangle * 251alloc_triangle(struct lp_scene *scene, unsigned nr_inputs, unsigned *tri_size) 252{ 253 unsigned input_array_sz = NUM_CHANNELS * (nr_inputs + 1) * sizeof(float); 254 struct lp_rast_triangle *tri; 255 unsigned bytes; 256 char *inputs; 257 258 assert(sizeof(*tri) % 16 == 0); 259 260 bytes = sizeof(*tri) + (3 * input_array_sz); 261 262 tri = lp_scene_alloc_aligned( scene, bytes, 16 ); 263 264 inputs = (char *) (tri + 1); 265 tri->inputs.a0 = (float (*)[4]) inputs; 266 tri->inputs.dadx = (float (*)[4]) (inputs + input_array_sz); 267 tri->inputs.dady = (float (*)[4]) (inputs + 2 * input_array_sz); 268 269 *tri_size = bytes; 270 271 return tri; 272} 273 274 275 276/** 277 * Do basic setup for triangle rasterization and determine which 278 * framebuffer tiles are touched. Put the triangle in the scene's 279 * bins for the tiles which we overlap. 280 */ 281static void 282do_triangle_ccw(struct lp_setup_context *setup, 283 const float (*v1)[4], 284 const float (*v2)[4], 285 const float (*v3)[4], 286 boolean frontfacing ) 287{ 288 /* x/y positions in fixed point */ 289 const int x1 = subpixel_snap(v1[0][0] + 0.5 - setup->pixel_offset); 290 const int x2 = subpixel_snap(v2[0][0] + 0.5 - setup->pixel_offset); 291 const int x3 = subpixel_snap(v3[0][0] + 0.5 - setup->pixel_offset); 292 const int y1 = subpixel_snap(v1[0][1] + 0.5 - setup->pixel_offset); 293 const int y2 = subpixel_snap(v2[0][1] + 0.5 - setup->pixel_offset); 294 const int y3 = subpixel_snap(v3[0][1] + 0.5 - setup->pixel_offset); 295 296 struct lp_scene *scene = lp_setup_get_current_scene(setup); 297 struct lp_rast_triangle *tri; 298 int area; 299 float oneoverarea; 300 int minx, maxx, miny, maxy; 301 unsigned tri_bytes; 302 303 tri = alloc_triangle(scene, setup->fs.nr_inputs, &tri_bytes); 304 305#ifdef DEBUG 306 tri->v[0][0] = v1[0][0]; 307 tri->v[1][0] = v2[0][0]; 308 tri->v[2][0] = v3[0][0]; 309 tri->v[0][1] = v1[0][1]; 310 tri->v[1][1] = v2[0][1]; 311 tri->v[2][1] = v3[0][1]; 312#endif 313 314 tri->dx12 = x1 - x2; 315 tri->dx23 = x2 - x3; 316 tri->dx31 = x3 - x1; 317 318 tri->dy12 = y1 - y2; 319 tri->dy23 = y2 - y3; 320 tri->dy31 = y3 - y1; 321 322 area = (tri->dx12 * tri->dy31 - tri->dx31 * tri->dy12); 323 324 LP_COUNT(nr_tris); 325 326 /* Cull non-ccw and zero-sized triangles. 327 * 328 * XXX: subject to overflow?? 329 */ 330 if (area <= 0) { 331 lp_scene_putback_data( scene, tri_bytes ); 332 LP_COUNT(nr_culled_tris); 333 return; 334 } 335 336 /* Bounding rectangle (in pixels) */ 337 minx = (MIN3(x1, x2, x3) + (FIXED_ONE-1)) >> FIXED_ORDER; 338 maxx = (MAX3(x1, x2, x3) + (FIXED_ONE-1)) >> FIXED_ORDER; 339 miny = (MIN3(y1, y2, y3) + (FIXED_ONE-1)) >> FIXED_ORDER; 340 maxy = (MAX3(y1, y2, y3) + (FIXED_ONE-1)) >> FIXED_ORDER; 341 342 if (setup->scissor_test) { 343 minx = MAX2(minx, setup->scissor.current.minx); 344 maxx = MIN2(maxx, setup->scissor.current.maxx); 345 miny = MAX2(miny, setup->scissor.current.miny); 346 maxy = MIN2(maxy, setup->scissor.current.maxy); 347 } 348 349 if (miny == maxy || 350 minx == maxx) { 351 lp_scene_putback_data( scene, tri_bytes ); 352 LP_COUNT(nr_culled_tris); 353 return; 354 } 355 356 /* 357 */ 358 oneoverarea = ((float)FIXED_ONE) / (float)area; 359 360 /* Setup parameter interpolants: 361 */ 362 setup_tri_coefficients( setup, tri, oneoverarea, v1, v2, v3, frontfacing ); 363 364 tri->inputs.facing = frontfacing ? 1.0F : -1.0F; 365 366 /* half-edge constants, will be interated over the whole render target. 367 */ 368 tri->c1 = tri->dy12 * x1 - tri->dx12 * y1; 369 tri->c2 = tri->dy23 * x2 - tri->dx23 * y2; 370 tri->c3 = tri->dy31 * x3 - tri->dx31 * y3; 371 372 /* correct for top-left fill convention: 373 */ 374 if (tri->dy12 < 0 || (tri->dy12 == 0 && tri->dx12 > 0)) tri->c1++; 375 if (tri->dy23 < 0 || (tri->dy23 == 0 && tri->dx23 > 0)) tri->c2++; 376 if (tri->dy31 < 0 || (tri->dy31 == 0 && tri->dx31 > 0)) tri->c3++; 377 378 tri->dy12 *= FIXED_ONE; 379 tri->dy23 *= FIXED_ONE; 380 tri->dy31 *= FIXED_ONE; 381 382 tri->dx12 *= FIXED_ONE; 383 tri->dx23 *= FIXED_ONE; 384 tri->dx31 *= FIXED_ONE; 385 386 /* find trivial reject offsets for each edge for a single-pixel 387 * sized block. These will be scaled up at each recursive level to 388 * match the active blocksize. Scaling in this way works best if 389 * the blocks are square. 390 */ 391 tri->eo1 = 0; 392 if (tri->dy12 < 0) tri->eo1 -= tri->dy12; 393 if (tri->dx12 > 0) tri->eo1 += tri->dx12; 394 395 tri->eo2 = 0; 396 if (tri->dy23 < 0) tri->eo2 -= tri->dy23; 397 if (tri->dx23 > 0) tri->eo2 += tri->dx23; 398 399 tri->eo3 = 0; 400 if (tri->dy31 < 0) tri->eo3 -= tri->dy31; 401 if (tri->dx31 > 0) tri->eo3 += tri->dx31; 402 403 /* Calculate trivial accept offsets from the above. 404 */ 405 tri->ei1 = tri->dx12 - tri->dy12 - tri->eo1; 406 tri->ei2 = tri->dx23 - tri->dy23 - tri->eo2; 407 tri->ei3 = tri->dx31 - tri->dy31 - tri->eo3; 408 409 /* Fill in the inputs.step[][] arrays. 410 * We've manually unrolled some loops here. 411 */ 412 { 413 const int xstep1 = -tri->dy12; 414 const int xstep2 = -tri->dy23; 415 const int xstep3 = -tri->dy31; 416 const int ystep1 = tri->dx12; 417 const int ystep2 = tri->dx23; 418 const int ystep3 = tri->dx31; 419 420#define SETUP_STEP(i, x, y) \ 421 do { \ 422 tri->inputs.step[0][i] = x * xstep1 + y * ystep1; \ 423 tri->inputs.step[1][i] = x * xstep2 + y * ystep2; \ 424 tri->inputs.step[2][i] = x * xstep3 + y * ystep3; \ 425 } while (0) 426 427 SETUP_STEP(0, 0, 0); 428 SETUP_STEP(1, 1, 0); 429 SETUP_STEP(2, 0, 1); 430 SETUP_STEP(3, 1, 1); 431 432 SETUP_STEP(4, 2, 0); 433 SETUP_STEP(5, 3, 0); 434 SETUP_STEP(6, 2, 1); 435 SETUP_STEP(7, 3, 1); 436 437 SETUP_STEP(8, 0, 2); 438 SETUP_STEP(9, 1, 2); 439 SETUP_STEP(10, 0, 3); 440 SETUP_STEP(11, 1, 3); 441 442 SETUP_STEP(12, 2, 2); 443 SETUP_STEP(13, 3, 2); 444 SETUP_STEP(14, 2, 3); 445 SETUP_STEP(15, 3, 3); 446#undef STEP 447 } 448 449 /* 450 * All fields of 'tri' are now set. The remaining code here is 451 * concerned with binning. 452 */ 453 454 /* Convert to tile coordinates: 455 */ 456 minx = minx / TILE_SIZE; 457 miny = miny / TILE_SIZE; 458 maxx = maxx / TILE_SIZE; 459 maxy = maxy / TILE_SIZE; 460 461 /* 462 * Clamp to framebuffer size 463 */ 464 minx = MAX2(minx, 0); 465 miny = MAX2(miny, 0); 466 maxx = MIN2(maxx, scene->tiles_x - 1); 467 maxy = MIN2(maxy, scene->tiles_y - 1); 468 469 /* Determine which tile(s) intersect the triangle's bounding box 470 */ 471 if (miny == maxy && minx == maxx) 472 { 473 /* Triangle is contained in a single tile: 474 */ 475 lp_scene_bin_command( scene, minx, miny, lp_rast_triangle, 476 lp_rast_arg_triangle(tri) ); 477 } 478 else 479 { 480 int c1 = (tri->c1 + 481 tri->dx12 * miny * TILE_SIZE - 482 tri->dy12 * minx * TILE_SIZE); 483 int c2 = (tri->c2 + 484 tri->dx23 * miny * TILE_SIZE - 485 tri->dy23 * minx * TILE_SIZE); 486 int c3 = (tri->c3 + 487 tri->dx31 * miny * TILE_SIZE - 488 tri->dy31 * minx * TILE_SIZE); 489 490 int ei1 = tri->ei1 << TILE_ORDER; 491 int ei2 = tri->ei2 << TILE_ORDER; 492 int ei3 = tri->ei3 << TILE_ORDER; 493 494 int eo1 = tri->eo1 << TILE_ORDER; 495 int eo2 = tri->eo2 << TILE_ORDER; 496 int eo3 = tri->eo3 << TILE_ORDER; 497 498 int xstep1 = -(tri->dy12 << TILE_ORDER); 499 int xstep2 = -(tri->dy23 << TILE_ORDER); 500 int xstep3 = -(tri->dy31 << TILE_ORDER); 501 502 int ystep1 = tri->dx12 << TILE_ORDER; 503 int ystep2 = tri->dx23 << TILE_ORDER; 504 int ystep3 = tri->dx31 << TILE_ORDER; 505 int x, y; 506 507 508 /* Test tile-sized blocks against the triangle. 509 * Discard blocks fully outside the tri. If the block is fully 510 * contained inside the tri, bin an lp_rast_shade_tile command. 511 * Else, bin a lp_rast_triangle command. 512 */ 513 for (y = miny; y <= maxy; y++) 514 { 515 int cx1 = c1; 516 int cx2 = c2; 517 int cx3 = c3; 518 boolean in = FALSE; /* are we inside the triangle? */ 519 520 for (x = minx; x <= maxx; x++) 521 { 522 if (cx1 + eo1 < 0 || 523 cx2 + eo2 < 0 || 524 cx3 + eo3 < 0) 525 { 526 /* do nothing */ 527 LP_COUNT(nr_empty_64); 528 if (in) 529 break; /* exiting triangle, all done with this row */ 530 } 531 else if (cx1 + ei1 > 0 && 532 cx2 + ei2 > 0 && 533 cx3 + ei3 > 0) 534 { 535 /* triangle covers the whole tile- shade whole tile */ 536 LP_COUNT(nr_fully_covered_64); 537 in = TRUE; 538 if(setup->fs.current.opaque) { 539 lp_scene_bin_reset( scene, x, y ); 540 lp_scene_bin_command( scene, x, y, 541 lp_rast_set_state, 542 lp_rast_arg_state(setup->fs.stored) ); 543 } 544 lp_scene_bin_command( scene, x, y, 545 lp_rast_shade_tile, 546 lp_rast_arg_inputs(&tri->inputs) ); 547 } 548 else 549 { 550 /* rasterizer/shade partial tile */ 551 LP_COUNT(nr_partially_covered_64); 552 in = TRUE; 553 lp_scene_bin_command( scene, x, y, 554 lp_rast_triangle, 555 lp_rast_arg_triangle(tri) ); 556 } 557 558 /* Iterate cx values across the region: 559 */ 560 cx1 += xstep1; 561 cx2 += xstep2; 562 cx3 += xstep3; 563 } 564 565 /* Iterate c values down the region: 566 */ 567 c1 += ystep1; 568 c2 += ystep2; 569 c3 += ystep3; 570 } 571 } 572} 573 574 575static void triangle_cw( struct lp_setup_context *setup, 576 const float (*v0)[4], 577 const float (*v1)[4], 578 const float (*v2)[4] ) 579{ 580 do_triangle_ccw( setup, v1, v0, v2, !setup->ccw_is_frontface ); 581} 582 583 584static void triangle_ccw( struct lp_setup_context *setup, 585 const float (*v0)[4], 586 const float (*v1)[4], 587 const float (*v2)[4] ) 588{ 589 do_triangle_ccw( setup, v0, v1, v2, setup->ccw_is_frontface ); 590} 591 592 593static void triangle_both( struct lp_setup_context *setup, 594 const float (*v0)[4], 595 const float (*v1)[4], 596 const float (*v2)[4] ) 597{ 598 /* edge vectors e = v0 - v2, f = v1 - v2 */ 599 const float ex = v0[0][0] - v2[0][0]; 600 const float ey = v0[0][1] - v2[0][1]; 601 const float fx = v1[0][0] - v2[0][0]; 602 const float fy = v1[0][1] - v2[0][1]; 603 604 /* det = cross(e,f).z */ 605 if (ex * fy - ey * fx < 0.0f) 606 triangle_ccw( setup, v0, v1, v2 ); 607 else 608 triangle_cw( setup, v0, v1, v2 ); 609} 610 611 612static void triangle_nop( struct lp_setup_context *setup, 613 const float (*v0)[4], 614 const float (*v1)[4], 615 const float (*v2)[4] ) 616{ 617} 618 619 620void 621lp_setup_choose_triangle( struct lp_setup_context *setup ) 622{ 623 switch (setup->cullmode) { 624 case PIPE_WINDING_NONE: 625 setup->triangle = triangle_both; 626 break; 627 case PIPE_WINDING_CCW: 628 setup->triangle = triangle_cw; 629 break; 630 case PIPE_WINDING_CW: 631 setup->triangle = triangle_ccw; 632 break; 633 default: 634 setup->triangle = triangle_nop; 635 break; 636 } 637} 638