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