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