Changeset 3598 for trunk/src/opengl/mesa/triangle.c
- Timestamp:
- May 23, 2000, 10:41:28 PM (25 years ago)
- File:
-
- 1 edited
-
trunk/src/opengl/mesa/triangle.c (modified) (40 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/opengl/mesa/triangle.c
r2962 r3598 1 /* $Id: triangle.c,v 1. 2 2000-03-01 18:49:38 jeroen Exp $ */1 /* $Id: triangle.c,v 1.3 2000-05-23 20:40:58 jeroen Exp $ */ 2 2 3 3 /* 4 4 * Mesa 3-D graphics library 5 * Version: 3. 15 * Version: 3.3 6 6 * 7 7 * Copyright (C) 1999 Brian Paul All Rights Reserved. … … 38 38 #include "all.h" 39 39 #else 40 #ifndef XFree86Server 41 #include <assert.h> 42 #include <math.h> 43 #include <stdio.h> 44 #else 45 #include "GL/xf86glx.h" 46 #endif 40 #include "glheader.h" 41 #include "aatriangle.h" 47 42 #include "types.h" 48 43 #include "context.h" … … 55 50 #include "triangle.h" 56 51 #include "vb.h" 52 #include "mem.h" 57 53 #endif 58 54 … … 87 83 { 88 84 #define INTERP_Z 1 89 90 #define SETUP_CODE \ 91 GLuint index = VB->IndexPtr->data[pv]; \ 92 if (1) { \ 93 /* set the color index */ \ 94 (*ctx->Driver.Index)( ctx, index ); \ 85 #define SETUP_CODE \ 86 GLuint index = VB->IndexPtr->data[pv]; \ 87 if (1) { \ 88 /* set the color index */ \ 89 (*ctx->Driver.Index)( ctx, index ); \ 95 90 } 96 91 97 #define INNER_LOOP( LEFT, RIGHT, Y ) 98 {\99 GLint i, n = RIGHT-LEFT;\100 GLdepth zspan[MAX_WIDTH];\101 if (n>0) {\102 for (i=0;i<n;i++) {\103 zspan[i] = FixedToDepth(ffz);\104 ffz += fdzdx;\105 }\106 gl_write_monoindex_span( ctx, n, LEFT, Y,\107 zspan, index, GL_POLYGON );\108 }\109 110 111 #include "tritemp.h" 92 #define INNER_LOOP( LEFT, RIGHT, Y ) \ 93 { \ 94 GLint i, n = RIGHT-LEFT; \ 95 GLdepth zspan[MAX_WIDTH]; \ 96 if (n>0) { \ 97 for (i=0;i<n;i++) { \ 98 zspan[i] = FixedToDepth(ffz); \ 99 ffz += fdzdx; \ 100 } \ 101 gl_write_monoindex_span( ctx, n, LEFT, Y, \ 102 zspan, index, GL_POLYGON ); \ 103 } \ 104 } 105 106 #include "tritemp.h" 112 107 } 113 108 … … 124 119 #define INTERP_INDEX 1 125 120 126 #define INNER_LOOP( LEFT, RIGHT, Y ) 127 {\128 GLint i, n = RIGHT-LEFT;\129 GLdepth zspan[MAX_WIDTH];\130 GLuint index[MAX_WIDTH]; 131 if (n>0) {\132 for (i=0;i<n;i++) {\133 zspan[i] = FixedToDepth(ffz);\134 index[i] = FixedToInt(ffi); 135 ffz += fdzdx;\136 ffi += fdidx;\137 }\138 gl_write_index_span( ctx, n, LEFT, Y, zspan,\139 index, GL_POLYGON );\140 }\141 121 #define INNER_LOOP( LEFT, RIGHT, Y ) \ 122 { \ 123 GLint i, n = RIGHT-LEFT; \ 124 GLdepth zspan[MAX_WIDTH]; \ 125 GLuint index[MAX_WIDTH]; \ 126 if (n>0) { \ 127 for (i=0;i<n;i++) { \ 128 zspan[i] = FixedToDepth(ffz); \ 129 index[i] = FixedToInt(ffi); \ 130 ffz += fdzdx; \ 131 ffi += fdidx; \ 132 } \ 133 gl_write_index_span( ctx, n, LEFT, Y, zspan, \ 134 index, GL_POLYGON ); \ 135 } \ 136 } 142 137 143 138 #include "tritemp.h" … … 153 148 { 154 149 #define INTERP_Z 1 155 156 #define SETUP_CODE \ 157 if (1) { \ 158 /* set the color */ \ 159 GLubyte r = VB->ColorPtr->data[pv][0]; \ 160 GLubyte g = VB->ColorPtr->data[pv][1]; \ 161 GLubyte b = VB->ColorPtr->data[pv][2]; \ 162 GLubyte a = VB->ColorPtr->data[pv][3]; \ 163 (*ctx->Driver.Color)( ctx, r, g, b, a ); \ 150 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 151 152 #define SETUP_CODE \ 153 if (1) { \ 154 /* set the color */ \ 155 GLubyte r = VB->ColorPtr->data[pv][0]; \ 156 GLubyte g = VB->ColorPtr->data[pv][1]; \ 157 GLubyte b = VB->ColorPtr->data[pv][2]; \ 158 GLubyte a = VB->ColorPtr->data[pv][3]; \ 159 (*ctx->Driver.Color)( ctx, r, g, b, a ); \ 164 160 } 165 161 166 #define INNER_LOOP( LEFT, RIGHT, Y ) 167 {\168 GLint i, n = RIGHT-LEFT;\169 GLdepth zspan[MAX_WIDTH];\170 if (n>0) {\171 for (i=0;i<n;i++) {\172 zspan[i] = FixedToDepth(ffz);\173 ffz += fdzdx;\174 }\175 gl_write_monocolor_span( ctx, n, LEFT, Y, zspan, 176 VB->ColorPtr->data[pv],\177 GL_POLYGON );\178 }\179 162 #define INNER_LOOP( LEFT, RIGHT, Y ) \ 163 { \ 164 GLint i, n = RIGHT-LEFT; \ 165 GLdepth zspan[MAX_WIDTH]; \ 166 if (n>0) { \ 167 for (i=0;i<n;i++) { \ 168 zspan[i] = FixedToDepth(ffz); \ 169 ffz += fdzdx; \ 170 } \ 171 gl_write_monocolor_span( ctx, n, LEFT, Y, zspan, \ 172 VB->ColorPtr->data[pv], \ 173 GL_POLYGON ); \ 174 } \ 175 } 180 176 181 177 #include "tritemp.h" 182 178 183 ASSERT(!ctx->Texture.ReallyEnabled); /* texturing must be off*/179 ASSERT(!ctx->Texture.ReallyEnabled); /* texturing must be off*/ 184 180 ASSERT(ctx->Light.ShadeModel==GL_FLAT); 185 181 } … … 195 191 (void) pv; 196 192 #define INTERP_Z 1 193 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 197 194 #define INTERP_RGB 1 198 195 #define INTERP_ALPHA 1 199 196 200 #define INNER_LOOP( LEFT, RIGHT, Y ) 201 {\202 GLint i, n = RIGHT-LEFT;\203 GLdepth zspan[MAX_WIDTH];\204 GLubyte rgba[MAX_WIDTH][4];\205 if (n>0) {\206 for (i=0;i<n;i++) {\207 zspan[i] = FixedToDepth(ffz);\208 rgba[i][RCOMP] = FixedToInt(ffr);\209 rgba[i][GCOMP] = FixedToInt(ffg);\210 rgba[i][BCOMP] = FixedToInt(ffb);\211 rgba[i][ACOMP] = FixedToInt(ffa);\212 ffz += fdzdx;\213 ffr += fdrdx;\214 ffg += fdgdx;\215 ffb += fdbdx;\216 ffa += fdadx;\217 }\218 gl_write_rgba_span( ctx, n, LEFT, Y,\219 (const GLdepth *) zspan, 220 rgba, GL_POLYGON );\221 }\222 197 #define INNER_LOOP( LEFT, RIGHT, Y ) \ 198 { \ 199 GLint i, n = RIGHT-LEFT; \ 200 GLdepth zspan[MAX_WIDTH]; \ 201 GLubyte rgba[MAX_WIDTH][4]; \ 202 if (n>0) { \ 203 for (i=0;i<n;i++) { \ 204 zspan[i] = FixedToDepth(ffz); \ 205 rgba[i][RCOMP] = FixedToInt(ffr); \ 206 rgba[i][GCOMP] = FixedToInt(ffg); \ 207 rgba[i][BCOMP] = FixedToInt(ffb); \ 208 rgba[i][ACOMP] = FixedToInt(ffa); \ 209 ffz += fdzdx; \ 210 ffr += fdrdx; \ 211 ffg += fdgdx; \ 212 ffb += fdbdx; \ 213 ffa += fdadx; \ 214 } \ 215 gl_write_rgba_span( ctx, n, LEFT, Y, \ 216 (const GLdepth *) zspan, \ 217 rgba, GL_POLYGON ); \ 218 } \ 219 } 223 220 224 221 #include "tritemp.h" … … 239 236 #define S_SCALE twidth 240 237 #define T_SCALE theight 241 #define SETUP_CODE 242 struct gl_texture_object *obj = ctx->Texture.Unit[0].CurrentD[2]; 243 GLint b = obj->BaseLevel; 244 GLfloat twidth = (GLfloat) obj->Image[b]->Width; 245 GLfloat theight = (GLfloat) obj->Image[b]->Height; 246 GLint twidth_log2 = obj->Image[b]->WidthLog2; 247 GLubyte *texture = obj->Image[b]->Data; 248 GLint smask = obj->Image[b]->Width - 1; 238 #define SETUP_CODE \ 239 struct gl_texture_object *obj = ctx->Texture.Unit[0].CurrentD[2]; \ 240 GLint b = obj->BaseLevel; \ 241 GLfloat twidth = (GLfloat) obj->Image[b]->Width; \ 242 GLfloat theight = (GLfloat) obj->Image[b]->Height; \ 243 GLint twidth_log2 = obj->Image[b]->WidthLog2; \ 244 GLubyte *texture = obj->Image[b]->Data; \ 245 GLint smask = obj->Image[b]->Width - 1; \ 249 246 GLint tmask = obj->Image[b]->Height - 1; 250 247 (void) pv; 251 248 252 #define INNER_LOOP( LEFT, RIGHT, Y ) 253 {\254 GLint i, n = RIGHT-LEFT;\255 GLubyte rgb[MAX_WIDTH][3];\256 if (n>0) {\249 #define INNER_LOOP( LEFT, RIGHT, Y ) \ 250 { \ 251 GLint i, n = RIGHT-LEFT; \ 252 GLubyte rgb[MAX_WIDTH][3]; \ 253 if (n>0) { \ 257 254 ffs -= FIXED_HALF; /* off-by-one error? */ \ 258 255 fft -= FIXED_HALF; \ 259 for (i=0;i<n;i++) {\260 GLint s = FixedToInt(ffs) & smask; 261 GLint t = FixedToInt(fft) & tmask; 262 GLint pos = (t << twidth_log2) + s; 263 pos = pos + pos + pos; /* multiply by 3 */ 264 rgb[i][RCOMP] = texture[pos]; 265 rgb[i][GCOMP] = texture[pos+1]; 266 rgb[i][BCOMP] = texture[pos+2]; 267 ffs += fdsdx;\268 fft += fdtdx;\269 }\270 (*ctx->Driver.WriteRGBSpan)( ctx, n, LEFT, Y, 271 (const GLubyte (*)[3]) rgb, NULL ); 272 }\273 256 for (i=0;i<n;i++) { \ 257 GLint s = FixedToInt(ffs) & smask; \ 258 GLint t = FixedToInt(fft) & tmask; \ 259 GLint pos = (t << twidth_log2) + s; \ 260 pos = pos + pos + pos; /* multiply by 3 */ \ 261 rgb[i][RCOMP] = texture[pos]; \ 262 rgb[i][GCOMP] = texture[pos+1]; \ 263 rgb[i][BCOMP] = texture[pos+2]; \ 264 ffs += fdsdx; \ 265 fft += fdtdx; \ 266 } \ 267 (*ctx->Driver.WriteRGBSpan)( ctx, n, LEFT, Y, \ 268 (const GLubyte (*)[3]) rgb, NULL ); \ 269 } \ 270 } 274 271 275 272 #include "tritemp.h" … … 286 283 { 287 284 #define INTERP_Z 1 285 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 288 286 #define INTERP_INT_ST 1 289 287 #define S_SCALE twidth 290 288 #define T_SCALE theight 291 #define SETUP_CODE 292 struct gl_texture_object *obj = ctx->Texture.Unit[0].CurrentD[2]; 293 GLint b = obj->BaseLevel; 294 GLfloat twidth = (GLfloat) obj->Image[b]->Width; 295 GLfloat theight = (GLfloat) obj->Image[b]->Height; 296 GLint twidth_log2 = obj->Image[b]->WidthLog2; 297 GLubyte *texture = obj->Image[b]->Data; 298 GLint smask = obj->Image[b]->Width - 1; 289 #define SETUP_CODE \ 290 struct gl_texture_object *obj = ctx->Texture.Unit[0].CurrentD[2]; \ 291 GLint b = obj->BaseLevel; \ 292 GLfloat twidth = (GLfloat) obj->Image[b]->Width; \ 293 GLfloat theight = (GLfloat) obj->Image[b]->Height; \ 294 GLint twidth_log2 = obj->Image[b]->WidthLog2; \ 295 GLubyte *texture = obj->Image[b]->Data; \ 296 GLint smask = obj->Image[b]->Width - 1; \ 299 297 GLint tmask = obj->Image[b]->Height - 1; 300 298 (void) pv; 301 299 302 #define INNER_LOOP( LEFT, RIGHT, Y ) 303 {\304 GLint i, n = RIGHT-LEFT;\305 GLubyte rgb[MAX_WIDTH][3];\306 GLubyte mask[MAX_WIDTH]; 307 if (n>0) {\300 #define INNER_LOOP( LEFT, RIGHT, Y ) \ 301 { \ 302 GLint i, n = RIGHT-LEFT; \ 303 GLubyte rgb[MAX_WIDTH][3]; \ 304 GLubyte mask[MAX_WIDTH]; \ 305 if (n>0) { \ 308 306 ffs -= FIXED_HALF; /* off-by-one error? */ \ 309 307 fft -= FIXED_HALF; \ 310 for (i=0;i<n;i++) {\311 GLdepth z = FixedToDepth(ffz); 312 if (z < zRow[i]) { 313 GLint s = FixedToInt(ffs) & smask; 314 GLint t = FixedToInt(fft) & tmask; 315 GLint pos = (t << twidth_log2) + s; 316 pos = pos + pos + pos; /* multiply by 3 */ 317 rgb[i][RCOMP] = texture[pos]; 318 rgb[i][GCOMP] = texture[pos+1]; 319 rgb[i][BCOMP] = texture[pos+2]; 320 zRow[i] = z;\321 mask[i] = 1; 322 } 323 else { 324 mask[i] = 0; 325 } 326 ffz += fdzdx;\327 ffs += fdsdx;\328 fft += fdtdx;\329 }\330 (*ctx->Driver.WriteRGBSpan)( ctx, n, LEFT, Y, 331 (const GLubyte (*)[3]) rgb, mask ); 332 }\333 308 for (i=0;i<n;i++) { \ 309 GLdepth z = FixedToDepth(ffz); \ 310 if (z < zRow[i]) { \ 311 GLint s = FixedToInt(ffs) & smask; \ 312 GLint t = FixedToInt(fft) & tmask; \ 313 GLint pos = (t << twidth_log2) + s; \ 314 pos = pos + pos + pos; /* multiply by 3 */ \ 315 rgb[i][RCOMP] = texture[pos]; \ 316 rgb[i][GCOMP] = texture[pos+1]; \ 317 rgb[i][BCOMP] = texture[pos+2]; \ 318 zRow[i] = z; \ 319 mask[i] = 1; \ 320 } \ 321 else { \ 322 mask[i] = 0; \ 323 } \ 324 ffz += fdzdx; \ 325 ffs += fdsdx; \ 326 fft += fdtdx; \ 327 } \ 328 (*ctx->Driver.WriteRGBSpan)( ctx, n, LEFT, Y, \ 329 (const GLubyte (*)[3]) rgb, mask ); \ 330 } \ 331 } 334 332 335 333 #include "tritemp.h" … … 342 340 */ 343 341 static void affine_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, 344 342 GLuint v2, GLuint pv ) 345 343 { 346 344 #define INTERP_Z 1 345 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 347 346 #define INTERP_RGB 1 348 347 #define INTERP_ALPHA 1 … … 350 349 #define S_SCALE twidth 351 350 #define T_SCALE theight 352 #define SETUP_CODE 353 struct gl_texture_unit *unit = ctx->Texture.Unit+0; 354 struct gl_texture_object *obj = unit->CurrentD[2]; 355 GLint b = obj->BaseLevel; 356 GLfloat twidth = (GLfloat) obj->Image[b]->Width; 357 GLfloat theight = (GLfloat) obj->Image[b]->Height; 358 GLint twidth_log2 = obj->Image[b]->WidthLog2; 359 GLubyte *texture = obj->Image[b]->Data; 360 GLint smask = obj->Image[b]->Width - 1; 351 #define SETUP_CODE \ 352 struct gl_texture_unit *unit = ctx->Texture.Unit+0; \ 353 struct gl_texture_object *obj = unit->CurrentD[2]; \ 354 GLint b = obj->BaseLevel; \ 355 GLfloat twidth = (GLfloat) obj->Image[b]->Width; \ 356 GLfloat theight = (GLfloat) obj->Image[b]->Height; \ 357 GLint twidth_log2 = obj->Image[b]->WidthLog2; \ 358 GLubyte *texture = obj->Image[b]->Data; \ 359 GLint smask = obj->Image[b]->Width - 1; \ 361 360 GLint tmask = obj->Image[b]->Height - 1; \ 362 361 GLint format = obj->Image[b]->Format; \ … … 366 365 GLfixed er, eg, eb, ea; \ 367 366 GLint tr, tg, tb, ta; \ 368 if (envmode == GL_BLEND || envmode == GL_ADD) {\367 if (envmode == GL_BLEND) { \ 369 368 /* potential off-by-one error here? (1.0f -> 2048 -> 0) */ \ 370 369 er = FloatToFixed(unit->EnvColor[0]); \ … … 409 408 410 409 #define LINEAR_RGB \ 411 410 tr = (ti * (si * tex00[0] + sf * tex01[0]) + \ 412 411 tf * (si * tex10[0] + sf * tex11[0])) >> 2 * FIXED_SHIFT; \ 413 412 tg = (ti * (si * tex00[1] + sf * tex01[1]) + \ 414 413 tf * (si * tex10[1] + sf * tex11[1])) >> 2 * FIXED_SHIFT; \ 415 414 tb = (ti * (si * tex00[2] + sf * tex01[2]) + \ 416 415 tf * (si * tex10[2] + sf * tex11[2])) >> 2 * FIXED_SHIFT; \ 417 416 ta = 0xff 418 417 419 418 #define NEAREST_RGBA \ … … 424 423 425 424 #define LINEAR_RGBA \ 426 425 tr = (ti * (si * tex00[0] + sf * tex01[0]) + \ 427 426 tf * (si * tex10[0] + sf * tex11[0])) >> 2 * FIXED_SHIFT; \ 428 427 tg = (ti * (si * tex00[1] + sf * tex01[1]) + \ 429 428 tf * (si * tex10[1] + sf * tex11[1])) >> 2 * FIXED_SHIFT; \ 430 429 tb = (ti * (si * tex00[2] + sf * tex01[2]) + \ 431 430 tf * (si * tex10[2] + sf * tex11[2])) >> 2 * FIXED_SHIFT; \ 432 431 ta = (ti * (si * tex00[3] + sf * tex01[3]) + \ 433 432 tf * (si * tex10[3] + sf * tex11[3])) >> 2 * FIXED_SHIFT 434 433 … … 440 439 441 440 #define DECAL \ 442 443 444 445 441 dest[0] = ((0xff - ta) * ffr + ((ta + 1) * tr << FIXED_SHIFT)) >> (FIXED_SHIFT + 8); \ 442 dest[1] = ((0xff - ta) * ffg + ((ta + 1) * tg << FIXED_SHIFT)) >> (FIXED_SHIFT + 8); \ 443 dest[2] = ((0xff - ta) * ffb + ((ta + 1) * tb << FIXED_SHIFT)) >> (FIXED_SHIFT + 8); \ 444 dest[3] = FixedToInt(ffa) 446 445 447 446 #define BLEND \ … … 449 448 dest[1] = ((0xff - tg) * ffg + (tg + 1) * eg) >> (FIXED_SHIFT + 8); \ 450 449 dest[2] = ((0xff - tb) * ffb + (tb + 1) * eb) >> (FIXED_SHIFT + 8); \ 451 450 dest[3] = ffa * (ta + 1) >> (FIXED_SHIFT + 8) 452 451 453 452 #define REPLACE \ … … 457 456 dest[3] = ta 458 457 459 #define ADD \460 dest[0] = ((ffr << 8) + (tr + 1) * er) >> (FIXED_SHIFT + 8); \461 dest[1] = ((ffg << 8) + (tg + 1) * eg) >> (FIXED_SHIFT + 8); \462 dest[2] = ((ffb << 8) + (tb + 1) * eb) >> (FIXED_SHIFT + 8); \463 dest[3] = ffa * (ta + 1) >> (FIXED_SHIFT + 8)464 465 458 /* shortcuts */ 466 459 … … 470 463 471 464 #define SPAN1(DO_TEX,COMP) \ 472 465 for (i=0;i<n;i++) { \ 473 466 GLint s = FixedToInt(ffs) & smask; \ 474 467 GLint t = FixedToInt(fft) & tmask; \ 475 468 GLint pos = (t << twidth_log2) + s; \ 476 469 GLubyte *tex00 = texture + COMP * pos; \ 477 470 zspan[i] = FixedToDepth(ffz); \ 478 471 DO_TEX; \ 479 472 ffz += fdzdx; \ 480 473 ffr += fdrdx; \ 481 474 ffg += fdgdx; \ 482 475 ffb += fdbdx; \ 483 484 485 476 ffa += fdadx; \ 477 ffs += fdsdx; \ 478 fft += fdtdx; \ 486 479 dest += 4; \ 487 480 } 488 481 489 482 #define SPAN2(DO_TEX,COMP) \ 490 483 for (i=0;i<n;i++) { \ 491 484 GLint s = FixedToInt(ffs) & smask; \ 492 485 GLint t = FixedToInt(fft) & tmask; \ … … 508 501 tex11 -= tbytesline; \ 509 502 } \ 510 503 zspan[i] = FixedToDepth(ffz); \ 511 504 DO_TEX; \ 512 505 ffz += fdzdx; \ 513 506 ffr += fdrdx; \ 514 507 ffg += fdgdx; \ 515 508 ffb += fdbdx; \ 516 517 518 509 ffa += fdadx; \ 510 ffs += fdsdx; \ 511 fft += fdtdx; \ 519 512 dest += 4; \ 520 513 } 521 514 522 515 /* here comes the heavy part.. (something for the compiler to chew on) */ 523 #define INNER_LOOP( LEFT, RIGHT, Y ) 524 {\525 GLint i, n = RIGHT-LEFT;\526 GLdepth zspan[MAX_WIDTH];\527 528 516 #define INNER_LOOP( LEFT, RIGHT, Y ) \ 517 { \ 518 GLint i, n = RIGHT-LEFT; \ 519 GLdepth zspan[MAX_WIDTH]; \ 520 GLubyte rgba[MAX_WIDTH][4]; \ 521 if (n>0) { \ 529 522 GLubyte *dest = rgba[0]; \ 530 523 ffs -= FIXED_HALF; /* off-by-one error? */ \ 531 524 fft -= FIXED_HALF; \ 532 525 switch (filter) { \ 533 534 526 case GL_NEAREST: \ 527 switch (format) { \ 535 528 case GL_RGB: \ 536 537 529 switch (envmode) { \ 530 case GL_MODULATE: \ 538 531 SPAN1(NEAREST_RGB;MODULATE,3); \ 539 532 break; \ 540 533 case GL_DECAL: \ 541 534 case GL_REPLACE: \ 542 535 SPAN1(NEAREST_RGB_REPLACE,3); \ … … 545 538 SPAN1(NEAREST_RGB;BLEND,3); \ 546 539 break; \ 547 case GL_ADD: \ 548 SPAN1(NEAREST_RGB;ADD,3); \ 549 break; \ 550 } \ 540 default: /* unexpected env mode */ \ 541 ABORT(); \ 542 } \ 551 543 break; \ 552 553 554 544 case GL_RGBA: \ 545 switch(envmode) { \ 546 case GL_MODULATE: \ 555 547 SPAN1(NEAREST_RGBA;MODULATE,4); \ 556 548 break; \ 557 549 case GL_DECAL: \ 558 550 SPAN1(NEAREST_RGBA;DECAL,4); \ 559 551 break; \ 560 552 case GL_BLEND: \ 561 553 SPAN1(NEAREST_RGBA;BLEND,4); \ 562 554 break; \ 563 555 case GL_REPLACE: \ 564 556 SPAN1(NEAREST_RGBA_REPLACE,4); \ 565 557 break; \ 566 case GL_ADD: \ 567 SPAN1(NEAREST_RGBA;ADD,4); \ 568 break; \ 569 } \ 558 default: /* unexpected env mode */ \ 559 ABORT(); \ 560 } \ 570 561 break; \ 571 562 } \ 572 563 break; \ 573 564 case GL_LINEAR: \ 574 565 ffs -= FIXED_HALF; \ 575 566 fft -= FIXED_HALF; \ 576 577 578 579 580 581 break; \ 582 583 567 switch (format) { \ 568 case GL_RGB: \ 569 switch (envmode) { \ 570 case GL_MODULATE: \ 571 SPAN2(LINEAR_RGB;MODULATE,3); \ 572 break; \ 573 case GL_DECAL: \ 574 case GL_REPLACE: \ 584 575 SPAN2(LINEAR_RGB;REPLACE,3); \ 585 576 break; \ 586 case GL_BLEND: \ 587 SPAN2(LINEAR_RGB;BLEND,3); \ 588 break; \ 589 case GL_ADD: \ 590 SPAN2(LINEAR_RGB;ADD,3); \ 591 break; \ 592 } \ 593 break; \ 594 case GL_RGBA: \ 595 switch (envmode) { \ 596 case GL_MODULATE: \ 597 SPAN2(LINEAR_RGBA;MODULATE,4); \ 598 break; \ 599 case GL_DECAL: \ 600 SPAN2(LINEAR_RGBA;DECAL,4); \ 601 break; \ 602 case GL_BLEND: \ 603 SPAN2(LINEAR_RGBA;BLEND,4); \ 604 break; \ 605 case GL_REPLACE: \ 606 SPAN2(LINEAR_RGBA;REPLACE,4); \ 607 break; \ 608 case GL_ADD: \ 609 SPAN2(LINEAR_RGBA;ADD,4); \ 610 break; \ 611 } \ 612 break; \ 613 } \ 577 case GL_BLEND: \ 578 SPAN2(LINEAR_RGB;BLEND,3); \ 579 break; \ 580 default: /* unexpected env mode */ \ 581 ABORT(); \ 582 } \ 583 break; \ 584 case GL_RGBA: \ 585 switch (envmode) { \ 586 case GL_MODULATE: \ 587 SPAN2(LINEAR_RGBA;MODULATE,4); \ 588 break; \ 589 case GL_DECAL: \ 590 SPAN2(LINEAR_RGBA;DECAL,4); \ 591 break; \ 592 case GL_BLEND: \ 593 SPAN2(LINEAR_RGBA;BLEND,4); \ 594 break; \ 595 case GL_REPLACE: \ 596 SPAN2(LINEAR_RGBA;REPLACE,4); \ 597 break; \ 598 default: /* unexpected env mode */ \ 599 ABORT(); \ 600 } \ 601 break; \ 602 } \ 614 603 break; \ 615 604 } \ 616 605 gl_write_rgba_span(ctx, n, LEFT, Y, zspan, \ 617 606 rgba, GL_POLYGON); \ … … 619 608 ffr = ffg = ffb = ffa = 0; \ 620 609 } \ 621 610 } 622 611 623 612 #include "tritemp.h" … … 637 626 #if 000 638 627 static void persp_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1, 639 628 GLuint v2, GLuint pv ) 640 629 { 641 630 642 631 #define INTERP_Z 1 632 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 643 633 #define INTERP_RGB 1 644 634 #define INTERP_ALPHA 1 645 635 #define INTERP_STUV 1 646 #define SETUP_CODE 647 struct gl_texture_unit *unit = ctx->Texture.Unit+0; 648 struct gl_texture_object *obj = unit->CurrentD[2]; 649 GLint b = obj->BaseLevel; 650 GLfloat twidth = (GLfloat) obj->Image[b]->Width; 651 GLfloat theight = (GLfloat) obj->Image[b]->Height; 652 GLint twidth_log2 = obj->Image[b]->WidthLog2; 653 GLubyte *texture = obj->Image[b]->Data; 636 #define SETUP_CODE \ 637 struct gl_texture_unit *unit = ctx->Texture.Unit+0; \ 638 struct gl_texture_object *obj = unit->CurrentD[2]; \ 639 GLint b = obj->BaseLevel; \ 640 GLfloat twidth = (GLfloat) obj->Image[b]->Width; \ 641 GLfloat theight = (GLfloat) obj->Image[b]->Height; \ 642 GLint twidth_log2 = obj->Image[b]->WidthLog2; \ 643 GLubyte *texture = obj->Image[b]->Data; \ 654 644 GLint smask = (obj->Image[b]->Width - 1); \ 655 645 GLint tmask = (obj->Image[b]->Height - 1); \ … … 661 651 GLfixed er, eg, eb, ea; \ 662 652 GLint tr, tg, tb, ta; \ 663 if (envmode == GL_BLEND || envmode == GL_ADD) {\653 if (envmode == GL_BLEND) { \ 664 654 er = FloatToFixed(unit->EnvColor[0]); \ 665 655 eg = FloatToFixed(unit->EnvColor[1]); \ … … 705 695 GLint pos = COMP * ((t << twidth_log2) + s); \ 706 696 GLubyte *tex00 = texture + pos; \ 707 697 zspan[i] = FixedToDepth(ffz); \ 708 698 DO_TEX; \ 709 699 ffz += fdzdx; \ 710 700 ffr += fdrdx; \ 711 701 ffg += fdgdx; \ 712 702 ffb += fdbdx; \ 713 703 ffa += fdadx; \ 714 704 SS += dSdx; \ 715 705 TT += dTdx; \ 716 706 vv += dvdx; \ 717 707 dest += 4; \ 718 708 } 719 709 720 710 #define SPAN2(DO_TEX,COMP) \ … … 723 713 GLfixed ffs = (int)(SS * invQ); \ 724 714 GLfixed fft = (int)(TT * invQ); \ 725 726 715 GLint s = FixedToInt(ffs) & smask; \ 716 GLint t = FixedToInt(fft) & tmask; \ 727 717 GLint sf = ffs & FIXED_FRAC_MASK; \ 728 718 GLint tf = fft & FIXED_FRAC_MASK; \ … … 742 732 tex11 -= tbytesline; \ 743 733 } \ 744 734 zspan[i] = FixedToDepth(ffz); \ 745 735 DO_TEX; \ 746 736 ffz += fdzdx; \ 747 737 ffr += fdrdx; \ 748 738 ffg += fdgdx; \ 749 739 ffb += fdbdx; \ 750 740 ffa += fdadx; \ 751 741 SS += dSdx; \ 752 742 TT += dTdx; \ 753 743 vv += dvdx; \ 754 744 dest += 4; \ 755 756 757 #define INNER_LOOP( LEFT, RIGHT, Y ) 758 {\759 GLint i, n = RIGHT-LEFT;\760 GLdepth zspan[MAX_WIDTH];\761 GLubyte rgba[MAX_WIDTH][4];\745 } 746 747 #define INNER_LOOP( LEFT, RIGHT, Y ) \ 748 { \ 749 GLint i, n = RIGHT-LEFT; \ 750 GLdepth zspan[MAX_WIDTH]; \ 751 GLubyte rgba[MAX_WIDTH][4]; \ 762 752 (void)uu; /* please GCC */ \ 763 753 if (n>0) { \ 764 754 GLfloat SS = ss * sscale; \ 765 755 GLfloat TT = tt * tscale; \ … … 768 758 GLubyte *dest = rgba[0]; \ 769 759 switch (filter) { \ 770 771 760 case GL_NEAREST: \ 761 switch (format) { \ 772 762 case GL_RGB: \ 773 774 763 switch (envmode) { \ 764 case GL_MODULATE: \ 775 765 SPAN1(NEAREST_RGB;MODULATE,3); \ 776 766 break; \ 777 767 case GL_DECAL: \ 778 768 case GL_REPLACE: \ 779 769 SPAN1(NEAREST_RGB_REPLACE,3); \ … … 782 772 SPAN1(NEAREST_RGB;BLEND,3); \ 783 773 break; \ 784 case GL_ADD: \ 785 SPAN1(NEAREST_RGB;ADD,3); \ 786 break; \ 787 } \ 774 default: /* unexpected env mode */ \ 775 ABORT(); \ 776 } \ 788 777 break; \ 789 790 791 778 case GL_RGBA: \ 779 switch(envmode) { \ 780 case GL_MODULATE: \ 792 781 SPAN1(NEAREST_RGBA;MODULATE,4); \ 793 782 break; \ 794 783 case GL_DECAL: \ 795 784 SPAN1(NEAREST_RGBA;DECAL,4); \ 796 785 break; \ 797 786 case GL_BLEND: \ 798 787 SPAN1(NEAREST_RGBA;BLEND,4); \ 799 788 break; \ 800 789 case GL_REPLACE: \ 801 790 SPAN1(NEAREST_RGBA_REPLACE,4); \ 802 791 break; \ 803 case GL_ADD: \ 804 SPAN1(NEAREST_RGBA;ADD,4); \ 805 break; \ 806 } \ 792 default: /* unexpected env mode */ \ 793 ABORT(); \ 794 } \ 807 795 break; \ 808 796 } \ 809 797 break; \ 810 811 812 813 814 815 816 817 818 break; \ 819 820 798 case GL_LINEAR: \ 799 SS -= 0.5f * FIXED_SCALE * vv; \ 800 TT -= 0.5f * FIXED_SCALE * vv; \ 801 switch (format) { \ 802 case GL_RGB: \ 803 switch (envmode) { \ 804 case GL_MODULATE: \ 805 SPAN2(LINEAR_RGB;MODULATE,3); \ 806 break; \ 807 case GL_DECAL: \ 808 case GL_REPLACE: \ 821 809 SPAN2(LINEAR_RGB;REPLACE,3); \ 822 810 break; \ 823 case GL_BLEND: \ 824 SPAN2(LINEAR_RGB;BLEND,3); \ 825 break; \ 826 case GL_ADD: \ 827 SPAN2(LINEAR_RGB;ADD,3); \ 828 break; \ 829 } \ 830 break; \ 831 case GL_RGBA: \ 832 switch (envmode) { \ 833 case GL_MODULATE: \ 834 SPAN2(LINEAR_RGBA;MODULATE,4); \ 835 break; \ 836 case GL_DECAL: \ 837 SPAN2(LINEAR_RGBA;DECAL,4); \ 838 break; \ 839 case GL_BLEND: \ 840 SPAN2(LINEAR_RGBA;BLEND,4); \ 841 break; \ 842 case GL_REPLACE: \ 843 SPAN2(LINEAR_RGBA;REPLACE,4); \ 844 break; \ 845 case GL_ADD: \ 846 SPAN2(LINEAR_RGBA;ADD,4); \ 847 break; \ 848 } \ 849 break; \ 850 } \ 811 case GL_BLEND: \ 812 SPAN2(LINEAR_RGB;BLEND,3); \ 813 break; \ 814 default: /* unexpected env mode */ \ 815 ABORT(); \ 816 } \ 817 break; \ 818 case GL_RGBA: \ 819 switch (envmode) { \ 820 case GL_MODULATE: \ 821 SPAN2(LINEAR_RGBA;MODULATE,4); \ 822 break; \ 823 case GL_DECAL: \ 824 SPAN2(LINEAR_RGBA;DECAL,4); \ 825 break; \ 826 case GL_BLEND: \ 827 SPAN2(LINEAR_RGBA;BLEND,4); \ 828 break; \ 829 case GL_REPLACE: \ 830 SPAN2(LINEAR_RGBA;REPLACE,4); \ 831 break; \ 832 default: /* unexpected env mode */ \ 833 ABORT(); \ 834 } \ 835 break; \ 836 } \ 851 837 break; \ 852 853 854 838 } \ 839 gl_write_rgba_span( ctx, n, LEFT, Y, zspan, \ 840 rgba, GL_POLYGON ); \ 855 841 ffr = ffg = ffb = ffa = 0; \ 856 857 842 } \ 843 } 858 844 859 845 … … 876 862 { 877 863 #define INTERP_Z 1 864 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 878 865 #define INTERP_RGB 1 879 866 #define INTERP_ALPHA 1 880 867 #define INTERP_STUV 1 881 #define SETUP_CODE 882 GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); 883 GLint r, g, b, a; 884 if (flat_shade) { 885 r = VB->ColorPtr->data[pv][0]; 886 g = VB->ColorPtr->data[pv][1]; 887 b = VB->ColorPtr->data[pv][2]; 888 a = VB->ColorPtr->data[pv][3]; 868 #define SETUP_CODE \ 869 GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \ 870 GLint r, g, b, a; \ 871 if (flat_shade) { \ 872 r = VB->ColorPtr->data[pv][0]; \ 873 g = VB->ColorPtr->data[pv][1]; \ 874 b = VB->ColorPtr->data[pv][2]; \ 875 a = VB->ColorPtr->data[pv][3]; \ 889 876 } 890 #define INNER_LOOP( LEFT, RIGHT, Y ) 891 {\892 GLint i, n = RIGHT-LEFT;\893 GLdepth zspan[MAX_WIDTH];\894 GLubyte rgba[MAX_WIDTH][4];\895 GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH]; 896 if (n>0) {\897 if (flat_shade) { 898 for (i=0;i<n;i++) { 899 GLdouble invQ = 1.0 / vv;\900 zspan[i] = FixedToDepth(ffz);\901 rgba[i][RCOMP] = r;\902 rgba[i][GCOMP] = g;\903 rgba[i][BCOMP] = b;\904 rgba[i][ACOMP] = a;\905 s[i] = ss*invQ;\906 t[i] = tt*invQ;\907 u[i] = uu*invQ;\908 ffz += fdzdx;\909 ss += dsdx;\910 tt += dtdx;\911 uu += dudx;\912 vv += dvdx;\913 }\914 } 915 else { 916 for (i=0;i<n;i++) { 917 GLdouble invQ = 1.0 / vv;\918 zspan[i] = FixedToDepth(ffz);\919 rgba[i][RCOMP] = FixedToInt(ffr);\920 rgba[i][GCOMP] = FixedToInt(ffg);\921 rgba[i][BCOMP] = FixedToInt(ffb);\922 rgba[i][ACOMP] = FixedToInt(ffa);\923 s[i] = ss*invQ;\924 t[i] = tt*invQ;\925 u[i] = uu*invQ;\926 ffz += fdzdx;\927 ffr += fdrdx;\928 ffg += fdgdx;\929 ffb += fdbdx;\930 ffa += fdadx;\931 ss += dsdx;\932 tt += dtdx;\933 uu += dudx;\934 vv += dvdx;\935 }\936 } 937 gl_write_texture_span( ctx, n, LEFT, Y, zspan,\938 s, t, u, NULL, 939 940 NULL, GL_POLYGON ); 941 }\942 877 #define INNER_LOOP( LEFT, RIGHT, Y ) \ 878 { \ 879 GLint i, n = RIGHT-LEFT; \ 880 GLdepth zspan[MAX_WIDTH]; \ 881 GLubyte rgba[MAX_WIDTH][4]; \ 882 GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH]; \ 883 if (n>0) { \ 884 if (flat_shade) { \ 885 for (i=0;i<n;i++) { \ 886 GLdouble invQ = 1.0 / vv; \ 887 zspan[i] = FixedToDepth(ffz); \ 888 rgba[i][RCOMP] = r; \ 889 rgba[i][GCOMP] = g; \ 890 rgba[i][BCOMP] = b; \ 891 rgba[i][ACOMP] = a; \ 892 s[i] = ss*invQ; \ 893 t[i] = tt*invQ; \ 894 u[i] = uu*invQ; \ 895 ffz += fdzdx; \ 896 ss += dsdx; \ 897 tt += dtdx; \ 898 uu += dudx; \ 899 vv += dvdx; \ 900 } \ 901 } \ 902 else { \ 903 for (i=0;i<n;i++) { \ 904 GLdouble invQ = 1.0 / vv; \ 905 zspan[i] = FixedToDepth(ffz); \ 906 rgba[i][RCOMP] = FixedToInt(ffr); \ 907 rgba[i][GCOMP] = FixedToInt(ffg); \ 908 rgba[i][BCOMP] = FixedToInt(ffb); \ 909 rgba[i][ACOMP] = FixedToInt(ffa); \ 910 s[i] = ss*invQ; \ 911 t[i] = tt*invQ; \ 912 u[i] = uu*invQ; \ 913 ffz += fdzdx; \ 914 ffr += fdrdx; \ 915 ffg += fdgdx; \ 916 ffb += fdbdx; \ 917 ffa += fdadx; \ 918 ss += dsdx; \ 919 tt += dtdx; \ 920 uu += dudx; \ 921 vv += dvdx; \ 922 } \ 923 } \ 924 gl_write_texture_span( ctx, n, LEFT, Y, zspan, \ 925 s, t, u, NULL, \ 926 rgba, \ 927 NULL, GL_POLYGON ); \ 928 } \ 929 } 943 930 944 931 #include "tritemp.h" … … 960 947 { 961 948 #define INTERP_Z 1 949 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 962 950 #define INTERP_RGB 1 963 951 #define INTERP_SPEC 1 964 952 #define INTERP_ALPHA 1 965 953 #define INTERP_STUV 1 966 #define SETUP_CODE 967 GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); 968 GLint r, g, b, a, sr, sg, sb; 969 if (flat_shade) { 970 r = VB->ColorPtr->data[pv][0]; 971 g = VB->ColorPtr->data[pv][1]; 972 b = VB->ColorPtr->data[pv][2]; 973 a = VB->ColorPtr->data[pv][3]; 974 sr = VB->Specular[pv][0]; 975 sg = VB->Specular[pv][1]; 976 sb = VB->Specular[pv][2]; 954 #define SETUP_CODE \ 955 GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \ 956 GLint r, g, b, a, sr, sg, sb; \ 957 if (flat_shade) { \ 958 r = VB->ColorPtr->data[pv][0]; \ 959 g = VB->ColorPtr->data[pv][1]; \ 960 b = VB->ColorPtr->data[pv][2]; \ 961 a = VB->ColorPtr->data[pv][3]; \ 962 sr = VB->Specular[pv][0]; \ 963 sg = VB->Specular[pv][1]; \ 964 sb = VB->Specular[pv][2]; \ 977 965 } 978 #define INNER_LOOP( LEFT, RIGHT, Y ) 979 {\980 GLint i, n = RIGHT-LEFT;\981 GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH]; 982 if (n>0) {\983 if (flat_shade) { 984 for (i=0;i<n;i++) { 985 GLdouble invQ = 1.0 / vv;\986 zspan[i] = FixedToDepth(ffz);\987 rgba[i][RCOMP] = r;\988 rgba[i][GCOMP] = g;\989 rgba[i][BCOMP] = b;\990 rgba[i][ACOMP] = a;\991 spec[i][RCOMP] = sr;\992 spec[i][GCOMP] = sg;\993 spec[i][BCOMP] = sb;\994 s[i] = ss*invQ;\995 t[i] = tt*invQ;\996 u[i] = uu*invQ;\997 ffz += fdzdx;\998 ss += dsdx;\999 tt += dtdx;\1000 uu += dudx;\1001 vv += dvdx;\1002 }\1003 } 1004 else { 1005 for (i=0;i<n;i++) { 1006 GLdouble invQ = 1.0 / vv;\1007 zspan[i] = FixedToDepth(ffz);\1008 rgba[i][RCOMP] = FixedToInt(ffr);\1009 rgba[i][GCOMP] = FixedToInt(ffg);\1010 rgba[i][BCOMP] = FixedToInt(ffb);\1011 rgba[i][ACOMP] = FixedToInt(ffa);\1012 spec[i][RCOMP] = FixedToInt(ffsr);\1013 spec[i][GCOMP] = FixedToInt(ffsg);\1014 spec[i][BCOMP] = FixedToInt(ffsb);\1015 s[i] = ss*invQ;\1016 t[i] = tt*invQ;\1017 u[i] = uu*invQ;\1018 ffz += fdzdx;\1019 ffr += fdrdx;\1020 ffg += fdgdx;\1021 ffb += fdbdx;\1022 ffa += fdadx;\1023 ffsr += fdsrdx;\1024 ffsg += fdsgdx;\1025 ffsb += fdsbdx;\1026 ss += dsdx;\1027 tt += dtdx;\1028 uu += dudx;\1029 vv += dvdx;\1030 }\1031 } 1032 gl_write_texture_span( ctx, n, LEFT, Y, zspan,\1033 s, t, u, NULL, rgba, 1034 (const GLubyte (*)[4]) spec, 1035 GL_POLYGON );\1036 }\1037 966 #define INNER_LOOP( LEFT, RIGHT, Y ) \ 967 { \ 968 GLint i, n = RIGHT-LEFT; \ 969 GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH]; \ 970 if (n>0) { \ 971 if (flat_shade) { \ 972 for (i=0;i<n;i++) { \ 973 GLdouble invQ = 1.0 / vv; \ 974 zspan[i] = FixedToDepth(ffz); \ 975 rgba[i][RCOMP] = r; \ 976 rgba[i][GCOMP] = g; \ 977 rgba[i][BCOMP] = b; \ 978 rgba[i][ACOMP] = a; \ 979 spec[i][RCOMP] = sr; \ 980 spec[i][GCOMP] = sg; \ 981 spec[i][BCOMP] = sb; \ 982 s[i] = ss*invQ; \ 983 t[i] = tt*invQ; \ 984 u[i] = uu*invQ; \ 985 ffz += fdzdx; \ 986 ss += dsdx; \ 987 tt += dtdx; \ 988 uu += dudx; \ 989 vv += dvdx; \ 990 } \ 991 } \ 992 else { \ 993 for (i=0;i<n;i++) { \ 994 GLdouble invQ = 1.0 / vv; \ 995 zspan[i] = FixedToDepth(ffz); \ 996 rgba[i][RCOMP] = FixedToInt(ffr); \ 997 rgba[i][GCOMP] = FixedToInt(ffg); \ 998 rgba[i][BCOMP] = FixedToInt(ffb); \ 999 rgba[i][ACOMP] = FixedToInt(ffa); \ 1000 spec[i][RCOMP] = FixedToInt(ffsr); \ 1001 spec[i][GCOMP] = FixedToInt(ffsg); \ 1002 spec[i][BCOMP] = FixedToInt(ffsb); \ 1003 s[i] = ss*invQ; \ 1004 t[i] = tt*invQ; \ 1005 u[i] = uu*invQ; \ 1006 ffz += fdzdx; \ 1007 ffr += fdrdx; \ 1008 ffg += fdgdx; \ 1009 ffb += fdbdx; \ 1010 ffa += fdadx; \ 1011 ffsr += fdsrdx; \ 1012 ffsg += fdsgdx; \ 1013 ffsb += fdsbdx; \ 1014 ss += dsdx; \ 1015 tt += dtdx; \ 1016 uu += dudx; \ 1017 vv += dvdx; \ 1018 } \ 1019 } \ 1020 gl_write_texture_span( ctx, n, LEFT, Y, zspan, \ 1021 s, t, u, NULL, rgba, \ 1022 (const GLubyte (*)[4]) spec, \ 1023 GL_POLYGON ); \ 1024 } \ 1025 } 1038 1026 1039 1027 #include "tritemp.h" … … 1043 1031 1044 1032 /* 1045 * Compute the lambda value (texture level value) for a fragment. 1046 */ 1047 static GLfloat compute_lambda( GLfloat s, GLfloat dsdx, GLfloat dsdy, 1048 GLfloat t, GLfloat dtdx, GLfloat dtdy, 1049 GLfloat invQ, GLfloat dqdx, GLfloat dqdy, 1050 GLfloat width, GLfloat height ) 1051 { 1052 GLfloat dudx, dudy, dvdx, dvdy; 1053 GLfloat r1, r2, rho2; 1054 GLfloat invQ_width = invQ * width; 1055 GLfloat invQ_height = invQ * height; 1056 1057 dudx = (dsdx - s*dqdx) * invQ_width; 1058 dudy = (dsdy - s*dqdy) * invQ_width; 1059 dvdx = (dtdx - t*dqdx) * invQ_height; 1060 dvdy = (dtdy - t*dqdy) * invQ_height; 1061 1062 r1 = dudx * dudx + dudy * dudy; 1063 r2 = dvdx * dvdx + dvdy * dvdy; 1064 1065 rho2 = r1 + r2; /* used to be: rho2 = MAX2(r1,r2); */ 1066 ASSERT( rho2 >= 0.0 ); 1067 1033 * Compute the lambda value for a fragment. (texture level of detail) 1034 */ 1035 static GLfloat 1036 compute_lambda( GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy, 1037 GLfloat invQ, GLfloat width, GLfloat height ) 1038 { 1039 GLfloat dudx = dsdx * invQ * width; 1040 GLfloat dudy = dsdy * invQ * width; 1041 GLfloat dvdx = dtdx * invQ * height; 1042 GLfloat dvdy = dtdy * invQ * height; 1043 GLfloat r1 = dudx * dudx + dudy * dudy; 1044 GLfloat r2 = dvdx * dvdx + dvdy * dvdy; 1045 GLfloat rho2 = r1 + r2; /* used to be: rho2 = MAX2(r1,r2); */ 1068 1046 /* return log base 2 of rho */ 1069 return log(rho2) * 1.442695 * 0.5; /* 1.442695 = 1/log(2)*/1047 return log(rho2) * 1.442695 * 0.5; /* 1.442695 = 1/log(2)*/ 1070 1048 } 1071 1049 … … 1085 1063 { 1086 1064 #define INTERP_Z 1 1065 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 1087 1066 #define INTERP_RGB 1 1088 1067 #define INTERP_ALPHA 1 1089 1068 #define INTERP_STUV 1 1090 1069 1091 #define SETUP_CODE 1092 const struct gl_texture_object *obj = ctx->Texture.Unit[0].Current; 1093 const GLint baseLevel = obj->BaseLevel; 1094 const struct gl_texture_image *texImage = obj->Image[baseLevel]; 1095 const GLfloat twidth = (GLfloat) texImage->Width; 1096 const GLfloat theight = (GLfloat) texImage->Height; 1097 const GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); 1098 GLint r, g, b, a; 1099 if (flat_shade) { 1100 r = VB->ColorPtr->data[pv][0]; 1101 g = VB->ColorPtr->data[pv][1]; 1102 b = VB->ColorPtr->data[pv][2]; 1103 a = VB->ColorPtr->data[pv][3]; 1070 #define SETUP_CODE \ 1071 const struct gl_texture_object *obj = ctx->Texture.Unit[0].Current; \ 1072 const GLint baseLevel = obj->BaseLevel; \ 1073 const struct gl_texture_image *texImage = obj->Image[baseLevel]; \ 1074 const GLfloat twidth = (GLfloat) texImage->Width; \ 1075 const GLfloat theight = (GLfloat) texImage->Height; \ 1076 const GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \ 1077 GLint r, g, b, a; \ 1078 if (flat_shade) { \ 1079 r = VB->ColorPtr->data[pv][0]; \ 1080 g = VB->ColorPtr->data[pv][1]; \ 1081 b = VB->ColorPtr->data[pv][2]; \ 1082 a = VB->ColorPtr->data[pv][3]; \ 1104 1083 } 1105 1084 1106 #define INNER_LOOP( LEFT, RIGHT, Y ) \ 1107 { \ 1108 GLint i, n = RIGHT-LEFT; \ 1109 GLdepth zspan[MAX_WIDTH]; \ 1110 GLubyte rgba[MAX_WIDTH][4]; \ 1111 GLfloat lambda[MAX_WIDTH]; \ 1112 if (n>0) { \ 1113 if (flat_shade) { \ 1114 for (i=0;i<n;i++) { \ 1115 GLdouble invQ = 1.0 / vv; \ 1116 zspan[i] = FixedToDepth(ffz); \ 1117 rgba[i][RCOMP] = r; \ 1118 rgba[i][GCOMP] = g; \ 1119 rgba[i][BCOMP] = b; \ 1120 rgba[i][ACOMP] = a; \ 1121 s[i] = ss*invQ; \ 1122 t[i] = tt*invQ; \ 1123 u[i] = uu*invQ; \ 1124 lambda[i] = compute_lambda( s[i], dsdx, dsdy, \ 1125 t[i], dtdx, dtdy, \ 1126 invQ, dvdx, dvdy, \ 1127 twidth, theight ); \ 1128 ffz += fdzdx; \ 1129 ss += dsdx; \ 1130 tt += dtdx; \ 1131 uu += dudx; \ 1132 vv += dvdx; \ 1133 } \ 1134 } \ 1135 else { \ 1136 for (i=0;i<n;i++) { \ 1137 GLdouble invQ = 1.0 / vv; \ 1138 zspan[i] = FixedToDepth(ffz); \ 1139 rgba[i][RCOMP] = FixedToInt(ffr); \ 1140 rgba[i][GCOMP] = FixedToInt(ffg); \ 1141 rgba[i][BCOMP] = FixedToInt(ffb); \ 1142 rgba[i][ACOMP] = FixedToInt(ffa); \ 1143 s[i] = ss*invQ; \ 1144 t[i] = tt*invQ; \ 1145 u[i] = uu*invQ; \ 1146 lambda[i] = compute_lambda( s[i], dsdx, dsdy, \ 1147 t[i], dtdx, dtdy, \ 1148 invQ, dvdx, dvdy, \ 1149 twidth, theight ); \ 1150 ffz += fdzdx; \ 1151 ffr += fdrdx; \ 1152 ffg += fdgdx; \ 1153 ffb += fdbdx; \ 1154 ffa += fdadx; \ 1155 ss += dsdx; \ 1156 tt += dtdx; \ 1157 uu += dudx; \ 1158 vv += dvdx; \ 1159 } \ 1160 } \ 1161 gl_write_texture_span( ctx, n, LEFT, Y, zspan, \ 1162 s, t, u, lambda, \ 1163 rgba, NULL, GL_POLYGON ); \ 1164 } \ 1165 } 1085 #define INNER_LOOP( LEFT, RIGHT, Y ) \ 1086 { \ 1087 GLint i, n = RIGHT-LEFT; \ 1088 GLdepth zspan[MAX_WIDTH]; \ 1089 GLubyte rgba[MAX_WIDTH][4]; \ 1090 GLfloat lambda[MAX_WIDTH]; \ 1091 if (n>0) { \ 1092 if (flat_shade) { \ 1093 for (i=0;i<n;i++) { \ 1094 GLdouble invQ = 1.0 / vv; \ 1095 zspan[i] = FixedToDepth(ffz); \ 1096 rgba[i][RCOMP] = r; \ 1097 rgba[i][GCOMP] = g; \ 1098 rgba[i][BCOMP] = b; \ 1099 rgba[i][ACOMP] = a; \ 1100 s[i] = ss*invQ; \ 1101 t[i] = tt*invQ; \ 1102 u[i] = uu*invQ; \ 1103 lambda[i] = compute_lambda( dsdx, dsdy, dtdx, dtdy, \ 1104 invQ, twidth, theight );\ 1105 ffz += fdzdx; \ 1106 ss += dsdx; \ 1107 tt += dtdx; \ 1108 uu += dudx; \ 1109 vv += dvdx; \ 1110 } \ 1111 } \ 1112 else { \ 1113 for (i=0;i<n;i++) { \ 1114 GLdouble invQ = 1.0 / vv; \ 1115 zspan[i] = FixedToDepth(ffz); \ 1116 rgba[i][RCOMP] = FixedToInt(ffr); \ 1117 rgba[i][GCOMP] = FixedToInt(ffg); \ 1118 rgba[i][BCOMP] = FixedToInt(ffb); \ 1119 rgba[i][ACOMP] = FixedToInt(ffa); \ 1120 s[i] = ss*invQ; \ 1121 t[i] = tt*invQ; \ 1122 u[i] = uu*invQ; \ 1123 lambda[i] = compute_lambda( dsdx, dsdy, dtdx, dtdy, \ 1124 invQ, twidth, theight );\ 1125 ffz += fdzdx; \ 1126 ffr += fdrdx; \ 1127 ffg += fdgdx; \ 1128 ffb += fdbdx; \ 1129 ffa += fdadx; \ 1130 ss += dsdx; \ 1131 tt += dtdx; \ 1132 uu += dudx; \ 1133 vv += dvdx; \ 1134 } \ 1135 } \ 1136 gl_write_texture_span( ctx, n, LEFT, Y, zspan, \ 1137 s, t, u, lambda, \ 1138 rgba, NULL, GL_POLYGON ); \ 1139 } \ 1140 } 1166 1141 1167 1142 #include "tritemp.h" … … 1184 1159 { 1185 1160 #define INTERP_Z 1 1161 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 1186 1162 #define INTERP_RGB 1 1187 1163 #define INTERP_SPEC 1 … … 1189 1165 #define INTERP_STUV 1 1190 1166 1191 #define SETUP_CODE 1192 const struct gl_texture_object *obj = ctx->Texture.Unit[0].Current; 1193 const GLint baseLevel = obj->BaseLevel; 1194 const struct gl_texture_image *texImage = obj->Image[baseLevel]; 1195 const GLfloat twidth = (GLfloat) texImage->Width; 1196 const GLfloat theight = (GLfloat) texImage->Height; 1197 const GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); 1198 GLint r, g, b, a, sr, sg, sb; 1199 if (flat_shade) { 1200 r = VB->ColorPtr->data[pv][0]; 1201 g = VB->ColorPtr->data[pv][1]; 1202 b = VB->ColorPtr->data[pv][2]; 1203 a = VB->ColorPtr->data[pv][3]; 1204 sr = VB->Specular[pv][0]; 1205 sg = VB->Specular[pv][1]; 1206 sb = VB->Specular[pv][2]; 1167 #define SETUP_CODE \ 1168 const struct gl_texture_object *obj = ctx->Texture.Unit[0].Current; \ 1169 const GLint baseLevel = obj->BaseLevel; \ 1170 const struct gl_texture_image *texImage = obj->Image[baseLevel]; \ 1171 const GLfloat twidth = (GLfloat) texImage->Width; \ 1172 const GLfloat theight = (GLfloat) texImage->Height; \ 1173 const GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \ 1174 GLint r, g, b, a, sr, sg, sb; \ 1175 if (flat_shade) { \ 1176 r = VB->ColorPtr->data[pv][0]; \ 1177 g = VB->ColorPtr->data[pv][1]; \ 1178 b = VB->ColorPtr->data[pv][2]; \ 1179 a = VB->ColorPtr->data[pv][3]; \ 1180 sr = VB->Specular[pv][0]; \ 1181 sg = VB->Specular[pv][1]; \ 1182 sb = VB->Specular[pv][2]; \ 1207 1183 } 1208 1184 1209 #define INNER_LOOP( LEFT, RIGHT, Y ) \ 1210 { \ 1211 GLint i, n = RIGHT-LEFT; \ 1212 GLdepth zspan[MAX_WIDTH]; \ 1213 GLubyte spec[MAX_WIDTH][4]; \ 1214 GLubyte rgba[MAX_WIDTH][4]; \ 1215 GLfloat lambda[MAX_WIDTH]; \ 1216 if (n>0) { \ 1217 if (flat_shade) { \ 1218 for (i=0;i<n;i++) { \ 1219 GLdouble invQ = 1.0 / vv; \ 1220 zspan[i] = FixedToDepth(ffz); \ 1221 rgba[i][RCOMP] = r; \ 1222 rgba[i][GCOMP] = g; \ 1223 rgba[i][BCOMP] = b; \ 1224 rgba[i][ACOMP] = a; \ 1225 spec[i][RCOMP] = sr; \ 1226 spec[i][GCOMP] = sg; \ 1227 spec[i][BCOMP] = sb; \ 1228 s[i] = ss*invQ; \ 1229 t[i] = tt*invQ; \ 1230 u[i] = uu*invQ; \ 1231 lambda[i] = compute_lambda( s[i], dsdx, dsdy, \ 1232 t[i], dtdx, dtdy, \ 1233 invQ, dvdx, dvdy, \ 1234 twidth, theight ); \ 1235 ffz += fdzdx; \ 1236 ss += dsdx; \ 1237 tt += dtdx; \ 1238 uu += dudx; \ 1239 vv += dvdx; \ 1240 } \ 1241 } \ 1242 else { \ 1243 for (i=0;i<n;i++) { \ 1244 GLdouble invQ = 1.0 / vv; \ 1245 zspan[i] = FixedToDepth(ffz); \ 1246 rgba[i][RCOMP] = FixedToInt(ffr); \ 1247 rgba[i][GCOMP] = FixedToInt(ffg); \ 1248 rgba[i][BCOMP] = FixedToInt(ffb); \ 1249 rgba[i][ACOMP] = FixedToInt(ffa); \ 1250 spec[i][RCOMP] = FixedToInt(ffsr); \ 1251 spec[i][GCOMP] = FixedToInt(ffsg); \ 1252 spec[i][BCOMP] = FixedToInt(ffsb); \ 1253 s[i] = ss*invQ; \ 1254 t[i] = tt*invQ; \ 1255 u[i] = uu*invQ; \ 1256 lambda[i] = compute_lambda( s[i], dsdx, dsdy, \ 1257 t[i], dtdx, dtdy, \ 1258 invQ, dvdx, dvdy, \ 1259 twidth, theight ); \ 1260 ffz += fdzdx; \ 1261 ffr += fdrdx; \ 1262 ffg += fdgdx; \ 1263 ffb += fdbdx; \ 1264 ffa += fdadx; \ 1265 ffsr += fdsrdx; \ 1266 ffsg += fdsgdx; \ 1267 ffsb += fdsbdx; \ 1268 ss += dsdx; \ 1269 tt += dtdx; \ 1270 uu += dudx; \ 1271 vv += dvdx; \ 1272 } \ 1273 } \ 1274 gl_write_texture_span( ctx, n, LEFT, Y, zspan, \ 1275 s, t, u, lambda, \ 1276 rgba, (const GLubyte (*)[4]) spec, \ 1277 GL_POLYGON ); \ 1278 } \ 1279 } 1185 #define INNER_LOOP( LEFT, RIGHT, Y ) \ 1186 { \ 1187 GLint i, n = RIGHT-LEFT; \ 1188 GLdepth zspan[MAX_WIDTH]; \ 1189 GLubyte spec[MAX_WIDTH][4]; \ 1190 GLubyte rgba[MAX_WIDTH][4]; \ 1191 GLfloat lambda[MAX_WIDTH]; \ 1192 if (n>0) { \ 1193 if (flat_shade) { \ 1194 for (i=0;i<n;i++) { \ 1195 GLdouble invQ = 1.0 / vv; \ 1196 zspan[i] = FixedToDepth(ffz); \ 1197 rgba[i][RCOMP] = r; \ 1198 rgba[i][GCOMP] = g; \ 1199 rgba[i][BCOMP] = b; \ 1200 rgba[i][ACOMP] = a; \ 1201 spec[i][RCOMP] = sr; \ 1202 spec[i][GCOMP] = sg; \ 1203 spec[i][BCOMP] = sb; \ 1204 s[i] = ss*invQ; \ 1205 t[i] = tt*invQ; \ 1206 u[i] = uu*invQ; \ 1207 lambda[i] = compute_lambda( dsdx, dsdy, dtdx, dtdy, \ 1208 invQ, twidth, theight );\ 1209 ffz += fdzdx; \ 1210 ss += dsdx; \ 1211 tt += dtdx; \ 1212 uu += dudx; \ 1213 vv += dvdx; \ 1214 } \ 1215 } \ 1216 else { \ 1217 for (i=0;i<n;i++) { \ 1218 GLdouble invQ = 1.0 / vv; \ 1219 zspan[i] = FixedToDepth(ffz); \ 1220 rgba[i][RCOMP] = FixedToInt(ffr); \ 1221 rgba[i][GCOMP] = FixedToInt(ffg); \ 1222 rgba[i][BCOMP] = FixedToInt(ffb); \ 1223 rgba[i][ACOMP] = FixedToInt(ffa); \ 1224 spec[i][RCOMP] = FixedToInt(ffsr); \ 1225 spec[i][GCOMP] = FixedToInt(ffsg); \ 1226 spec[i][BCOMP] = FixedToInt(ffsb); \ 1227 s[i] = ss*invQ; \ 1228 t[i] = tt*invQ; \ 1229 u[i] = uu*invQ; \ 1230 lambda[i] = compute_lambda( dsdx, dsdy, dtdx, dtdy, \ 1231 invQ, twidth, theight );\ 1232 ffz += fdzdx; \ 1233 ffr += fdrdx; \ 1234 ffg += fdgdx; \ 1235 ffb += fdbdx; \ 1236 ffa += fdadx; \ 1237 ffsr += fdsrdx; \ 1238 ffsg += fdsgdx; \ 1239 ffsb += fdsbdx; \ 1240 ss += dsdx; \ 1241 tt += dtdx; \ 1242 uu += dudx; \ 1243 vv += dvdx; \ 1244 } \ 1245 } \ 1246 gl_write_texture_span( ctx, n, LEFT, Y, zspan, \ 1247 s, t, u, lambda, \ 1248 rgba, (const GLubyte (*)[4]) spec, \ 1249 GL_POLYGON ); \ 1250 } \ 1251 } 1280 1252 1281 1253 #include "tritemp.h" … … 1297 1269 GLubyte rgba[MAX_WIDTH][4]; 1298 1270 #define INTERP_Z 1 1271 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 1299 1272 #define INTERP_RGB 1 1300 1273 #define INTERP_ALPHA 1 … … 1302 1275 #define INTERP_STUV1 1 1303 1276 1304 #define SETUP_CODE 1305 const struct gl_texture_object *obj0 = ctx->Texture.Unit[0].Current; 1306 const GLint baseLevel0 = obj0->BaseLevel; 1307 const struct gl_texture_image *texImage0 = obj0->Image[baseLevel0]; 1308 const GLfloat twidth0 = (GLfloat) texImage0->Width; 1309 const GLfloat theight0 = (GLfloat) texImage0->Height; 1310 const struct gl_texture_object *obj1 = ctx->Texture.Unit[1].Current; 1311 const GLint baseLevel1 = obj1->BaseLevel; 1312 const struct gl_texture_image *texImage1 = obj1->Image[baseLevel1]; 1313 const GLfloat twidth1 = (GLfloat) texImage1->Width; 1314 const GLfloat theight1 = (GLfloat) texImage1->Height; 1315 const GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); 1316 GLint r, g, b, a; 1317 if (flat_shade) { 1318 r = VB->ColorPtr->data[pv][0]; 1319 g = VB->ColorPtr->data[pv][1]; 1320 b = VB->ColorPtr->data[pv][2]; 1321 a = VB->ColorPtr->data[pv][3]; 1277 #define SETUP_CODE \ 1278 const struct gl_texture_object *obj0 = ctx->Texture.Unit[0].Current; \ 1279 const GLint baseLevel0 = obj0->BaseLevel; \ 1280 const struct gl_texture_image *texImage0 = obj0->Image[baseLevel0]; \ 1281 const GLfloat twidth0 = (GLfloat) texImage0->Width; \ 1282 const GLfloat theight0 = (GLfloat) texImage0->Height; \ 1283 const struct gl_texture_object *obj1 = ctx->Texture.Unit[1].Current; \ 1284 const GLint baseLevel1 = obj1->BaseLevel; \ 1285 const struct gl_texture_image *texImage1 = obj1->Image[baseLevel1]; \ 1286 const GLfloat twidth1 = (GLfloat) texImage1->Width; \ 1287 const GLfloat theight1 = (GLfloat) texImage1->Height; \ 1288 const GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT); \ 1289 GLint r, g, b, a; \ 1290 if (flat_shade) { \ 1291 r = VB->ColorPtr->data[pv][0]; \ 1292 g = VB->ColorPtr->data[pv][1]; \ 1293 b = VB->ColorPtr->data[pv][2]; \ 1294 a = VB->ColorPtr->data[pv][3]; \ 1322 1295 } 1323 1296 1324 #define INNER_LOOP( LEFT, RIGHT, Y ) 1325 {\1326 GLint i, n = RIGHT-LEFT;\1327 GLdepth zspan[MAX_WIDTH];\1328 GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH]; 1329 if (n>0) {\1330 if (flat_shade) {\1331 for (i=0;i<n;i++) {\1332 GLdouble invQ = 1.0 / vv;\1333 GLdouble invQ1 = 1.0 / vv1;\1334 zspan[i] = FixedToDepth(ffz);\1335 rgba[i][RCOMP] = r;\1336 rgba[i][GCOMP] = g;\1337 rgba[i][BCOMP] = b;\1338 rgba[i][ACOMP] = a;\1339 s[0][i] = ss*invQ;\1340 t[0][i] = tt*invQ;\1341 u[0][i] = uu*invQ;\1342 lambda[0][i] = compute_lambda( s[0][i], dsdx, dsdy,\1343 t[0][i], dtdx, dtdy,\1344 invQ, dvdx, dvdy,\1345 twidth0, theight0 );\1346 s[1][i] = ss1*invQ1;\1347 t[1][i] = tt1*invQ1;\1348 u[1][i] = uu1*invQ1;\1349 lambda[1][i] = compute_lambda( s[1][i], ds1dx, ds1dy,\1350 t[1][i], dt1dx, dt1dy,\1351 invQ1, dvdx, dvdy,\1352 twidth1, theight1 );\1353 ffz += fdzdx;\1354 ss += dsdx;\1355 tt += dtdx;\1356 uu += dudx;\1357 vv += dvdx;\1358 ss1 += ds1dx;\1359 tt1 += dt1dx;\1360 uu1 += du1dx;\1361 vv1 += dv1dx;\1362 }\1363 } 1364 else { 1365 for (i=0;i<n;i++) {\1366 GLdouble invQ = 1.0 / vv;\1367 GLdouble invQ1 = 1.0 / vv1;\1368 zspan[i] = FixedToDepth(ffz);\1369 rgba[i][RCOMP] = FixedToInt(ffr);\1370 rgba[i][GCOMP] = FixedToInt(ffg);\1371 rgba[i][BCOMP] = FixedToInt(ffb);\1372 rgba[i][ACOMP] = FixedToInt(ffa);\1373 s[0][i] = ss*invQ;\1374 t[0][i] = tt*invQ;\1375 u[0][i] = uu*invQ;\1376 lambda[0][i] = compute_lambda( s[0][i], dsdx, dsdy,\1377 t[0][i], dtdx, dtdy,\1378 invQ, dvdx, dvdy,\1379 twidth0, theight0 );\1380 s[1][i] = ss1*invQ1;\1381 t[1][i] = tt1*invQ1;\1382 u[1][i] = uu1*invQ1;\1383 lambda[1][i] = compute_lambda( s[1][i], ds1dx, ds1dy,\1384 t[1][i], dt1dx, dt1dy,\1385 invQ1, dvdx, dvdy,\1386 twidth1, theight1 );\1387 ffz += fdzdx;\1388 ffr += fdrdx;\1389 ffg += fdgdx;\1390 ffb += fdbdx;\1391 ffa += fdadx;\1392 ss += dsdx;\1393 tt += dtdx;\1394 uu += dudx;\1395 vv += dvdx;\1396 ss1 += ds1dx;\1397 tt1 += dt1dx;\1398 uu1 += du1dx;\1399 vv1 += dv1dx;\1400 }\1401 } 1402 gl_write_multitexture_span( ctx, 2, n, LEFT, Y, zspan,\1403 (const GLfloat (*)[MAX_WIDTH]) s, 1404 (const GLfloat (*)[MAX_WIDTH]) t, 1405 (const GLfloat (*)[MAX_WIDTH]) u, 1406 (GLfloat (*)[MAX_WIDTH]) lambda, 1407 rgba, NULL, GL_POLYGON );\1408 }\1409 1297 #define INNER_LOOP( LEFT, RIGHT, Y ) \ 1298 { \ 1299 GLint i, n = RIGHT-LEFT; \ 1300 GLdepth zspan[MAX_WIDTH]; \ 1301 GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH]; \ 1302 if (n>0) { \ 1303 if (flat_shade) { \ 1304 for (i=0;i<n;i++) { \ 1305 GLdouble invQ = 1.0 / vv; \ 1306 GLdouble invQ1 = 1.0 / vv1; \ 1307 zspan[i] = FixedToDepth(ffz); \ 1308 rgba[i][RCOMP] = r; \ 1309 rgba[i][GCOMP] = g; \ 1310 rgba[i][BCOMP] = b; \ 1311 rgba[i][ACOMP] = a; \ 1312 s[0][i] = ss*invQ; \ 1313 t[0][i] = tt*invQ; \ 1314 u[0][i] = uu*invQ; \ 1315 lambda[0][i] = compute_lambda( dsdx, dsdy, \ 1316 dtdx, dtdy, \ 1317 invQ, \ 1318 twidth0, theight0 ); \ 1319 s[1][i] = ss1*invQ1; \ 1320 t[1][i] = tt1*invQ1; \ 1321 u[1][i] = uu1*invQ1; \ 1322 lambda[1][i] = compute_lambda( ds1dx, ds1dy, \ 1323 dt1dx, dt1dy, \ 1324 invQ1, \ 1325 twidth1, theight1 ); \ 1326 ffz += fdzdx; \ 1327 ss += dsdx; \ 1328 tt += dtdx; \ 1329 uu += dudx; \ 1330 vv += dvdx; \ 1331 ss1 += ds1dx; \ 1332 tt1 += dt1dx; \ 1333 uu1 += du1dx; \ 1334 vv1 += dv1dx; \ 1335 } \ 1336 } \ 1337 else { \ 1338 for (i=0;i<n;i++) { \ 1339 GLdouble invQ = 1.0 / vv; \ 1340 GLdouble invQ1 = 1.0 / vv1; \ 1341 zspan[i] = FixedToDepth(ffz); \ 1342 rgba[i][RCOMP] = FixedToInt(ffr); \ 1343 rgba[i][GCOMP] = FixedToInt(ffg); \ 1344 rgba[i][BCOMP] = FixedToInt(ffb); \ 1345 rgba[i][ACOMP] = FixedToInt(ffa); \ 1346 s[0][i] = ss*invQ; \ 1347 t[0][i] = tt*invQ; \ 1348 u[0][i] = uu*invQ; \ 1349 lambda[0][i] = compute_lambda( dsdx, dsdy, \ 1350 dtdx, dtdy, \ 1351 invQ, \ 1352 twidth0, theight0 ); \ 1353 s[1][i] = ss1*invQ1; \ 1354 t[1][i] = tt1*invQ1; \ 1355 u[1][i] = uu1*invQ1; \ 1356 lambda[1][i] = compute_lambda( ds1dx, ds1dy, \ 1357 dt1dx, dt1dy, \ 1358 invQ1, \ 1359 twidth1, theight1 ); \ 1360 ffz += fdzdx; \ 1361 ffr += fdrdx; \ 1362 ffg += fdgdx; \ 1363 ffb += fdbdx; \ 1364 ffa += fdadx; \ 1365 ss += dsdx; \ 1366 tt += dtdx; \ 1367 uu += dudx; \ 1368 vv += dvdx; \ 1369 ss1 += ds1dx; \ 1370 tt1 += dt1dx; \ 1371 uu1 += du1dx; \ 1372 vv1 += dv1dx; \ 1373 } \ 1374 } \ 1375 gl_write_multitexture_span( ctx, 2, n, LEFT, Y, zspan, \ 1376 (const GLfloat (*)[MAX_WIDTH]) s, \ 1377 (const GLfloat (*)[MAX_WIDTH]) t, \ 1378 (const GLfloat (*)[MAX_WIDTH]) u, \ 1379 (GLfloat (*)[MAX_WIDTH]) lambda, \ 1380 rgba, NULL, GL_POLYGON ); \ 1381 } \ 1382 } 1410 1383 1411 1384 #include "tritemp.h" … … 1477 1450 # define dputs(s) 1478 1451 #endif 1452 1453 1479 1454 1480 1455 /* … … 1493 1468 if (ctx->Driver.TriangleFunc) { 1494 1469 /* Device driver will draw triangles. */ 1495 return; 1470 dputs("Driver triangle"); 1471 return; 1472 } 1473 1474 if (ctx->Polygon.SmoothFlag) { 1475 _mesa_set_aa_triangle_function(ctx); 1476 ASSERT(ctx->Driver.TriangleFunc); 1477 return; 1496 1478 } 1497 1479 1498 1480 if (ctx->Texture.ReallyEnabled) { 1499 1481 /* Ugh, we do a _lot_ of tests to pick the best textured tri func */ 1500 1501 1482 GLint format, filter; 1483 const struct gl_texture_object *current2Dtex = ctx->Texture.Unit[0].CurrentD[2]; 1502 1484 const struct gl_texture_image *image; 1503 1485 /* First see if we can used an optimized 2-D texture function */ 1504 1486 if (ctx->Texture.ReallyEnabled==TEXTURE0_2D 1505 1487 && current2Dtex->WrapS==GL_REPEAT 1506 1488 && current2Dtex->WrapT==GL_REPEAT 1507 1489 && ((image = current2Dtex->Image[current2Dtex->BaseLevel]) != 0) /* correct! */ 1508 1490 && image->Border==0 1509 1491 && ((format = image->Format)==GL_RGB || format==GL_RGBA) 1510 && (filter = current2Dtex->MinFilter)==current2Dtex->MagFilter 1511 && ctx->Light.Model.ColorControl==GL_SINGLE_COLOR) { 1512 1513 if (ctx->Hint.PerspectiveCorrection==GL_FASTEST) { 1514 1515 if (filter==GL_NEAREST 1516 && format==GL_RGB 1517 && (ctx->Texture.Unit[0].EnvMode==GL_REPLACE 1518 || ctx->Texture.Unit[0].EnvMode==GL_DECAL) 1519 && ((ctx->RasterMask==DEPTH_BIT 1520 && ctx->Depth.Func==GL_LESS 1521 && ctx->Depth.Mask==GL_TRUE) 1522 || ctx->RasterMask==0) 1523 && ctx->Polygon.StippleFlag==GL_FALSE) { 1524 1525 if (ctx->RasterMask==DEPTH_BIT) { 1526 ctx->Driver.TriangleFunc = simple_z_textured_triangle; 1527 dputs("simple_z_textured_triangle"); 1528 } 1529 else { 1530 ctx->Driver.TriangleFunc = simple_textured_triangle; 1531 dputs("simple_textured_triangle"); 1532 } 1533 } 1534 else { 1535 ctx->Driver.TriangleFunc = affine_textured_triangle; 1536 dputs("affine_textured_triangle"); 1537 } 1538 } 1539 else { 1540 /*ctx->Driver.TriangleFunc = persp_textured_triangle;*/ 1492 && (filter = current2Dtex->MinFilter)==current2Dtex->MagFilter 1493 && ctx->Light.Model.ColorControl==GL_SINGLE_COLOR) { 1494 1495 if (ctx->Hint.PerspectiveCorrection==GL_FASTEST) { 1496 1497 if (filter==GL_NEAREST 1498 && format==GL_RGB 1499 && (ctx->Texture.Unit[0].EnvMode==GL_REPLACE 1500 || ctx->Texture.Unit[0].EnvMode==GL_DECAL) 1501 && ((ctx->RasterMask==DEPTH_BIT 1502 && ctx->Depth.Func==GL_LESS 1503 && ctx->Depth.Mask==GL_TRUE) 1504 || ctx->RasterMask==0) 1505 && ctx->Polygon.StippleFlag==GL_FALSE) { 1506 1507 if (ctx->RasterMask==DEPTH_BIT) { 1508 ctx->Driver.TriangleFunc = simple_z_textured_triangle; 1509 dputs("simple_z_textured_triangle"); 1510 } 1511 else { 1512 ctx->Driver.TriangleFunc = simple_textured_triangle; 1513 dputs("simple_textured_triangle"); 1514 } 1515 } 1516 else { 1517 if (ctx->Texture.Unit[0].EnvMode==GL_ADD) { 1518 ctx->Driver.TriangleFunc = general_textured_triangle; 1519 dputs("general_textured_triangle"); 1520 } 1521 else { 1522 ctx->Driver.TriangleFunc = affine_textured_triangle; 1523 dputs("affine_textured_triangle"); 1524 } 1525 } 1526 } 1527 else { 1528 /*ctx->Driver.TriangleFunc = persp_textured_triangle;*/ 1541 1529 ctx->Driver.TriangleFunc = general_textured_triangle; 1542 1543 1544 1530 dputs("persp_textured_triangle"); 1531 } 1532 } 1545 1533 else { 1546 1534 /* More complicated textures (mipmap, multi-tex, sep specular) */ … … 1558 1546 /* multi-texture! */ 1559 1547 ctx->Driver.TriangleFunc = lambda_multitextured_triangle; 1560 1548 dputs("lambda_multitextured_triangle"); 1561 1549 } 1562 1550 else if (ctx->Light.Enabled && … … 1565 1553 if (needLambda) { 1566 1554 ctx->Driver.TriangleFunc = lambda_textured_spec_triangle; 1567 1568 1555 dputs("lambda_textured_spec_triangle"); 1556 } 1569 1557 else { 1570 1558 ctx->Driver.TriangleFunc = general_textured_spec_triangle; 1571 1572 1559 dputs("general_textured_spec_triangle"); 1560 } 1573 1561 } 1574 1562 else { 1575 1563 if (needLambda) { 1576 1564 ctx->Driver.TriangleFunc = lambda_textured_triangle; 1577 1578 1565 dputs("lambda_textured_triangle"); 1566 } 1579 1567 else { 1580 1568 ctx->Driver.TriangleFunc = general_textured_triangle; 1581 1582 1569 dputs("general_textured_triangle"); 1570 } 1583 1571 } 1584 1572 } 1585 1573 } 1586 1574 else { 1587 if (ctx->Light.ShadeModel==GL_SMOOTH) { 1588 /* smooth shaded, no texturing, stippled or some raster ops */ 1589 if (rgbmode) 1575 if (ctx->Light.ShadeModel==GL_SMOOTH) { 1576 /* smooth shaded, no texturing, stippled or some raster ops */ 1577 if (rgbmode) { 1578 dputs("smooth_rgba_triangle"); 1590 1579 ctx->Driver.TriangleFunc = smooth_rgba_triangle; 1591 else 1580 } 1581 else { 1582 dputs("smooth_ci_triangle"); 1592 1583 ctx->Driver.TriangleFunc = smooth_ci_triangle; 1593 } 1594 else { 1595 /* flat shaded, no texturing, stippled or some raster ops */ 1596 if (rgbmode) 1584 } 1585 } 1586 else { 1587 /* flat shaded, no texturing, stippled or some raster ops */ 1588 if (rgbmode) { 1589 dputs("flat_rgba_triangle"); 1597 1590 ctx->Driver.TriangleFunc = flat_rgba_triangle; 1598 else 1591 } 1592 else { 1593 dputs("flat_ci_triangle"); 1599 1594 ctx->Driver.TriangleFunc = flat_ci_triangle; 1600 } 1595 } 1596 } 1601 1597 } 1602 1598 }
Note:
See TracChangeset
for help on using the changeset viewer.
