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