diff options
Diffstat (limited to 'src/mesa/swrast/s_triangle.c')
| -rw-r--r-- | src/mesa/swrast/s_triangle.c | 2448 |
1 files changed, 2448 insertions, 0 deletions
diff --git a/src/mesa/swrast/s_triangle.c b/src/mesa/swrast/s_triangle.c new file mode 100644 index 00000000000..4b00d8aff9a --- /dev/null +++ b/src/mesa/swrast/s_triangle.c @@ -0,0 +1,2448 @@ +/* $Id: s_triangle.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */ + +/* + * Mesa 3-D graphics library + * Version: 3.5 + * + * Copyright (C) 1999-2000 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. + */ + + +/* + * Triangle rasterizers + * When the device driver doesn't implement triangle rasterization Mesa + * will use these functions to draw triangles. + */ + + +#include "glheader.h" +#include "context.h" +#include "feedback.h" +#include "macros.h" +#include "mem.h" +#include "mmath.h" +#include "teximage.h" +#include "texstate.h" + +#include "s_aatriangle.h" +#include "s_depth.h" +#include "s_span.h" + +static GLboolean cull_triangle( GLcontext *ctx, + GLuint v0, GLuint v1, GLuint v2, GLuint pv ) +{ + struct vertex_buffer *VB = ctx->VB; + GLfloat (*win)[4] = VB->Win.data; + GLfloat ex = win[v1][0] - win[v0][0]; + GLfloat ey = win[v1][1] - win[v0][1]; + GLfloat fx = win[v2][0] - win[v0][0]; + GLfloat fy = win[v2][1] - win[v0][1]; + GLfloat c = ex*fy-ey*fx; + + if (c * ctx->backface_sign > 0) + return 0; + + return 1; +} + + +/* + * Render a flat-shaded color index triangle. + */ +static void flat_ci_triangle( GLcontext *ctx, + GLuint v0, GLuint v1, GLuint v2, GLuint pv ) +{ +#define INTERP_Z 1 +#define SETUP_CODE \ + GLuint index = VB->IndexPtr->data[pv]; \ + if (1) { \ + /* set the color index */ \ + (*ctx->Driver.Index)( ctx, index ); \ + } + +#define INNER_LOOP( LEFT, RIGHT, Y ) \ + { \ + const GLint n = RIGHT-LEFT; \ + GLint i; \ + GLdepth zspan[MAX_WIDTH]; \ + GLfixed fogspan[MAX_WIDTH]; \ + if (n>0) { \ + for (i=0;i<n;i++) { \ + zspan[i] = FixedToDepth(ffz); \ + ffz += fdzdx; \ + fogspan[i] = fffog / 256; \ + fffog += fdfogdx; \ + } \ + gl_write_monoindex_span( ctx, n, LEFT, Y, zspan, \ + fogspan, index, GL_POLYGON ); \ + } \ + } + +#include "s_tritemp.h" +} + + + +/* + * Render a smooth-shaded color index triangle. + */ +static void smooth_ci_triangle( GLcontext *ctx, + GLuint v0, GLuint v1, GLuint v2, GLuint pv ) +{ + (void) pv; +#define INTERP_Z 1 +#define INTERP_INDEX 1 + +#define INNER_LOOP( LEFT, RIGHT, Y ) \ + { \ + const GLint n = RIGHT-LEFT; \ + GLint i; \ + GLdepth zspan[MAX_WIDTH]; \ + GLfixed fogspan[MAX_WIDTH]; \ + GLuint index[MAX_WIDTH]; \ + if (n>0) { \ + for (i=0;i<n;i++) { \ + zspan[i] = FixedToDepth(ffz); \ + ffz += fdzdx; \ + index[i] = FixedToInt(ffi); \ + ffi += fdidx; \ + fogspan[i] = fffog / 256; \ + fffog += fdfogdx; \ + } \ + gl_write_index_span( ctx, n, LEFT, Y, zspan, fogspan, \ + index, GL_POLYGON ); \ + } \ + } + +#include "s_tritemp.h" +} + + + +/* + * Render a flat-shaded RGBA triangle. + */ +static void flat_rgba_triangle( GLcontext *ctx, + GLuint v0, GLuint v1, GLuint v2, GLuint pv ) +{ +#define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE + +#define SETUP_CODE \ + if (1) { \ + /* set the color */ \ + GLchan r = VB->ColorPtr->data[pv][0]; \ + GLchan g = VB->ColorPtr->data[pv][1]; \ + GLchan b = VB->ColorPtr->data[pv][2]; \ + GLchan a = VB->ColorPtr->data[pv][3]; \ + (*ctx->Driver.Color)( ctx, r, g, b, a ); \ + } + +#define INNER_LOOP( LEFT, RIGHT, Y ) \ + { \ + const GLint n = RIGHT-LEFT; \ + GLint i; \ + GLdepth zspan[MAX_WIDTH]; \ + GLfixed fogspan[MAX_WIDTH]; \ + if (n>0) { \ + for (i=0;i<n;i++) { \ + zspan[i] = FixedToDepth(ffz); \ + ffz += fdzdx; \ + fogspan[i] = fffog / 256; \ + fffog += fdfogdx; \ + } \ + gl_write_monocolor_span( ctx, n, LEFT, Y, zspan, \ + fogspan, \ + VB->ColorPtr->data[pv], \ + GL_POLYGON ); \ + } \ + } + +#include "s_tritemp.h" + + ASSERT(!ctx->Texture.ReallyEnabled); /* texturing must be off */ + ASSERT(ctx->Light.ShadeModel==GL_FLAT); +} + + + +/* + * Render a smooth-shaded RGBA triangle. + */ +static void smooth_rgba_triangle( GLcontext *ctx, + GLuint v0, GLuint v1, GLuint v2, GLuint pv ) +{ + (void) pv; +#define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE +#define INTERP_RGB 1 +#define INTERP_ALPHA 1 + +#define INNER_LOOP( LEFT, RIGHT, Y ) \ + { \ + const GLint n = RIGHT-LEFT; \ + GLint i; \ + GLdepth zspan[MAX_WIDTH]; \ + GLchan rgba[MAX_WIDTH][4]; \ + GLfixed fogspan[MAX_WIDTH]; \ + if (n>0) { \ + for (i=0;i<n;i++) { \ + zspan[i] = FixedToDepth(ffz); \ + rgba[i][RCOMP] = FixedToInt(ffr); \ + rgba[i][GCOMP] = FixedToInt(ffg); \ + rgba[i][BCOMP] = FixedToInt(ffb); \ + rgba[i][ACOMP] = FixedToInt(ffa); \ + fogspan[i] = fffog / 256; \ + fffog += fdfogdx; \ + ffz += fdzdx; \ + ffr += fdrdx; \ + ffg += fdgdx; \ + ffb += fdbdx; \ + ffa += fdadx; \ + } \ + gl_write_rgba_span( ctx, n, LEFT, Y, \ + (CONST GLdepth *) zspan, \ + fogspan, \ + rgba, GL_POLYGON ); \ + } \ + } + +#include "s_tritemp.h" + + ASSERT(!ctx->Texture.ReallyEnabled); /* texturing must be off */ + ASSERT(ctx->Light.ShadeModel==GL_SMOOTH); +} + + +/* + * Render an RGB, GL_DECAL, textured triangle. + * Interpolate S,T only w/out mipmapping or perspective correction. + * + * No fog. + */ +static void simple_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, + GLuint v2, GLuint pv ) +{ +#define INTERP_INT_TEX 1 +#define S_SCALE twidth +#define T_SCALE theight +#define SETUP_CODE \ + struct gl_texture_object *obj = ctx->Texture.Unit[0].CurrentD[2]; \ + GLint b = obj->BaseLevel; \ + GLfloat twidth = (GLfloat) obj->Image[b]->Width; \ + GLfloat theight = (GLfloat) obj->Image[b]->Height; \ + GLint twidth_log2 = obj->Image[b]->WidthLog2; \ + GLchan *texture = obj->Image[b]->Data; \ + GLint smask = obj->Image[b]->Width - 1; \ + GLint tmask = obj->Image[b]->Height - 1; \ + (void) pv; \ + if (!texture) { \ + if (!_mesa_get_teximages_from_driver(ctx, obj)) \ + return; \ + texture = obj->Image[b]->Data; \ + ASSERT(texture); \ + } + +#define INNER_LOOP( LEFT, RIGHT, Y ) \ + { \ + CONST GLint n = RIGHT-LEFT; \ + GLint i; \ + GLchan rgb[MAX_WIDTH][3]; \ + if (n>0) { \ + ffs -= FIXED_HALF; /* off-by-one error? */ \ + fft -= FIXED_HALF; \ + for (i=0;i<n;i++) { \ + GLint s = FixedToInt(ffs) & smask; \ + GLint t = FixedToInt(fft) & tmask; \ + GLint pos = (t << twidth_log2) + s; \ + pos = pos + pos + pos; /* multiply by 3 */ \ + rgb[i][RCOMP] = texture[pos]; \ + rgb[i][GCOMP] = texture[pos+1]; \ + rgb[i][BCOMP] = texture[pos+2]; \ + ffs += fdsdx; \ + fft += fdtdx; \ + } \ + (*ctx->Driver.WriteRGBSpan)( ctx, n, LEFT, Y, \ + (CONST GLchan (*)[3]) rgb, NULL ); \ + } \ + } + +#include "s_tritemp.h" +} + + +/* + * Render an RGB, GL_DECAL, textured triangle. + * Interpolate S,T, GL_LESS depth test, w/out mipmapping or + * perspective correction. + * + * No fog. + */ +static void simple_z_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, + GLuint v2, GLuint pv ) +{ +#define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE +#define INTERP_INT_TEX 1 +#define S_SCALE twidth +#define T_SCALE theight +#define SETUP_CODE \ + struct gl_texture_object *obj = ctx->Texture.Unit[0].CurrentD[2]; \ + GLint b = obj->BaseLevel; \ + GLfloat twidth = (GLfloat) obj->Image[b]->Width; \ + GLfloat theight = (GLfloat) obj->Image[b]->Height; \ + GLint twidth_log2 = obj->Image[b]->WidthLog2; \ + GLchan *texture = obj->Image[b]->Data; \ + GLint smask = obj->Image[b]->Width - 1; \ + GLint tmask = obj->Image[b]->Height - 1; \ + (void) pv; \ + if (!texture) { \ + if (!_mesa_get_teximages_from_driver(ctx, obj)) \ + return; \ + texture = obj->Image[b]->Data; \ + ASSERT(texture); \ + } + +#define INNER_LOOP( LEFT, RIGHT, Y ) \ + { \ + CONST GLint n = RIGHT-LEFT; \ + GLint i; \ + GLchan rgb[MAX_WIDTH][3]; \ + GLubyte mask[MAX_WIDTH]; \ + (void) fffog; \ + if (n>0) { \ + ffs -= FIXED_HALF; /* off-by-one error? */ \ + fft -= FIXED_HALF; \ + for (i=0;i<n;i++) { \ + GLdepth z = FixedToDepth(ffz); \ + if (z < zRow[i]) { \ + GLint s = FixedToInt(ffs) & smask; \ + GLint t = FixedToInt(fft) & tmask; \ + GLint pos = (t << twidth_log2) + s; \ + pos = pos + pos + pos; /* multiply by 3 */ \ + rgb[i][RCOMP] = texture[pos]; \ + rgb[i][GCOMP] = texture[pos+1]; \ + rgb[i][BCOMP] = texture[pos+2]; \ + zRow[i] = z; \ + mask[i] = 1; \ + } \ + else { \ + mask[i] = 0; \ + } \ + ffz += fdzdx; \ + ffs += fdsdx; \ + fft += fdtdx; \ + } \ + (*ctx->Driver.WriteRGBSpan)( ctx, n, LEFT, Y, \ + (CONST GLchan (*)[3]) rgb, mask ); \ + } \ + } + +#include "s_tritemp.h" +} + + + +/* + * Render an RGB/RGBA textured triangle without perspective correction. + */ +static void affine_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, + GLuint v2, GLuint pv ) +{ +#define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE +#define INTERP_RGB 1 +#define INTERP_ALPHA 1 +#define INTERP_INT_TEX 1 +#define S_SCALE twidth +#define T_SCALE theight +#define SETUP_CODE \ + struct gl_texture_unit *unit = ctx->Texture.Unit+0; \ + struct gl_texture_object *obj = unit->CurrentD[2]; \ + GLint b = obj->BaseLevel; \ + GLfloat twidth = (GLfloat) obj->Image[b]->Width; \ + GLfloat theight = (GLfloat) obj->Image[b]->Height; \ + GLint twidth_log2 = obj->Image[b]->WidthLog2; \ + GLchan *texture = obj->Image[b]->Data; \ + GLint smask = obj->Image[b]->Width - 1; \ + GLint tmask = obj->Image[b]->Height - 1; \ + GLint format = obj->Image[b]->Format; \ + GLint filter = obj->MinFilter; \ + GLint envmode = unit->EnvMode; \ + GLint comp, tbytesline, tsize; \ + GLfixed er, eg, eb, ea; \ + GLint tr, tg, tb, ta; \ + if (!texture) { \ + if (!_mesa_get_teximages_from_driver(ctx, obj)) \ + return; \ + texture = obj->Image[b]->Data; \ + ASSERT(texture); \ + } \ + if (envmode == GL_BLEND || envmode == GL_ADD) { \ + /* potential off-by-one error here? (1.0f -> 2048 -> 0) */ \ + er = FloatToFixed(unit->EnvColor[0]); \ + eg = FloatToFixed(unit->EnvColor[1]); \ + eb = FloatToFixed(unit->EnvColor[2]); \ + ea = FloatToFixed(unit->EnvColor[3]); \ + } \ + switch (format) { \ + case GL_ALPHA: \ + case GL_LUMINANCE: \ + case GL_INTENSITY: \ + comp = 1; \ + break; \ + case GL_LUMINANCE_ALPHA: \ + comp = 2; \ + break; \ + case GL_RGB: \ + comp = 3; \ + break; \ + case GL_RGBA: \ + comp = 4; \ + break; \ + default: \ + gl_problem(NULL, "Bad texture format in affine_texture_triangle");\ + return; \ + } \ + tbytesline = obj->Image[b]->Width * comp; \ + tsize = theight * tbytesline; + (void) pv; + + /* Instead of defining a function for each mode, a test is done + * between the outer and inner loops. This is to reduce code size + * and complexity. Observe that an optimizing compiler kills + * unused variables (for instance tf,sf,ti,si in case of GL_NEAREST). + */ + +#define NEAREST_RGB \ + tr = tex00[0]; \ + tg = tex00[1]; \ + tb = tex00[2]; \ + ta = 0xff + +#define LINEAR_RGB \ + tr = (ti * (si * tex00[0] + sf * tex01[0]) + \ + tf * (si * tex10[0] + sf * tex11[0])) >> 2 * FIXED_SHIFT; \ + tg = (ti * (si * tex00[1] + sf * tex01[1]) + \ + tf * (si * tex10[1] + sf * tex11[1])) >> 2 * FIXED_SHIFT; \ + tb = (ti * (si * tex00[2] + sf * tex01[2]) + \ + tf * (si * tex10[2] + sf * tex11[2])) >> 2 * FIXED_SHIFT; \ + ta = 0xff + +#define NEAREST_RGBA \ + tr = tex00[0]; \ + tg = tex00[1]; \ + tb = tex00[2]; \ + ta = tex00[3] + +#define LINEAR_RGBA \ + tr = (ti * (si * tex00[0] + sf * tex01[0]) + \ + tf * (si * tex10[0] + sf * tex11[0])) >> 2 * FIXED_SHIFT; \ + tg = (ti * (si * tex00[1] + sf * tex01[1]) + \ + tf * (si * tex10[1] + sf * tex11[1])) >> 2 * FIXED_SHIFT; \ + tb = (ti * (si * tex00[2] + sf * tex01[2]) + \ + tf * (si * tex10[2] + sf * tex11[2])) >> 2 * FIXED_SHIFT; \ + ta = (ti * (si * tex00[3] + sf * tex01[3]) + \ + tf * (si * tex10[3] + sf * tex11[3])) >> 2 * FIXED_SHIFT + +#define MODULATE \ + dest[0] = ffr * (tr + 1) >> (FIXED_SHIFT + 8); \ + dest[1] = ffg * (tg + 1) >> (FIXED_SHIFT + 8); \ + dest[2] = ffb * (tb + 1) >> (FIXED_SHIFT + 8); \ + dest[3] = ffa * (ta + 1) >> (FIXED_SHIFT + 8) + +#define DECAL \ + dest[0] = ((0xff - ta) * ffr + ((ta + 1) * tr << FIXED_SHIFT)) >> (FIXED_SHIFT + 8); \ + dest[1] = ((0xff - ta) * ffg + ((ta + 1) * tg << FIXED_SHIFT)) >> (FIXED_SHIFT + 8); \ + dest[2] = ((0xff - ta) * ffb + ((ta + 1) * tb << FIXED_SHIFT)) >> (FIXED_SHIFT + 8); \ + dest[3] = FixedToInt(ffa) + +#define BLEND \ + dest[0] = ((0xff - tr) * ffr + (tr + 1) * er) >> (FIXED_SHIFT + 8); \ + dest[1] = ((0xff - tg) * ffg + (tg + 1) * eg) >> (FIXED_SHIFT + 8); \ + dest[2] = ((0xff - tb) * ffb + (tb + 1) * eb) >> (FIXED_SHIFT + 8); \ + dest[3] = ffa * (ta + 1) >> (FIXED_SHIFT + 8) + +#define REPLACE \ + dest[0] = tr; \ + dest[1] = tg; \ + dest[2] = tb; \ + dest[3] = ta + +#define ADD \ + dest[0] = ((ffr << 8) + (tr + 1) * er) >> (FIXED_SHIFT + 8); \ + dest[1] = ((ffg << 8) + (tg + 1) * eg) >> (FIXED_SHIFT + 8); \ + dest[2] = ((ffb << 8) + (tb + 1) * eb) >> (FIXED_SHIFT + 8); \ + dest[3] = ffa * (ta + 1) >> (FIXED_SHIFT + 8) + +/* shortcuts */ + +#define NEAREST_RGB_REPLACE NEAREST_RGB;REPLACE + +#define NEAREST_RGBA_REPLACE *(GLint *)dest = *(GLint *)tex00 + +#define SPAN1(DO_TEX,COMP) \ + for (i=0;i<n;i++) { \ + GLint s = FixedToInt(ffs) & smask; \ + GLint t = FixedToInt(fft) & tmask; \ + GLint pos = (t << twidth_log2) + s; \ + GLchan *tex00 = texture + COMP * pos; \ + zspan[i] = FixedToDepth(ffz); \ + fogspan[i] = fffog / 256; \ + DO_TEX; \ + fffog += fdfogdx; \ + ffz += fdzdx; \ + ffr += fdrdx; \ + ffg += fdgdx; \ + ffb += fdbdx; \ + ffa += fdadx; \ + ffs += fdsdx; \ + fft += fdtdx; \ + dest += 4; \ + } + +#define SPAN2(DO_TEX,COMP) \ + for (i=0;i<n;i++) { \ + GLint s = FixedToInt(ffs) & smask; \ + GLint t = FixedToInt(fft) & tmask; \ + GLint sf = ffs & FIXED_FRAC_MASK; \ + GLint tf = fft & FIXED_FRAC_MASK; \ + GLint si = FIXED_FRAC_MASK - sf; \ + GLint ti = FIXED_FRAC_MASK - tf; \ + GLint pos = (t << twidth_log2) + s; \ + GLchan *tex00 = texture + COMP * pos; \ + GLchan *tex10 = tex00 + tbytesline; \ + GLchan *tex01 = tex00 + COMP; \ + GLchan *tex11 = tex10 + COMP; \ + if (t == tmask) { \ + tex10 -= tsize; \ + tex11 -= tsize; \ + } \ + if (s == smask) { \ + tex01 -= tbytesline; \ + tex11 -= tbytesline; \ + } \ + zspan[i] = FixedToDepth(ffz); \ + fogspan[i] = fffog / 256; \ + DO_TEX; \ + fffog += fdfogdx; \ + ffz += fdzdx; \ + ffr += fdrdx; \ + ffg += fdgdx; \ + ffb += fdbdx; \ + ffa += fdadx; \ + ffs += fdsdx; \ + fft += fdtdx; \ + dest += 4; \ + } + +/* here comes the heavy part.. (something for the compiler to chew on) */ +#define INNER_LOOP( LEFT, RIGHT, Y ) \ + { \ + CONST GLint n = RIGHT-LEFT; \ + GLint i; \ + GLdepth zspan[MAX_WIDTH]; \ + GLfixed fogspan[MAX_WIDTH]; \ + GLchan rgba[MAX_WIDTH][4]; \ + if (n>0) { \ + GLchan *dest = rgba[0]; \ + ffs -= FIXED_HALF; /* off-by-one error? */ \ + fft -= FIXED_HALF; \ + switch (filter) { \ + case GL_NEAREST: \ + switch (format) { \ + case GL_RGB: \ + switch (envmode) { \ + case GL_MODULATE: \ + SPAN1(NEAREST_RGB;MODULATE,3); \ + break; \ + case GL_DECAL: \ + case GL_REPLACE: \ + SPAN1(NEAREST_RGB_REPLACE,3); \ + break; \ + case GL_BLEND: \ + SPAN1(NEAREST_RGB;BLEND,3); \ + break; \ + case GL_ADD: \ + SPAN1(NEAREST_RGB;ADD,3); \ + break; \ + default: /* unexpected env mode */ \ + abort(); \ + } \ + break; \ + case GL_RGBA: \ + switch(envmode) { \ + case GL_MODULATE: \ + SPAN1(NEAREST_RGBA;MODULATE,4); \ + break; \ + case GL_DECAL: \ + SPAN1(NEAREST_RGBA;DECAL,4); \ + break; \ + case GL_BLEND: \ + SPAN1(NEAREST_RGBA;BLEND,4); \ + break; \ + case GL_ADD: \ + SPAN1(NEAREST_RGBA;ADD,4); \ + break; \ + case GL_REPLACE: \ + SPAN1(NEAREST_RGBA_REPLACE,4); \ + break; \ + default: /* unexpected env mode */ \ + abort(); \ + } \ + break; \ + } \ + break; \ + case GL_LINEAR: \ + ffs -= FIXED_HALF; \ + fft -= FIXED_HALF; \ + switch (format) { \ + case GL_RGB: \ + switch (envmode) { \ + case GL_MODULATE: \ + SPAN2(LINEAR_RGB;MODULATE,3); \ + break; \ + case GL_DECAL: \ + case GL_REPLACE: \ + SPAN2(LINEAR_RGB;REPLACE,3); \ + break; \ + case GL_BLEND: \ + SPAN2(LINEAR_RGB;BLEND,3); \ + break; \ + case GL_ADD: \ + SPAN2(LINEAR_RGB;ADD,3); \ + break; \ + default: /* unexpected env mode */ \ + abort(); \ + } \ + break; \ + case GL_RGBA: \ + switch (envmode) { \ + case GL_MODULATE: \ + SPAN2(LINEAR_RGBA;MODULATE,4); \ + break; \ + case GL_DECAL: \ + SPAN2(LINEAR_RGBA;DECAL,4); \ + break; \ + case GL_BLEND: \ + SPAN2(LINEAR_RGBA;BLEND,4); \ + break; \ + case GL_ADD: \ + SPAN2(LINEAR_RGBA;ADD,4); \ + break; \ + case GL_REPLACE: \ + SPAN2(LINEAR_RGBA;REPLACE,4); \ + break; \ + default: /* unexpected env mode */ \ + abort(); \ + } \ + break; \ + } \ + break; \ + } \ + gl_write_rgba_span(ctx, n, LEFT, Y, zspan, \ + fogspan, \ + rgba, GL_POLYGON); \ + /* explicit kill of variables: */ \ + ffr = ffg = ffb = ffa = 0; \ + } \ + } + +#include "s_tritemp.h" +#undef SPAN1 +#undef SPAN2 +} + + + +/* + * Render an perspective corrected RGB/RGBA textured triangle. + * The Q (aka V in Mesa) coordinate must be zero such that the divide + * by interpolated Q/W comes out right. + * + * This function only renders textured triangles that use GL_NEAREST. + * Perspective correction works right. + * + * This function written by Klaus Niederkrueger <[email protected]> + * Send all questions and bug reports to him. + */ +static void near_persp_textured_triangle(GLcontext *ctx, GLuint v0, GLuint v1, + GLuint v2, GLuint pv ) +{ +/* The BIAS value is used to shift negative values into positive values. + * Without this, negative texture values don't GL_REPEAT correctly at just + * below zero, because (int)-0.5 = 0 = (int)0.5. We're not going to worry + * about texture coords less than -BIAS. This could be fixed by using + * FLOORF etc. instead, but this is slower... + */ +#define BIAS 4096.0F + +#define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE +#define INTERP_RGB 1 +#define INTERP_ALPHA 1 +#define INTERP_TEX 1 +#define SETUP_CODE \ + struct gl_texture_unit *unit = ctx->Texture.Unit+0; \ + struct gl_texture_object *obj = unit->CurrentD[2]; \ + const GLint b = obj->BaseLevel; \ + const GLfloat twidth = (GLfloat) obj->Image[b]->Width; \ + const GLfloat theight = (GLfloat) obj->Image[b]->Height; \ + const GLint twidth_log2 = obj->Image[b]->WidthLog2; \ + GLchan *texture = obj->Image[b]->Data; \ + const GLint smask = (obj->Image[b]->Width - 1); \ + const GLint tmask = (obj->Image[b]->Height - 1); \ + const GLint format = obj->Image[b]->Format; \ + const GLint envmode = unit->EnvMode; \ + GLfloat sscale, tscale; \ + /*GLint comp, tbytesline, tsize; */ \ + GLfixed er, eg, eb, ea; \ + GLint tr, tg, tb, ta; \ + if (!texture) { \ + if (!_mesa_get_teximages_from_driver(ctx, obj)) \ + return; \ + texture = obj->Image[b]->Data; \ + ASSERT(texture); \ + } \ + if (envmode == GL_BLEND || envmode == GL_ADD) { \ + er = FloatToFixed(unit->EnvColor[0]); \ + eg = FloatToFixed(unit->EnvColor[1]); \ + eb = FloatToFixed(unit->EnvColor[2]); \ + ea = FloatToFixed(unit->EnvColor[3]); \ + } \ + /*switch (format) { \ + case GL_ALPHA: \ + case GL_LUMINANCE: \ + case GL_INTENSITY: \ + comp = 1; \ + break; \ + case GL_LUMINANCE_ALPHA: \ + comp = 2; \ + break; \ + case GL_RGB: \ + comp = 3; \ + break; \ + case GL_RGBA: \ + comp = 4; \ + break; \ + default: \ + gl_problem(NULL, "Bad texture format in near_persp_texture_triangle"); \ + return; \ + } */ \ + sscale = twidth; \ + tscale = theight; \ + /*tbytesline = obj->Image[b]->Width * comp; \ + tsize = theight * tbytesline;*/ + (void) pv; + +#define OLD_SPAN(DO_TEX,COMP) \ + for (i=0;i<n;i++) { \ + GLfloat invQ = 1.0f / vv; \ + GLint s = (int)(SS * invQ + BIAS) & smask; \ + GLint t = (int)(TT * invQ + BIAS) & tmask; \ + GLint pos = COMP * ((t << twidth_log2) + s); \ + GLchan *tex00 = texture + pos; \ + zspan[i] = FixedToDepth(ffz); \ + fogspan[i] = fffog / 256; \ + DO_TEX; \ + fffog += fdfogdx; \ + ffz += fdzdx; \ + ffr += fdrdx; \ + ffg += fdgdx; \ + ffb += fdbdx; \ + ffa += fdadx; \ + SS += dSdx; \ + TT += dTdx; \ + vv += dvdx; \ + dest += 4; \ + } + +#define X_Y_TEX_COORD(X, Y) ((((int)(X) & tmask) << twidth_log2) + ((int)(Y) & smask)) +#define Y_X_TEX_COORD(X, Y) ((((int)(Y) & tmask) << twidth_log2) + ((int)(X) & smask)) + +#define SPAN1(DO_TEX, COMP, TEX_COORD) { \ + GLfloat x_max = CEILF(x_tex); \ + GLfloat y_max = y_tex + (x_max - x_tex) * dy_dx; \ + GLint j, x_m = (int)x_max; \ + GLint pos; \ + if ((int)y_max != (int)y_tex) { \ + GLfloat x_mid = x_tex + (CEILF(y_tex)-y_tex) * dx_dy; \ + j = (nominator + vv * x_mid)/(denominator - dvdx*x_mid); \ + pos = COMP * TEX_COORD(x_tex, y_tex); \ + DRAW_LINE (DO_TEX); \ + y_tex = y_max; \ + } \ + nominator += vv * x_max; \ + denominator -= dvdx * x_max; \ + j = nominator / denominator; \ + pos = COMP * TEX_COORD(x_tex, y_tex); \ + DRAW_LINE (DO_TEX); \ + while (i<n) { \ + y_tex = y_max; \ + y_max += dy_dx; \ + if ((int)y_max != (int)y_tex) { \ + GLfloat x_mid = (CEILF(y_tex)-y_tex) * dx_dy; \ + j = (nominator + vv * x_mid)/(denominator - dvdx*x_mid); \ + pos = COMP * TEX_COORD(x_m, y_tex); \ + DRAW_LINE (DO_TEX); \ + y_tex = y_max; \ + } \ + nominator += vv; \ + denominator -= dvdx; \ + j = nominator/denominator; \ + pos = COMP * TEX_COORD(x_m, y_tex); \ + DRAW_LINE (DO_TEX); \ + x_m ++; \ + } \ +} + +#define SPAN2(DO_TEX, COMP, TEX_COORD) { \ + GLfloat x_max = CEILF (x_tex); \ + GLfloat y_max = y_tex + (x_max - x_tex) * dy_dx; \ + GLint j, x_m = (int) x_max; \ + GLint pos; \ + if ((int)y_max != (int)y_tex) { \ + GLfloat x_mid = x_tex + (FLOORF(y_tex)-y_tex) * dx_dy; \ + j = (nominator + vv * x_mid)/(denominator - dvdx*x_mid); \ + pos = COMP * TEX_COORD(x_tex, y_tex); \ + DRAW_LINE (DO_TEX); \ + y_tex = y_max; \ + } \ + nominator += vv * x_max; \ + denominator -= dvdx * x_max; \ + j = nominator / denominator; \ + pos = COMP * TEX_COORD(x_tex, y_tex); \ + DRAW_LINE (DO_TEX); \ + while (i<n) { \ + y_tex = y_max; \ + y_max += dy_dx; \ + if ((int)y_max != (int)y_tex) { \ + GLfloat x_mid = (FLOORF(y_tex)-y_tex) * dx_dy; \ + j = (nominator + vv * x_mid)/(denominator - dvdx*x_mid);\ + pos = COMP * TEX_COORD(x_m, y_tex); \ + DRAW_LINE (DO_TEX); \ + y_tex = y_max; \ + } \ + nominator += vv; \ + denominator -= dvdx; \ + j = nominator/denominator; \ + pos = COMP * TEX_COORD(x_m, y_tex); \ + DRAW_LINE (DO_TEX); \ + x_m ++; \ + } \ +} + +#define SPAN3(DO_TEX, COMP, TEX_COORD) { \ + GLfloat x_min = FLOORF (x_tex); \ + GLfloat y_min = y_tex + (x_min - x_tex) * dy_dx; \ + GLint j, x_m = (int)x_min; \ + GLint pos; \ + if ((int)y_min != (int)y_tex) { \ + GLfloat x_mid = x_tex + (CEILF(y_tex)-y_tex) * dx_dy; \ + j = (nominator + vv * x_mid)/(denominator - dvdx*x_mid); \ + pos = COMP * TEX_COORD(x_m, y_tex); \ + DRAW_LINE (DO_TEX); \ + y_tex = y_min; \ + } \ + nominator += vv*x_min; \ + denominator -= dvdx*x_min; \ + j = nominator / denominator; \ + pos = COMP * TEX_COORD(x_m, y_tex); \ + DRAW_LINE (DO_TEX); \ + while (i<n) { \ + x_m --; \ + y_tex = y_min; \ + y_min -= dy_dx; \ + if ((int)y_min != (int)y_tex) { \ + GLfloat x_mid = (CEILF(y_tex)-y_tex) * dx_dy; \ + j = (nominator + vv * x_mid)/(denominator - dvdx*x_mid); \ + pos = COMP * TEX_COORD(x_m, y_tex); \ + DRAW_LINE (DO_TEX); \ + y_tex = y_min; \ + } \ + nominator -= vv; \ + denominator += dvdx; \ + j = nominator/denominator; \ + pos = COMP * TEX_COORD(x_m, y_tex); \ + DRAW_LINE (DO_TEX); \ + } \ +} + +#define SPAN4(DO_TEX, COMP, TEX_COORD) \ +{ \ + GLfloat x_min = FLOORF(x_tex); \ + GLint x_m = (int)x_min; \ + GLfloat y_min = y_tex + (x_min - x_tex) * dy_dx; \ + GLint j; \ + GLint pos; \ + if ((int)y_min != (int)y_tex) { \ + GLfloat x_mid = x_tex + (FLOORF(y_tex)-y_tex) * dx_dy; \ + j = (nominator + vv * x_mid)/(denominator - dvdx*x_mid); \ + pos = COMP * TEX_COORD(x_m, y_tex); \ + DRAW_LINE (DO_TEX); \ + y_tex = y_min; \ + } \ + nominator += vv * x_min; \ + denominator -= dvdx * x_min; \ + j = nominator / denominator; \ + pos = COMP * TEX_COORD(x_m, y_tex); \ + DRAW_LINE (DO_TEX); \ + while (i<n) { \ + x_m --; \ + y_tex = y_min; \ + y_min -= dy_dx; \ + if ((int)y_min != (int)y_tex) { \ + GLfloat x_mid = (FLOORF(y_tex)-y_tex) * dx_dy; \ + j = (nominator + vv * x_mid)/(denominator - dvdx*x_mid); \ + pos = COMP * TEX_COORD(x_m, (y_tex)); \ + DRAW_LINE (DO_TEX); \ + y_tex = y_min; \ + } \ + nominator -= vv; \ + denominator += dvdx; \ + j = nominator/denominator; \ + pos = COMP * TEX_COORD(x_m, y_tex); \ + DRAW_LINE (DO_TEX); \ + } \ +} + +#define DRAW_LINE(DO_TEX) \ + { \ + GLchan *tex00 = texture + pos; \ + if (j>n || j<-100000) \ + j = n; \ + while (i<j) { \ + zspan[i] = FixedToDepth(ffz); \ + fogspan[i] = fffog / 256; \ + DO_TEX; \ + fffog += fdfogdx; \ + ffz += fdzdx; \ + ffr += fdrdx; \ + ffg += fdgdx; \ + ffb += fdbdx; \ + ffa += fdadx; \ + dest += 4; \ + i++; \ + } \ + } + +#define INNER_LOOP( LEFT, RIGHT, Y ) \ + { \ + GLint i = 0; \ + const GLint n = RIGHT-LEFT; \ + GLdepth zspan[MAX_WIDTH]; \ + GLfixed fogspan[MAX_WIDTH]; \ + GLchan rgba[MAX_WIDTH][4]; \ + (void)uu; /* please GCC */ \ + if (n > 0) { \ + GLchan *dest = rgba[0]; \ + GLfloat SS = ss * sscale; \ + GLfloat TT = tt * tscale; \ + GLfloat dSdx = dsdx * sscale; \ + GLfloat dTdx = dtdx * tscale; \ + GLfloat x_tex; \ + GLfloat y_tex; \ + GLfloat dx_tex; \ + GLfloat dy_tex; \ + if (n<5) /* When line very short, setup-time > speed-gain. */ \ + goto old_span; /* So: take old method */ \ + x_tex = SS / vv, \ + y_tex = TT / vv; \ + dx_tex = (SS + n * dSdx) / (vv + n * dvdx) - x_tex, \ + dy_tex = (TT + n * dTdx) / (vv + n * dvdx) - y_tex; \ + /* Choose between walking over texture or over pixelline: */ \ + /* If there are few texels, walk over texture otherwise */ \ + /* walk over pixelarray. The quotient on the right side */ \ + /* should give the timeratio needed to draw one texel in */ \ + /* comparison to one pixel. Depends on CPU. */ \ + if (dx_tex*dx_tex + dy_tex*dy_tex < (n*n)/16) { \ + x_tex += BIAS; \ + y_tex += BIAS; \ + if (dx_tex*dx_tex > dy_tex*dy_tex) { \ + /* if (FABSF(dx_tex) > FABSF(dy_tex)) */ \ + GLfloat nominator = - SS - vv * BIAS; \ + GLfloat denominator = dvdx * BIAS + dSdx; \ + GLfloat dy_dx; \ + GLfloat dx_dy; \ + if (dy_tex != 0.0f) { \ + dy_dx = dy_tex / dx_tex; \ + dx_dy = 1.0f/dy_dx; \ + } \ + else \ + dy_dx = 0.0f; \ + if (dx_tex > 0.0f) { \ + if (dy_tex > 0.0f) { \ + switch (format) { \ + case GL_RGB: \ + switch (envmode) { \ + case GL_MODULATE: \ + SPAN1(NEAREST_RGB;MODULATE,3, Y_X_TEX_COORD);\ + break; \ + case GL_DECAL: \ + case GL_REPLACE: \ + SPAN1(NEAREST_RGB_REPLACE,3, Y_X_TEX_COORD); \ + break; \ + case GL_BLEND: \ + SPAN1(NEAREST_RGB;BLEND,3, Y_X_TEX_COORD); \ + break; \ + case GL_ADD: \ + SPAN1(NEAREST_RGB;ADD,3, Y_X_TEX_COORD); \ + break; \ + default: /* unexpected env mode */ \ + abort(); \ + } \ + break; \ + case GL_RGBA: \ + switch(envmode) { \ + case GL_MODULATE: \ + SPAN1(NEAREST_RGBA;MODULATE,4, Y_X_TEX_COORD);\ + break; \ + case GL_DECAL: \ + SPAN1(NEAREST_RGBA;DECAL,4, Y_X_TEX_COORD); \ + break; \ + case GL_BLEND: \ + SPAN1(NEAREST_RGBA;BLEND,4, Y_X_TEX_COORD); \ + break; \ + case GL_ADD: \ + SPAN1(NEAREST_RGBA;ADD,4, Y_X_TEX_COORD); \ + break; \ + case GL_REPLACE: \ + SPAN1(NEAREST_RGBA_REPLACE,4, Y_X_TEX_COORD);\ + break; \ + default: /* unexpected env mode */ \ + abort(); \ + } \ + break; \ + } \ + } \ + else { /* dy_tex <= 0.0f */ \ + switch (format) { \ + case GL_RGB: \ + switch (envmode) { \ + case GL_MODULATE: \ + SPAN2(NEAREST_RGB;MODULATE,3, Y_X_TEX_COORD);\ + break; \ + case GL_DECAL: \ + case GL_REPLACE: \ + SPAN2(NEAREST_RGB_REPLACE,3, Y_X_TEX_COORD); \ + break; \ + case GL_BLEND: \ + SPAN2(NEAREST_RGB;BLEND,3, Y_X_TEX_COORD); \ + break; \ + case GL_ADD: \ + SPAN2(NEAREST_RGB;ADD,3, Y_X_TEX_COORD); \ + break; \ + default: /* unexpected env mode */ \ + abort(); \ + } \ + break; \ + case GL_RGBA: \ + switch(envmode) { \ + case GL_MODULATE: \ + SPAN2(NEAREST_RGBA;MODULATE,4, Y_X_TEX_COORD);\ + break; \ + case GL_DECAL: \ + SPAN2(NEAREST_RGBA;DECAL,4, Y_X_TEX_COORD); \ + break; \ + case GL_BLEND: \ + SPAN2(NEAREST_RGBA;BLEND,4, Y_X_TEX_COORD); \ + break; \ + case GL_ADD: \ + SPAN2(NEAREST_RGBA;ADD,4, Y_X_TEX_COORD); \ + break; \ + case GL_REPLACE: \ + SPAN2(NEAREST_RGBA_REPLACE,4, Y_X_TEX_COORD);\ + break; \ + default: /* unexpected env mode */ \ + abort(); \ + } \ + break; \ + } \ + } \ + } \ + else { /* dx_tex < 0.0f */ \ + if (dy_tex > 0.0f) { \ + switch (format) { \ + case GL_RGB: \ + switch (envmode) { \ + case GL_MODULATE: \ + SPAN3(NEAREST_RGB;MODULATE,3, Y_X_TEX_COORD);\ + break; \ + case GL_DECAL: \ + case GL_REPLACE: \ + SPAN3(NEAREST_RGB_REPLACE,3, Y_X_TEX_COORD); \ + break; \ + case GL_BLEND: \ + SPAN3(NEAREST_RGB;BLEND,3, Y_X_TEX_COORD); \ + break; \ + case GL_ADD: \ + SPAN3(NEAREST_RGB;ADD,3, Y_X_TEX_COORD); \ + break; \ + default: /* unexpected env mode */ \ + abort(); \ + } \ + break; \ + case GL_RGBA: \ + switch(envmode) { \ + case GL_MODULATE: \ + SPAN3(NEAREST_RGBA;MODULATE,4, Y_X_TEX_COORD);\ + break; \ + case GL_DECAL: \ + SPAN3(NEAREST_RGBA;DECAL,4, Y_X_TEX_COORD); \ + break; \ + case GL_BLEND: \ + SPAN3(NEAREST_RGBA;BLEND,4, Y_X_TEX_COORD); \ + break; \ + case GL_ADD: \ + SPAN3(NEAREST_RGBA;ADD,4, Y_X_TEX_COORD); \ + break; \ + case GL_REPLACE: \ + SPAN3(NEAREST_RGBA_REPLACE,4, Y_X_TEX_COORD);\ + break; \ + default: /* unexpected env mode */ \ + abort(); \ + } \ + break; \ + } \ + } \ + else { /* dy_tex <= 0.0f */ \ + switch (format) { \ + case GL_RGB: \ + switch (envmode) { \ + case GL_MODULATE: \ + SPAN4(NEAREST_RGB;MODULATE,3, Y_X_TEX_COORD);\ + break; \ + case GL_DECAL: \ + case GL_REPLACE: \ + SPAN4(NEAREST_RGB_REPLACE,3, Y_X_TEX_COORD); \ + break; \ + case GL_BLEND: \ + SPAN4(NEAREST_RGB;BLEND,3, Y_X_TEX_COORD); \ + break; \ + case GL_ADD: \ + SPAN4(NEAREST_RGB;ADD,3, Y_X_TEX_COORD); \ + break; \ + default: \ + abort(); \ + } \ + break; \ + case GL_RGBA: \ + switch(envmode) { \ + case GL_MODULATE: \ + SPAN4(NEAREST_RGBA;MODULATE,4, Y_X_TEX_COORD);\ + break; \ + case GL_DECAL: \ + SPAN4(NEAREST_RGBA;DECAL,4, Y_X_TEX_COORD); \ + break; \ + case GL_BLEND: \ + SPAN4(NEAREST_RGBA;BLEND,4, Y_X_TEX_COORD); \ + break; \ + case GL_ADD: \ + SPAN4(NEAREST_RGBA;ADD,4, Y_X_TEX_COORD); \ + break; \ + case GL_REPLACE: \ + SPAN4(NEAREST_RGBA_REPLACE,4, Y_X_TEX_COORD);\ + break; \ + default: /* unexpected env mode */ \ + abort(); \ + } \ + break; \ + } \ + } \ + } \ + } \ + else { /* FABSF(dx_tex) > FABSF(dy_tex) */ \ + GLfloat swap; \ + GLfloat dy_dx; \ + GLfloat dx_dy; \ + GLfloat nominator, denominator; \ + if (dx_tex == 0.0f /* && dy_tex == 0.0f*/) \ + goto old_span; /* case so special, that use old */ \ + /* swap some x-values and y-values */ \ + SS = TT; \ + dSdx = dTdx; \ + swap = x_tex, x_tex = y_tex, y_tex = swap; \ + swap = dx_tex, dx_tex = dy_tex, dy_tex = swap; \ + nominator = - SS - vv * BIAS; \ + denominator = dvdx * BIAS + dSdx; \ + if (dy_tex != 0.0f) { \ + dy_dx = dy_tex / dx_tex; \ + dx_dy = 1.0f/dy_dx; \ + } \ + else \ + dy_dx = 0.0f; \ + if (dx_tex > 0.0f) { \ + if (dy_tex > 0.0f) { \ + switch (format) { \ + case GL_RGB: \ + switch (envmode) { \ + case GL_MODULATE: \ + SPAN1(NEAREST_RGB;MODULATE,3, X_Y_TEX_COORD);\ + break; \ + case GL_DECAL: \ + case GL_REPLACE: \ + SPAN1(NEAREST_RGB_REPLACE,3, X_Y_TEX_COORD); \ + break; \ + case GL_BLEND: \ + SPAN1(NEAREST_RGB;BLEND,3, X_Y_TEX_COORD); \ + break; \ + case GL_ADD: \ + SPAN1(NEAREST_RGB;ADD,3, X_Y_TEX_COORD); \ + break; \ + default: /* unexpected env mode */ \ + abort(); \ + } \ + break; \ + case GL_RGBA: \ + switch(envmode) { \ + case GL_MODULATE: \ + SPAN1(NEAREST_RGBA;MODULATE,4, X_Y_TEX_COORD);\ + break; \ + case GL_DECAL: \ + SPAN1(NEAREST_RGBA;DECAL,4, X_Y_TEX_COORD); \ + break; \ + case GL_BLEND: \ + SPAN1(NEAREST_RGBA;BLEND,4, X_Y_TEX_COORD); \ + break; \ + case GL_ADD: \ + SPAN1(NEAREST_RGBA;ADD,4, X_Y_TEX_COORD); \ + break; \ + case GL_REPLACE: \ + SPAN1(NEAREST_RGBA_REPLACE,4, X_Y_TEX_COORD);\ + break; \ + default: \ + abort(); \ + } \ + break; \ + } \ + } \ + else { /* dy_tex <= 0.0f */ \ + switch (format) { \ + case GL_RGB: \ + switch (envmode) { \ + case GL_MODULATE: \ + SPAN2(NEAREST_RGB;MODULATE,3, X_Y_TEX_COORD);\ + break; \ + case GL_DECAL: \ + case GL_REPLACE: \ + SPAN2(NEAREST_RGB_REPLACE,3, X_Y_TEX_COORD); \ + break; \ + case GL_BLEND: \ + SPAN2(NEAREST_RGB;BLEND,3, X_Y_TEX_COORD); \ + break; \ + case GL_ADD: \ + SPAN2(NEAREST_RGB;ADD,3, X_Y_TEX_COORD); \ + break; \ + default: \ + abort(); \ + } \ + break; \ + case GL_RGBA: \ + switch(envmode) { \ + case GL_MODULATE: \ + SPAN2(NEAREST_RGBA;MODULATE,4, X_Y_TEX_COORD);\ + break; \ + case GL_DECAL: \ + SPAN2(NEAREST_RGBA;DECAL,4, X_Y_TEX_COORD); \ + break; \ + case GL_BLEND: \ + SPAN2(NEAREST_RGBA;BLEND,4, X_Y_TEX_COORD); \ + break; \ + case GL_ADD: \ + SPAN2(NEAREST_RGBA;ADD,4, X_Y_TEX_COORD); \ + break; \ + case GL_REPLACE: \ + SPAN2(NEAREST_RGBA_REPLACE,4, X_Y_TEX_COORD);\ + break; \ + default: \ + abort(); \ + } \ + break; \ + } \ + } \ + } \ + else { /* dx_tex < 0.0f */ \ + if (dy_tex > 0.0f) { \ + switch (format) { \ + case GL_RGB: \ + switch (envmode) { \ + case GL_MODULATE: \ + SPAN3(NEAREST_RGB;MODULATE,3, X_Y_TEX_COORD);\ + break; \ + case GL_DECAL: \ + case GL_REPLACE: \ + SPAN3(NEAREST_RGB_REPLACE,3, X_Y_TEX_COORD); \ + break; \ + case GL_BLEND: \ + SPAN3(NEAREST_RGB;BLEND,3, X_Y_TEX_COORD); \ + break; \ + case GL_ADD: \ + SPAN3(NEAREST_RGB;ADD,3, X_Y_TEX_COORD); \ + break; \ + default: \ + abort(); \ + } \ + break; \ + case GL_RGBA: \ + switch(envmode) { \ + case GL_MODULATE: \ + SPAN3(NEAREST_RGBA;MODULATE,4, X_Y_TEX_COORD);\ + break; \ + case GL_DECAL: \ + SPAN3(NEAREST_RGBA;DECAL,4, X_Y_TEX_COORD); \ + break; \ + case GL_BLEND: \ + SPAN3(NEAREST_RGBA;BLEND,4, X_Y_TEX_COORD); \ + break; \ + case GL_ADD: \ + SPAN3(NEAREST_RGBA;ADD,4, X_Y_TEX_COORD); \ + break; \ + case GL_REPLACE: \ + SPAN3(NEAREST_RGBA_REPLACE,4, X_Y_TEX_COORD);\ + break; \ + default: \ + abort(); \ + } \ + break; \ + } \ + } \ + else { /* dy_tex <= 0.0f */ \ + switch (format) { \ + case GL_RGB: \ + switch (envmode) { \ + case GL_MODULATE: \ + SPAN4(NEAREST_RGB;MODULATE,3, X_Y_TEX_COORD);\ + break; \ + case GL_DECAL: \ + case GL_REPLACE: \ + SPAN4(NEAREST_RGB_REPLACE,3, X_Y_TEX_COORD); \ + break; \ + case GL_BLEND: \ + SPAN4(NEAREST_RGB;BLEND,3, X_Y_TEX_COORD); \ + break; \ + case GL_ADD: \ + SPAN4(NEAREST_RGB;ADD,3, X_Y_TEX_COORD); \ + break; \ + default: \ + abort(); \ + } \ + break; \ + case GL_RGBA: \ + switch(envmode) { \ + case GL_MODULATE: \ + SPAN4(NEAREST_RGBA;MODULATE,4, X_Y_TEX_COORD);\ + break; \ + case GL_DECAL: \ + SPAN4(NEAREST_RGBA;DECAL,4, X_Y_TEX_COORD); \ + break; \ + case GL_BLEND: \ + SPAN4(NEAREST_RGBA;BLEND,4, X_Y_TEX_COORD); \ + break; \ + case GL_ADD: \ + SPAN4(NEAREST_RGBA;ADD,4, X_Y_TEX_COORD); \ + break; \ + case GL_REPLACE: \ + SPAN4(NEAREST_RGBA_REPLACE,4, X_Y_TEX_COORD);\ + break; \ + default: \ + abort(); \ + } \ + break; \ + } \ + } \ + } \ + } \ + } \ + else { \ + old_span: \ + switch (format) { \ + case GL_RGB: \ + switch (envmode) { \ + case GL_MODULATE: \ + OLD_SPAN(NEAREST_RGB;MODULATE,3); \ + break; \ + case GL_DECAL: \ + case GL_REPLACE: \ + OLD_SPAN(NEAREST_RGB_REPLACE,3); \ + break; \ + case GL_BLEND: \ + OLD_SPAN(NEAREST_RGB;BLEND,3); \ + break; \ + case GL_ADD: \ + OLD_SPAN(NEAREST_RGB;ADD,3); \ + break; \ + default: \ + abort(); \ + } \ + break; \ + case GL_RGBA: \ + switch(envmode) { \ + case GL_MODULATE: \ + OLD_SPAN(NEAREST_RGBA;MODULATE,4); \ + break; \ + case GL_DECAL: \ + OLD_SPAN(NEAREST_RGBA;DECAL,4); \ + break; \ + case GL_BLEND: \ + OLD_SPAN(NEAREST_RGBA;BLEND,4); \ + break; \ + case GL_ADD: \ + OLD_SPAN(NEAREST_RGBA;ADD,4); \ + break; \ + case GL_REPLACE: \ + OLD_SPAN(NEAREST_RGBA_REPLACE,4); \ + break; \ + default: \ + abort(); \ + } \ + break; \ + } \ + } \ + gl_write_rgba_span( ctx, n, LEFT, Y, zspan, \ + fogspan, rgba, GL_POLYGON); \ + ffr = ffg = ffb = ffa = 0; \ + } \ + } \ + +#include "s_tritemp.h" +#undef OLD_SPAN +#undef SPAN1 +#undef SPAN2 +#undef SPAN3 +#undef SPAN4 +#undef X_Y_TEX_COORD +#undef Y_X_TEX_COORD +#undef DRAW_LINE +#undef BIAS +} + + + +/* + * Render an perspective corrected RGB/RGBA textured triangle. + * The Q (aka V in Mesa) coordinate must be zero such that the divide + * by interpolated Q/W comes out right. + * + * This function written by Klaus Niederkrueger <[email protected]> + * Send all questions and bug reports to him. + */ +static void lin_persp_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, + GLuint v2, GLuint pv ) +{ +#define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE +#define INTERP_RGB 1 +#define INTERP_ALPHA 1 +#define INTERP_TEX 1 +#define SETUP_CODE \ + struct gl_texture_unit *unit = ctx->Texture.Unit+0; \ + struct gl_texture_object *obj = unit->CurrentD[2]; \ + const GLint b = obj->BaseLevel; \ + const GLfloat twidth = (GLfloat) obj->Image[b]->Width; \ + const GLfloat theight = (GLfloat) obj->Image[b]->Height; \ + const GLint twidth_log2 = obj->Image[b]->WidthLog2; \ + GLchan *texture = obj->Image[b]->Data; \ + const GLint smask = (obj->Image[b]->Width - 1); \ + const GLint tmask = (obj->Image[b]->Height - 1); \ + const GLint format = obj->Image[b]->Format; \ + const GLint envmode = unit->EnvMode; \ + GLfloat sscale, tscale; \ + GLint comp, tbytesline, tsize; \ + GLfixed er, eg, eb, ea; \ + GLint tr, tg, tb, ta; \ + if (!texture) { \ + if (!_mesa_get_teximages_from_driver(ctx, obj)) \ + return; \ + texture = obj->Image[b]->Data; \ + ASSERT(texture); \ + } \ + if (envmode == GL_BLEND || envmode == GL_ADD) { \ + er = FloatToFixed(unit->EnvColor[0]); \ + eg = FloatToFixed(unit->EnvColor[1]); \ + eb = FloatToFixed(unit->EnvColor[2]); \ + ea = FloatToFixed(unit->EnvColor[3]); \ + } \ + switch (format) { \ + case GL_ALPHA: \ + case GL_LUMINANCE: \ + case GL_INTENSITY: \ + comp = 1; \ + break; \ + case GL_LUMINANCE_ALPHA: \ + comp = 2; \ + break; \ + case GL_RGB: \ + comp = 3; \ + break; \ + case GL_RGBA: \ + comp = 4; \ + break; \ + default: \ + gl_problem(NULL, "Bad texture format in lin_persp_texture_triangle"); \ + return; \ + } \ + sscale = FIXED_SCALE * twidth; \ + tscale = FIXED_SCALE * theight; \ + tbytesline = obj->Image[b]->Width * comp; \ + tsize = theight * tbytesline; + (void) pv; + +#define SPAN(DO_TEX,COMP) \ + for (i=0;i<n;i++) { \ + GLfloat invQ = 1.0f / vv; \ + GLfixed ffs = (int)(SS * invQ); \ + GLfixed fft = (int)(TT * invQ); \ + GLint s = FixedToInt(ffs) & smask; \ + GLint t = FixedToInt(fft) & tmask; \ + GLint sf = ffs & FIXED_FRAC_MASK; \ + GLint tf = fft & FIXED_FRAC_MASK; \ + GLint si = FIXED_FRAC_MASK - sf; \ + GLint ti = FIXED_FRAC_MASK - tf; \ + GLint pos = COMP * ((t << twidth_log2) + s); \ + GLchan *tex00 = texture + pos; \ + GLchan *tex10 = tex00 + tbytesline; \ + GLchan *tex01 = tex00 + COMP; \ + GLchan *tex11 = tex10 + COMP; \ + if (t == tmask) { \ + tex10 -= tsize; \ + tex11 -= tsize; \ + } \ + if (s == smask) { \ + tex01 -= tbytesline; \ + tex11 -= tbytesline; \ + } \ + zspan[i] = FixedToDepth(ffz); \ + fogspan[i] = fffog / 256; \ + DO_TEX; \ + fffog += fdfogdx; \ + ffz += fdzdx; \ + ffr += fdrdx; \ + ffg += fdgdx; \ + ffb += fdbdx; \ + ffa += fdadx; \ + SS += dSdx; \ + TT += dTdx; \ + vv += dvdx; \ + dest += 4; \ + } + +#define INNER_LOOP( LEFT, RIGHT, Y ) \ + { \ + GLint i; \ + const GLint n = RIGHT-LEFT; \ + GLdepth zspan[MAX_WIDTH]; \ + GLfixed fogspan[MAX_WIDTH]; \ + GLchan rgba[MAX_WIDTH][4]; \ + (void) uu; /* please GCC */ \ + if (n > 0) { \ + GLfloat SS = ss * sscale; \ + GLfloat TT = tt * tscale; \ + GLfloat dSdx = dsdx * sscale; \ + GLfloat dTdx = dtdx * tscale; \ + GLchan *dest = rgba[0]; \ + SS -= 0.5f * FIXED_SCALE * vv; \ + TT -= 0.5f * FIXED_SCALE * vv; \ + switch (format) { \ + case GL_RGB: \ + switch (envmode) { \ + case GL_MODULATE: \ + SPAN(LINEAR_RGB;MODULATE,3); \ + break; \ + case GL_DECAL: \ + case GL_REPLACE: \ + SPAN(LINEAR_RGB;REPLACE,3); \ + break; \ + case GL_BLEND: \ + SPAN(LINEAR_RGB;BLEND,3); \ + break; \ + case GL_ADD: \ + SPAN(LINEAR_RGB;ADD,3); \ + break; \ + default: \ + abort(); \ + } \ + break; \ + case GL_RGBA: \ + switch (envmode) { \ + case GL_MODULATE: \ + SPAN(LINEAR_RGBA;MODULATE,4); \ + break; \ + case GL_DECAL: \ + SPAN(LINEAR_RGBA;DECAL,4); \ + break; \ + case GL_BLEND: \ + SPAN(LINEAR_RGBA;BLEND,4); \ + break; \ + case GL_REPLACE: \ + SPAN(LINEAR_RGBA;REPLACE,4); \ + break; \ + case GL_ADD: \ + SPAN(LINEAR_RGBA;ADD,4); \ + break; \ + default: /* unexpected env mode */ \ + abort(); \ + } \ + } \ + gl_write_rgba_span( ctx, n, LEFT, Y, zspan, \ + fogspan, \ + rgba, GL_POLYGON ); \ + ffr = ffg = ffb = ffa = 0; \ + } \ + } + + +#include "s_tritemp.h" +#undef SPAN +} + + + +/* + * Render a smooth-shaded, textured, RGBA triangle. + * Interpolate S,T,U with perspective correction, w/out mipmapping. + * Note: we use texture coordinates S,T,U,V instead of S,T,R,Q because + * R is already used for red. + */ +static void general_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, + GLuint v2, GLuint pv ) +{ +#define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE +#define INTERP_RGB 1 +#define INTERP_ALPHA 1 +#define INTERP_TEX 1 +#define SETUP_CODE \ + GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \ + GLint r, g, b, a; \ + if (flat_shade) { \ + r = VB->ColorPtr->data[pv][0]; \ + g = VB->ColorPtr->data[pv][1]; \ + b = VB->ColorPtr->data[pv][2]; \ + a = VB->ColorPtr->data[pv][3]; \ + } +#define INNER_LOOP( LEFT, RIGHT, Y ) \ + { \ + GLint i; \ + const GLint n = RIGHT-LEFT; \ + GLdepth zspan[MAX_WIDTH]; \ + GLfixed fogspan[MAX_WIDTH]; \ + GLchan rgba[MAX_WIDTH][4]; \ + GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH]; \ + if (n>0) { \ + if (flat_shade) { \ + for (i=0;i<n;i++) { \ + GLdouble invQ = 1.0 / vv; \ + zspan[i] = FixedToDepth(ffz); \ + fogspan[i] = fffog / 256; \ + rgba[i][RCOMP] = r; \ + rgba[i][GCOMP] = g; \ + rgba[i][BCOMP] = b; \ + rgba[i][ACOMP] = a; \ + s[i] = ss*invQ; \ + t[i] = tt*invQ; \ + u[i] = uu*invQ; \ + fffog += fdfogdx; \ + ffz += fdzdx; \ + ss += dsdx; \ + tt += dtdx; \ + uu += dudx; \ + vv += dvdx; \ + } \ + } \ + else { \ + for (i=0;i<n;i++) { \ + GLdouble invQ = 1.0 / vv; \ + zspan[i] = FixedToDepth(ffz); \ + rgba[i][RCOMP] = FixedToInt(ffr); \ + rgba[i][GCOMP] = FixedToInt(ffg); \ + rgba[i][BCOMP] = FixedToInt(ffb); \ + rgba[i][ACOMP] = FixedToInt(ffa); \ + fogspan[i] = fffog / 256; \ + s[i] = ss*invQ; \ + t[i] = tt*invQ; \ + u[i] = uu*invQ; \ + fffog += fdfogdx; \ + ffz += fdzdx; \ + ffr += fdrdx; \ + ffg += fdgdx; \ + ffb += fdbdx; \ + ffa += fdadx; \ + ss += dsdx; \ + tt += dtdx; \ + uu += dudx; \ + vv += dvdx; \ + } \ + } \ + gl_write_texture_span( ctx, n, LEFT, Y, zspan, fogspan, \ + s, t, u, NULL, \ + rgba, \ + NULL, GL_POLYGON ); \ + } \ + } + +#include "s_tritemp.h" +} + + +/* + * Render a smooth-shaded, textured, RGBA triangle with separate specular + * color interpolation. + * Interpolate S,T,U with perspective correction, w/out mipmapping. + * Note: we use texture coordinates S,T,U,V instead of S,T,R,Q because + * R is already used for red. + */ +static void general_textured_spec_triangle1( GLcontext *ctx, GLuint v0, + GLuint v1, GLuint v2, GLuint pv, + GLdepth zspan[MAX_WIDTH], + GLfixed fogspan[MAX_WIDTH], + GLchan rgba[MAX_WIDTH][4], + GLchan spec[MAX_WIDTH][4] ) +{ +#define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE +#define INTERP_RGB 1 +#define INTERP_SPEC 1 +#define INTERP_ALPHA 1 +#define INTERP_TEX 1 +#define SETUP_CODE \ + GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \ + GLint r, g, b, a, sr, sg, sb; \ + if (flat_shade) { \ + r = VB->ColorPtr->data[pv][0]; \ + g = VB->ColorPtr->data[pv][1]; \ + b = VB->ColorPtr->data[pv][2]; \ + a = VB->ColorPtr->data[pv][3]; \ + sr = VB->SecondaryColorPtr->data[pv][0]; \ + sg = VB->SecondaryColorPtr->data[pv][1]; \ + sb = VB->SecondaryColorPtr->data[pv][2]; \ + } +#define INNER_LOOP( LEFT, RIGHT, Y ) \ + { \ + GLint i; \ + const GLint n = RIGHT-LEFT; \ + GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH]; \ + if (n>0) { \ + if (flat_shade) { \ + for (i=0;i<n;i++) { \ + GLdouble invQ = 1.0 / vv; \ + zspan[i] = FixedToDepth(ffz); \ + fogspan[i] = fffog / 256; \ + rgba[i][RCOMP] = r; \ + rgba[i][GCOMP] = g; \ + rgba[i][BCOMP] = b; \ + rgba[i][ACOMP] = a; \ + spec[i][RCOMP] = sr; \ + spec[i][GCOMP] = sg; \ + spec[i][BCOMP] = sb; \ + s[i] = ss*invQ; \ + t[i] = tt*invQ; \ + u[i] = uu*invQ; \ + fffog += fdfogdx; \ + ffz += fdzdx; \ + ss += dsdx; \ + tt += dtdx; \ + uu += dudx; \ + vv += dvdx; \ + } \ + } \ + else { \ + for (i=0;i<n;i++) { \ + GLdouble invQ = 1.0 / vv; \ + zspan[i] = FixedToDepth(ffz); \ + fogspan[i] = fffog / 256; \ + rgba[i][RCOMP] = FixedToInt(ffr); \ + rgba[i][GCOMP] = FixedToInt(ffg); \ + rgba[i][BCOMP] = FixedToInt(ffb); \ + rgba[i][ACOMP] = FixedToInt(ffa); \ + spec[i][RCOMP] = FixedToInt(ffsr); \ + spec[i][GCOMP] = FixedToInt(ffsg); \ + spec[i][BCOMP] = FixedToInt(ffsb); \ + s[i] = ss*invQ; \ + t[i] = tt*invQ; \ + u[i] = uu*invQ; \ + fffog += fdfogdx; \ + ffz += fdzdx; \ + ffr += fdrdx; \ + ffg += fdgdx; \ + ffb += fdbdx; \ + ffa += fdadx; \ + ffsr += fdsrdx; \ + ffsg += fdsgdx; \ + ffsb += fdsbdx; \ + ss += dsdx; \ + tt += dtdx; \ + uu += dudx; \ + vv += dvdx; \ + } \ + } \ + gl_write_texture_span( ctx, n, LEFT, Y, zspan, \ + fogspan, \ + s, t, u, NULL, rgba, \ + (CONST GLchan (*)[4]) spec, \ + GL_POLYGON ); \ + } \ + } + +#include "s_tritemp.h" +} + + + +/* + * Compute the lambda value for a fragment. (texture level of detail) + */ +static INLINE GLfloat +compute_lambda( GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy, + GLfloat invQ, GLfloat width, GLfloat height ) +{ + GLfloat dudx = dsdx * invQ * width; + GLfloat dudy = dsdy * invQ * width; + GLfloat dvdx = dtdx * invQ * height; + GLfloat dvdy = dtdy * invQ * height; + GLfloat r1 = dudx * dudx + dudy * dudy; + GLfloat r2 = dvdx * dvdx + dvdy * dvdy; + GLfloat rho2 = r1 + r2; /* used to be: rho2 = MAX2(r1,r2); */ + /* return log base 2 of rho */ + return log(rho2) * 1.442695 * 0.5; /* 1.442695 = 1/log(2) */ +} + + +/* + * Render a smooth-shaded, textured, RGBA triangle. + * Interpolate S,T,U with perspective correction and compute lambda for + * each fragment. Lambda is used to determine whether to use the + * minification or magnification filter. If minification and using + * mipmaps, lambda is also used to select the texture level of detail. + */ +static void lambda_textured_triangle1( GLcontext *ctx, GLuint v0, GLuint v1, + GLuint v2, GLuint pv, + GLfloat s[MAX_WIDTH], + GLfloat t[MAX_WIDTH], + GLfloat u[MAX_WIDTH] ) +{ +#define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE +#define INTERP_RGB 1 +#define INTERP_ALPHA 1 +#define INTERP_TEX 1 + +#define SETUP_CODE \ + const struct gl_texture_object *obj = ctx->Texture.Unit[0].Current; \ + const GLint baseLevel = obj->BaseLevel; \ + const struct gl_texture_image *texImage = obj->Image[baseLevel]; \ + const GLfloat twidth = (GLfloat) texImage->Width; \ + const GLfloat theight = (GLfloat) texImage->Height; \ + const GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \ + GLint r, g, b, a; \ + if (flat_shade) { \ + r = VB->ColorPtr->data[pv][0]; \ + g = VB->ColorPtr->data[pv][1]; \ + b = VB->ColorPtr->data[pv][2]; \ + a = VB->ColorPtr->data[pv][3]; \ + } + +#define INNER_LOOP( LEFT, RIGHT, Y ) \ + { \ + GLint i; \ + const GLint n = RIGHT-LEFT; \ + GLdepth zspan[MAX_WIDTH]; \ + GLfixed fogspan[MAX_WIDTH]; \ + GLchan rgba[MAX_WIDTH][4]; \ + GLfloat lambda[MAX_WIDTH]; \ + if (n>0) { \ + if (flat_shade) { \ + for (i=0;i<n;i++) { \ + GLdouble invQ = 1.0 / vv; \ + zspan[i] = FixedToDepth(ffz); \ + fogspan[i] = fffog / 256; \ + rgba[i][RCOMP] = r; \ + rgba[i][GCOMP] = g; \ + rgba[i][BCOMP] = b; \ + rgba[i][ACOMP] = a; \ + s[i] = ss*invQ; \ + t[i] = tt*invQ; \ + u[i] = uu*invQ; \ + lambda[i] = compute_lambda( dsdx, dsdy, dtdx, dtdy, \ + invQ, twidth, theight );\ + ffz += fdzdx; \ + fffog += fdfogdx; \ + ss += dsdx; \ + tt += dtdx; \ + uu += dudx; \ + vv += dvdx; \ + } \ + } \ + else { \ + for (i=0;i<n;i++) { \ + GLdouble invQ = 1.0 / vv; \ + zspan[i] = FixedToDepth(ffz); \ + fogspan[i] = fffog / 256; \ + rgba[i][RCOMP] = FixedToInt(ffr); \ + rgba[i][GCOMP] = FixedToInt(ffg); \ + rgba[i][BCOMP] = FixedToInt(ffb); \ + rgba[i][ACOMP] = FixedToInt(ffa); \ + s[i] = ss*invQ; \ + t[i] = tt*invQ; \ + u[i] = uu*invQ; \ + lambda[i] = compute_lambda( dsdx, dsdy, dtdx, dtdy, \ + invQ, twidth, theight );\ + ffz += fdzdx; \ + fffog += fdfogdx; \ + ffr += fdrdx; \ + ffg += fdgdx; \ + ffb += fdbdx; \ + ffa += fdadx; \ + ss += dsdx; \ + tt += dtdx; \ + uu += dudx; \ + vv += dvdx; \ + } \ + } \ + gl_write_texture_span( ctx, n, LEFT, Y, zspan, fogspan, \ + s, t, u, lambda, \ + rgba, NULL, GL_POLYGON ); \ + } \ + } + +#include "s_tritemp.h" +} + + +/* + * Render a smooth-shaded, textured, RGBA triangle with separate specular + * interpolation. + * Interpolate S,T,U with perspective correction and compute lambda for + * each fragment. Lambda is used to determine whether to use the + * minification or magnification filter. If minification and using + * mipmaps, lambda is also used to select the texture level of detail. + */ +static void lambda_textured_spec_triangle1( GLcontext *ctx, GLuint v0, + GLuint v1, GLuint v2, GLuint pv, + GLfloat s[MAX_WIDTH], + GLfloat t[MAX_WIDTH], + GLfloat u[MAX_WIDTH] ) +{ +#define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE +#define INTERP_RGB 1 +#define INTERP_SPEC 1 +#define INTERP_ALPHA 1 +#define INTERP_TEX 1 + +#define SETUP_CODE \ + const struct gl_texture_object *obj = ctx->Texture.Unit[0].Current; \ + const GLint baseLevel = obj->BaseLevel; \ + const struct gl_texture_image *texImage = obj->Image[baseLevel]; \ + const GLfloat twidth = (GLfloat) texImage->Width; \ + const GLfloat theight = (GLfloat) texImage->Height; \ + const GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \ + GLint r, g, b, a, sr, sg, sb; \ + if (flat_shade) { \ + r = VB->ColorPtr->data[pv][0]; \ + g = VB->ColorPtr->data[pv][1]; \ + b = VB->ColorPtr->data[pv][2]; \ + a = VB->ColorPtr->data[pv][3]; \ + sr = VB->SecondaryColorPtr->data[pv][0]; \ + sg = VB->SecondaryColorPtr->data[pv][1]; \ + sb = VB->SecondaryColorPtr->data[pv][2]; \ + } + +#define INNER_LOOP( LEFT, RIGHT, Y ) \ + { \ + GLint i; \ + const GLint n = RIGHT-LEFT; \ + GLdepth zspan[MAX_WIDTH]; \ + GLfixed fogspan[MAX_WIDTH]; \ + GLchan spec[MAX_WIDTH][4]; \ + GLchan rgba[MAX_WIDTH][4]; \ + GLfloat lambda[MAX_WIDTH]; \ + if (n>0) { \ + if (flat_shade) { \ + for (i=0;i<n;i++) { \ + GLdouble invQ = 1.0 / vv; \ + zspan[i] = FixedToDepth(ffz); \ + fogspan[i] = fffog / 256; \ + rgba[i][RCOMP] = r; \ + rgba[i][GCOMP] = g; \ + rgba[i][BCOMP] = b; \ + rgba[i][ACOMP] = a; \ + spec[i][RCOMP] = sr; \ + spec[i][GCOMP] = sg; \ + spec[i][BCOMP] = sb; \ + s[i] = ss*invQ; \ + t[i] = tt*invQ; \ + u[i] = uu*invQ; \ + lambda[i] = compute_lambda( dsdx, dsdy, dtdx, dtdy, \ + invQ, twidth, theight );\ + fffog += fdfogdx; \ + ffz += fdzdx; \ + ss += dsdx; \ + tt += dtdx; \ + uu += dudx; \ + vv += dvdx; \ + } \ + } \ + else { \ + for (i=0;i<n;i++) { \ + GLdouble invQ = 1.0 / vv; \ + zspan[i] = FixedToDepth(ffz); \ + fogspan[i] = fffog / 256; \ + rgba[i][RCOMP] = FixedToInt(ffr); \ + rgba[i][GCOMP] = FixedToInt(ffg); \ + rgba[i][BCOMP] = FixedToInt(ffb); \ + rgba[i][ACOMP] = FixedToInt(ffa); \ + spec[i][RCOMP] = FixedToInt(ffsr); \ + spec[i][GCOMP] = FixedToInt(ffsg); \ + spec[i][BCOMP] = FixedToInt(ffsb); \ + s[i] = ss*invQ; \ + t[i] = tt*invQ; \ + u[i] = uu*invQ; \ + lambda[i] = compute_lambda( dsdx, dsdy, dtdx, dtdy, \ + invQ, twidth, theight );\ + fffog += fdfogdx; \ + ffz += fdzdx; \ + ffr += fdrdx; \ + ffg += fdgdx; \ + ffb += fdbdx; \ + ffa += fdadx; \ + ffsr += fdsrdx; \ + ffsg += fdsgdx; \ + ffsb += fdsbdx; \ + ss += dsdx; \ + tt += dtdx; \ + uu += dudx; \ + vv += dvdx; \ + } \ + } \ + gl_write_texture_span( ctx, n, LEFT, Y, zspan, fogspan, \ + s, t, u, lambda, \ + rgba, (CONST GLchan (*)[4]) spec, \ + GL_POLYGON ); \ + } \ + } + +#include "s_tritemp.h" +} + + +/* + * This is the big one! + * Interpolate Z, RGB, Alpha, and two sets of texture coordinates. + * Yup, it's slow. + */ +static void lambda_multitextured_triangle1( GLcontext *ctx, GLuint v0, + GLuint v1, GLuint v2, GLuint pv, + GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH], + GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH], + GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH] + ) +{ +#define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE +#define INTERP_RGB 1 +#define INTERP_ALPHA 1 +#define INTERP_MULTITEX 1 + +#define SETUP_CODE \ + GLchan rgba[MAX_WIDTH][4]; \ + const GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \ + GLfloat twidth[MAX_TEXTURE_UNITS], theight[MAX_TEXTURE_UNITS]; \ + GLint r, g, b, a; \ + if (flat_shade) { \ + r = VB->ColorPtr->data[pv][0]; \ + g = VB->ColorPtr->data[pv][1]; \ + b = VB->ColorPtr->data[pv][2]; \ + a = VB->ColorPtr->data[pv][3]; \ + } \ + { \ + GLuint unit; \ + for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { \ + if (ctx->Texture.Unit[unit].ReallyEnabled) { \ + const struct gl_texture_object *obj = ctx->Texture.Unit[unit].Current; \ + const GLint baseLevel = obj->BaseLevel; \ + const struct gl_texture_image *texImage = obj->Image[baseLevel]; \ + twidth[unit] = (GLfloat) texImage->Width; \ + theight[unit] = (GLfloat) texImage->Height; \ + } \ + } \ + } + + + +#define INNER_LOOP( LEFT, RIGHT, Y ) \ + { \ + GLint i; \ + const GLint n = RIGHT-LEFT; \ + GLdepth zspan[MAX_WIDTH]; \ + GLfixed fogspan[MAX_WIDTH]; \ + GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH]; \ + if (n > 0) { \ + if (flat_shade) { \ + for (i=0;i<n;i++) { \ + zspan[i] = FixedToDepth(ffz); \ + fogspan[i] = fffog / 256; \ + fffog += fdfogdx; \ + ffz += fdzdx; \ + rgba[i][RCOMP] = r; \ + rgba[i][GCOMP] = g; \ + rgba[i][BCOMP] = b; \ + rgba[i][ACOMP] = a; \ + { \ + GLuint unit; \ + for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { \ + if (ctx->Texture.Unit[unit].ReallyEnabled) { \ + GLdouble invQ = 1.0 / vv[unit]; \ + s[unit][i] = ss[unit] * invQ; \ + t[unit][i] = tt[unit] * invQ; \ + u[unit][i] = uu[unit] * invQ; \ + lambda[unit][i] = compute_lambda(dsdx[unit], dsdy[unit],\ + dtdx[unit], dtdy[unit], invQ, \ + twidth[unit], theight[unit] ); \ + ss[unit] += dsdx[unit]; \ + tt[unit] += dtdx[unit]; \ + uu[unit] += dudx[unit]; \ + vv[unit] += dvdx[unit]; \ + } \ + } \ + } \ + } \ + } \ + else { /* smooth shade */ \ + for (i=0;i<n;i++) { \ + zspan[i] = FixedToDepth(ffz); \ + fogspan[i] = fffog / 256; \ + ffz += fdzdx; \ + fffog += fdfogdx; \ + rgba[i][RCOMP] = FixedToInt(ffr); \ + rgba[i][GCOMP] = FixedToInt(ffg); \ + rgba[i][BCOMP] = FixedToInt(ffb); \ + rgba[i][ACOMP] = FixedToInt(ffa); \ + ffr += fdrdx; \ + ffg += fdgdx; \ + ffb += fdbdx; \ + ffa += fdadx; \ + { \ + GLuint unit; \ + for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { \ + if (ctx->Texture.Unit[unit].ReallyEnabled) { \ + GLdouble invQ = 1.0 / vv[unit]; \ + s[unit][i] = ss[unit] * invQ; \ + t[unit][i] = tt[unit] * invQ; \ + u[unit][i] = uu[unit] * invQ; \ + lambda[unit][i] = compute_lambda(dsdx[unit], dsdy[unit],\ + dtdx[unit], dtdy[unit], invQ, \ + twidth[unit], theight[unit] ); \ + ss[unit] += dsdx[unit]; \ + tt[unit] += dtdx[unit]; \ + uu[unit] += dudx[unit]; \ + vv[unit] += dvdx[unit]; \ + } \ + } \ + } \ + } \ + } \ + gl_write_multitexture_span( ctx, n, LEFT, Y, zspan, fogspan, \ + (const GLfloat (*)[MAX_WIDTH]) s, \ + (const GLfloat (*)[MAX_WIDTH]) t, \ + (const GLfloat (*)[MAX_WIDTH]) u, \ + (GLfloat (*)[MAX_WIDTH]) lambda, \ + rgba, NULL, GL_POLYGON ); \ + } \ + } +#include "s_tritemp.h" +} + + +/* + * These wrappers are needed to deal with the 32KB / stack frame limit + * on Mac / PowerPC systems. + */ + +static void general_textured_spec_triangle(GLcontext *ctx, GLuint v0, + GLuint v1, GLuint v2, GLuint pv) +{ + GLdepth zspan[MAX_WIDTH]; + GLfixed fogspan[MAX_WIDTH]; + GLchan rgba[MAX_WIDTH][4], spec[MAX_WIDTH][4]; + general_textured_spec_triangle1(ctx,v0,v1,v2,pv,zspan,fogspan,rgba,spec); +} + +static void lambda_textured_triangle( GLcontext *ctx, GLuint v0, + GLuint v1, GLuint v2, GLuint pv ) +{ + GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH]; + lambda_textured_triangle1(ctx,v0,v1,v2,pv,s,t,u); +} + +static void lambda_textured_spec_triangle( GLcontext *ctx, GLuint v0, + GLuint v1, GLuint v2, GLuint pv ) +{ + GLfloat s[MAX_WIDTH]; + GLfloat t[MAX_WIDTH]; + GLfloat u[MAX_WIDTH]; + lambda_textured_spec_triangle1(ctx,v0,v1,v2,pv,s,t,u); +} + + +static void lambda_multitextured_triangle( GLcontext *ctx, GLuint v0, + GLuint v1, GLuint v2, GLuint pv) +{ + + GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH]; + GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH]; + DEFMARRAY(GLfloat,u,MAX_TEXTURE_UNITS,MAX_WIDTH); + CHECKARRAY(u,return); + + lambda_multitextured_triangle1(ctx,v0,v1,v2,pv,s,t,u); + + UNDEFARRAY(u); +} + + + +static void occlusion_zless_triangle( GLcontext *ctx, GLuint v0, GLuint v1, + GLuint v2, GLuint pv ) +{ + (void)pv; + if (ctx->OcclusionResult) { + return; + } + +#define DO_OCCLUSION_TEST +#define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE +#define INNER_LOOP( LEFT, RIGHT, Y ) \ + { \ + GLint i; \ + const GLint len = RIGHT-LEFT; \ + for (i=0;i<len;i++) { \ + GLdepth z = FixedToDepth(ffz); \ + (void) fffog; \ + if (z < zRow[i]) { \ + ctx->OcclusionResult = GL_TRUE; \ + return; \ + } \ + ffz += fdzdx; \ + } \ + } +#include "s_tritemp.h" +} + + + +/* + * Null rasterizer for measuring transformation speed. + */ +static void null_triangle( GLcontext *ctx, GLuint v0, GLuint v1, + GLuint v2, GLuint pv ) +{ + (void) ctx; + (void) v0; + (void) v1; + (void) v2; + (void) pv; +} + + +#if 0 +# define dputs(s) puts(s) +#else +# define dputs(s) +#endif + + + +/* + * Determine which triangle rendering function to use given the current + * rendering context. + * + * Please update the summary flag _SWRAST_NEW_TRIANGLE if you add or + * remove tests to this code. + */ +void +_swrast_set_triangle_function( GLcontext *ctx ) +{ + const GLboolean rgbmode = ctx->Visual.RGBAflag; + + if (ctx->RenderMode==GL_RENDER) { + if (ctx->NoRaster) { + ctx->Driver.TriangleFunc = null_triangle; + return; + } + if (ctx->Driver.TriangleFunc) { + /* Device driver will draw triangles. */ + dputs("Driver triangle"); + return; + } + + if (ctx->Polygon.SmoothFlag) { + _mesa_set_aa_triangle_function(ctx); + ASSERT(ctx->Driver.TriangleFunc); + return; + } + + if (ctx->Depth.OcclusionTest && + ctx->Depth.Test && + ctx->Depth.Mask == GL_FALSE && + ctx->Depth.Func == GL_LESS && + !ctx->Stencil.Enabled) { + if ((rgbmode && + ctx->Color.ColorMask[0] == 0 && + ctx->Color.ColorMask[1] == 0 && + ctx->Color.ColorMask[2] == 0 && + ctx->Color.ColorMask[3] == 0) + || + (!rgbmode && ctx->Color.IndexMask == 0)) { + dputs("occlusion_test_triangle"); + ctx->Driver.TriangleFunc = occlusion_zless_triangle; + return; + } + } + + if (ctx->Texture.ReallyEnabled) { + /* Ugh, we do a _lot_ of tests to pick the best textured tri func */ + GLint format, filter; + const struct gl_texture_object *current2Dtex = ctx->Texture.Unit[0].CurrentD[2]; + const struct gl_texture_image *image; + /* First see if we can used an optimized 2-D texture function */ + if (ctx->Texture.ReallyEnabled==TEXTURE0_2D + && current2Dtex->WrapS==GL_REPEAT + && current2Dtex->WrapT==GL_REPEAT + && ((image = current2Dtex->Image[current2Dtex->BaseLevel]) != 0) /* correct! */ + && image->Border==0 + && ((format = image->Format)==GL_RGB || format==GL_RGBA) + && (filter = current2Dtex->MinFilter)==current2Dtex->MagFilter + && ctx->Light.Model.ColorControl==GL_SINGLE_COLOR + && ctx->Texture.Unit[0].EnvMode!=GL_COMBINE_EXT) { + + if (ctx->Hint.PerspectiveCorrection==GL_FASTEST) { + + if (filter==GL_NEAREST + && format==GL_RGB + && (ctx->Texture.Unit[0].EnvMode==GL_REPLACE + || ctx->Texture.Unit[0].EnvMode==GL_DECAL) + && ((ctx->RasterMask==DEPTH_BIT + && ctx->Depth.Func==GL_LESS + && ctx->Depth.Mask==GL_TRUE) + || ctx->RasterMask==0) + && ctx->Polygon.StippleFlag==GL_FALSE) { + + if (ctx->RasterMask==DEPTH_BIT) { + ctx->Driver.TriangleFunc = simple_z_textured_triangle; + dputs("simple_z_textured_triangle"); + } + else { + ctx->Driver.TriangleFunc = simple_textured_triangle; + dputs("simple_textured_triangle"); + } + } + else { + if (ctx->Texture.Unit[0].EnvMode==GL_ADD) { + ctx->Driver.TriangleFunc = general_textured_triangle; + dputs("general_textured_triangle"); + } + else { + ctx->Driver.TriangleFunc = affine_textured_triangle; + dputs("affine_textured_triangle"); + } + } + } + else { + if (filter==GL_NEAREST) { + ctx->Driver.TriangleFunc = near_persp_textured_triangle; + dputs("near_persp_textured_triangle"); + } + else { + ctx->Driver.TriangleFunc = lin_persp_textured_triangle; + dputs("lin_persp_textured_triangle"); + } + } + } + else { + /* More complicated textures (mipmap, multi-tex, sep specular) */ + GLboolean needLambda; + /* if mag filter != min filter we need to compute lambda */ + const struct gl_texture_object *obj = ctx->Texture.Unit[0].Current; + if (obj && obj->MinFilter != obj->MagFilter) + needLambda = GL_TRUE; + else + needLambda = GL_FALSE; + if (ctx->Texture.MultiTextureEnabled) { + ctx->Driver.TriangleFunc = lambda_multitextured_triangle; + dputs("lambda_multitextured_triangle"); + } + else if ((ctx->Light.Enabled && + ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR) + || ctx->Fog.ColorSumEnabled) { + /* separate specular color interpolation */ + if (needLambda) { + ctx->Driver.TriangleFunc = lambda_textured_spec_triangle; + dputs("lambda_textured_spec_triangle"); + } + else { + ctx->Driver.TriangleFunc = general_textured_spec_triangle; + dputs("general_textured_spec_triangle"); + } + } + else { + if (needLambda) { + ctx->Driver.TriangleFunc = lambda_textured_triangle; + dputs("lambda_textured_triangle"); + } + else { + ctx->Driver.TriangleFunc = general_textured_triangle; + dputs("general_textured_triangle"); + } + } + } + } + else { + if (ctx->Light.ShadeModel==GL_SMOOTH) { + /* smooth shaded, no texturing, stippled or some raster ops */ + if (rgbmode) { + dputs("smooth_rgba_triangle"); + ctx->Driver.TriangleFunc = smooth_rgba_triangle; + } + else { + dputs("smooth_ci_triangle"); + ctx->Driver.TriangleFunc = smooth_ci_triangle; + } + } + else { + /* flat shaded, no texturing, stippled or some raster ops */ + if (rgbmode) { + dputs("flat_rgba_triangle"); + ctx->Driver.TriangleFunc = flat_rgba_triangle; + } + else { + dputs("flat_ci_triangle"); + ctx->Driver.TriangleFunc = flat_ci_triangle; + } + } + } + } + else if (ctx->RenderMode==GL_FEEDBACK) { + ctx->Driver.TriangleFunc = gl_feedback_triangle; + } + else { + /* GL_SELECT mode */ + ctx->Driver.TriangleFunc = gl_select_triangle; + } +} |