• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Mesa 3-D graphics library
3  * Version:  7.3
4  *
5  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a
8  * copy of this software and associated documentation files (the "Software"),
9  * to deal in the Software without restriction, including without limitation
10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11  * and/or sell copies of the Software, and to permit persons to whom the
12  * Software is furnished to do so, subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included
15  * in all copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23  */
24 
25 
26 /*
27  * When the device driver doesn't implement triangle rasterization it
28  * can hook in _swrast_Triangle, which eventually calls one of these
29  * functions to draw triangles.
30  */
31 
32 #include "main/glheader.h"
33 #include "main/context.h"
34 #include "main/colormac.h"
35 #include "main/imports.h"
36 #include "main/macros.h"
37 #include "main/mtypes.h"
38 #include "main/state.h"
39 #include "main/samplerobj.h"
40 #include "program/prog_instruction.h"
41 
42 #include "s_aatriangle.h"
43 #include "s_context.h"
44 #include "s_feedback.h"
45 #include "s_span.h"
46 #include "s_triangle.h"
47 
48 
49 /**
50  * Test if a triangle should be culled.  Used for feedback and selection mode.
51  * \return GL_TRUE if the triangle is to be culled, GL_FALSE otherwise.
52  */
53 GLboolean
_swrast_culltriangle(struct gl_context * ctx,const SWvertex * v0,const SWvertex * v1,const SWvertex * v2)54 _swrast_culltriangle( struct gl_context *ctx,
55                       const SWvertex *v0,
56                       const SWvertex *v1,
57                       const SWvertex *v2 )
58 {
59    SWcontext *swrast = SWRAST_CONTEXT(ctx);
60    GLfloat ex = v1->attrib[FRAG_ATTRIB_WPOS][0] - v0->attrib[FRAG_ATTRIB_WPOS][0];
61    GLfloat ey = v1->attrib[FRAG_ATTRIB_WPOS][1] - v0->attrib[FRAG_ATTRIB_WPOS][1];
62    GLfloat fx = v2->attrib[FRAG_ATTRIB_WPOS][0] - v0->attrib[FRAG_ATTRIB_WPOS][0];
63    GLfloat fy = v2->attrib[FRAG_ATTRIB_WPOS][1] - v0->attrib[FRAG_ATTRIB_WPOS][1];
64    GLfloat c = ex*fy-ey*fx;
65 
66    if (c * swrast->_BackfaceSign * swrast->_BackfaceCullSign <= 0.0F)
67       return GL_FALSE;
68 
69    return GL_TRUE;
70 }
71 
72 
73 
74 /*
75  * Render a flat-shaded RGBA triangle.
76  */
77 #define NAME flat_rgba_triangle
78 #define INTERP_Z 1
79 #define SETUP_CODE				\
80    ASSERT(ctx->Texture._EnabledCoordUnits == 0);\
81    ASSERT(ctx->Light.ShadeModel==GL_FLAT);	\
82    span.interpMask |= SPAN_RGBA;		\
83    span.red = ChanToFixed(v2->color[0]);	\
84    span.green = ChanToFixed(v2->color[1]);	\
85    span.blue = ChanToFixed(v2->color[2]);	\
86    span.alpha = ChanToFixed(v2->color[3]);	\
87    span.redStep = 0;				\
88    span.greenStep = 0;				\
89    span.blueStep = 0;				\
90    span.alphaStep = 0;
91 #define RENDER_SPAN( span )  _swrast_write_rgba_span(ctx, &span);
92 #include "s_tritemp.h"
93 
94 
95 
96 /*
97  * Render a smooth-shaded RGBA triangle.
98  */
99 #define NAME smooth_rgba_triangle
100 #define INTERP_Z 1
101 #define INTERP_RGB 1
102 #define INTERP_ALPHA 1
103 #define SETUP_CODE				\
104    {						\
105       /* texturing must be off */		\
106       ASSERT(ctx->Texture._EnabledCoordUnits == 0);	\
107       ASSERT(ctx->Light.ShadeModel==GL_SMOOTH);	\
108    }
109 #define RENDER_SPAN( span )  _swrast_write_rgba_span(ctx, &span);
110 #include "s_tritemp.h"
111 
112 
113 
114 /*
115  * Render an RGB, GL_DECAL, textured triangle.
116  * Interpolate S,T only w/out mipmapping or perspective correction.
117  *
118  * No fog.  No depth testing.
119  */
120 #define NAME simple_textured_triangle
121 #define INTERP_INT_TEX 1
122 #define S_SCALE twidth
123 #define T_SCALE theight
124 
125 #define SETUP_CODE							\
126    struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];	\
127    const struct gl_texture_object *obj = 				\
128       ctx->Texture.Unit[0].CurrentTex[TEXTURE_2D_INDEX];		\
129    const struct gl_texture_image *texImg =				\
130       obj->Image[0][obj->BaseLevel];					\
131    const struct swrast_texture_image *swImg =				\
132       swrast_texture_image_const(texImg);				\
133    const GLfloat twidth = (GLfloat) texImg->Width;			\
134    const GLfloat theight = (GLfloat) texImg->Height;			\
135    const GLint twidth_log2 = texImg->WidthLog2;				\
136    const GLubyte *texture = (const GLubyte *) swImg->Map;		\
137    const GLint smask = texImg->Width - 1;				\
138    const GLint tmask = texImg->Height - 1;				\
139    ASSERT(texImg->TexFormat == MESA_FORMAT_RGB888);			\
140    if (!rb || !texture) {						\
141       return;								\
142    }
143 
144 #define RENDER_SPAN( span )						\
145    GLuint i;								\
146    GLubyte (*rgba)[4] = swrast->SpanArrays->rgba8;			\
147    span.intTex[0] -= FIXED_HALF; /* off-by-one error? */		\
148    span.intTex[1] -= FIXED_HALF;					\
149    for (i = 0; i < span.end; i++) {					\
150       GLint s = FixedToInt(span.intTex[0]) & smask;			\
151       GLint t = FixedToInt(span.intTex[1]) & tmask;			\
152       GLint pos = (t << twidth_log2) + s;				\
153       pos = pos + pos + pos;  /* multiply by 3 */			\
154       rgba[i][RCOMP] = texture[pos+2];					\
155       rgba[i][GCOMP] = texture[pos+1];					\
156       rgba[i][BCOMP] = texture[pos+0];					\
157       rgba[i][ACOMP] = 0xff;                                            \
158       span.intTex[0] += span.intTexStep[0];				\
159       span.intTex[1] += span.intTexStep[1];				\
160    }									\
161    _swrast_put_row(ctx, rb, GL_UNSIGNED_BYTE, span.end,                 \
162                    span.x, span.y, rgba, NULL);
163 
164 #include "s_tritemp.h"
165 
166 
167 
168 /*
169  * Render an RGB, GL_DECAL, textured triangle.
170  * Interpolate S,T, GL_LESS depth test, w/out mipmapping or
171  * perspective correction.
172  * Depth buffer bits must be <= sizeof(DEFAULT_SOFTWARE_DEPTH_TYPE)
173  *
174  * No fog.
175  */
176 #define NAME simple_z_textured_triangle
177 #define INTERP_Z 1
178 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
179 #define INTERP_INT_TEX 1
180 #define S_SCALE twidth
181 #define T_SCALE theight
182 
183 #define SETUP_CODE							\
184    struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];	\
185    const struct gl_texture_object *obj = 				\
186       ctx->Texture.Unit[0].CurrentTex[TEXTURE_2D_INDEX];		\
187    const struct gl_texture_image *texImg = 				\
188        obj->Image[0][obj->BaseLevel]; 					\
189    const struct swrast_texture_image *swImg =				\
190       swrast_texture_image_const(texImg);				\
191    const GLfloat twidth = (GLfloat) texImg->Width;			\
192    const GLfloat theight = (GLfloat) texImg->Height;			\
193    const GLint twidth_log2 = texImg->WidthLog2;				\
194    const GLubyte *texture = (const GLubyte *) swImg->Map;		\
195    const GLint smask = texImg->Width - 1;				\
196    const GLint tmask = texImg->Height - 1;				\
197    ASSERT(texImg->TexFormat == MESA_FORMAT_RGB888);			\
198    if (!rb || !texture) {						\
199       return;								\
200    }
201 
202 #define RENDER_SPAN( span )						\
203    GLuint i;				    				\
204    GLubyte (*rgba)[4] = swrast->SpanArrays->rgba8;			\
205    GLubyte *mask = swrast->SpanArrays->mask;                            \
206    span.intTex[0] -= FIXED_HALF; /* off-by-one error? */		\
207    span.intTex[1] -= FIXED_HALF;					\
208    for (i = 0; i < span.end; i++) {					\
209       const GLuint z = FixedToDepth(span.z);				\
210       if (z < zRow[i]) {						\
211          GLint s = FixedToInt(span.intTex[0]) & smask;			\
212          GLint t = FixedToInt(span.intTex[1]) & tmask;			\
213          GLint pos = (t << twidth_log2) + s;				\
214          pos = pos + pos + pos;  /* multiply by 3 */			\
215          rgba[i][RCOMP] = texture[pos+2];				\
216          rgba[i][GCOMP] = texture[pos+1];				\
217          rgba[i][BCOMP] = texture[pos+0];				\
218          rgba[i][ACOMP] = 0xff;          				\
219          zRow[i] = z;							\
220          mask[i] = 1;							\
221       }									\
222       else {								\
223          mask[i] = 0;							\
224       }									\
225       span.intTex[0] += span.intTexStep[0];				\
226       span.intTex[1] += span.intTexStep[1];				\
227       span.z += span.zStep;						\
228    }									\
229    _swrast_put_row(ctx, rb, GL_UNSIGNED_BYTE,                           \
230                    span.end, span.x, span.y, rgba, mask);
231 
232 #include "s_tritemp.h"
233 
234 
235 #if CHAN_TYPE != GL_FLOAT
236 
237 struct affine_info
238 {
239    GLenum filter;
240    GLenum format;
241    GLenum envmode;
242    GLint smask, tmask;
243    GLint twidth_log2;
244    const GLchan *texture;
245    GLfixed er, eg, eb, ea;
246    GLint tbytesline, tsize;
247 };
248 
249 
250 static inline GLint
ilerp(GLint t,GLint a,GLint b)251 ilerp(GLint t, GLint a, GLint b)
252 {
253    return a + ((t * (b - a)) >> FIXED_SHIFT);
254 }
255 
256 static inline GLint
ilerp_2d(GLint ia,GLint ib,GLint v00,GLint v10,GLint v01,GLint v11)257 ilerp_2d(GLint ia, GLint ib, GLint v00, GLint v10, GLint v01, GLint v11)
258 {
259    const GLint temp0 = ilerp(ia, v00, v10);
260    const GLint temp1 = ilerp(ia, v01, v11);
261    return ilerp(ib, temp0, temp1);
262 }
263 
264 
265 /* This function can handle GL_NEAREST or GL_LINEAR sampling of 2D RGB or RGBA
266  * textures with GL_REPLACE, GL_MODULATE, GL_BLEND, GL_DECAL or GL_ADD
267  * texture env modes.
268  */
269 static inline void
affine_span(struct gl_context * ctx,SWspan * span,struct affine_info * info)270 affine_span(struct gl_context *ctx, SWspan *span,
271             struct affine_info *info)
272 {
273    GLchan sample[4];  /* the filtered texture sample */
274    const GLuint texEnableSave = ctx->Texture._EnabledCoordUnits;
275 
276    /* Instead of defining a function for each mode, a test is done
277     * between the outer and inner loops. This is to reduce code size
278     * and complexity. Observe that an optimizing compiler kills
279     * unused variables (for instance tf,sf,ti,si in case of GL_NEAREST).
280     */
281 
282 #define NEAREST_RGB		\
283    sample[RCOMP] = tex00[2];	\
284    sample[GCOMP] = tex00[1];	\
285    sample[BCOMP] = tex00[0];	\
286    sample[ACOMP] = CHAN_MAX;
287 
288 #define LINEAR_RGB							\
289    sample[RCOMP] = ilerp_2d(sf, tf, tex00[2], tex01[2], tex10[2], tex11[2]);\
290    sample[GCOMP] = ilerp_2d(sf, tf, tex00[1], tex01[1], tex10[1], tex11[1]);\
291    sample[BCOMP] = ilerp_2d(sf, tf, tex00[0], tex01[0], tex10[0], tex11[0]);\
292    sample[ACOMP] = CHAN_MAX;
293 
294 #define NEAREST_RGBA  \
295    sample[RCOMP] = tex00[3];	\
296    sample[GCOMP] = tex00[2];	\
297    sample[BCOMP] = tex00[1];	\
298    sample[ACOMP] = tex00[0];
299 
300 #define LINEAR_RGBA							\
301    sample[RCOMP] = ilerp_2d(sf, tf, tex00[3], tex01[3], tex10[3], tex11[3]);\
302    sample[GCOMP] = ilerp_2d(sf, tf, tex00[2], tex01[2], tex10[2], tex11[2]);\
303    sample[BCOMP] = ilerp_2d(sf, tf, tex00[1], tex01[1], tex10[1], tex11[1]);\
304    sample[ACOMP] = ilerp_2d(sf, tf, tex00[0], tex01[0], tex10[0], tex11[0])
305 
306 #define MODULATE							  \
307    dest[RCOMP] = span->red   * (sample[RCOMP] + 1u) >> (FIXED_SHIFT + 8); \
308    dest[GCOMP] = span->green * (sample[GCOMP] + 1u) >> (FIXED_SHIFT + 8); \
309    dest[BCOMP] = span->blue  * (sample[BCOMP] + 1u) >> (FIXED_SHIFT + 8); \
310    dest[ACOMP] = span->alpha * (sample[ACOMP] + 1u) >> (FIXED_SHIFT + 8)
311 
312 #define DECAL								\
313    dest[RCOMP] = ((CHAN_MAX - sample[ACOMP]) * span->red +		\
314                ((sample[ACOMP] + 1) * sample[RCOMP] << FIXED_SHIFT))	\
315                >> (FIXED_SHIFT + 8);					\
316    dest[GCOMP] = ((CHAN_MAX - sample[ACOMP]) * span->green +		\
317                ((sample[ACOMP] + 1) * sample[GCOMP] << FIXED_SHIFT))	\
318                >> (FIXED_SHIFT + 8);					\
319    dest[BCOMP] = ((CHAN_MAX - sample[ACOMP]) * span->blue +		\
320                ((sample[ACOMP] + 1) * sample[BCOMP] << FIXED_SHIFT))	\
321                >> (FIXED_SHIFT + 8);					\
322    dest[ACOMP] = FixedToInt(span->alpha)
323 
324 #define BLEND								\
325    dest[RCOMP] = ((CHAN_MAX - sample[RCOMP]) * span->red		\
326                + (sample[RCOMP] + 1) * info->er) >> (FIXED_SHIFT + 8);	\
327    dest[GCOMP] = ((CHAN_MAX - sample[GCOMP]) * span->green		\
328                + (sample[GCOMP] + 1) * info->eg) >> (FIXED_SHIFT + 8);	\
329    dest[BCOMP] = ((CHAN_MAX - sample[BCOMP]) * span->blue		\
330                + (sample[BCOMP] + 1) * info->eb) >> (FIXED_SHIFT + 8);	\
331    dest[ACOMP] = span->alpha * (sample[ACOMP] + 1) >> (FIXED_SHIFT + 8)
332 
333 #define REPLACE  COPY_CHAN4(dest, sample)
334 
335 #define ADD								\
336    {									\
337       GLint rSum = FixedToInt(span->red)   + (GLint) sample[RCOMP];	\
338       GLint gSum = FixedToInt(span->green) + (GLint) sample[GCOMP];	\
339       GLint bSum = FixedToInt(span->blue)  + (GLint) sample[BCOMP];	\
340       dest[RCOMP] = MIN2(rSum, CHAN_MAX);				\
341       dest[GCOMP] = MIN2(gSum, CHAN_MAX);				\
342       dest[BCOMP] = MIN2(bSum, CHAN_MAX);				\
343       dest[ACOMP] = span->alpha * (sample[ACOMP] + 1) >> (FIXED_SHIFT + 8); \
344   }
345 
346 /* shortcuts */
347 
348 #define NEAREST_RGB_REPLACE		\
349    NEAREST_RGB;				\
350    dest[0] = sample[0];			\
351    dest[1] = sample[1];			\
352    dest[2] = sample[2];			\
353    dest[3] = FixedToInt(span->alpha);
354 
355 #define NEAREST_RGBA_REPLACE  \
356    dest[RCOMP] = tex00[3]; \
357    dest[GCOMP] = tex00[2]; \
358    dest[BCOMP] = tex00[1]; \
359    dest[ACOMP] = tex00[0]
360 
361 #define SPAN_NEAREST(DO_TEX, COMPS)					\
362 	for (i = 0; i < span->end; i++) {				\
363            /* Isn't it necessary to use FixedFloor below?? */		\
364            GLint s = FixedToInt(span->intTex[0]) & info->smask;		\
365            GLint t = FixedToInt(span->intTex[1]) & info->tmask;		\
366            GLint pos = (t << info->twidth_log2) + s;			\
367            const GLchan *tex00 = info->texture + COMPS * pos;		\
368            DO_TEX;							\
369            span->red += span->redStep;					\
370 	   span->green += span->greenStep;				\
371            span->blue += span->blueStep;				\
372 	   span->alpha += span->alphaStep;				\
373 	   span->intTex[0] += span->intTexStep[0];			\
374 	   span->intTex[1] += span->intTexStep[1];			\
375            dest += 4;							\
376 	}
377 
378 #define SPAN_LINEAR(DO_TEX, COMPS)					\
379 	for (i = 0; i < span->end; i++) {				\
380            /* Isn't it necessary to use FixedFloor below?? */		\
381            const GLint s = FixedToInt(span->intTex[0]) & info->smask;	\
382            const GLint t = FixedToInt(span->intTex[1]) & info->tmask;	\
383            const GLfixed sf = span->intTex[0] & FIXED_FRAC_MASK;	\
384            const GLfixed tf = span->intTex[1] & FIXED_FRAC_MASK;	\
385            const GLint pos = (t << info->twidth_log2) + s;		\
386            const GLchan *tex00 = info->texture + COMPS * pos;		\
387            const GLchan *tex10 = tex00 + info->tbytesline;		\
388            const GLchan *tex01 = tex00 + COMPS;				\
389            const GLchan *tex11 = tex10 + COMPS;				\
390            if (t == info->tmask) {					\
391               tex10 -= info->tsize;					\
392               tex11 -= info->tsize;					\
393            }								\
394            if (s == info->smask) {					\
395               tex01 -= info->tbytesline;				\
396               tex11 -= info->tbytesline;				\
397            }								\
398            DO_TEX;							\
399            span->red += span->redStep;					\
400 	   span->green += span->greenStep;				\
401            span->blue += span->blueStep;				\
402 	   span->alpha += span->alphaStep;				\
403 	   span->intTex[0] += span->intTexStep[0];			\
404 	   span->intTex[1] += span->intTexStep[1];			\
405            dest += 4;							\
406 	}
407 
408 
409    GLuint i;
410    GLchan *dest = span->array->rgba[0];
411 
412    /* Disable tex units so they're not re-applied in swrast_write_rgba_span */
413    ctx->Texture._EnabledCoordUnits = 0x0;
414 
415    span->intTex[0] -= FIXED_HALF;
416    span->intTex[1] -= FIXED_HALF;
417    switch (info->filter) {
418    case GL_NEAREST:
419       switch (info->format) {
420       case MESA_FORMAT_RGB888:
421          switch (info->envmode) {
422          case GL_MODULATE:
423             SPAN_NEAREST(NEAREST_RGB;MODULATE,3);
424             break;
425          case GL_DECAL:
426          case GL_REPLACE:
427             SPAN_NEAREST(NEAREST_RGB_REPLACE,3);
428             break;
429          case GL_BLEND:
430             SPAN_NEAREST(NEAREST_RGB;BLEND,3);
431             break;
432          case GL_ADD:
433             SPAN_NEAREST(NEAREST_RGB;ADD,3);
434             break;
435          default:
436             _mesa_problem(ctx, "bad tex env mode in SPAN_LINEAR");
437             return;
438          }
439          break;
440       case MESA_FORMAT_RGBA8888:
441          switch(info->envmode) {
442          case GL_MODULATE:
443             SPAN_NEAREST(NEAREST_RGBA;MODULATE,4);
444             break;
445          case GL_DECAL:
446             SPAN_NEAREST(NEAREST_RGBA;DECAL,4);
447             break;
448          case GL_BLEND:
449             SPAN_NEAREST(NEAREST_RGBA;BLEND,4);
450             break;
451          case GL_ADD:
452             SPAN_NEAREST(NEAREST_RGBA;ADD,4);
453             break;
454          case GL_REPLACE:
455             SPAN_NEAREST(NEAREST_RGBA_REPLACE,4);
456             break;
457          default:
458             _mesa_problem(ctx, "bad tex env mode (2) in SPAN_LINEAR");
459             return;
460          }
461          break;
462       }
463       break;
464 
465    case GL_LINEAR:
466       span->intTex[0] -= FIXED_HALF;
467       span->intTex[1] -= FIXED_HALF;
468       switch (info->format) {
469       case MESA_FORMAT_RGB888:
470          switch (info->envmode) {
471          case GL_MODULATE:
472             SPAN_LINEAR(LINEAR_RGB;MODULATE,3);
473             break;
474          case GL_DECAL:
475          case GL_REPLACE:
476             SPAN_LINEAR(LINEAR_RGB;REPLACE,3);
477             break;
478          case GL_BLEND:
479             SPAN_LINEAR(LINEAR_RGB;BLEND,3);
480             break;
481          case GL_ADD:
482             SPAN_LINEAR(LINEAR_RGB;ADD,3);
483             break;
484          default:
485             _mesa_problem(ctx, "bad tex env mode (3) in SPAN_LINEAR");
486             return;
487          }
488          break;
489       case MESA_FORMAT_RGBA8888:
490          switch (info->envmode) {
491          case GL_MODULATE:
492             SPAN_LINEAR(LINEAR_RGBA;MODULATE,4);
493             break;
494          case GL_DECAL:
495             SPAN_LINEAR(LINEAR_RGBA;DECAL,4);
496             break;
497          case GL_BLEND:
498             SPAN_LINEAR(LINEAR_RGBA;BLEND,4);
499             break;
500          case GL_ADD:
501             SPAN_LINEAR(LINEAR_RGBA;ADD,4);
502             break;
503          case GL_REPLACE:
504             SPAN_LINEAR(LINEAR_RGBA;REPLACE,4);
505             break;
506          default:
507             _mesa_problem(ctx, "bad tex env mode (4) in SPAN_LINEAR");
508             return;
509          }
510          break;
511       }
512       break;
513    }
514    span->interpMask &= ~SPAN_RGBA;
515    ASSERT(span->arrayMask & SPAN_RGBA);
516 
517    _swrast_write_rgba_span(ctx, span);
518 
519    /* re-enable texture units */
520    ctx->Texture._EnabledCoordUnits = texEnableSave;
521 
522 #undef SPAN_NEAREST
523 #undef SPAN_LINEAR
524 }
525 
526 
527 
528 /*
529  * Render an RGB/RGBA textured triangle without perspective correction.
530  */
531 #define NAME affine_textured_triangle
532 #define INTERP_Z 1
533 #define INTERP_RGB 1
534 #define INTERP_ALPHA 1
535 #define INTERP_INT_TEX 1
536 #define S_SCALE twidth
537 #define T_SCALE theight
538 
539 #define SETUP_CODE							\
540    struct affine_info info;						\
541    struct gl_texture_unit *unit = ctx->Texture.Unit+0;			\
542    const struct gl_texture_object *obj = 				\
543       ctx->Texture.Unit[0].CurrentTex[TEXTURE_2D_INDEX];		\
544    const struct gl_texture_image *texImg = 				\
545       obj->Image[0][obj->BaseLevel]; 					\
546    const struct swrast_texture_image *swImg =				\
547       swrast_texture_image_const(texImg);				\
548    const GLfloat twidth = (GLfloat) texImg->Width;			\
549    const GLfloat theight = (GLfloat) texImg->Height;			\
550    info.texture = (const GLchan *) swImg->Map;				\
551    info.twidth_log2 = texImg->WidthLog2;				\
552    info.smask = texImg->Width - 1;					\
553    info.tmask = texImg->Height - 1;					\
554    info.format = texImg->TexFormat;					\
555    info.filter = obj->Sampler.MinFilter;				\
556    info.envmode = unit->EnvMode;					\
557    info.er = 0;					\
558    info.eg = 0;					\
559    info.eb = 0;					\
560    span.arrayMask |= SPAN_RGBA;						\
561 									\
562    if (info.envmode == GL_BLEND) {					\
563       /* potential off-by-one error here? (1.0f -> 2048 -> 0) */	\
564       info.er = FloatToFixed(unit->EnvColor[RCOMP] * CHAN_MAXF);	\
565       info.eg = FloatToFixed(unit->EnvColor[GCOMP] * CHAN_MAXF);	\
566       info.eb = FloatToFixed(unit->EnvColor[BCOMP] * CHAN_MAXF);	\
567       info.ea = FloatToFixed(unit->EnvColor[ACOMP] * CHAN_MAXF);	\
568    }									\
569    if (!info.texture) {							\
570       /* this shouldn't happen */					\
571       return;								\
572    }									\
573 									\
574    switch (info.format) {						\
575    case MESA_FORMAT_RGB888:						\
576       info.tbytesline = texImg->Width * 3;				\
577       break;								\
578    case MESA_FORMAT_RGBA8888:						\
579       info.tbytesline = texImg->Width * 4;				\
580       break;								\
581    default:								\
582       _mesa_problem(NULL, "Bad texture format in affine_texture_triangle");\
583       return;								\
584    }									\
585    info.tsize = texImg->Height * info.tbytesline;
586 
587 #define RENDER_SPAN( span )   affine_span(ctx, &span, &info);
588 
589 #include "s_tritemp.h"
590 
591 
592 
593 struct persp_info
594 {
595    GLenum filter;
596    GLenum format;
597    GLenum envmode;
598    GLint smask, tmask;
599    GLint twidth_log2;
600    const GLchan *texture;
601    GLfixed er, eg, eb, ea;   /* texture env color */
602    GLint tbytesline, tsize;
603 };
604 
605 
606 static inline void
fast_persp_span(struct gl_context * ctx,SWspan * span,struct persp_info * info)607 fast_persp_span(struct gl_context *ctx, SWspan *span,
608 		struct persp_info *info)
609 {
610    GLchan sample[4];  /* the filtered texture sample */
611 
612   /* Instead of defining a function for each mode, a test is done
613    * between the outer and inner loops. This is to reduce code size
614    * and complexity. Observe that an optimizing compiler kills
615    * unused variables (for instance tf,sf,ti,si in case of GL_NEAREST).
616    */
617 #define SPAN_NEAREST(DO_TEX,COMP)					\
618 	for (i = 0; i < span->end; i++) {				\
619            GLdouble invQ = tex_coord[2] ?				\
620                                  (1.0 / tex_coord[2]) : 1.0;            \
621            GLfloat s_tmp = (GLfloat) (tex_coord[0] * invQ);		\
622            GLfloat t_tmp = (GLfloat) (tex_coord[1] * invQ);		\
623            GLint s = IFLOOR(s_tmp) & info->smask;	        	\
624            GLint t = IFLOOR(t_tmp) & info->tmask;	        	\
625            GLint pos = (t << info->twidth_log2) + s;			\
626            const GLchan *tex00 = info->texture + COMP * pos;		\
627            DO_TEX;							\
628            span->red += span->redStep;					\
629 	   span->green += span->greenStep;				\
630            span->blue += span->blueStep;				\
631 	   span->alpha += span->alphaStep;				\
632 	   tex_coord[0] += tex_step[0];					\
633 	   tex_coord[1] += tex_step[1];					\
634 	   tex_coord[2] += tex_step[2];					\
635            dest += 4;							\
636 	}
637 
638 #define SPAN_LINEAR(DO_TEX,COMP)					\
639 	for (i = 0; i < span->end; i++) {				\
640            GLdouble invQ = tex_coord[2] ?				\
641                                  (1.0 / tex_coord[2]) : 1.0;            \
642            const GLfloat s_tmp = (GLfloat) (tex_coord[0] * invQ);	\
643            const GLfloat t_tmp = (GLfloat) (tex_coord[1] * invQ);	\
644            const GLfixed s_fix = FloatToFixed(s_tmp) - FIXED_HALF;	\
645            const GLfixed t_fix = FloatToFixed(t_tmp) - FIXED_HALF;      \
646            const GLint s = FixedToInt(FixedFloor(s_fix)) & info->smask;	\
647            const GLint t = FixedToInt(FixedFloor(t_fix)) & info->tmask;	\
648            const GLfixed sf = s_fix & FIXED_FRAC_MASK;			\
649            const GLfixed tf = t_fix & FIXED_FRAC_MASK;			\
650            const GLint pos = (t << info->twidth_log2) + s;		\
651            const GLchan *tex00 = info->texture + COMP * pos;		\
652            const GLchan *tex10 = tex00 + info->tbytesline;		\
653            const GLchan *tex01 = tex00 + COMP;				\
654            const GLchan *tex11 = tex10 + COMP;				\
655            if (t == info->tmask) {					\
656               tex10 -= info->tsize;					\
657               tex11 -= info->tsize;					\
658            }								\
659            if (s == info->smask) {					\
660               tex01 -= info->tbytesline;				\
661               tex11 -= info->tbytesline;				\
662            }								\
663            DO_TEX;							\
664            span->red   += span->redStep;				\
665 	   span->green += span->greenStep;				\
666            span->blue  += span->blueStep;				\
667 	   span->alpha += span->alphaStep;				\
668 	   tex_coord[0] += tex_step[0];					\
669 	   tex_coord[1] += tex_step[1];					\
670 	   tex_coord[2] += tex_step[2];					\
671            dest += 4;							\
672 	}
673 
674    GLuint i;
675    GLfloat tex_coord[3], tex_step[3];
676    GLchan *dest = span->array->rgba[0];
677 
678    const GLuint texEnableSave = ctx->Texture._EnabledCoordUnits;
679    ctx->Texture._EnabledCoordUnits = 0;
680 
681    tex_coord[0] = span->attrStart[FRAG_ATTRIB_TEX0][0]  * (info->smask + 1);
682    tex_step[0] = span->attrStepX[FRAG_ATTRIB_TEX0][0] * (info->smask + 1);
683    tex_coord[1] = span->attrStart[FRAG_ATTRIB_TEX0][1] * (info->tmask + 1);
684    tex_step[1] = span->attrStepX[FRAG_ATTRIB_TEX0][1] * (info->tmask + 1);
685    /* span->attrStart[FRAG_ATTRIB_TEX0][2] only if 3D-texturing, here only 2D */
686    tex_coord[2] = span->attrStart[FRAG_ATTRIB_TEX0][3];
687    tex_step[2] = span->attrStepX[FRAG_ATTRIB_TEX0][3];
688 
689    switch (info->filter) {
690    case GL_NEAREST:
691       switch (info->format) {
692       case MESA_FORMAT_RGB888:
693          switch (info->envmode) {
694          case GL_MODULATE:
695             SPAN_NEAREST(NEAREST_RGB;MODULATE,3);
696             break;
697          case GL_DECAL:
698          case GL_REPLACE:
699             SPAN_NEAREST(NEAREST_RGB_REPLACE,3);
700             break;
701          case GL_BLEND:
702             SPAN_NEAREST(NEAREST_RGB;BLEND,3);
703             break;
704          case GL_ADD:
705             SPAN_NEAREST(NEAREST_RGB;ADD,3);
706             break;
707          default:
708             _mesa_problem(ctx, "bad tex env mode (5) in SPAN_LINEAR");
709             return;
710          }
711          break;
712       case MESA_FORMAT_RGBA8888:
713          switch(info->envmode) {
714          case GL_MODULATE:
715             SPAN_NEAREST(NEAREST_RGBA;MODULATE,4);
716             break;
717          case GL_DECAL:
718             SPAN_NEAREST(NEAREST_RGBA;DECAL,4);
719             break;
720          case GL_BLEND:
721             SPAN_NEAREST(NEAREST_RGBA;BLEND,4);
722             break;
723          case GL_ADD:
724             SPAN_NEAREST(NEAREST_RGBA;ADD,4);
725             break;
726          case GL_REPLACE:
727             SPAN_NEAREST(NEAREST_RGBA_REPLACE,4);
728             break;
729          default:
730             _mesa_problem(ctx, "bad tex env mode (6) in SPAN_LINEAR");
731             return;
732          }
733          break;
734       }
735       break;
736 
737    case GL_LINEAR:
738       switch (info->format) {
739       case MESA_FORMAT_RGB888:
740          switch (info->envmode) {
741          case GL_MODULATE:
742             SPAN_LINEAR(LINEAR_RGB;MODULATE,3);
743             break;
744          case GL_DECAL:
745          case GL_REPLACE:
746             SPAN_LINEAR(LINEAR_RGB;REPLACE,3);
747             break;
748          case GL_BLEND:
749             SPAN_LINEAR(LINEAR_RGB;BLEND,3);
750             break;
751          case GL_ADD:
752             SPAN_LINEAR(LINEAR_RGB;ADD,3);
753             break;
754          default:
755             _mesa_problem(ctx, "bad tex env mode (7) in SPAN_LINEAR");
756             return;
757          }
758          break;
759       case MESA_FORMAT_RGBA8888:
760          switch (info->envmode) {
761          case GL_MODULATE:
762             SPAN_LINEAR(LINEAR_RGBA;MODULATE,4);
763             break;
764          case GL_DECAL:
765             SPAN_LINEAR(LINEAR_RGBA;DECAL,4);
766             break;
767          case GL_BLEND:
768             SPAN_LINEAR(LINEAR_RGBA;BLEND,4);
769             break;
770          case GL_ADD:
771             SPAN_LINEAR(LINEAR_RGBA;ADD,4);
772             break;
773          case GL_REPLACE:
774             SPAN_LINEAR(LINEAR_RGBA;REPLACE,4);
775             break;
776          default:
777             _mesa_problem(ctx, "bad tex env mode (8) in SPAN_LINEAR");
778             return;
779          }
780          break;
781       }
782       break;
783    }
784 
785    ASSERT(span->arrayMask & SPAN_RGBA);
786    _swrast_write_rgba_span(ctx, span);
787 
788 #undef SPAN_NEAREST
789 #undef SPAN_LINEAR
790 
791    /* restore state */
792    ctx->Texture._EnabledCoordUnits = texEnableSave;
793 }
794 
795 
796 /*
797  * Render an perspective corrected RGB/RGBA textured triangle.
798  * The Q (aka V in Mesa) coordinate must be zero such that the divide
799  * by interpolated Q/W comes out right.
800  *
801  */
802 #define NAME persp_textured_triangle
803 #define INTERP_Z 1
804 #define INTERP_RGB 1
805 #define INTERP_ALPHA 1
806 #define INTERP_ATTRIBS 1
807 
808 #define SETUP_CODE							\
809    struct persp_info info;						\
810    const struct gl_texture_unit *unit = ctx->Texture.Unit+0;		\
811    const struct gl_texture_object *obj = 				\
812       ctx->Texture.Unit[0].CurrentTex[TEXTURE_2D_INDEX];		\
813    const struct gl_texture_image *texImg = 				\
814       obj->Image[0][obj->BaseLevel];			 		\
815    const struct swrast_texture_image *swImg =				\
816       swrast_texture_image_const(texImg);				\
817    info.texture = (const GLchan *) swImg->Map;				\
818    info.twidth_log2 = texImg->WidthLog2;				\
819    info.smask = texImg->Width - 1;					\
820    info.tmask = texImg->Height - 1;					\
821    info.format = texImg->TexFormat;					\
822    info.filter = obj->Sampler.MinFilter;				\
823    info.envmode = unit->EnvMode;					\
824    info.er = 0;					\
825    info.eg = 0;					\
826    info.eb = 0;					\
827 									\
828    if (info.envmode == GL_BLEND) {					\
829       /* potential off-by-one error here? (1.0f -> 2048 -> 0) */	\
830       info.er = FloatToFixed(unit->EnvColor[RCOMP] * CHAN_MAXF);	\
831       info.eg = FloatToFixed(unit->EnvColor[GCOMP] * CHAN_MAXF);	\
832       info.eb = FloatToFixed(unit->EnvColor[BCOMP] * CHAN_MAXF);	\
833       info.ea = FloatToFixed(unit->EnvColor[ACOMP] * CHAN_MAXF);	\
834    }									\
835    if (!info.texture) {							\
836       /* this shouldn't happen */					\
837       return;								\
838    }									\
839 									\
840    switch (info.format) {						\
841    case MESA_FORMAT_RGB888:						\
842       info.tbytesline = texImg->Width * 3;				\
843       break;								\
844    case MESA_FORMAT_RGBA8888:						\
845       info.tbytesline = texImg->Width * 4;				\
846       break;								\
847    default:								\
848       _mesa_problem(NULL, "Bad texture format in persp_textured_triangle");\
849       return;								\
850    }									\
851    info.tsize = texImg->Height * info.tbytesline;
852 
853 #define RENDER_SPAN( span )			\
854    span.interpMask &= ~SPAN_RGBA;		\
855    span.arrayMask |= SPAN_RGBA;			\
856    fast_persp_span(ctx, &span, &info);
857 
858 #include "s_tritemp.h"
859 
860 #endif /*CHAN_TYPE != GL_FLOAT*/
861 
862 
863 
864 /*
865  * Render an RGBA triangle with arbitrary attributes.
866  */
867 #define NAME general_triangle
868 #define INTERP_Z 1
869 #define INTERP_RGB 1
870 #define INTERP_ALPHA 1
871 #define INTERP_ATTRIBS 1
872 #define RENDER_SPAN( span )   _swrast_write_rgba_span(ctx, &span);
873 #include "s_tritemp.h"
874 
875 
876 
877 
878 /*
879  * Special tri function for occlusion testing
880  */
881 #define NAME occlusion_zless_16_triangle
882 #define INTERP_Z 1
883 #define SETUP_CODE							\
884    struct gl_renderbuffer *rb =                                         \
885       ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;           \
886    struct gl_query_object *q = ctx->Query.CurrentOcclusionObject;	\
887    ASSERT(ctx->Depth.Test);						\
888    ASSERT(!ctx->Depth.Mask);						\
889    ASSERT(ctx->Depth.Func == GL_LESS);					\
890    assert(rb->Format == MESA_FORMAT_Z16);                               \
891    if (!q) {								\
892       return;								\
893    }
894 #define RENDER_SPAN( span )						\
895    {                                                                    \
896       GLuint i;								\
897       const GLushort *zRow = (const GLushort *)				\
898          _swrast_pixel_address(rb, span.x, span.y);                     \
899       for (i = 0; i < span.end; i++) {					\
900          GLuint z = FixedToDepth(span.z);				\
901          if (z < zRow[i]) {						\
902             q->Result++;						\
903          }								\
904          span.z += span.zStep;						\
905       }									\
906    }
907 #include "s_tritemp.h"
908 
909 
910 
911 static void
nodraw_triangle(struct gl_context * ctx,const SWvertex * v0,const SWvertex * v1,const SWvertex * v2)912 nodraw_triangle( struct gl_context *ctx,
913                  const SWvertex *v0,
914                  const SWvertex *v1,
915                  const SWvertex *v2 )
916 {
917    (void) (ctx && v0 && v1 && v2);
918 }
919 
920 
921 /*
922  * This is used when separate specular color is enabled, but not
923  * texturing.  We add the specular color to the primary color,
924  * draw the triangle, then restore the original primary color.
925  * Inefficient, but seldom needed.
926  */
927 void
_swrast_add_spec_terms_triangle(struct gl_context * ctx,const SWvertex * v0,const SWvertex * v1,const SWvertex * v2)928 _swrast_add_spec_terms_triangle(struct gl_context *ctx, const SWvertex *v0,
929                                 const SWvertex *v1, const SWvertex *v2)
930 {
931    SWvertex *ncv0 = (SWvertex *)v0; /* drop const qualifier */
932    SWvertex *ncv1 = (SWvertex *)v1;
933    SWvertex *ncv2 = (SWvertex *)v2;
934    GLfloat rSum, gSum, bSum;
935    GLchan cSave[3][4];
936 
937    /* save original colors */
938    COPY_CHAN4( cSave[0], ncv0->color );
939    COPY_CHAN4( cSave[1], ncv1->color );
940    COPY_CHAN4( cSave[2], ncv2->color );
941    /* sum v0 */
942    rSum = CHAN_TO_FLOAT(ncv0->color[0]) + ncv0->attrib[FRAG_ATTRIB_COL1][0];
943    gSum = CHAN_TO_FLOAT(ncv0->color[1]) + ncv0->attrib[FRAG_ATTRIB_COL1][1];
944    bSum = CHAN_TO_FLOAT(ncv0->color[2]) + ncv0->attrib[FRAG_ATTRIB_COL1][2];
945    UNCLAMPED_FLOAT_TO_CHAN(ncv0->color[0], rSum);
946    UNCLAMPED_FLOAT_TO_CHAN(ncv0->color[1], gSum);
947    UNCLAMPED_FLOAT_TO_CHAN(ncv0->color[2], bSum);
948    /* sum v1 */
949    rSum = CHAN_TO_FLOAT(ncv1->color[0]) + ncv1->attrib[FRAG_ATTRIB_COL1][0];
950    gSum = CHAN_TO_FLOAT(ncv1->color[1]) + ncv1->attrib[FRAG_ATTRIB_COL1][1];
951    bSum = CHAN_TO_FLOAT(ncv1->color[2]) + ncv1->attrib[FRAG_ATTRIB_COL1][2];
952    UNCLAMPED_FLOAT_TO_CHAN(ncv1->color[0], rSum);
953    UNCLAMPED_FLOAT_TO_CHAN(ncv1->color[1], gSum);
954    UNCLAMPED_FLOAT_TO_CHAN(ncv1->color[2], bSum);
955    /* sum v2 */
956    rSum = CHAN_TO_FLOAT(ncv2->color[0]) + ncv2->attrib[FRAG_ATTRIB_COL1][0];
957    gSum = CHAN_TO_FLOAT(ncv2->color[1]) + ncv2->attrib[FRAG_ATTRIB_COL1][1];
958    bSum = CHAN_TO_FLOAT(ncv2->color[2]) + ncv2->attrib[FRAG_ATTRIB_COL1][2];
959    UNCLAMPED_FLOAT_TO_CHAN(ncv2->color[0], rSum);
960    UNCLAMPED_FLOAT_TO_CHAN(ncv2->color[1], gSum);
961    UNCLAMPED_FLOAT_TO_CHAN(ncv2->color[2], bSum);
962    /* draw */
963    SWRAST_CONTEXT(ctx)->SpecTriangle( ctx, ncv0, ncv1, ncv2 );
964    /* restore original colors */
965    COPY_CHAN4( ncv0->color, cSave[0] );
966    COPY_CHAN4( ncv1->color, cSave[1] );
967    COPY_CHAN4( ncv2->color, cSave[2] );
968 }
969 
970 
971 
972 #ifdef DEBUG
973 
974 /* record the current triangle function name */
975 const char *_mesa_triFuncName = NULL;
976 
977 #define USE(triFunc)				\
978 do {						\
979     _mesa_triFuncName = #triFunc;		\
980     /*printf("%s\n", _mesa_triFuncName);*/	\
981     swrast->Triangle = triFunc;			\
982 } while (0)
983 
984 #else
985 
986 #define USE(triFunc)  swrast->Triangle = triFunc;
987 
988 #endif
989 
990 
991 
992 
993 /*
994  * Determine which triangle rendering function to use given the current
995  * rendering context.
996  *
997  * Please update the summary flag _SWRAST_NEW_TRIANGLE if you add or
998  * remove tests to this code.
999  */
1000 void
_swrast_choose_triangle(struct gl_context * ctx)1001 _swrast_choose_triangle( struct gl_context *ctx )
1002 {
1003    SWcontext *swrast = SWRAST_CONTEXT(ctx);
1004 
1005    if (ctx->Polygon.CullFlag &&
1006        ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK) {
1007       USE(nodraw_triangle);
1008       return;
1009    }
1010 
1011    if (ctx->RenderMode==GL_RENDER) {
1012       struct gl_renderbuffer *depthRb =
1013          ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
1014 
1015       if (ctx->Polygon.SmoothFlag) {
1016          _swrast_set_aa_triangle_function(ctx);
1017          ASSERT(swrast->Triangle);
1018          return;
1019       }
1020 
1021       /* special case for occlusion testing */
1022       if (ctx->Query.CurrentOcclusionObject &&
1023           ctx->Depth.Test &&
1024           ctx->Depth.Mask == GL_FALSE &&
1025           ctx->Depth.Func == GL_LESS &&
1026           !ctx->Stencil._Enabled &&
1027           depthRb &&
1028           depthRb->Format == MESA_FORMAT_Z16) {
1029          if (ctx->Color.ColorMask[0][0] == 0 &&
1030 	     ctx->Color.ColorMask[0][1] == 0 &&
1031 	     ctx->Color.ColorMask[0][2] == 0 &&
1032 	     ctx->Color.ColorMask[0][3] == 0) {
1033             USE(occlusion_zless_16_triangle);
1034             return;
1035          }
1036       }
1037 
1038       /*
1039        * XXX should examine swrast->_ActiveAttribMask to determine what
1040        * needs to be interpolated.
1041        */
1042       if (ctx->Texture._EnabledCoordUnits ||
1043 	  _swrast_use_fragment_program(ctx) ||
1044           ctx->ATIFragmentShader._Enabled ||
1045           _mesa_need_secondary_color(ctx) ||
1046           swrast->_FogEnabled) {
1047          /* Ugh, we do a _lot_ of tests to pick the best textured tri func */
1048          const struct gl_texture_object *texObj2D;
1049          const struct gl_sampler_object *samp;
1050          const struct gl_texture_image *texImg;
1051          const struct swrast_texture_image *swImg;
1052          GLenum minFilter, magFilter, envMode;
1053          gl_format format;
1054          texObj2D = ctx->Texture.Unit[0].CurrentTex[TEXTURE_2D_INDEX];
1055          if (ctx->Texture.Unit[0].Sampler)
1056             samp = ctx->Texture.Unit[0].Sampler;
1057          else if (texObj2D)
1058             samp = &texObj2D->Sampler;
1059          else
1060             samp = NULL;
1061 
1062          texImg = texObj2D ? texObj2D->Image[0][texObj2D->BaseLevel] : NULL;
1063          swImg = swrast_texture_image_const(texImg);
1064 
1065          format = texImg ? texImg->TexFormat : MESA_FORMAT_NONE;
1066          minFilter = texObj2D ? samp->MinFilter : GL_NONE;
1067          magFilter = texObj2D ? samp->MagFilter : GL_NONE;
1068          envMode = ctx->Texture.Unit[0].EnvMode;
1069 
1070          /* First see if we can use an optimized 2-D texture function */
1071          if (ctx->Texture._EnabledCoordUnits == 0x1
1072              && !_swrast_use_fragment_program(ctx)
1073              && !ctx->ATIFragmentShader._Enabled
1074              && ctx->Texture._EnabledUnits == 0x1
1075              && ctx->Texture.Unit[0]._ReallyEnabled == TEXTURE_2D_BIT
1076              && samp->WrapS == GL_REPEAT
1077              && samp->WrapT == GL_REPEAT
1078              && texObj2D->_Swizzle == SWIZZLE_NOOP
1079              && swImg->_IsPowerOfTwo
1080              && texImg->Border == 0
1081              && texImg->Width == swImg->RowStride
1082              && (format == MESA_FORMAT_RGB888 || format == MESA_FORMAT_RGBA8888)
1083              && minFilter == magFilter
1084              && ctx->Light.Model.ColorControl == GL_SINGLE_COLOR
1085              && !swrast->_FogEnabled
1086              && ctx->Texture.Unit[0].EnvMode != GL_COMBINE_EXT
1087              && ctx->Texture.Unit[0].EnvMode != GL_COMBINE4_NV) {
1088 	    if (ctx->Hint.PerspectiveCorrection==GL_FASTEST) {
1089 	       if (minFilter == GL_NEAREST
1090 		   && format == MESA_FORMAT_RGB888
1091 		   && (envMode == GL_REPLACE || envMode == GL_DECAL)
1092 		   && ((swrast->_RasterMask == (DEPTH_BIT | TEXTURE_BIT)
1093 			&& ctx->Depth.Func == GL_LESS
1094 			&& ctx->Depth.Mask == GL_TRUE)
1095 		       || swrast->_RasterMask == TEXTURE_BIT)
1096 		   && ctx->Polygon.StippleFlag == GL_FALSE
1097                    && ctx->DrawBuffer->Visual.depthBits <= 16) {
1098 		  if (swrast->_RasterMask == (DEPTH_BIT | TEXTURE_BIT)) {
1099 		     USE(simple_z_textured_triangle);
1100 		  }
1101 		  else {
1102 		     USE(simple_textured_triangle);
1103 		  }
1104 	       }
1105 	       else {
1106 #if CHAN_BITS != 8
1107                   USE(general_triangle);
1108 #else
1109                   if (format == MESA_FORMAT_RGBA8888 && !_mesa_little_endian()) {
1110                      /* We only handle RGBA8888 correctly on little endian
1111                       * in the optimized code above.
1112                       */
1113                      USE(general_triangle);
1114                   }
1115                   else {
1116                      USE(affine_textured_triangle);
1117                  }
1118 #endif
1119 	       }
1120 	    }
1121 	    else {
1122 #if CHAN_BITS != 8
1123                USE(general_triangle);
1124 #else
1125                USE(persp_textured_triangle);
1126 #endif
1127 	    }
1128 	 }
1129          else {
1130             /* general case textured triangles */
1131             USE(general_triangle);
1132          }
1133       }
1134       else {
1135          ASSERT(!swrast->_FogEnabled);
1136          ASSERT(!_mesa_need_secondary_color(ctx));
1137 	 if (ctx->Light.ShadeModel==GL_SMOOTH) {
1138 	    /* smooth shaded, no texturing, stippled or some raster ops */
1139 #if CHAN_BITS != 8
1140                USE(general_triangle);
1141 #else
1142                USE(smooth_rgba_triangle);
1143 #endif
1144 	 }
1145 	 else {
1146 	    /* flat shaded, no texturing, stippled or some raster ops */
1147 #if CHAN_BITS != 8
1148             USE(general_triangle);
1149 #else
1150             USE(flat_rgba_triangle);
1151 #endif
1152 	 }
1153       }
1154    }
1155    else if (ctx->RenderMode==GL_FEEDBACK) {
1156       USE(_swrast_feedback_triangle);
1157    }
1158    else {
1159       /* GL_SELECT mode */
1160       USE(_swrast_select_triangle);
1161    }
1162 }
1163