/* $Id: s_aatritemp.h,v 1.19 2001/07/13 20:07:37 brianp Exp $ */ /* * Mesa 3-D graphics library * Version: 3.5 * * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* * Antialiased Triangle Rasterizer Template * * This file is #include'd to generate custom AA triangle rasterizers. * NOTE: this code hasn't been optimized yet. That'll come after it * works correctly. * * The following macros may be defined to indicate what auxillary information * must be copmuted across the triangle: * DO_Z - if defined, compute Z values * DO_RGBA - if defined, compute RGBA values * DO_INDEX - if defined, compute color index values * DO_SPEC - if defined, compute specular RGB values * DO_TEX - if defined, compute unit 0 STRQ texcoords * DO_MULTITEX - if defined, compute all unit's STRQ texcoords */ /*void triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv )*/ { const GLfloat *p0 = v0->win; const GLfloat *p1 = v1->win; const GLfloat *p2 = v2->win; const SWvertex *vMin, *vMid, *vMax; GLfloat xMin, yMin, xMid, yMid, xMax, yMax; GLfloat majDx, majDy, botDx, botDy, topDx, topDy; GLfloat area; GLboolean majorOnLeft; GLfloat bf = SWRAST_CONTEXT(ctx)->_backface_sign; #ifdef DO_Z GLfloat zPlane[4]; GLdepth z[MAX_WIDTH]; #endif #ifdef DO_FOG GLfloat fogPlane[4]; GLfloat fog[MAX_WIDTH]; #else GLfloat *fog = NULL; #endif #ifdef DO_RGBA GLfloat rPlane[4], gPlane[4], bPlane[4], aPlane[4]; DEFMARRAY(GLchan, rgba, MAX_WIDTH, 4); /* mac 32k limitation */ #endif #ifdef DO_INDEX GLfloat iPlane[4]; GLuint index[MAX_WIDTH]; GLint icoverageSpan[MAX_WIDTH]; GLfloat coverageSpan[MAX_WIDTH]; #else GLfloat coverageSpan[MAX_WIDTH]; #endif #ifdef DO_SPEC GLfloat srPlane[4], sgPlane[4], sbPlane[4]; DEFMARRAY(GLchan, spec, MAX_WIDTH, 4); #endif #ifdef DO_TEX GLfloat sPlane[4], tPlane[4], uPlane[4], vPlane[4]; GLfloat texWidth, texHeight; DEFARRAY(GLfloat, s, MAX_WIDTH); /* mac 32k limitation */ DEFARRAY(GLfloat, t, MAX_WIDTH); DEFARRAY(GLfloat, u, MAX_WIDTH); DEFARRAY(GLfloat, lambda, MAX_WIDTH); #elif defined(DO_MULTITEX) GLfloat sPlane[MAX_TEXTURE_UNITS][4]; GLfloat tPlane[MAX_TEXTURE_UNITS][4]; GLfloat uPlane[MAX_TEXTURE_UNITS][4]; GLfloat vPlane[MAX_TEXTURE_UNITS][4]; GLfloat texWidth[MAX_TEXTURE_UNITS], texHeight[MAX_TEXTURE_UNITS]; DEFMARRAY(GLfloat, s, MAX_TEXTURE_UNITS, MAX_WIDTH); /* mac 32k limit */ DEFMARRAY(GLfloat, t, MAX_TEXTURE_UNITS, MAX_WIDTH); DEFMARRAY(GLfloat, u, MAX_TEXTURE_UNITS, MAX_WIDTH); DEFMARRAY(GLfloat, lambda, MAX_TEXTURE_UNITS, MAX_WIDTH); #endif #ifdef DO_RGBA CHECKARRAY(rgba, return); /* mac 32k limitation */ #endif #ifdef DO_SPEC CHECKARRAY(spec, return); #endif #if defined(DO_TEX) || defined(DO_MULTITEX) CHECKARRAY(s, return); CHECKARRAY(t, return); CHECKARRAY(u, return); CHECKARRAY(lambda, return); #endif /* determine bottom to top order of vertices */ { GLfloat y0 = v0->win[1]; GLfloat y1 = v1->win[1]; GLfloat y2 = v2->win[1]; if (y0 <= y1) { if (y1 <= y2) { vMin = v0; vMid = v1; vMax = v2; /* y0<=y1<=y2 */ } else if (y2 <= y0) { vMin = v2; vMid = v0; vMax = v1; /* y2<=y0<=y1 */ } else { vMin = v0; vMid = v2; vMax = v1; bf = -bf; /* y0<=y2<=y1 */ } } else { if (y0 <= y2) { vMin = v1; vMid = v0; vMax = v2; bf = -bf; /* y1<=y0<=y2 */ } else if (y2 <= y1) { vMin = v2; vMid = v1; vMax = v0; bf = -bf; /* y2<=y1<=y0 */ } else { vMin = v1; vMid = v2; vMax = v0; /* y1<=y2<=y0 */ } } } xMin = vMin->win[0]; yMin = vMin->win[1]; xMid = vMid->win[0]; yMid = vMid->win[1]; xMax = vMax->win[0]; yMax = vMax->win[1]; /* the major edge is between the top and bottom vertices */ majDx = xMax - xMin; majDy = yMax - yMin; /* the bottom edge is between the bottom and mid vertices */ botDx = xMid - xMin; botDy = yMid - yMin; /* the top edge is between the top and mid vertices */ topDx = xMax - xMid; topDy = yMax - yMid; /* compute clockwise / counter-clockwise orientation and do BF culling */ area = majDx * botDy - botDx * majDy; /* Do backface culling */ if (area * bf < 0 || area * area < .0025) return; majorOnLeft = (GLboolean) (area < 0.0F); #ifndef DO_OCCLUSION_TEST ctx->OcclusionResult = GL_TRUE; #endif assert(majDy > 0.0F); /* Plane equation setup: * We evaluate plane equations at window (x,y) coordinates in order * to compute color, Z, fog, texcoords, etc. This isn't terribly * efficient but it's easy and reliable. It also copes with computing * interpolated data just outside the triangle's edges. */ #ifdef DO_Z compute_plane(p0, p1, p2, p0[2], p1[2], p2[2], zPlane); #endif #ifdef DO_FOG compute_plane(p0, p1, p2, v0->fog, v1->fog, v2->fog, fogPlane); #endif #ifdef DO_RGBA if (ctx->Light.ShadeModel == GL_SMOOTH) { compute_plane(p0, p1, p2, v0->color[0], v1->color[0], v2->color[0], rPlane); compute_plane(p0, p1, p2, v0->color[1], v1->color[1], v2->color[1], gPlane); compute_plane(p0, p1, p2, v0->color[2], v1->color[2], v2->color[2], bPlane); compute_plane(p0, p1, p2, v0->color[3], v1->color[3], v2->color[3], aPlane); } else { constant_plane(v2->color[RCOMP], rPlane); constant_plane(v2->color[GCOMP], gPlane); constant_plane(v2->color[BCOMP], bPlane); constant_plane(v2->color[ACOMP], aPlane); } #endif #ifdef DO_INDEX if (ctx->Light.ShadeModel == GL_SMOOTH) { compute_plane(p0, p1, p2, v0->index, v1->index, v2->index, iPlane); } else { constant_plane(v2->index, iPlane); } #endif #ifdef DO_SPEC if (ctx->Light.ShadeModel == GL_SMOOTH) { compute_plane(p0, p1, p2, v0->specular[0], v1->specular[0], v2->specular[0],srPlane); compute_plane(p0, p1, p2, v0->specular[1], v1->specular[1], v2->specular[1],sgPlane); compute_plane(p0, p1, p2, v0->specular[2], v1->specular[2], v2->specular[2],sbPlane); } else { constant_plane(v2->specular[RCOMP], srPlane); constant_plane(v2->specular[GCOMP], sgPlane); constant_plane(v2->specular[BCOMP], sbPlane); } #endif #ifdef DO_TEX { const struct gl_texture_object *obj = ctx->Texture.Unit[0]._Current; const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel]; const GLfloat invW0 = v0->win[3]; const GLfloat invW1 = v1->win[3]; const GLfloat invW2 = v2->win[3]; const GLfloat s0 = v0->texcoord[0][0] * invW0; const GLfloat s1 = v1->texcoord[0][0] * invW1; const GLfloat s2 = v2->texcoord[0][0] * invW2; const GLfloat t0 = v0->texcoord[0][1] * invW0; const GLfloat t1 = v1->texcoord[0][1] * invW1; const GLfloat t2 = v2->texcoord[0][1] * invW2; const GLfloat r0 = v0->texcoord[0][2] * invW0; const GLfloat r1 = v1->texcoord[0][2] * invW1; const GLfloat r2 = v2->texcoord[0][2] * invW2; const GLfloat q0 = v0->texcoord[0][3] * invW0; const GLfloat q1 = v1->texcoord[0][3] * invW1; const GLfloat q2 = v2->texcoord[0][3] * invW2; compute_plane(p0, p1, p2, s0, s1, s2, sPlane); compute_plane(p0, p1, p2, t0, t1, t2, tPlane); compute_plane(p0, p1, p2, r0, r1, r2, uPlane); compute_plane(p0, p1, p2, q0, q1, q2, vPlane); texWidth = (GLfloat) texImage->Width; texHeight = (GLfloat) texImage->Height; } #elif defined(DO_MULTITEX) { GLuint u; for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { if (ctx->Texture.Unit[u]._ReallyEnabled) { const struct gl_texture_object *obj = ctx->Texture.Unit[u]._Current; const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel]; const GLfloat invW0 = v0->win[3]; const GLfloat invW1 = v1->win[3]; const GLfloat invW2 = v2->win[3]; const GLfloat s0 = v0->texcoord[u][0] * invW0; const GLfloat s1 = v1->texcoord[u][0] * invW1; const GLfloat s2 = v2->texcoord[u][0] * invW2; const GLfloat t0 = v0->texcoord[u][1] * invW0; const GLfloat t1 = v1->texcoord[u][1] * invW1; const GLfloat t2 = v2->texcoord[u][1] * invW2; const GLfloat r0 = v0->texcoord[u][2] * invW0; const GLfloat r1 = v1->texcoord[u][2] * invW1; const GLfloat r2 = v2->texcoord[u][2] * invW2; const GLfloat q0 = v0->texcoord[u][3] * invW0; const GLfloat q1 = v1->texcoord[u][3] * invW1; const GLfloat q2 = v2->texcoord[u][3] * invW2; compute_plane(p0, p1, p2, s0, s1, s2, sPlane[u]); compute_plane(p0, p1, p2, t0, t1, t2, tPlane[u]); compute_plane(p0, p1, p2, r0, r1, r2, uPlane[u]); compute_plane(p0, p1, p2, q0, q1, q2, vPlane[u]); texWidth[u] = (GLfloat) texImage->Width; texHeight[u] = (GLfloat) texImage->Height; } } } #endif /* Begin bottom-to-top scan over the triangle. * The long edge will either be on the left or right side of the * triangle. We always scan from the long edge toward the shorter * edges, stopping when we find that coverage = 0. If the long edge * is on the left we scan left-to-right. Else, we scan right-to-left. */ { const GLint iyMin = (GLint) yMin; const GLint iyMax = (GLint) yMax + 1; /* upper edge and lower edge derivatives */ const GLfloat topDxDy = (topDy != 0.0F) ? topDx / topDy : 0.0F; const GLfloat botDxDy = (botDy != 0.0F) ? botDx / botDy : 0.0F; const GLfloat *pA, *pB, *pC; const GLfloat majDxDy = majDx / majDy; const GLfloat absMajDxDy = FABSF(majDxDy); const GLfloat absTopDxDy = FABSF(topDxDy); const GLfloat absBotDxDy = FABSF(botDxDy); #if 0 GLfloat xMaj = xMin - (yMin - (GLfloat) iyMin) * majDxDy; GLfloat xBot = xMaj; GLfloat xTop = xMid - (yMid - (GLint) yMid) * topDxDy; #else GLfloat xMaj; GLfloat xBot; GLfloat xTop; #endif GLint iy; GLint k; /* pA, pB, pC are the vertices in counter-clockwise order */ if (majorOnLeft) { pA = vMin->win; pB = vMid->win; pC = vMax->win; xMaj = xMin - absMajDxDy - 1.0; xBot = xMin + absBotDxDy + 1.0; xTop = xMid + absTopDxDy + 1.0; } else { pA = vMin->win; pB = vMax->win; pC = vMid->win; xMaj = xMin + absMajDxDy + 1.0; xBot = xMin - absBotDxDy - 1.0; xTop = xMid - absTopDxDy - 1.0; } /* Scan from bottom to top */ for (iy = iyMin; iy < iyMax; iy++, xMaj += majDxDy) { GLint ix, i, j, len; GLint iRight, iLeft; GLfloat coverage = 0.0F; if (majorOnLeft) { iLeft = (GLint) (xMaj + 0.0); /* compute right */ if (iy <= yMid) { /* we're in the lower part */ iRight = (GLint) (xBot + 0.0); xBot += botDxDy; } else { /* we're in the upper part */ iRight = (GLint) (xTop + 0.0); xTop += topDxDy; } } else { iRight = (GLint) (xMaj + 0.0); /* compute left */ if (iy <= yMid) { /* we're in the lower part */ iLeft = (GLint) (xBot - 0.0); xBot += botDxDy; } else { /* we're in the upper part */ iLeft = (GLint) (xTop - 0.0); xTop += topDxDy; } } #ifdef DEBUG for (i = 0; i < MAX_WIDTH; i++) { coverageSpan[i] = -1.0; } #endif if (iLeft < 0) iLeft = 0; if (iRight >= ctx->DrawBuffer->_Xmax) iRight = ctx->DrawBuffer->_Xmax - 1; /*printf("%d: iLeft = %d iRight = %d\n", iy, iLeft, iRight);*/ /* The pixels at y in [iLeft, iRight] (inclusive) are candidates */ /* scan left to right until we hit 100% coverage or the right edge */ i = iLeft; while (i < iRight) { coverage = compute_coveragef(pA, pB, pC, i, iy); if (coverage == 0.0F) { if (i == iLeft) iLeft++; /* skip zero coverage pixels */ else { iRight = i; i--; break; /* went past right edge */ } } else { coverageSpan[i - iLeft] = coverage; if (coverage == 1.0F) break; } i++; } assert(coverageSpan[i-iLeft] > 0.0 || iLeft == iRight); assert(i == iRight || coverage == 1.0 || coverage == 0.0); /* scan right to left until we hit 100% coverage or the left edge */ j = iRight; assert(j - iLeft >= 0); while (1) { coverage = compute_coveragef(pA, pB, pC, j, iy); if (coverage == 0.0F) { if (j == iRight && j > i) iRight--; /* skip zero coverage pixels */ else break; } else { if (j <= i) break; assert(j - iLeft >= 0); coverageSpan[j - iLeft] = coverage; if (coverage == 1.0F) break; } /*printf("%d: coverage[%d]' = %g\n", iy, j-iLeft, coverage);*/ j--; } assert(coverageSpan[j-iLeft] > 0.0 || iRight <= iLeft); printf("iLeft=%d i=%d j=%d iRight=%d\n", iLeft, i, j, iRight); assert(iLeft >= 0); assert(iLeft < ctx->DrawBuffer->_Xmax); assert(iRight >= 0); assert(iRight < ctx->DrawBuffer->_Xmax); assert(iRight >= iLeft); /* any pixels left in between must have 100% coverage */ k = i + 1; while (k < j) { coverageSpan[k - iLeft] = 1.0F; k++; } len = iRight - iLeft; /*printf("len = %d\n", len);*/ assert(len >= 0); assert(len < MAX_WIDTH); if (len == 0) continue; #ifdef DEBUG for (k = 0; k < len; k++) { assert(coverageSpan[k] > 0.0); } #endif /* * Compute color, texcoords, etc for the span */ { const GLfloat cx = iLeft + 0.5F, cy = iy + 0.5F; #ifdef DO_Z GLfloat zFrag = solve_plane(cx, cy, zPlane); const GLfloat zStep = -zPlane[0] / zPlane[2]; #endif #ifdef DO_FOG GLfloat fogFrag = solve_plane(cx, cy, fogPlane); const GLfloat fogStep = -fogPlane[0] / fogPlane[2]; #endif #ifdef DO_RGBA /* to do */ #endif #ifdef DO_INDEX /* to do */ #endif #ifdef DO_SPEC /* to do */ #endif #ifdef DO_TEX GLfloat sFrag = solve_plane(cx, cy, sPlane); GLfloat tFrag = solve_plane(cx, cy, tPlane); GLfloat uFrag = solve_plane(cx, cy, uPlane); GLfloat vFrag = solve_plane(cx, cy, vPlane); const GLfloat sStep = -sPlane[0] / sPlane[2]; const GLfloat tStep = -tPlane[0] / tPlane[2]; const GLfloat uStep = -uPlane[0] / uPlane[2]; const GLfloat vStep = -vPlane[0] / vPlane[2]; #elif defined(DO_MULTITEX) /* to do */ #endif for (ix = iLeft; ix < iRight; ix++) { const GLint k = ix - iLeft; const GLfloat cx = ix + 0.5F, cy = iy + 0.5F; #ifdef DO_Z z[k] = zFrag; zFrag += zStep; #endif #ifdef DO_FOG fog[k] = fogFrag; fogFrag += fogStep; #endif #ifdef DO_RGBA rgba[k][RCOMP] = solve_plane_chan(cx, cy, rPlane); rgba[k][GCOMP] = solve_plane_chan(cx, cy, gPlane); rgba[k][BCOMP] = solve_plane_chan(cx, cy, bPlane); rgba[k][ACOMP] = solve_plane_chan(cx, cy, aPlane); #endif #ifdef DO_INDEX index[k] = (GLint) solve_plane(cx, cy, iPlane); #endif #ifdef DO_SPEC spec[k][RCOMP] = solve_plane_chan(cx, cy, srPlane); spec[k][GCOMP] = solve_plane_chan(cx, cy, sgPlane); spec[k][BCOMP] = solve_plane_chan(cx, cy, sbPlane); #endif #ifdef DO_TEX s[k] = sFrag / vFrag; t[k] = tFrag / vFrag; u[k] = uFrag / vFrag; lambda[k] = compute_lambda(sPlane, tPlane, 1.0F / vFrag, texWidth, texHeight); sFrag += sStep; tFrag += tStep; uFrag += uStep; vFrag += vStep; #elif defined(DO_MULTITEX) { GLuint unit; for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { if (ctx->Texture.Unit[unit]._ReallyEnabled) { GLfloat invQ = solve_plane_recip(cx, cy, vPlane[unit]); s[unit][k] = solve_plane(cx, cy, sPlane[unit]) * invQ; t[unit][k] = solve_plane(cx, cy, tPlane[unit]) * invQ; u[unit][k] = solve_plane(cx, cy, uPlane[unit]) * invQ; lambda[unit][k] = compute_lambda(sPlane[unit], tPlane[unit], invQ, texWidth[unit], texHeight[unit]); } } } #endif } /* for ix */ } /* * Write/process the span of fragments. */ #ifdef DO_MULTITEX _mesa_write_multitexture_span(ctx, len, iLeft, iy, z, fog, (const GLfloat (*)[MAX_WIDTH]) s, (const GLfloat (*)[MAX_WIDTH]) t, (const GLfloat (*)[MAX_WIDTH]) u, (GLfloat (*)[MAX_WIDTH]) lambda, rgba, # ifdef DO_SPEC (const GLchan (*)[4]) spec, # else NULL, # endif coverageSpan, GL_POLYGON); #elif defined(DO_TEX) _mesa_write_texture_span(ctx, len, iLeft, iy, z, fog, s, t, u, lambda, rgba, # ifdef DO_SPEC (const GLchan (*)[4]) spec, # else NULL, # endif coverageSpan, GL_POLYGON); #elif defined(DO_RGBA) _mesa_write_rgba_span(ctx, len, iLeft, iy, z, fog, rgba, coverageSpan, GL_POLYGON); #elif defined(DO_INDEX) _mesa_write_index_span(ctx, len, iLeft, iy, z, fog, index, icoverageSpan, GL_POLYGON); #endif } /* for iy */ } #ifdef DO_RGBA UNDEFARRAY(rgba); /* mac 32k limitation */ #endif #ifdef DO_SPEC UNDEFARRAY(spec); #endif #if defined(DO_TEX) || defined(DO_MULTITEX) UNDEFARRAY(s); UNDEFARRAY(t); UNDEFARRAY(u); UNDEFARRAY(lambda); #endif } #ifdef DO_Z #undef DO_Z #endif #ifdef DO_FOG #undef DO_FOG #endif #ifdef DO_RGBA #undef DO_RGBA #endif #ifdef DO_INDEX #undef DO_INDEX #endif #ifdef DO_SPEC #undef DO_SPEC #endif #ifdef DO_TEX #undef DO_TEX #endif #ifdef DO_MULTITEX #undef DO_MULTITEX #endif #ifdef DO_OCCLUSION_TEST #undef DO_OCCLUSION_TEST #endif