1/* 2 * Mesa 3-D graphics library 3 * Version: 7.0.3 4 * 5 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included 15 * in all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 23 */ 24 25 26/* 27 * Antialiased Triangle Rasterizer Template 28 * 29 * This file is #include'd to generate custom AA triangle rasterizers. 30 * NOTE: this code hasn't been optimized yet. That'll come after it 31 * works correctly. 32 * 33 * The following macros may be defined to indicate what auxillary information 34 * must be copmuted across the triangle: 35 * DO_Z - if defined, compute Z values 36 * DO_ATTRIBS - if defined, compute texcoords, varying, etc. 37 */ 38 39/*void triangle( struct gl_context *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv )*/ 40{ 41 const SWcontext *swrast = SWRAST_CONTEXT(ctx); 42 const GLfloat *p0 = v0->attrib[FRAG_ATTRIB_WPOS]; 43 const GLfloat *p1 = v1->attrib[FRAG_ATTRIB_WPOS]; 44 const GLfloat *p2 = v2->attrib[FRAG_ATTRIB_WPOS]; 45 const SWvertex *vMin, *vMid, *vMax; 46 GLint iyMin, iyMax; 47 GLfloat yMin, yMax; 48 GLboolean ltor; 49 GLfloat majDx, majDy; /* major (i.e. long) edge dx and dy */ 50 51 SWspan span; 52 53#ifdef DO_Z 54 GLfloat zPlane[4]; 55#endif 56 GLfloat rPlane[4], gPlane[4], bPlane[4], aPlane[4]; 57#if defined(DO_ATTRIBS) 58 GLfloat attrPlane[FRAG_ATTRIB_MAX][4][4]; 59 GLfloat wPlane[4]; /* win[3] */ 60#endif 61 GLfloat bf = SWRAST_CONTEXT(ctx)->_BackfaceCullSign; 62 63 (void) swrast; 64 65 INIT_SPAN(span, GL_POLYGON); 66 span.arrayMask = SPAN_COVERAGE; 67 68 /* determine bottom to top order of vertices */ 69 { 70 GLfloat y0 = v0->attrib[FRAG_ATTRIB_WPOS][1]; 71 GLfloat y1 = v1->attrib[FRAG_ATTRIB_WPOS][1]; 72 GLfloat y2 = v2->attrib[FRAG_ATTRIB_WPOS][1]; 73 if (y0 <= y1) { 74 if (y1 <= y2) { 75 vMin = v0; vMid = v1; vMax = v2; /* y0<=y1<=y2 */ 76 } 77 else if (y2 <= y0) { 78 vMin = v2; vMid = v0; vMax = v1; /* y2<=y0<=y1 */ 79 } 80 else { 81 vMin = v0; vMid = v2; vMax = v1; bf = -bf; /* y0<=y2<=y1 */ 82 } 83 } 84 else { 85 if (y0 <= y2) { 86 vMin = v1; vMid = v0; vMax = v2; bf = -bf; /* y1<=y0<=y2 */ 87 } 88 else if (y2 <= y1) { 89 vMin = v2; vMid = v1; vMax = v0; bf = -bf; /* y2<=y1<=y0 */ 90 } 91 else { 92 vMin = v1; vMid = v2; vMax = v0; /* y1<=y2<=y0 */ 93 } 94 } 95 } 96 97 majDx = vMax->attrib[FRAG_ATTRIB_WPOS][0] - vMin->attrib[FRAG_ATTRIB_WPOS][0]; 98 majDy = vMax->attrib[FRAG_ATTRIB_WPOS][1] - vMin->attrib[FRAG_ATTRIB_WPOS][1]; 99 100 /* front/back-face determination and cullling */ 101 { 102 const GLfloat botDx = vMid->attrib[FRAG_ATTRIB_WPOS][0] - vMin->attrib[FRAG_ATTRIB_WPOS][0]; 103 const GLfloat botDy = vMid->attrib[FRAG_ATTRIB_WPOS][1] - vMin->attrib[FRAG_ATTRIB_WPOS][1]; 104 const GLfloat area = majDx * botDy - botDx * majDy; 105 /* Do backface culling */ 106 if (area * bf < 0 || area == 0 || IS_INF_OR_NAN(area)) 107 return; 108 ltor = (GLboolean) (area < 0.0F); 109 110 span.facing = area * swrast->_BackfaceSign > 0.0F; 111 } 112 113 /* Plane equation setup: 114 * We evaluate plane equations at window (x,y) coordinates in order 115 * to compute color, Z, fog, texcoords, etc. This isn't terribly 116 * efficient but it's easy and reliable. 117 */ 118#ifdef DO_Z 119 compute_plane(p0, p1, p2, p0[2], p1[2], p2[2], zPlane); 120 span.arrayMask |= SPAN_Z; 121#endif 122 if (ctx->Light.ShadeModel == GL_SMOOTH) { 123 compute_plane(p0, p1, p2, v0->color[RCOMP], v1->color[RCOMP], v2->color[RCOMP], rPlane); 124 compute_plane(p0, p1, p2, v0->color[GCOMP], v1->color[GCOMP], v2->color[GCOMP], gPlane); 125 compute_plane(p0, p1, p2, v0->color[BCOMP], v1->color[BCOMP], v2->color[BCOMP], bPlane); 126 compute_plane(p0, p1, p2, v0->color[ACOMP], v1->color[ACOMP], v2->color[ACOMP], aPlane); 127 } 128 else { 129 constant_plane(v2->color[RCOMP], rPlane); 130 constant_plane(v2->color[GCOMP], gPlane); 131 constant_plane(v2->color[BCOMP], bPlane); 132 constant_plane(v2->color[ACOMP], aPlane); 133 } 134 span.arrayMask |= SPAN_RGBA; 135#if defined(DO_ATTRIBS) 136 { 137 const GLfloat invW0 = v0->attrib[FRAG_ATTRIB_WPOS][3]; 138 const GLfloat invW1 = v1->attrib[FRAG_ATTRIB_WPOS][3]; 139 const GLfloat invW2 = v2->attrib[FRAG_ATTRIB_WPOS][3]; 140 compute_plane(p0, p1, p2, invW0, invW1, invW2, wPlane); 141 span.attrStepX[FRAG_ATTRIB_WPOS][3] = plane_dx(wPlane); 142 span.attrStepY[FRAG_ATTRIB_WPOS][3] = plane_dy(wPlane); 143 ATTRIB_LOOP_BEGIN 144 GLuint c; 145 if (swrast->_InterpMode[attr] == GL_FLAT) { 146 for (c = 0; c < 4; c++) { 147 constant_plane(v2->attrib[attr][c] * invW2, attrPlane[attr][c]); 148 } 149 } 150 else { 151 for (c = 0; c < 4; c++) { 152 const GLfloat a0 = v0->attrib[attr][c] * invW0; 153 const GLfloat a1 = v1->attrib[attr][c] * invW1; 154 const GLfloat a2 = v2->attrib[attr][c] * invW2; 155 compute_plane(p0, p1, p2, a0, a1, a2, attrPlane[attr][c]); 156 } 157 } 158 for (c = 0; c < 4; c++) { 159 span.attrStepX[attr][c] = plane_dx(attrPlane[attr][c]); 160 span.attrStepY[attr][c] = plane_dy(attrPlane[attr][c]); 161 } 162 ATTRIB_LOOP_END 163 } 164#endif 165 166 /* Begin bottom-to-top scan over the triangle. 167 * The long edge will either be on the left or right side of the 168 * triangle. We always scan from the long edge toward the shorter 169 * edges, stopping when we find that coverage = 0. If the long edge 170 * is on the left we scan left-to-right. Else, we scan right-to-left. 171 */ 172 yMin = vMin->attrib[FRAG_ATTRIB_WPOS][1]; 173 yMax = vMax->attrib[FRAG_ATTRIB_WPOS][1]; 174 iyMin = (GLint) yMin; 175 iyMax = (GLint) yMax + 1; 176 177 if (ltor) { 178 /* scan left to right */ 179 const GLfloat *pMin = vMin->attrib[FRAG_ATTRIB_WPOS]; 180 const GLfloat *pMid = vMid->attrib[FRAG_ATTRIB_WPOS]; 181 const GLfloat *pMax = vMax->attrib[FRAG_ATTRIB_WPOS]; 182 const GLfloat dxdy = majDx / majDy; 183 const GLfloat xAdj = dxdy < 0.0F ? -dxdy : 0.0F; 184 GLint iy; 185#ifdef _OPENMP 186#pragma omp parallel for schedule(dynamic) private(iy) firstprivate(span) 187#endif 188 for (iy = iyMin; iy < iyMax; iy++) { 189 GLfloat x = pMin[0] - (yMin - iy) * dxdy; 190 GLint ix, startX = (GLint) (x - xAdj); 191 GLuint count; 192 GLfloat coverage = 0.0F; 193 194#ifdef _OPENMP 195 /* each thread needs to use a different (global) SpanArrays variable */ 196 span.array = SWRAST_CONTEXT(ctx)->SpanArrays + omp_get_thread_num(); 197#endif 198 /* skip over fragments with zero coverage */ 199 while (startX < SWRAST_MAX_WIDTH) { 200 coverage = compute_coveragef(pMin, pMid, pMax, startX, iy); 201 if (coverage > 0.0F) 202 break; 203 startX++; 204 } 205 206 /* enter interior of triangle */ 207 ix = startX; 208 209#if defined(DO_ATTRIBS) 210 /* compute attributes at left-most fragment */ 211 span.attrStart[FRAG_ATTRIB_WPOS][3] = solve_plane(ix + 0.5F, iy + 0.5F, wPlane); 212 ATTRIB_LOOP_BEGIN 213 GLuint c; 214 for (c = 0; c < 4; c++) { 215 span.attrStart[attr][c] = solve_plane(ix + 0.5F, iy + 0.5F, attrPlane[attr][c]); 216 } 217 ATTRIB_LOOP_END 218#endif 219 220 count = 0; 221 while (coverage > 0.0F) { 222 /* (cx,cy) = center of fragment */ 223 const GLfloat cx = ix + 0.5F, cy = iy + 0.5F; 224 SWspanarrays *array = span.array; 225 array->coverage[count] = coverage; 226#ifdef DO_Z 227 array->z[count] = (GLuint) solve_plane(cx, cy, zPlane); 228#endif 229 array->rgba[count][RCOMP] = solve_plane_chan(cx, cy, rPlane); 230 array->rgba[count][GCOMP] = solve_plane_chan(cx, cy, gPlane); 231 array->rgba[count][BCOMP] = solve_plane_chan(cx, cy, bPlane); 232 array->rgba[count][ACOMP] = solve_plane_chan(cx, cy, aPlane); 233 ix++; 234 count++; 235 coverage = compute_coveragef(pMin, pMid, pMax, ix, iy); 236 } 237 238 if (ix > startX) { 239 span.x = startX; 240 span.y = iy; 241 span.end = (GLuint) ix - (GLuint) startX; 242 _swrast_write_rgba_span(ctx, &span); 243 } 244 } 245 } 246 else { 247 /* scan right to left */ 248 const GLfloat *pMin = vMin->attrib[FRAG_ATTRIB_WPOS]; 249 const GLfloat *pMid = vMid->attrib[FRAG_ATTRIB_WPOS]; 250 const GLfloat *pMax = vMax->attrib[FRAG_ATTRIB_WPOS]; 251 const GLfloat dxdy = majDx / majDy; 252 const GLfloat xAdj = dxdy > 0 ? dxdy : 0.0F; 253 GLint iy; 254#ifdef _OPENMP 255#pragma omp parallel for schedule(dynamic) private(iy) firstprivate(span) 256#endif 257 for (iy = iyMin; iy < iyMax; iy++) { 258 GLfloat x = pMin[0] - (yMin - iy) * dxdy; 259 GLint ix, left, startX = (GLint) (x + xAdj); 260 GLuint count, n; 261 GLfloat coverage = 0.0F; 262 263#ifdef _OPENMP 264 /* each thread needs to use a different (global) SpanArrays variable */ 265 span.array = SWRAST_CONTEXT(ctx)->SpanArrays + omp_get_thread_num(); 266#endif 267 /* make sure we're not past the window edge */ 268 if (startX >= ctx->DrawBuffer->_Xmax) { 269 startX = ctx->DrawBuffer->_Xmax - 1; 270 } 271 272 /* skip fragments with zero coverage */ 273 while (startX > 0) { 274 coverage = compute_coveragef(pMin, pMax, pMid, startX, iy); 275 if (coverage > 0.0F) 276 break; 277 startX--; 278 } 279 280 /* enter interior of triangle */ 281 ix = startX; 282 count = 0; 283 while (coverage > 0.0F) { 284 /* (cx,cy) = center of fragment */ 285 const GLfloat cx = ix + 0.5F, cy = iy + 0.5F; 286 SWspanarrays *array = span.array; 287 ASSERT(ix >= 0); 288 array->coverage[ix] = coverage; 289#ifdef DO_Z 290 array->z[ix] = (GLuint) solve_plane(cx, cy, zPlane); 291#endif 292 array->rgba[ix][RCOMP] = solve_plane_chan(cx, cy, rPlane); 293 array->rgba[ix][GCOMP] = solve_plane_chan(cx, cy, gPlane); 294 array->rgba[ix][BCOMP] = solve_plane_chan(cx, cy, bPlane); 295 array->rgba[ix][ACOMP] = solve_plane_chan(cx, cy, aPlane); 296 ix--; 297 count++; 298 coverage = compute_coveragef(pMin, pMax, pMid, ix, iy); 299 } 300 301#if defined(DO_ATTRIBS) 302 /* compute attributes at left-most fragment */ 303 span.attrStart[FRAG_ATTRIB_WPOS][3] = solve_plane(ix + 1.5F, iy + 0.5F, wPlane); 304 ATTRIB_LOOP_BEGIN 305 GLuint c; 306 for (c = 0; c < 4; c++) { 307 span.attrStart[attr][c] = solve_plane(ix + 1.5F, iy + 0.5F, attrPlane[attr][c]); 308 } 309 ATTRIB_LOOP_END 310#endif 311 312 if (startX > ix) { 313 n = (GLuint) startX - (GLuint) ix; 314 315 left = ix + 1; 316 317 /* shift all values to the left */ 318 /* XXX this is temporary */ 319 { 320 SWspanarrays *array = span.array; 321 GLint j; 322 for (j = 0; j < (GLint) n; j++) { 323 array->coverage[j] = array->coverage[j + left]; 324 COPY_CHAN4(array->rgba[j], array->rgba[j + left]); 325#ifdef DO_Z 326 array->z[j] = array->z[j + left]; 327#endif 328 } 329 } 330 331 span.x = left; 332 span.y = iy; 333 span.end = n; 334 _swrast_write_rgba_span(ctx, &span); 335 } 336 } 337 } 338} 339 340 341#undef DO_Z 342#undef DO_ATTRIBS 343#undef DO_OCCLUSION_TEST 344