1 /* 2 * Mesa 3-D graphics library 3 * 4 * Copyright (C) 1999-2006 Brian Paul All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included 14 * in all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 * OTHER DEALINGS IN THE SOFTWARE. 23 */ 24 25 26 /* 27 * This file contains "accelerated" triangle functions. It should be 28 * fairly easy to write new special-purpose triangle functions and hook 29 * them into this module. 30 */ 31 32 33 #include <stdio.h> 34 #include "c99_math.h" 35 #include "main/imports.h" 36 #include "main/mtypes.h" 37 #include "glxheader.h" 38 #include "xmesaP.h" 39 40 /* Internal swrast includes: 41 */ 42 #include "swrast/s_context.h" 43 #include "swrast/s_depth.h" 44 #include "swrast/s_triangle.h" 45 46 47 #define GET_XRB(XRB) struct xmesa_renderbuffer *XRB = \ 48 xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]) 49 50 51 /**********************************************************************/ 52 /*** Triangle rendering ***/ 53 /**********************************************************************/ 54 55 56 #if CHAN_BITS == 8 57 58 /* 59 * XImage, smooth, depth-buffered, PF_TRUECOLOR triangle. 60 */ 61 #define NAME smooth_TRUECOLOR_z_triangle 62 #define INTERP_Z 1 63 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 64 #define INTERP_RGB 1 65 #define SETUP_CODE \ 66 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 67 GET_XRB(xrb); 68 69 #define RENDER_SPAN( span ) { \ 70 GLint x = span.x, y = YFLIP(xrb, span.y); \ 71 GLuint i; \ 72 for (i = 0; i < span.end; i++, x++) { \ 73 const DEPTH_TYPE z = FixedToDepth(span.z); \ 74 if (z < zRow[i]) { \ 75 unsigned long p; \ 76 PACK_TRUECOLOR(p, FixedToInt(span.red), \ 77 FixedToInt(span.green), FixedToInt(span.blue)); \ 78 XMesaPutPixel(xrb->ximage, x, y, p); \ 79 zRow[i] = z; \ 80 } \ 81 span.red += span.redStep; \ 82 span.green += span.greenStep; \ 83 span.blue += span.blueStep; \ 84 span.z += span.zStep; \ 85 } } 86 87 #include "swrast/s_tritemp.h" 88 89 90 91 92 /* 93 * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle. 94 */ 95 #define NAME smooth_8A8B8G8R_z_triangle 96 #define INTERP_Z 1 97 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 98 #define INTERP_RGB 1 99 #define INTERP_ALPHA 1 100 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 101 #define PIXEL_TYPE GLuint 102 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 103 #define SETUP_CODE \ 104 GET_XRB(xrb); 105 #define RENDER_SPAN( span ) { \ 106 GLuint i; \ 107 for (i = 0; i < span.end; i++) { \ 108 const DEPTH_TYPE z = FixedToDepth(span.z); \ 109 if (z < zRow[i]) { \ 110 pRow[i] = PACK_8A8B8G8R(FixedToInt(span.red), \ 111 FixedToInt(span.green), FixedToInt(span.blue), \ 112 FixedToInt(span.alpha)); \ 113 zRow[i] = z; \ 114 } \ 115 span.red += span.redStep; \ 116 span.green += span.greenStep; \ 117 span.blue += span.blueStep; \ 118 span.alpha += span.alphaStep; \ 119 span.z += span.zStep; \ 120 } } 121 122 #include "swrast/s_tritemp.h" 123 124 125 126 /* 127 * XImage, smooth, depth-buffered, PF_8A8R8G8B triangle. 128 */ 129 #define NAME smooth_8A8R8G8B_z_triangle 130 #define INTERP_Z 1 131 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 132 #define INTERP_RGB 1 133 #define INTERP_ALPHA 1 134 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 135 #define PIXEL_TYPE GLuint 136 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 137 #define SETUP_CODE \ 138 GET_XRB(xrb); 139 140 #define RENDER_SPAN( span ) { \ 141 GLuint i; \ 142 for (i = 0; i < span.end; i++) { \ 143 const DEPTH_TYPE z = FixedToDepth(span.z); \ 144 if (z < zRow[i]) { \ 145 pRow[i] = PACK_8A8R8G8B(FixedToInt(span.red), \ 146 FixedToInt(span.green), FixedToInt(span.blue), \ 147 FixedToInt(span.alpha)); \ 148 zRow[i] = z; \ 149 } \ 150 span.red += span.redStep; \ 151 span.green += span.greenStep; \ 152 span.blue += span.blueStep; \ 153 span.alpha += span.alphaStep; \ 154 span.z += span.zStep; \ 155 } } 156 157 #include "swrast/s_tritemp.h" 158 159 160 161 /* 162 * XImage, smooth, depth-buffered, PF_8R8G8B triangle. 163 */ 164 #define NAME smooth_8R8G8B_z_triangle 165 #define INTERP_Z 1 166 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 167 #define INTERP_RGB 1 168 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 169 #define PIXEL_TYPE GLuint 170 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 171 #define SETUP_CODE \ 172 GET_XRB(xrb); 173 174 #define RENDER_SPAN( span ) { \ 175 GLuint i; \ 176 for (i = 0; i < span.end; i++) { \ 177 const DEPTH_TYPE z = FixedToDepth(span.z); \ 178 if (z < zRow[i]) { \ 179 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \ 180 FixedToInt(span.green), FixedToInt(span.blue)); \ 181 zRow[i] = z; \ 182 } \ 183 span.red += span.redStep; \ 184 span.green += span.greenStep; \ 185 span.blue += span.blueStep; \ 186 span.z += span.zStep; \ 187 } } 188 189 #include "swrast/s_tritemp.h" 190 191 192 193 /* 194 * XImage, smooth, depth-buffered, PF_8R8G8B24 triangle. 195 */ 196 #define NAME smooth_8R8G8B24_z_triangle 197 #define INTERP_Z 1 198 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 199 #define INTERP_RGB 1 200 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y) 201 #define PIXEL_TYPE bgr_t 202 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 203 #define SETUP_CODE \ 204 GET_XRB(xrb); 205 #define RENDER_SPAN( span ) { \ 206 GLuint i; \ 207 for (i = 0; i < span.end; i++) { \ 208 const DEPTH_TYPE z = FixedToDepth(span.z); \ 209 if (z < zRow[i]) { \ 210 PIXEL_TYPE *ptr = pRow + i; \ 211 ptr->r = FixedToInt(span.red); \ 212 ptr->g = FixedToInt(span.green); \ 213 ptr->b = FixedToInt(span.blue); \ 214 zRow[i] = z; \ 215 } \ 216 span.red += span.redStep; \ 217 span.green += span.greenStep; \ 218 span.blue += span.blueStep; \ 219 span.z += span.zStep; \ 220 } } 221 #include "swrast/s_tritemp.h" 222 223 224 225 /* 226 * XImage, smooth, depth-buffered, PF_TRUEDITHER triangle. 227 */ 228 #define NAME smooth_TRUEDITHER_z_triangle 229 #define INTERP_Z 1 230 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 231 #define INTERP_RGB 1 232 #define SETUP_CODE \ 233 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 234 GET_XRB(xrb); 235 #define RENDER_SPAN( span ) { \ 236 GLuint i; \ 237 GLint x = span.x, y = YFLIP(xrb, span.y); \ 238 for (i = 0; i < span.end; i++, x++) { \ 239 const DEPTH_TYPE z = FixedToDepth(span.z); \ 240 if (z < zRow[i]) { \ 241 unsigned long p; \ 242 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \ 243 FixedToInt(span.green), FixedToInt(span.blue)); \ 244 XMesaPutPixel(xrb->ximage, x, y, p); \ 245 zRow[i] = z; \ 246 } \ 247 span.red += span.redStep; \ 248 span.green += span.greenStep; \ 249 span.blue += span.blueStep; \ 250 span.z += span.zStep; \ 251 } } 252 #include "swrast/s_tritemp.h" 253 254 255 256 /* 257 * XImage, smooth, depth-buffered, PF_5R6G5B triangle. 258 */ 259 #define NAME smooth_5R6G5B_z_triangle 260 #define INTERP_Z 1 261 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 262 #define INTERP_RGB 1 263 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y) 264 #define PIXEL_TYPE GLushort 265 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 266 #define SETUP_CODE \ 267 GET_XRB(xrb); 268 #define RENDER_SPAN( span ) { \ 269 GLuint i; \ 270 for (i = 0; i < span.end; i++) { \ 271 const DEPTH_TYPE z = FixedToDepth(span.z); \ 272 if (z < zRow[i]) { \ 273 pRow[i] = PACK_5R6G5B(FixedToInt(span.red), \ 274 FixedToInt(span.green), FixedToInt(span.blue)); \ 275 zRow[i] = z; \ 276 } \ 277 span.red += span.redStep; \ 278 span.green += span.greenStep; \ 279 span.blue += span.blueStep; \ 280 span.z += span.zStep; \ 281 } } 282 #include "swrast/s_tritemp.h" 283 284 285 286 /* 287 * XImage, smooth, depth-buffered, PF_DITHER_5R6G5B triangle. 288 */ 289 #define NAME smooth_DITHER_5R6G5B_z_triangle 290 #define INTERP_Z 1 291 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 292 #define INTERP_RGB 1 293 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y) 294 #define PIXEL_TYPE GLushort 295 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 296 #define SETUP_CODE \ 297 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 298 GET_XRB(xrb); 299 #define RENDER_SPAN( span ) { \ 300 GLuint i; \ 301 GLint x = span.x, y = YFLIP(xrb, span.y); \ 302 for (i = 0; i < span.end; i++, x++) { \ 303 const DEPTH_TYPE z = FixedToDepth(span.z); \ 304 if (z < zRow[i]) { \ 305 PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \ 306 FixedToInt(span.green), FixedToInt(span.blue)); \ 307 zRow[i] = z; \ 308 } \ 309 span.red += span.redStep; \ 310 span.green += span.greenStep; \ 311 span.blue += span.blueStep; \ 312 span.z += span.zStep; \ 313 } } 314 #include "swrast/s_tritemp.h" 315 316 317 318 /* 319 * XImage, flat, depth-buffered, PF_TRUECOLOR triangle. 320 */ 321 #define NAME flat_TRUECOLOR_z_triangle 322 #define INTERP_Z 1 323 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 324 #define SETUP_CODE \ 325 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 326 GET_XRB(xrb); \ 327 XMesaImage *img = xrb->ximage; \ 328 unsigned long pixel; \ 329 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]); 330 #define RENDER_SPAN( span ) { \ 331 GLuint i; \ 332 GLint x = span.x, y = YFLIP(xrb, span.y); \ 333 for (i = 0; i < span.end; i++, x++) { \ 334 const DEPTH_TYPE z = FixedToDepth(span.z); \ 335 if (z < zRow[i]) { \ 336 XMesaPutPixel(img, x, y, pixel); \ 337 zRow[i] = z; \ 338 } \ 339 span.z += span.zStep; \ 340 } } 341 #include "swrast/s_tritemp.h" 342 343 344 345 /* 346 * XImage, flat, depth-buffered, PF_8A8B8G8R triangle. 347 */ 348 #define NAME flat_8A8B8G8R_z_triangle 349 #define INTERP_Z 1 350 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 351 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 352 #define PIXEL_TYPE GLuint 353 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 354 #define SETUP_CODE \ 355 GET_XRB(xrb); \ 356 GLuint p = PACK_8A8B8G8R( v2->color[0], v2->color[1],\ 357 v2->color[2], v2->color[3]); 358 #define RENDER_SPAN( span ) { \ 359 GLuint i; \ 360 for (i = 0; i < span.end; i++) { \ 361 const DEPTH_TYPE z = FixedToDepth(span.z); \ 362 if (z < zRow[i]) { \ 363 pRow[i] = (PIXEL_TYPE) p; \ 364 zRow[i] = z; \ 365 } \ 366 span.z += span.zStep; \ 367 } } 368 #include "swrast/s_tritemp.h" 369 370 371 372 /* 373 * XImage, flat, depth-buffered, PF_8A8R8G8B triangle. 374 */ 375 #define NAME flat_8A8R8G8B_z_triangle 376 #define INTERP_Z 1 377 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 378 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 379 #define PIXEL_TYPE GLuint 380 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 381 #define SETUP_CODE \ 382 GET_XRB(xrb); \ 383 GLuint p = PACK_8A8R8G8B(v2->color[0], v2->color[1], \ 384 v2->color[2], v2->color[3]); 385 #define RENDER_SPAN( span ) { \ 386 GLuint i; \ 387 for (i = 0; i < span.end; i++) { \ 388 const DEPTH_TYPE z = FixedToDepth(span.z); \ 389 if (z < zRow[i]) { \ 390 pRow[i] = (PIXEL_TYPE) p; \ 391 zRow[i] = z; \ 392 } \ 393 span.z += span.zStep; \ 394 } } 395 #include "swrast/s_tritemp.h" 396 397 398 399 /* 400 * XImage, flat, depth-buffered, PF_8R8G8B triangle. 401 */ 402 #define NAME flat_8R8G8B_z_triangle 403 #define INTERP_Z 1 404 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 405 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 406 #define PIXEL_TYPE GLuint 407 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 408 #define SETUP_CODE \ 409 GET_XRB(xrb); \ 410 GLuint p = PACK_8R8G8B( v2->color[0], v2->color[1], v2->color[2] ); 411 #define RENDER_SPAN( span ) { \ 412 GLuint i; \ 413 for (i = 0; i < span.end; i++) { \ 414 DEPTH_TYPE z = FixedToDepth(span.z); \ 415 if (z < zRow[i]) { \ 416 pRow[i] = (PIXEL_TYPE) p; \ 417 zRow[i] = z; \ 418 } \ 419 span.z += span.zStep; \ 420 } } 421 422 #include "swrast/s_tritemp.h" 423 424 425 426 /* 427 * XImage, flat, depth-buffered, PF_8R8G8B24 triangle. 428 */ 429 #define NAME flat_8R8G8B24_z_triangle 430 #define INTERP_Z 1 431 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 432 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y) 433 #define PIXEL_TYPE bgr_t 434 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 435 #define SETUP_CODE \ 436 GET_XRB(xrb); \ 437 const GLubyte *color = v2->color; 438 #define RENDER_SPAN( span ) { \ 439 GLuint i; \ 440 for (i = 0; i < span.end; i++) { \ 441 const DEPTH_TYPE z = FixedToDepth(span.z); \ 442 if (z < zRow[i]) { \ 443 PIXEL_TYPE *ptr = pRow + i; \ 444 ptr->r = color[RCOMP]; \ 445 ptr->g = color[GCOMP]; \ 446 ptr->b = color[BCOMP]; \ 447 zRow[i] = z; \ 448 } \ 449 span.z += span.zStep; \ 450 } } 451 #include "swrast/s_tritemp.h" 452 453 454 455 /* 456 * XImage, flat, depth-buffered, PF_TRUEDITHER triangle. 457 */ 458 #define NAME flat_TRUEDITHER_z_triangle 459 #define INTERP_Z 1 460 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 461 #define SETUP_CODE \ 462 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 463 GET_XRB(xrb); \ 464 XMesaImage *img = xrb->ximage; 465 #define RENDER_SPAN( span ) { \ 466 GLuint i; \ 467 GLint x = span.x, y = YFLIP(xrb, span.y); \ 468 for (i = 0; i < span.end; i++, x++) { \ 469 const DEPTH_TYPE z = FixedToDepth(span.z); \ 470 if (z < zRow[i]) { \ 471 unsigned long p; \ 472 PACK_TRUEDITHER(p, x, y, v2->color[0], \ 473 v2->color[1], v2->color[2]); \ 474 XMesaPutPixel(img, x, y, p); \ 475 zRow[i] = z; \ 476 } \ 477 span.z += span.zStep; \ 478 } } 479 #include "swrast/s_tritemp.h" 480 481 482 483 /* 484 * XImage, flat, depth-buffered, PF_5R6G5B triangle. 485 */ 486 #define NAME flat_5R6G5B_z_triangle 487 #define INTERP_Z 1 488 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 489 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y) 490 #define PIXEL_TYPE GLushort 491 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 492 #define SETUP_CODE \ 493 GET_XRB(xrb); \ 494 GLushort p = PACK_5R6G5B( v2->color[0], v2->color[1], v2->color[2] ); 495 #define RENDER_SPAN( span ) { \ 496 GLuint i; \ 497 for (i = 0; i < span.end; i++) { \ 498 const DEPTH_TYPE z = FixedToDepth(span.z); \ 499 if (z < zRow[i]) { \ 500 pRow[i] = (PIXEL_TYPE) p; \ 501 zRow[i] = z; \ 502 } \ 503 span.z += span.zStep; \ 504 } } 505 #include "swrast/s_tritemp.h" 506 507 508 509 /* 510 * XImage, flat, depth-buffered, PF_DITHER_5R6G5B triangle. 511 */ 512 #define NAME flat_DITHER_5R6G5B_z_triangle 513 #define INTERP_Z 1 514 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 515 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y) 516 #define PIXEL_TYPE GLushort 517 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 518 #define SETUP_CODE \ 519 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 520 GET_XRB(xrb); \ 521 const GLubyte *color = v2->color; 522 #define RENDER_SPAN( span ) { \ 523 GLuint i; \ 524 GLint x = span.x, y = YFLIP(xrb, span.y); \ 525 for (i = 0; i < span.end; i++, x++) { \ 526 const DEPTH_TYPE z = FixedToDepth(span.z); \ 527 if (z < zRow[i]) { \ 528 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \ 529 color[GCOMP], color[BCOMP]); \ 530 zRow[i] = z; \ 531 } \ 532 span.z += span.zStep; \ 533 } } 534 #include "swrast/s_tritemp.h" 535 536 537 /* 538 * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle. 539 */ 540 #define NAME smooth_TRUECOLOR_triangle 541 #define INTERP_RGB 1 542 #define SETUP_CODE \ 543 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 544 GET_XRB(xrb); \ 545 XMesaImage *img = xrb->ximage; 546 #define RENDER_SPAN( span ) { \ 547 GLuint i; \ 548 GLint x = span.x, y = YFLIP(xrb, span.y); \ 549 for (i = 0; i < span.end; i++, x++) { \ 550 unsigned long p; \ 551 PACK_TRUECOLOR(p, FixedToInt(span.red), \ 552 FixedToInt(span.green), FixedToInt(span.blue)); \ 553 XMesaPutPixel(img, x, y, p); \ 554 span.red += span.redStep; \ 555 span.green += span.greenStep; \ 556 span.blue += span.blueStep; \ 557 } } 558 #include "swrast/s_tritemp.h" 559 560 561 562 /* 563 * XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle. 564 */ 565 #define NAME smooth_8A8B8G8R_triangle 566 #define INTERP_RGB 1 567 #define INTERP_ALPHA 1 568 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 569 #define PIXEL_TYPE GLuint 570 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 571 #define SETUP_CODE \ 572 GET_XRB(xrb); 573 #define RENDER_SPAN( span ) { \ 574 GLuint i; \ 575 for (i = 0; i < span.end; i++) { \ 576 pRow[i] = PACK_8A8B8G8R(FixedToInt(span.red), \ 577 FixedToInt(span.green), FixedToInt(span.blue), \ 578 FixedToInt(span.alpha)); \ 579 span.red += span.redStep; \ 580 span.green += span.greenStep; \ 581 span.blue += span.blueStep; \ 582 span.alpha += span.alphaStep; \ 583 } } 584 #include "swrast/s_tritemp.h" 585 586 587 588 /* 589 * XImage, smooth, NON-depth-buffered, PF_8A8R8G8B triangle. 590 */ 591 #define NAME smooth_8A8R8G8B_triangle 592 #define INTERP_RGB 1 593 #define INTERP_ALPHA 1 594 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 595 #define PIXEL_TYPE GLuint 596 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 597 #define SETUP_CODE \ 598 GET_XRB(xrb); 599 #define RENDER_SPAN( span ) { \ 600 GLuint i; \ 601 for (i = 0; i < span.end; i++) { \ 602 pRow[i] = PACK_8A8R8G8B(FixedToInt(span.red), \ 603 FixedToInt(span.green), FixedToInt(span.blue), \ 604 FixedToInt(span.alpha)); \ 605 span.red += span.redStep; \ 606 span.green += span.greenStep; \ 607 span.blue += span.blueStep; \ 608 span.alpha += span.alphaStep; \ 609 } } 610 #include "swrast/s_tritemp.h" 611 612 613 614 /* 615 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle. 616 */ 617 #define NAME smooth_8R8G8B_triangle 618 #define INTERP_RGB 1 619 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 620 #define PIXEL_TYPE GLuint 621 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 622 #define SETUP_CODE \ 623 GET_XRB(xrb); 624 #define RENDER_SPAN( span ) { \ 625 GLuint i; \ 626 for (i = 0; i < span.end; i++) { \ 627 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \ 628 FixedToInt(span.green), FixedToInt(span.blue) ); \ 629 span.red += span.redStep; \ 630 span.green += span.greenStep; \ 631 span.blue += span.blueStep; \ 632 } } 633 #include "swrast/s_tritemp.h" 634 635 636 637 /* 638 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle. 639 */ 640 #define NAME smooth_8R8G8B24_triangle 641 #define INTERP_RGB 1 642 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y) 643 #define PIXEL_TYPE bgr_t 644 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 645 #define SETUP_CODE \ 646 GET_XRB(xrb); 647 #define RENDER_SPAN( span ) { \ 648 GLuint i; \ 649 PIXEL_TYPE *pixel = pRow; \ 650 for (i = 0; i < span.end; i++, pixel++) { \ 651 pixel->r = FixedToInt(span.red); \ 652 pixel->g = FixedToInt(span.green); \ 653 pixel->b = FixedToInt(span.blue); \ 654 span.red += span.redStep; \ 655 span.green += span.greenStep; \ 656 span.blue += span.blueStep; \ 657 } } 658 #include "swrast/s_tritemp.h" 659 660 661 662 /* 663 * XImage, smooth, NON-depth-buffered, PF_TRUEDITHER triangle. 664 */ 665 #define NAME smooth_TRUEDITHER_triangle 666 #define INTERP_RGB 1 667 #define SETUP_CODE \ 668 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 669 GET_XRB(xrb); \ 670 XMesaImage *img = xrb->ximage; 671 #define RENDER_SPAN( span ) { \ 672 GLuint i; \ 673 GLint x = span.x, y = YFLIP(xrb, span.y); \ 674 for (i = 0; i < span.end; i++, x++) { \ 675 unsigned long p; \ 676 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \ 677 FixedToInt(span.green), FixedToInt(span.blue)); \ 678 XMesaPutPixel(img, x, y, p ); \ 679 span.red += span.redStep; \ 680 span.green += span.greenStep; \ 681 span.blue += span.blueStep; \ 682 } } 683 #include "swrast/s_tritemp.h" 684 685 686 687 /* 688 * XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle. 689 */ 690 #define NAME smooth_5R6G5B_triangle 691 #define INTERP_RGB 1 692 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y) 693 #define PIXEL_TYPE GLushort 694 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 695 #define SETUP_CODE \ 696 GET_XRB(xrb); 697 #define RENDER_SPAN( span ) { \ 698 GLuint i; \ 699 for (i = 0; i < span.end; i++) { \ 700 pRow[i] = (PIXEL_TYPE) PACK_5R6G5B(FixedToInt(span.red), \ 701 FixedToInt(span.green), FixedToInt(span.blue)); \ 702 span.red += span.redStep; \ 703 span.green += span.greenStep; \ 704 span.blue += span.blueStep; \ 705 } } 706 #include "swrast/s_tritemp.h" 707 708 709 710 /* 711 * XImage, smooth, NON-depth-buffered, PF_DITHER_5R6G5B triangle. 712 */ 713 #define NAME smooth_DITHER_5R6G5B_triangle 714 #define INTERP_RGB 1 715 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y) 716 #define PIXEL_TYPE GLushort 717 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 718 #define SETUP_CODE \ 719 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 720 GET_XRB(xrb); 721 #define RENDER_SPAN( span ) { \ 722 GLuint i; \ 723 GLint x = span.x, y = YFLIP(xrb, span.y); \ 724 for (i = 0; i < span.end; i++, x++) { \ 725 PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \ 726 FixedToInt(span.green), FixedToInt(span.blue)); \ 727 span.red += span.redStep; \ 728 span.green += span.greenStep; \ 729 span.blue += span.blueStep; \ 730 } } 731 #include "swrast/s_tritemp.h" 732 733 734 735 /* 736 * XImage, flat, NON-depth-buffered, PF_TRUECOLOR triangle. 737 */ 738 #define NAME flat_TRUECOLOR_triangle 739 #define SETUP_CODE \ 740 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 741 GET_XRB(xrb); \ 742 XMesaImage *img = xrb->ximage; \ 743 unsigned long pixel; \ 744 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]); 745 #define RENDER_SPAN( span ) { \ 746 GLuint i; \ 747 GLint x = span.x, y = YFLIP(xrb, span.y); \ 748 for (i = 0; i < span.end; i++, x++) { \ 749 XMesaPutPixel(img, x, y, pixel); \ 750 } } 751 #include "swrast/s_tritemp.h" 752 753 754 755 /* 756 * XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle. 757 */ 758 #define NAME flat_8A8B8G8R_triangle 759 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 760 #define PIXEL_TYPE GLuint 761 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 762 #define SETUP_CODE \ 763 GET_XRB(xrb); \ 764 unsigned long p = PACK_8B8G8R( v2->color[0], \ 765 v2->color[1], v2->color[2] ); 766 #define RENDER_SPAN( span ) { \ 767 GLuint i; \ 768 for (i = 0; i < span.end; i++) { \ 769 pRow[i] = (PIXEL_TYPE) p; \ 770 } } 771 #include "swrast/s_tritemp.h" 772 773 774 775 /* 776 * XImage, flat, NON-depth-buffered, PF_8A8R8G8B triangle. 777 */ 778 #define NAME flat_8A8R8G8B_triangle 779 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 780 #define PIXEL_TYPE GLuint 781 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 782 #define SETUP_CODE \ 783 GET_XRB(xrb); \ 784 unsigned long p = PACK_8R8G8B( v2->color[0], \ 785 v2->color[1], v2->color[2] ); 786 #define RENDER_SPAN( span ) { \ 787 GLuint i; \ 788 for (i = 0; i < span.end; i++) { \ 789 pRow[i] = (PIXEL_TYPE) p; \ 790 } } 791 #include "swrast/s_tritemp.h" 792 793 794 795 /* 796 * XImage, flat, NON-depth-buffered, PF_8R8G8B triangle. 797 */ 798 #define NAME flat_8R8G8B_triangle 799 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 800 #define PIXEL_TYPE GLuint 801 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 802 #define SETUP_CODE \ 803 GET_XRB(xrb); \ 804 unsigned long p = PACK_8R8G8B( v2->color[0], \ 805 v2->color[1], v2->color[2] ); 806 #define RENDER_SPAN( span ) { \ 807 GLuint i; \ 808 for (i = 0; i < span.end; i++) { \ 809 pRow[i] = (PIXEL_TYPE) p; \ 810 } } 811 #include "swrast/s_tritemp.h" 812 813 814 815 /* 816 * XImage, flat, NON-depth-buffered, PF_8R8G8B24 triangle. 817 */ 818 #define NAME flat_8R8G8B24_triangle 819 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y) 820 #define PIXEL_TYPE bgr_t 821 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 822 #define SETUP_CODE \ 823 GET_XRB(xrb); \ 824 const GLubyte *color = v2->color; 825 #define RENDER_SPAN( span ) { \ 826 GLuint i; \ 827 PIXEL_TYPE *pixel = pRow; \ 828 for (i = 0; i < span.end; i++, pixel++) { \ 829 pixel->r = color[RCOMP]; \ 830 pixel->g = color[GCOMP]; \ 831 pixel->b = color[BCOMP]; \ 832 } } 833 #include "swrast/s_tritemp.h" 834 835 836 837 /* 838 * XImage, flat, NON-depth-buffered, PF_TRUEDITHER triangle. 839 */ 840 #define NAME flat_TRUEDITHER_triangle 841 #define SETUP_CODE \ 842 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 843 GET_XRB(xrb); \ 844 XMesaImage *img = xrb->ximage; 845 #define RENDER_SPAN( span ) { \ 846 GLuint i; \ 847 GLint x = span.x, y = YFLIP(xrb, span.y); \ 848 for (i = 0; i < span.end; i++, x++) { \ 849 unsigned long p; \ 850 PACK_TRUEDITHER(p, x, y, v2->color[0], \ 851 v2->color[1], v2->color[2] ); \ 852 XMesaPutPixel(img, x, y, p); \ 853 } } 854 #include "swrast/s_tritemp.h" 855 856 857 858 /* 859 * XImage, flat, NON-depth-buffered, PF_5R6G5B triangle. 860 */ 861 #define NAME flat_5R6G5B_triangle 862 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y) 863 #define PIXEL_TYPE GLushort 864 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 865 #define SETUP_CODE \ 866 GET_XRB(xrb); \ 867 unsigned long p = PACK_5R6G5B( v2->color[0], \ 868 v2->color[1], v2->color[2] ); 869 #define RENDER_SPAN( span ) { \ 870 GLuint i; \ 871 for (i = 0; i < span.end; i++) { \ 872 pRow[i] = (PIXEL_TYPE) p; \ 873 } } 874 #include "swrast/s_tritemp.h" 875 876 877 878 /* 879 * XImage, flat, NON-depth-buffered, PF_DITHER_5R6G5B triangle. 880 */ 881 #define NAME flat_DITHER_5R6G5B_triangle 882 #define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y) 883 #define PIXEL_TYPE GLushort 884 #define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 885 #define SETUP_CODE \ 886 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 887 GET_XRB(xrb); \ 888 const GLubyte *color = v2->color; 889 #define RENDER_SPAN( span ) { \ 890 GLuint i; \ 891 GLint x = span.x, y = YFLIP(xrb, span.y); \ 892 for (i = 0; i < span.end; i++, x++) { \ 893 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \ 894 color[GCOMP], color[BCOMP]); \ 895 } } 896 #include "swrast/s_tritemp.h" 897 898 899 900 #endif /* CHAN_BITS == 8 */ 901 902 903 #if defined(DEBUG) && CHAN_BITS == 8 904 extern void _xmesa_print_triangle_func( swrast_tri_func triFunc ); 905 void _xmesa_print_triangle_func( swrast_tri_func triFunc ) 906 { 907 printf("XMesa tri func = "); 908 if (triFunc ==smooth_TRUECOLOR_z_triangle) 909 printf("smooth_TRUECOLOR_z_triangle\n"); 910 else if (triFunc ==smooth_8A8B8G8R_z_triangle) 911 printf("smooth_8A8B8G8R_z_triangle\n"); 912 else if (triFunc ==smooth_8A8R8G8B_z_triangle) 913 printf("smooth_8A8R8G8B_z_triangle\n"); 914 else if (triFunc ==smooth_8R8G8B_z_triangle) 915 printf("smooth_8R8G8B_z_triangle\n"); 916 else if (triFunc ==smooth_8R8G8B24_z_triangle) 917 printf("smooth_8R8G8B24_z_triangle\n"); 918 else if (triFunc ==smooth_TRUEDITHER_z_triangle) 919 printf("smooth_TRUEDITHER_z_triangle\n"); 920 else if (triFunc ==smooth_5R6G5B_z_triangle) 921 printf("smooth_5R6G5B_z_triangle\n"); 922 else if (triFunc ==smooth_DITHER_5R6G5B_z_triangle) 923 printf("smooth_DITHER_5R6G5B_z_triangle\n"); 924 else if (triFunc ==flat_TRUECOLOR_z_triangle) 925 printf("flat_TRUECOLOR_z_triangle\n"); 926 else if (triFunc ==flat_8A8B8G8R_z_triangle) 927 printf("flat_8A8B8G8R_z_triangle\n"); 928 else if (triFunc ==flat_8A8R8G8B_z_triangle) 929 printf("flat_8A8R8G8B_z_triangle\n"); 930 else if (triFunc ==flat_8R8G8B_z_triangle) 931 printf("flat_8R8G8B_z_triangle\n"); 932 else if (triFunc ==flat_8R8G8B24_z_triangle) 933 printf("flat_8R8G8B24_z_triangle\n"); 934 else if (triFunc ==flat_TRUEDITHER_z_triangle) 935 printf("flat_TRUEDITHER_z_triangle\n"); 936 else if (triFunc ==flat_5R6G5B_z_triangle) 937 printf("flat_5R6G5B_z_triangle\n"); 938 else if (triFunc ==flat_DITHER_5R6G5B_z_triangle) 939 printf("flat_DITHER_5R6G5B_z_triangle\n"); 940 else if (triFunc ==smooth_TRUECOLOR_triangle) 941 printf("smooth_TRUECOLOR_triangle\n"); 942 else if (triFunc ==smooth_8A8B8G8R_triangle) 943 printf("smooth_8A8B8G8R_triangle\n"); 944 else if (triFunc ==smooth_8A8R8G8B_triangle) 945 printf("smooth_8A8R8G8B_triangle\n"); 946 else if (triFunc ==smooth_8R8G8B_triangle) 947 printf("smooth_8R8G8B_triangle\n"); 948 else if (triFunc ==smooth_8R8G8B24_triangle) 949 printf("smooth_8R8G8B24_triangle\n"); 950 else if (triFunc ==smooth_TRUEDITHER_triangle) 951 printf("smooth_TRUEDITHER_triangle\n"); 952 else if (triFunc ==smooth_5R6G5B_triangle) 953 printf("smooth_5R6G5B_triangle\n"); 954 else if (triFunc ==smooth_DITHER_5R6G5B_triangle) 955 printf("smooth_DITHER_5R6G5B_triangle\n"); 956 else if (triFunc ==flat_TRUECOLOR_triangle) 957 printf("flat_TRUECOLOR_triangle\n"); 958 else if (triFunc ==flat_TRUEDITHER_triangle) 959 printf("flat_TRUEDITHER_triangle\n"); 960 else if (triFunc ==flat_8A8B8G8R_triangle) 961 printf("flat_8A8B8G8R_triangle\n"); 962 else if (triFunc ==flat_8A8R8G8B_triangle) 963 printf("flat_8A8R8G8B_triangle\n"); 964 else if (triFunc ==flat_8R8G8B_triangle) 965 printf("flat_8R8G8B_triangle\n"); 966 else if (triFunc ==flat_8R8G8B24_triangle) 967 printf("flat_8R8G8B24_triangle\n"); 968 else if (triFunc ==flat_5R6G5B_triangle) 969 printf("flat_5R6G5B_triangle\n"); 970 else if (triFunc ==flat_DITHER_5R6G5B_triangle) 971 printf("flat_DITHER_5R6G5B_triangle\n"); 972 else 973 printf("???\n"); 974 } 975 #endif 976 977 978 #ifdef DEBUG 979 980 /* record the current triangle function name */ 981 static const char *triFuncName = NULL; 982 983 #define USE(triFunc) \ 984 do { \ 985 triFuncName = #triFunc; \ 986 return triFunc; \ 987 } while (0) 988 989 #else 990 991 #define USE(triFunc) return triFunc 992 993 #endif 994 995 996 /** 997 * Return pointer to line drawing function, or NULL if we should use a 998 * swrast fallback. 999 */ 1000 static swrast_tri_func 1001 get_triangle_func(struct gl_context *ctx) 1002 { 1003 #if CHAN_BITS == 8 1004 SWcontext *swrast = SWRAST_CONTEXT(ctx); 1005 XMesaContext xmesa = XMESA_CONTEXT(ctx); 1006 const struct xmesa_renderbuffer *xrb; 1007 1008 #ifdef DEBUG 1009 triFuncName = NULL; 1010 #endif 1011 1012 /* trivial fallback tests */ 1013 if ((ctx->DrawBuffer->_ColorDrawBufferIndexes[0] != BUFFER_BIT_FRONT_LEFT) && 1014 (ctx->DrawBuffer->_ColorDrawBufferIndexes[0] != BUFFER_BIT_BACK_LEFT)) 1015 return (swrast_tri_func) NULL; 1016 if (ctx->RenderMode != GL_RENDER) 1017 return (swrast_tri_func) NULL; 1018 if (ctx->Polygon.SmoothFlag) 1019 return (swrast_tri_func) NULL; 1020 if (ctx->Texture._MaxEnabledTexImageUnit != -1) 1021 return (swrast_tri_func) NULL; 1022 if (swrast->_RasterMask & MULTI_DRAW_BIT) 1023 return (swrast_tri_func) NULL; 1024 if (ctx->Polygon.CullFlag && 1025 ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK) 1026 return (swrast_tri_func) NULL; 1027 1028 xrb = xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]); 1029 1030 if (xrb->ximage) { 1031 if ( ctx->Light.ShadeModel==GL_SMOOTH 1032 && swrast->_RasterMask==DEPTH_BIT 1033 && ctx->Depth.Func==GL_LESS 1034 && ctx->Depth.Mask==GL_TRUE 1035 && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS 1036 && ctx->Polygon.StippleFlag==GL_FALSE) { 1037 switch (xmesa->pixelformat) { 1038 case PF_Truecolor: 1039 USE(smooth_TRUECOLOR_z_triangle); 1040 case PF_8A8B8G8R: 1041 USE(smooth_8A8B8G8R_z_triangle); 1042 case PF_8A8R8G8B: 1043 USE(smooth_8A8R8G8B_z_triangle); 1044 case PF_8R8G8B: 1045 USE(smooth_8R8G8B_z_triangle); 1046 case PF_8R8G8B24: 1047 USE(smooth_8R8G8B24_z_triangle); 1048 case PF_Dither_True: 1049 USE(smooth_TRUEDITHER_z_triangle); 1050 case PF_5R6G5B: 1051 USE(smooth_5R6G5B_z_triangle); 1052 case PF_Dither_5R6G5B: 1053 USE(smooth_DITHER_5R6G5B_z_triangle); 1054 default: 1055 return (swrast_tri_func) NULL; 1056 } 1057 } 1058 if ( ctx->Light.ShadeModel==GL_FLAT 1059 && swrast->_RasterMask==DEPTH_BIT 1060 && ctx->Depth.Func==GL_LESS 1061 && ctx->Depth.Mask==GL_TRUE 1062 && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS 1063 && ctx->Polygon.StippleFlag==GL_FALSE) { 1064 switch (xmesa->pixelformat) { 1065 case PF_Truecolor: 1066 USE(flat_TRUECOLOR_z_triangle); 1067 case PF_8A8B8G8R: 1068 USE(flat_8A8B8G8R_z_triangle); 1069 case PF_8A8R8G8B: 1070 USE(flat_8A8R8G8B_z_triangle); 1071 case PF_8R8G8B: 1072 USE(flat_8R8G8B_z_triangle); 1073 case PF_8R8G8B24: 1074 USE(flat_8R8G8B24_z_triangle); 1075 case PF_Dither_True: 1076 USE(flat_TRUEDITHER_z_triangle); 1077 case PF_5R6G5B: 1078 USE(flat_5R6G5B_z_triangle); 1079 case PF_Dither_5R6G5B: 1080 USE(flat_DITHER_5R6G5B_z_triangle); 1081 default: 1082 return (swrast_tri_func) NULL; 1083 } 1084 } 1085 if ( swrast->_RasterMask==0 /* no depth test */ 1086 && ctx->Light.ShadeModel==GL_SMOOTH 1087 && ctx->Polygon.StippleFlag==GL_FALSE) { 1088 switch (xmesa->pixelformat) { 1089 case PF_Truecolor: 1090 USE(smooth_TRUECOLOR_triangle); 1091 case PF_8A8B8G8R: 1092 USE(smooth_8A8B8G8R_triangle); 1093 case PF_8A8R8G8B: 1094 USE(smooth_8A8R8G8B_triangle); 1095 case PF_8R8G8B: 1096 USE(smooth_8R8G8B_triangle); 1097 case PF_8R8G8B24: 1098 USE(smooth_8R8G8B24_triangle); 1099 case PF_Dither_True: 1100 USE(smooth_TRUEDITHER_triangle); 1101 case PF_5R6G5B: 1102 USE(smooth_5R6G5B_triangle); 1103 case PF_Dither_5R6G5B: 1104 USE(smooth_DITHER_5R6G5B_triangle); 1105 default: 1106 return (swrast_tri_func) NULL; 1107 } 1108 } 1109 1110 if ( swrast->_RasterMask==0 /* no depth test */ 1111 && ctx->Light.ShadeModel==GL_FLAT 1112 && ctx->Polygon.StippleFlag==GL_FALSE) { 1113 switch (xmesa->pixelformat) { 1114 case PF_Truecolor: 1115 USE(flat_TRUECOLOR_triangle); 1116 case PF_Dither_True: 1117 USE(flat_TRUEDITHER_triangle); 1118 case PF_8A8B8G8R: 1119 USE(flat_8A8B8G8R_triangle); 1120 case PF_8A8R8G8B: 1121 USE(flat_8A8R8G8B_triangle); 1122 case PF_8R8G8B: 1123 USE(flat_8R8G8B_triangle); 1124 case PF_8R8G8B24: 1125 USE(flat_8R8G8B24_triangle); 1126 case PF_5R6G5B: 1127 USE(flat_5R6G5B_triangle); 1128 case PF_Dither_5R6G5B: 1129 USE(flat_DITHER_5R6G5B_triangle); 1130 default: 1131 return (swrast_tri_func) NULL; 1132 } 1133 } 1134 } 1135 #endif /* CHAN_BITS == 8 */ 1136 1137 return (swrast_tri_func) NULL; 1138 } 1139 1140 1141 /* Override for the swrast tri-selection function. Try to use one 1142 * of our internal tri functions, otherwise fall back to the 1143 * standard swrast functions. 1144 */ 1145 void xmesa_choose_triangle( struct gl_context *ctx ) 1146 { 1147 SWcontext *swrast = SWRAST_CONTEXT(ctx); 1148 1149 if (!(swrast->Triangle = get_triangle_func( ctx ))) 1150 _swrast_choose_triangle( ctx ); 1151 } 1152 1153
