This is triangle.c in view mode; [Download] [Up]
/* $Id: triangle.c,v 1.27 1997/06/23 00:40:03 brianp Exp $ */ /* * Mesa 3-D graphics library * Version: 2.3 * Copyright (C) 1995-1997 Brian Paul * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the Free * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* * $Log: triangle.c,v $ * Revision 1.27 1997/06/23 00:40:03 brianp * added a DEFARRAY/UNDEFARRAY for the Mac * * Revision 1.26 1997/06/20 02:51:38 brianp * changed color components from GLfixed to GLubyte * * Revision 1.25 1997/06/03 01:38:22 brianp * fixed divide by zero problem in feedback function (William Mitchell) * * Revision 1.24 1997/05/28 03:26:49 brianp * added precompiled header (PCH) support * * Revision 1.23 1997/05/17 03:40:55 brianp * refined textured triangle selection code (Mats Lofkvist) * * Revision 1.22 1997/05/03 00:51:02 brianp * removed calls to gl_texturing_enabled() * * Revision 1.21 1997/04/14 21:38:15 brianp * fixed a typo (dtdx instead of dudx) in lambda_textured_triangle() * * Revision 1.20 1997/04/14 02:00:39 brianp * #include "texstate.h" instead of "texture.h" * * Revision 1.19 1997/04/12 12:27:16 brianp * replaced ctx->TriangleFunc with ctx->Driver.TriangleFunc * * Revision 1.18 1997/04/02 03:12:06 brianp * replaced ctx->IdentityTexMat with ctx->TextureMatrixType * * Revision 1.17 1997/03/13 03:05:31 brianp * removed unused shift variable in feedback_triangle() * * Revision 1.16 1997/03/08 02:04:27 brianp * better implementation of feedback function * * Revision 1.15 1997/03/04 18:54:13 brianp * renamed mipmap_textured_triangle() to lambda_textured_triangle() * better comments about lambda and mipmapping * * Revision 1.14 1997/02/20 23:47:35 brianp * triangle feedback colors were wrong when using smooth shading * * Revision 1.13 1997/02/19 10:24:26 brianp * use a GLdouble instead of a GLfloat for wwvvInv (perspective correction) * * Revision 1.12 1997/02/09 19:53:43 brianp * now use TEXTURE_xD enable constants * * Revision 1.11 1997/02/09 18:51:02 brianp * added GL_EXT_texture3D support * * Revision 1.10 1997/01/16 03:36:43 brianp * added #include "texture.h" * * Revision 1.9 1997/01/09 19:50:49 brianp * now call gl_texturing_enabled() * * Revision 1.8 1996/12/20 20:23:30 brianp * the test for using general_textured_triangle() was wrong * * Revision 1.7 1996/12/12 22:37:30 brianp * projective textures didn't work right * * Revision 1.6 1996/11/08 02:21:21 brianp * added null drawing function for GL_NO_RASTER * * Revision 1.5 1996/10/01 03:31:17 brianp * use new FixedToDepth() macro * * Revision 1.4 1996/09/27 01:30:37 brianp * removed unneeded INTERP_ALPHA from flat_rgba_triangle() * * Revision 1.3 1996/09/15 14:19:16 brianp * now use GLframebuffer and GLvisual * * Revision 1.2 1996/09/15 01:48:58 brianp * removed #define NULL 0 * * Revision 1.1 1996/09/13 01:38:16 brianp * Initial revision * */ /* * Triangle rasterizers */ #ifdef PCH #include "all.h" #else #include <assert.h> #include <math.h> #include <stdio.h> #include "depth.h" #include "feedback.h" #include "macros.h" #include "span.h" #include "texstate.h" #include "triangle.h" #include "types.h" #include "vb.h" #endif /* * Put triangle in feedback buffer. */ static void feedback_triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv ) { struct vertex_buffer *VB = ctx->VB; GLfloat color[4]; GLuint i; GLfloat invRedScale = ctx->Visual->InvRedScale; GLfloat invGreenScale = ctx->Visual->InvGreenScale; GLfloat invBlueScale = ctx->Visual->InvBlueScale; GLfloat invAlphaScale = ctx->Visual->InvAlphaScale; FEEDBACK_TOKEN( ctx, (GLfloat) GL_POLYGON_TOKEN ); FEEDBACK_TOKEN( ctx, (GLfloat) 3 ); /* three vertices */ if (ctx->Light.ShadeModel==GL_FLAT) { /* flat shading - same color for each vertex */ color[0] = (GLfloat) VB->Color[pv][0] * invRedScale; color[1] = (GLfloat) VB->Color[pv][1] * invGreenScale; color[2] = (GLfloat) VB->Color[pv][2] * invBlueScale; color[3] = (GLfloat) VB->Color[pv][3] * invAlphaScale; } for (i=0;i<3;i++) { GLfloat x, y, z, w; GLfloat tc[4]; GLuint v; GLfloat invq; if (i==0) v = v0; else if (i==1) v = v1; else v = v2; x = VB->Win[v][0]; y = VB->Win[v][1]; z = VB->Win[v][2] / DEPTH_SCALE; w = VB->Clip[v][3]; if (ctx->Light.ShadeModel==GL_SMOOTH) { /* smooth shading - different color for each vertex */ color[0] = VB->Color[v][0] * invRedScale; color[1] = VB->Color[v][1] * invGreenScale; color[2] = VB->Color[v][2] * invBlueScale; color[3] = VB->Color[v][3] * invAlphaScale; } invq = (VB->TexCoord[v][3]==0.0) ? 1.0 : (1.0F / VB->TexCoord[v][3]); tc[0] = VB->TexCoord[v][0] * invq; tc[1] = VB->TexCoord[v][1] * invq; tc[2] = VB->TexCoord[v][2] * invq; tc[3] = VB->TexCoord[v][3]; gl_feedback_vertex( ctx, x, y, z, w, color, (GLfloat) VB->Index[v], tc ); } } /* * Put triangle in selection buffer. */ static void select_triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv ) { struct vertex_buffer *VB = ctx->VB; gl_update_hitflag( ctx, VB->Win[v0][2] / DEPTH_SCALE ); gl_update_hitflag( ctx, VB->Win[v1][2] / DEPTH_SCALE ); gl_update_hitflag( ctx, VB->Win[v2][2] / DEPTH_SCALE ); } /* * 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->Index[pv]; \ if (!VB->MonoColor) { \ /* set the color index */ \ (*ctx->Driver.Index)( ctx, index ); \ } #define INNER_LOOP( LEFT, RIGHT, Y ) \ { \ GLint i, n = RIGHT-LEFT; \ GLdepth zspan[MAX_WIDTH]; \ if (n>0) { \ for (i=0;i<n;i++) { \ zspan[i] = FixedToDepth(ffz); \ ffz += fdzdx; \ } \ gl_write_monoindex_span( ctx, n, LEFT, Y, \ zspan, index, GL_POLYGON ); \ } \ } #include "tritemp.h" } /* * Render a smooth-shaded color index triangle. */ static void smooth_ci_triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv ) { #define INTERP_Z 1 #define INTERP_INDEX 1 #define INNER_LOOP( LEFT, RIGHT, Y ) \ { \ GLint i, n = RIGHT-LEFT; \ GLdepth zspan[MAX_WIDTH]; \ GLuint index[MAX_WIDTH]; \ if (n>0) { \ for (i=0;i<n;i++) { \ zspan[i] = FixedToDepth(ffz); \ index[i] = FixedToInt(ffi); \ ffz += fdzdx; \ ffi += fdidx; \ } \ gl_write_index_span( ctx, n, LEFT, Y, zspan, \ index, GL_POLYGON ); \ } \ } #include "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 SETUP_CODE \ if (!VB->MonoColor) { \ /* set the color */ \ GLubyte r = VB->Color[pv][0]; \ GLubyte g = VB->Color[pv][1]; \ GLubyte b = VB->Color[pv][2]; \ GLubyte a = VB->Color[pv][3]; \ (*ctx->Driver.Color)( ctx, r, g, b, a ); \ } #define INNER_LOOP( LEFT, RIGHT, Y ) \ { \ GLint i, n = RIGHT-LEFT; \ GLdepth zspan[MAX_WIDTH]; \ if (n>0) { \ for (i=0;i<n;i++) { \ zspan[i] = FixedToDepth(ffz); \ ffz += fdzdx; \ } \ gl_write_monocolor_span( ctx, n, LEFT, Y, zspan, \ VB->Color[pv][0], VB->Color[pv][1],\ VB->Color[pv][2], VB->Color[pv][3],\ GL_POLYGON ); \ } \ } #include "tritemp.h" } /* * Render a smooth-shaded RGBA triangle. */ static void smooth_rgba_triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv ) { #define INTERP_Z 1 #define INTERP_RGB 1 #define INTERP_ALPHA 1 #define INNER_LOOP( LEFT, RIGHT, Y ) \ { \ GLint i, n = RIGHT-LEFT; \ GLdepth zspan[MAX_WIDTH]; \ GLubyte red[MAX_WIDTH], green[MAX_WIDTH]; \ GLubyte blue[MAX_WIDTH], alpha[MAX_WIDTH]; \ if (n>0) { \ for (i=0;i<n;i++) { \ zspan[i] = FixedToDepth(ffz); \ red[i] = FixedToInt(ffr); \ green[i] = FixedToInt(ffg); \ blue[i] = FixedToInt(ffb); \ alpha[i] = FixedToInt(ffa); \ ffz += fdzdx; \ ffr += fdrdx; \ ffg += fdgdx; \ ffb += fdbdx; \ ffa += fdadx; \ } \ gl_write_color_span( ctx, n, LEFT, Y, zspan, \ red, green, blue, alpha, \ GL_POLYGON ); \ } \ } #include "tritemp.h" } /* * Render an RGB, GL_DECAL, textured triangle. * Interpolate S,T only w/out mipmapping or perspective correction. */ static void simple_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv ) { #define INTERP_ST 1 #define S_SCALE twidth #define T_SCALE theight #define SETUP_CODE \ GLfloat twidth = (GLfloat) ctx->Texture.Current2D->Image[0]->Width; \ GLfloat theight = (GLfloat) ctx->Texture.Current2D->Image[0]->Height;\ GLint twidth_log2 = ctx->Texture.Current2D->Image[0]->WidthLog2; \ GLubyte *texture = ctx->Texture.Current2D->Image[0]->Data; \ GLint smask = ctx->Texture.Current2D->Image[0]->Width - 1; \ GLint tmask = ctx->Texture.Current2D->Image[0]->Height - 1; #define INNER_LOOP( LEFT, RIGHT, Y ) \ { \ GLint i, n = RIGHT-LEFT; \ GLubyte red[MAX_WIDTH], green[MAX_WIDTH]; \ GLubyte blue[MAX_WIDTH], alpha[MAX_WIDTH]; \ if (n>0) { \ 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 */ \ red[i] = texture[pos]; \ green[i] = texture[pos+1]; \ blue[i] = texture[pos+2]; \ alpha[i] = 255; \ ffs += fdsdx; \ fft += fdtdx; \ } \ (*ctx->Driver.WriteColorSpan)( ctx, n, LEFT, Y, \ red, green, blue, alpha, NULL ); \ } \ } #include "tritemp.h" } /* * Render an RGB, GL_DECAL, textured triangle. * Interpolate S,T, GL_LESS depth test, w/out mipmapping or * perspective correction. */ static void simple_z_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv ) { #define INTERP_Z 1 #define INTERP_ST 1 #define S_SCALE twidth #define T_SCALE theight #define SETUP_CODE \ GLfloat twidth = (GLfloat) ctx->Texture.Current2D->Image[0]->Width; \ GLfloat theight = (GLfloat) ctx->Texture.Current2D->Image[0]->Height;\ GLint twidth_log2 = ctx->Texture.Current2D->Image[0]->WidthLog2; \ GLubyte *texture = ctx->Texture.Current2D->Image[0]->Data; \ GLint smask = ctx->Texture.Current2D->Image[0]->Width - 1; \ GLint tmask = ctx->Texture.Current2D->Image[0]->Height - 1; #define INNER_LOOP( LEFT, RIGHT, Y ) \ { \ GLint i, n = RIGHT-LEFT; \ GLubyte red[MAX_WIDTH], green[MAX_WIDTH]; \ GLubyte blue[MAX_WIDTH], alpha[MAX_WIDTH]; \ GLubyte mask[MAX_WIDTH]; \ if (n>0) { \ 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 */\ red[i] = texture[pos]; \ green[i] = texture[pos+1]; \ blue[i] = texture[pos+2]; \ alpha[i] = 255; \ zRow[i] = z; \ mask[i] = 1; \ } \ else { \ mask[i] = 0; \ } \ ffz += fdzdx; \ ffs += fdsdx; \ fft += fdtdx; \ } \ (*ctx->Driver.WriteColorSpan)( ctx, n, LEFT, Y, \ red, green, blue, alpha, mask ); \ } \ } #include "tritemp.h" } /* * 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 INTERP_RGB 1 #define INTERP_ALPHA 1 #define INTERP_STW 1 #define INTERP_UV 1 #define SETUP_CODE \ GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \ GLint r, g, b, a; \ if (flat_shade) { \ r = VB->Color[pv][0]; \ g = VB->Color[pv][1]; \ b = VB->Color[pv][2]; \ a = VB->Color[pv][3]; \ } #define INNER_LOOP( LEFT, RIGHT, Y ) \ { \ GLint i, n = RIGHT-LEFT; \ GLdepth zspan[MAX_WIDTH]; \ GLubyte red[MAX_WIDTH], green[MAX_WIDTH]; \ GLubyte blue[MAX_WIDTH], alpha[MAX_WIDTH]; \ GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH]; \ if (n>0) { \ if (flat_shade) { \ for (i=0;i<n;i++) { \ GLdouble wwvvInv = 1.0 / (ww*vv); \ zspan[i] = FixedToDepth(ffz); \ red[i] = r; \ green[i] = g; \ blue[i] = b; \ alpha[i] = a; \ s[i] = ss*wwvvInv; \ t[i] = tt*wwvvInv; \ u[i] = uu*wwvvInv; \ ffz += fdzdx; \ ss += dsdx; \ tt += dtdx; \ uu += dudx; \ vv += dvdx; \ ww += dwdx; \ } \ } \ else { \ for (i=0;i<n;i++) { \ GLdouble wwvvInv = 1.0 / (ww*vv); \ zspan[i] = FixedToDepth(ffz); \ red[i] = FixedToInt(ffr); \ green[i] = FixedToInt(ffg); \ blue[i] = FixedToInt(ffb); \ alpha[i] = FixedToInt(ffa); \ s[i] = ss*wwvvInv; \ t[i] = tt*wwvvInv; \ u[i] = uu*wwvvInv; \ ffz += fdzdx; \ ffr += fdrdx; \ ffg += fdgdx; \ ffb += fdbdx; \ ffa += fdadx; \ ss += dsdx; \ tt += dtdx; \ uu += dudx; \ ww += dwdx; \ vv += dvdx; \ } \ } \ gl_write_texture_span( ctx, n, LEFT, Y, zspan, \ s, t, u, NULL, \ red, green, blue, alpha, \ GL_POLYGON ); \ } \ } #include "tritemp.h" } /* * Compute the lambda (texture level value) for a fragment. */ static GLfloat compute_lambda( GLfloat s, GLfloat t, GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy, GLfloat w, GLfloat width, GLfloat height ) { /* TODO: this function can probably be optimized a bit */ GLfloat invw = 1.0F / w; GLfloat s0, t0, s1, t1, s2, t2; GLfloat dudx, dudy, dvdx, dvdy; GLfloat r1, r2, rho; s0 = s * invw; t0 = t * invw; s1 = (s+dsdx) * invw; t1 = (t+dtdx) * invw; s2 = (s+dsdy) * invw; t2 = (t+dtdy) * invw; dudx = (s1-s0) * width; dudy = (s2-s0) * width; dvdx = (t1-t0) * height; dvdy = (t2-t0) * height; /* r1 = sqrt( dudx * dudx + dvdx * dvdx ); */ /* r2 = sqrt( dudy * dudy + dvdy * dvdy ); */ if (dudx<0.0F) dudx = -dudx; if (dudy<0.0F) dudy = -dudy; if (dvdx<0.0F) dvdx = -dvdx; if (dvdy<0.0F) dvdy = -dvdy; r1 = MAX2( dudx, dudy ); r2 = MAX2( dvdx, dvdy ); rho = MAX2(r1,r2); if (rho<=0.0F) { return 0.0F; } else { /* return log base 2 of rho */ return log(rho) * 1.442695; /* 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_triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv ) { #define INTERP_Z 1 #define INTERP_RGB 1 #define INTERP_ALPHA 1 #define INTERP_STW 1 #define INTERP_UV 1 #define SETUP_CODE \ GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \ GLint r, g, b, a; \ GLfloat twidth, theight; \ if (ctx->Texture.Enabled & TEXTURE_3D) { \ twidth = (GLfloat) ctx->Texture.Current3D->Image[0]->Width; \ theight = (GLfloat) ctx->Texture.Current3D->Image[0]->Height; \ } \ else if (ctx->Texture.Enabled & TEXTURE_2D) { \ twidth = (GLfloat) ctx->Texture.Current2D->Image[0]->Width; \ theight = (GLfloat) ctx->Texture.Current2D->Image[0]->Height; \ } \ else { \ twidth = (GLfloat) ctx->Texture.Current1D->Image[0]->Width; \ theight = 1.0; \ } \ if (flat_shade) { \ r = VB->Color[pv][0]; \ g = VB->Color[pv][1]; \ b = VB->Color[pv][2]; \ a = VB->Color[pv][3]; \ } #define INNER_LOOP( LEFT, RIGHT, Y ) \ { \ GLint i, n = RIGHT-LEFT; \ GLdepth zspan[MAX_WIDTH]; \ GLubyte red[MAX_WIDTH], green[MAX_WIDTH]; \ GLubyte blue[MAX_WIDTH], alpha[MAX_WIDTH]; \ GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH]; \ DEFARRAY(GLfloat,lambda,MAX_WIDTH); \ if (n>0) { \ if (flat_shade) { \ for (i=0;i<n;i++) { \ GLdouble wwvvInv = 1.0 / (ww*vv); \ zspan[i] = FixedToDepth(ffz); \ red[i] = r; \ green[i] = g; \ blue[i] = b; \ alpha[i] = a; \ s[i] = ss*wwvvInv; \ t[i] = tt*wwvvInv; \ u[i] = uu*wwvvInv; \ lambda[i] = compute_lambda( s[i], t[i], \ dsdx, dsdy, \ dtdx, dtdy, ww, \ twidth, theight ); \ ffz += fdzdx; \ ss += dsdx; \ tt += dtdx; \ uu += dudx; \ vv += dvdx; \ ww += dwdx; \ } \ } \ else { \ for (i=0;i<n;i++) { \ GLdouble wwvvInv = 1.0 / (ww*vv); \ zspan[i] = FixedToDepth(ffz); \ red[i] = FixedToInt(ffr); \ green[i] = FixedToInt(ffg); \ blue[i] = FixedToInt(ffb); \ alpha[i] = FixedToInt(ffa); \ s[i] = ss*wwvvInv; \ t[i] = tt*wwvvInv; \ u[i] = uu*wwvvInv; \ lambda[i] = compute_lambda( s[i], t[i], \ dsdx, dsdy, \ dtdx, dtdy, ww, \ twidth, theight ); \ ffz += fdzdx; \ ffr += fdrdx; \ ffg += fdgdx; \ ffb += fdbdx; \ ffa += fdadx; \ ss += dsdx; \ tt += dtdx; \ uu += dudx; \ vv += dvdx; \ ww += dwdx; \ } \ } \ gl_write_texture_span( ctx, n, LEFT, Y, zspan, \ s, t, u, lambda, \ red, green, blue, alpha, \ GL_POLYGON ); \ } \ UNDEFARRAY(lambda); \ } #include "tritemp.h" } /* * Null rasterizer for measuring transformation speed. */ static void null_triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv ) { } /* * Determine which triangle rendering function to use given the current * rendering context. */ void gl_set_triangle_function( GLcontext *ctx ) { 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. */ } else if (ctx->Texture.Enabled) { if ( (ctx->Texture.Enabled==TEXTURE_2D) && ctx->Texture.Current2D->Complete && ctx->Texture.Current2D->MinFilter==GL_NEAREST && ctx->Texture.Current2D->MagFilter==GL_NEAREST && ctx->Texture.Current2D->WrapS==GL_REPEAT && ctx->Texture.Current2D->WrapT==GL_REPEAT && ctx->Texture.Current2D->Image[0]->Format==GL_RGB && ctx->Texture.Current2D->Image[0]->Border==0 && (ctx->Texture.EnvMode==GL_DECAL || ctx->Texture.EnvMode==GL_REPLACE) && ctx->Hint.PerspectiveCorrection==GL_FASTEST && ctx->TextureMatrixType==MATRIX_IDENTITY && ((ctx->RasterMask==DEPTH_BIT && ctx->Depth.Func==GL_LESS && ctx->Depth.Mask==GL_TRUE) || ctx->RasterMask==0) && ctx->Polygon.StippleFlag==GL_FALSE && ctx->Visual->EightBitColor) { if (ctx->RasterMask==DEPTH_BIT) { ctx->Driver.TriangleFunc = simple_z_textured_triangle; } else { ctx->Driver.TriangleFunc = simple_textured_triangle; } } else { GLboolean needLambda = GL_TRUE; /* if mag filter == min filter we're not mipmapping */ if (ctx->Texture.Enabled & TEXTURE_3D) { if (ctx->Texture.Current3D->MinFilter== ctx->Texture.Current3D->MagFilter) { needLambda = GL_FALSE; } } else if (ctx->Texture.Enabled & TEXTURE_2D) { if (ctx->Texture.Current2D->MinFilter== ctx->Texture.Current2D->MagFilter) { needLambda = GL_FALSE; } } else if (ctx->Texture.Enabled & TEXTURE_1D) { if (ctx->Texture.Current1D->MinFilter== ctx->Texture.Current1D->MagFilter) { needLambda = GL_FALSE; } } ctx->Driver.TriangleFunc = needLambda ? lambda_textured_triangle : general_textured_triangle; } } else { if (ctx->Light.ShadeModel==GL_SMOOTH) { /* smooth shaded, no texturing, stippled or some raster ops */ ctx->Driver.TriangleFunc = rgbmode ? smooth_rgba_triangle : smooth_ci_triangle; } else { /* flat shaded, no texturing, stippled or some raster ops */ ctx->Driver.TriangleFunc = rgbmode ? flat_rgba_triangle : flat_ci_triangle; } } } else if (ctx->RenderMode==GL_FEEDBACK) { ctx->Driver.TriangleFunc = feedback_triangle; } else { /* GL_SELECT mode */ ctx->Driver.TriangleFunc = select_triangle; } }
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.