xm_tri.c revision ff73c783cc47361ff0dd819c82d067b4b85870dd
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 "glxheader.h" 34#include "depth.h" 35#include "macros.h" 36#include "imports.h" 37#include "mtypes.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]->Wrapped) 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, smooth, depth-buffered, 8-bit, PF_DITHER8 triangle. 320 */ 321#define NAME smooth_DITHER8_z_triangle 322#define INTERP_Z 1 323#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 324#define INTERP_RGB 1 325#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y) 326#define PIXEL_TYPE GLubyte 327#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 328#define SETUP_CODE \ 329 GET_XRB(xrb); 330#define RENDER_SPAN( span ) \ 331 GLuint i; \ 332 GLint x = span.x, y = YFLIP(xrb, span.y); \ 333 XDITHER_SETUP(y); \ 334 for (i = 0; i < span.end; i++, x++) { \ 335 const DEPTH_TYPE z = FixedToDepth(span.z); \ 336 if (z < zRow[i]) { \ 337 pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red),\ 338 FixedToInt(span.green), FixedToInt(span.blue) ); \ 339 zRow[i] = z; \ 340 } \ 341 span.red += span.redStep; \ 342 span.green += span.greenStep; \ 343 span.blue += span.blueStep; \ 344 span.z += span.zStep; \ 345 } 346#include "swrast/s_tritemp.h" 347 348 349 350/* 351 * XImage, smooth, depth-buffered, PF_DITHER triangle. 352 */ 353#define NAME smooth_DITHER_z_triangle 354#define INTERP_Z 1 355#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 356#define INTERP_RGB 1 357#define SETUP_CODE \ 358 GET_XRB(xrb); \ 359 XMesaImage *img = xrb->ximage; 360#define RENDER_SPAN( span ) \ 361 GLuint i; \ 362 GLint x = span.x, y = YFLIP(xrb, span.y); \ 363 XDITHER_SETUP(y); \ 364 for (i = 0; i < span.end; i++, x++) { \ 365 const DEPTH_TYPE z = FixedToDepth(span.z); \ 366 if (z < zRow[i]) { \ 367 unsigned long p = XDITHER(x, FixedToInt(span.red), \ 368 FixedToInt(span.green), FixedToInt(span.blue)); \ 369 XMesaPutPixel(img, x, y, p); \ 370 zRow[i] = z; \ 371 } \ 372 span.red += span.redStep; \ 373 span.green += span.greenStep; \ 374 span.blue += span.blueStep; \ 375 span.z += span.zStep; \ 376 } 377#include "swrast/s_tritemp.h" 378 379 380 381/* 382 * XImage, smooth, depth-buffered, 8-bit PF_LOOKUP triangle. 383 */ 384#define NAME smooth_LOOKUP8_z_triangle 385#define INTERP_Z 1 386#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 387#define INTERP_RGB 1 388#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y) 389#define PIXEL_TYPE GLubyte 390#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 391#define SETUP_CODE \ 392 GET_XRB(xrb); 393#define RENDER_SPAN( span ) \ 394 GLuint i; \ 395 LOOKUP_SETUP; \ 396 for (i = 0; i < span.end; i++) { \ 397 const DEPTH_TYPE z = FixedToDepth(span.z); \ 398 if (z < zRow[i]) { \ 399 pRow[i] = LOOKUP(FixedToInt(span.red), \ 400 FixedToInt(span.green), FixedToInt(span.blue)); \ 401 zRow[i] = z; \ 402 } \ 403 span.red += span.redStep; \ 404 span.green += span.greenStep; \ 405 span.blue += span.blueStep; \ 406 span.z += span.zStep; \ 407 } 408#include "swrast/s_tritemp.h" 409 410 411 412/* 413 * XImage, smooth, depth-buffered, 8-bit PF_HPCR triangle. 414 */ 415#define NAME smooth_HPCR_z_triangle 416#define INTERP_Z 1 417#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 418#define INTERP_RGB 1 419#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y) 420#define PIXEL_TYPE GLubyte 421#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 422#define SETUP_CODE \ 423 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 424 GET_XRB(xrb); 425#define RENDER_SPAN( span ) \ 426 GLuint i; \ 427 GLint x = span.x, y = YFLIP(xrb, span.y); \ 428 for (i = 0; i < span.end; i++, x++) { \ 429 const DEPTH_TYPE z = FixedToDepth(span.z); \ 430 if (z < zRow[i]) { \ 431 pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red), \ 432 FixedToInt(span.green), FixedToInt(span.blue) ); \ 433 zRow[i] = z; \ 434 } \ 435 span.red += span.redStep; \ 436 span.green += span.greenStep; \ 437 span.blue += span.blueStep; \ 438 span.z += span.zStep; \ 439 } 440#include "swrast/s_tritemp.h" 441 442 443 444/* 445 * XImage, flat, depth-buffered, PF_TRUECOLOR triangle. 446 */ 447#define NAME flat_TRUECOLOR_z_triangle 448#define INTERP_Z 1 449#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 450#define SETUP_CODE \ 451 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 452 GET_XRB(xrb); \ 453 XMesaImage *img = xrb->ximage; \ 454 unsigned long pixel; \ 455 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]); 456#define RENDER_SPAN( span ) \ 457 GLuint i; \ 458 GLint x = span.x, y = YFLIP(xrb, span.y); \ 459 for (i = 0; i < span.end; i++, x++) { \ 460 const DEPTH_TYPE z = FixedToDepth(span.z); \ 461 if (z < zRow[i]) { \ 462 XMesaPutPixel(img, x, y, pixel); \ 463 zRow[i] = z; \ 464 } \ 465 span.z += span.zStep; \ 466 } 467#include "swrast/s_tritemp.h" 468 469 470 471/* 472 * XImage, flat, depth-buffered, PF_8A8B8G8R triangle. 473 */ 474#define NAME flat_8A8B8G8R_z_triangle 475#define INTERP_Z 1 476#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 477#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 478#define PIXEL_TYPE GLuint 479#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 480#define SETUP_CODE \ 481 GET_XRB(xrb); \ 482 GLuint p = PACK_8A8B8G8R( v2->color[0], v2->color[1],\ 483 v2->color[2], v2->color[3]); 484#define RENDER_SPAN( span ) \ 485 GLuint i; \ 486 for (i = 0; i < span.end; i++) { \ 487 const DEPTH_TYPE z = FixedToDepth(span.z); \ 488 if (z < zRow[i]) { \ 489 pRow[i] = (PIXEL_TYPE) p; \ 490 zRow[i] = z; \ 491 } \ 492 span.z += span.zStep; \ 493 } 494#include "swrast/s_tritemp.h" 495 496 497 498/* 499 * XImage, flat, depth-buffered, PF_8A8R8G8B triangle. 500 */ 501#define NAME flat_8A8R8G8B_z_triangle 502#define INTERP_Z 1 503#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 504#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 505#define PIXEL_TYPE GLuint 506#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 507#define SETUP_CODE \ 508 GET_XRB(xrb); \ 509 GLuint p = PACK_8A8R8G8B(v2->color[0], v2->color[1], \ 510 v2->color[2], v2->color[3]); 511#define RENDER_SPAN( span ) \ 512 GLuint i; \ 513 for (i = 0; i < span.end; i++) { \ 514 const DEPTH_TYPE z = FixedToDepth(span.z); \ 515 if (z < zRow[i]) { \ 516 pRow[i] = (PIXEL_TYPE) p; \ 517 zRow[i] = z; \ 518 } \ 519 span.z += span.zStep; \ 520 } 521#include "swrast/s_tritemp.h" 522 523 524 525/* 526 * XImage, flat, depth-buffered, PF_8R8G8B triangle. 527 */ 528#define NAME flat_8R8G8B_z_triangle 529#define INTERP_Z 1 530#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 531#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 532#define PIXEL_TYPE GLuint 533#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 534#define SETUP_CODE \ 535 GET_XRB(xrb); \ 536 GLuint p = PACK_8R8G8B( v2->color[0], v2->color[1], v2->color[2] ); 537#define RENDER_SPAN( span ) \ 538 GLuint i; \ 539 for (i = 0; i < span.end; i++) { \ 540 DEPTH_TYPE z = FixedToDepth(span.z); \ 541 if (z < zRow[i]) { \ 542 pRow[i] = (PIXEL_TYPE) p; \ 543 zRow[i] = z; \ 544 } \ 545 span.z += span.zStep; \ 546 } 547 548#include "swrast/s_tritemp.h" 549 550 551 552/* 553 * XImage, flat, depth-buffered, PF_8R8G8B24 triangle. 554 */ 555#define NAME flat_8R8G8B24_z_triangle 556#define INTERP_Z 1 557#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 558#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y) 559#define PIXEL_TYPE bgr_t 560#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 561#define SETUP_CODE \ 562 GET_XRB(xrb); \ 563 const GLubyte *color = v2->color; 564#define RENDER_SPAN( span ) \ 565 GLuint i; \ 566 for (i = 0; i < span.end; i++) { \ 567 const DEPTH_TYPE z = FixedToDepth(span.z); \ 568 if (z < zRow[i]) { \ 569 PIXEL_TYPE *ptr = pRow + i; \ 570 ptr->r = color[RCOMP]; \ 571 ptr->g = color[GCOMP]; \ 572 ptr->b = color[BCOMP]; \ 573 zRow[i] = z; \ 574 } \ 575 span.z += span.zStep; \ 576 } 577#include "swrast/s_tritemp.h" 578 579 580 581/* 582 * XImage, flat, depth-buffered, PF_TRUEDITHER triangle. 583 */ 584#define NAME flat_TRUEDITHER_z_triangle 585#define INTERP_Z 1 586#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 587#define SETUP_CODE \ 588 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 589 GET_XRB(xrb); \ 590 XMesaImage *img = xrb->ximage; 591#define RENDER_SPAN( span ) \ 592 GLuint i; \ 593 GLint x = span.x, y = YFLIP(xrb, span.y); \ 594 for (i = 0; i < span.end; i++, x++) { \ 595 const DEPTH_TYPE z = FixedToDepth(span.z); \ 596 if (z < zRow[i]) { \ 597 unsigned long p; \ 598 PACK_TRUEDITHER(p, x, y, v2->color[0], \ 599 v2->color[1], v2->color[2]); \ 600 XMesaPutPixel(img, x, y, p); \ 601 zRow[i] = z; \ 602 } \ 603 span.z += span.zStep; \ 604 } 605#include "swrast/s_tritemp.h" 606 607 608 609/* 610 * XImage, flat, depth-buffered, PF_5R6G5B triangle. 611 */ 612#define NAME flat_5R6G5B_z_triangle 613#define INTERP_Z 1 614#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 615#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y) 616#define PIXEL_TYPE GLushort 617#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 618#define SETUP_CODE \ 619 GET_XRB(xrb); \ 620 GLushort p = PACK_5R6G5B( v2->color[0], v2->color[1], v2->color[2] ); 621#define RENDER_SPAN( span ) \ 622 GLuint i; \ 623 for (i = 0; i < span.end; i++) { \ 624 const DEPTH_TYPE z = FixedToDepth(span.z); \ 625 if (z < zRow[i]) { \ 626 pRow[i] = (PIXEL_TYPE) p; \ 627 zRow[i] = z; \ 628 } \ 629 span.z += span.zStep; \ 630 } 631#include "swrast/s_tritemp.h" 632 633 634 635/* 636 * XImage, flat, depth-buffered, PF_DITHER_5R6G5B triangle. 637 */ 638#define NAME flat_DITHER_5R6G5B_z_triangle 639#define INTERP_Z 1 640#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 641#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y) 642#define PIXEL_TYPE GLushort 643#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 644#define SETUP_CODE \ 645 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 646 GET_XRB(xrb); \ 647 const GLubyte *color = v2->color; 648#define RENDER_SPAN( span ) \ 649 GLuint i; \ 650 GLint x = span.x, y = YFLIP(xrb, span.y); \ 651 for (i = 0; i < span.end; i++, x++) { \ 652 const DEPTH_TYPE z = FixedToDepth(span.z); \ 653 if (z < zRow[i]) { \ 654 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \ 655 color[GCOMP], color[BCOMP]); \ 656 zRow[i] = z; \ 657 } \ 658 span.z += span.zStep; \ 659 } 660#include "swrast/s_tritemp.h" 661 662 663 664/* 665 * XImage, flat, depth-buffered, 8-bit PF_DITHER triangle. 666 */ 667#define NAME flat_DITHER8_z_triangle 668#define INTERP_Z 1 669#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 670#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y) 671#define PIXEL_TYPE GLubyte 672#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 673#define SETUP_CODE \ 674 GET_XRB(xrb); \ 675 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] ); 676#define RENDER_SPAN( span ) \ 677 GLuint i; \ 678 GLint x = span.x, y = YFLIP(xrb, span.y); \ 679 FLAT_DITHER_ROW_SETUP(YFLIP(xrb, y)); \ 680 for (i = 0; i < span.end; i++, x++) { \ 681 const DEPTH_TYPE z = FixedToDepth(span.z); \ 682 if (z < zRow[i]) { \ 683 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x); \ 684 zRow[i] = z; \ 685 } \ 686 span.z += span.zStep; \ 687 } 688#include "swrast/s_tritemp.h" 689 690 691 692/* 693 * XImage, flat, depth-buffered, PF_DITHER triangle. 694 */ 695#define NAME flat_DITHER_z_triangle 696#define INTERP_Z 1 697#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 698#define SETUP_CODE \ 699 GET_XRB(xrb); \ 700 XMesaImage *img = xrb->ximage; \ 701 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] ); 702#define RENDER_SPAN( span ) \ 703 GLuint i; \ 704 GLint x = span.x, y = YFLIP(xrb, span.y); \ 705 FLAT_DITHER_ROW_SETUP(y); \ 706 for (i = 0; i < span.end; i++, x++) { \ 707 const DEPTH_TYPE z = FixedToDepth(span.z); \ 708 if (z < zRow[i]) { \ 709 unsigned long p = FLAT_DITHER(x); \ 710 XMesaPutPixel(img, x, y, p); \ 711 zRow[i] = z; \ 712 } \ 713 span.z += span.zStep; \ 714 } 715#include "swrast/s_tritemp.h" 716 717 718 719/* 720 * XImage, flat, depth-buffered, 8-bit PF_HPCR triangle. 721 */ 722#define NAME flat_HPCR_z_triangle 723#define INTERP_Z 1 724#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 725#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y) 726#define PIXEL_TYPE GLubyte 727#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 728#define SETUP_CODE \ 729 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 730 GET_XRB(xrb); \ 731 GLubyte r = v2->color[0]; \ 732 GLubyte g = v2->color[1]; \ 733 GLubyte b = v2->color[2]; 734#define RENDER_SPAN( span ) \ 735 GLuint i; \ 736 GLint x = span.x, y = YFLIP(xrb, span.y); \ 737 for (i = 0; i < span.end; i++, x++) { \ 738 const DEPTH_TYPE z = FixedToDepth(span.z); \ 739 if (z < zRow[i]) { \ 740 pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b); \ 741 zRow[i] = z; \ 742 } \ 743 span.z += span.zStep; \ 744 } 745#include "swrast/s_tritemp.h" 746 747 748 749/* 750 * XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle. 751 */ 752#define NAME flat_LOOKUP8_z_triangle 753#define INTERP_Z 1 754#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE 755#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y) 756#define PIXEL_TYPE GLubyte 757#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 758#define SETUP_CODE \ 759 GET_XRB(xrb); \ 760 LOOKUP_SETUP; \ 761 GLubyte r = v2->color[0]; \ 762 GLubyte g = v2->color[1]; \ 763 GLubyte b = v2->color[2]; \ 764 GLubyte p = LOOKUP(r,g,b); 765#define RENDER_SPAN( span ) \ 766 GLuint i; \ 767 for (i = 0; i < span.end; i++) { \ 768 const DEPTH_TYPE z = FixedToDepth(span.z); \ 769 if (z < zRow[i]) { \ 770 pRow[i] = p; \ 771 zRow[i] = z; \ 772 } \ 773 span.z += span.zStep; \ 774 } 775#include "swrast/s_tritemp.h" 776 777 778 779/* 780 * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle. 781 */ 782#define NAME smooth_TRUECOLOR_triangle 783#define INTERP_RGB 1 784#define SETUP_CODE \ 785 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 786 GET_XRB(xrb); \ 787 XMesaImage *img = xrb->ximage; 788#define RENDER_SPAN( span ) \ 789 GLuint i; \ 790 GLint x = span.x, y = YFLIP(xrb, span.y); \ 791 for (i = 0; i < span.end; i++, x++) { \ 792 unsigned long p; \ 793 PACK_TRUECOLOR(p, FixedToInt(span.red), \ 794 FixedToInt(span.green), FixedToInt(span.blue)); \ 795 XMesaPutPixel(img, x, y, p); \ 796 span.red += span.redStep; \ 797 span.green += span.greenStep; \ 798 span.blue += span.blueStep; \ 799 } 800#include "swrast/s_tritemp.h" 801 802 803 804/* 805 * XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle. 806 */ 807#define NAME smooth_8A8B8G8R_triangle 808#define INTERP_RGB 1 809#define INTERP_ALPHA 1 810#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 811#define PIXEL_TYPE GLuint 812#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 813#define SETUP_CODE \ 814 GET_XRB(xrb); 815#define RENDER_SPAN( span ) \ 816 GLuint i; \ 817 for (i = 0; i < span.end; i++) { \ 818 pRow[i] = PACK_8A8B8G8R(FixedToInt(span.red), \ 819 FixedToInt(span.green), FixedToInt(span.blue), \ 820 FixedToInt(span.alpha)); \ 821 span.red += span.redStep; \ 822 span.green += span.greenStep; \ 823 span.blue += span.blueStep; \ 824 span.alpha += span.alphaStep; \ 825 } 826#include "swrast/s_tritemp.h" 827 828 829 830/* 831 * XImage, smooth, NON-depth-buffered, PF_8A8R8G8B triangle. 832 */ 833#define NAME smooth_8A8R8G8B_triangle 834#define INTERP_RGB 1 835#define INTERP_ALPHA 1 836#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 837#define PIXEL_TYPE GLuint 838#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 839#define SETUP_CODE \ 840 GET_XRB(xrb); 841#define RENDER_SPAN( span ) \ 842 GLuint i; \ 843 for (i = 0; i < span.end; i++) { \ 844 pRow[i] = PACK_8A8R8G8B(FixedToInt(span.red), \ 845 FixedToInt(span.green), FixedToInt(span.blue), \ 846 FixedToInt(span.alpha)); \ 847 span.red += span.redStep; \ 848 span.green += span.greenStep; \ 849 span.blue += span.blueStep; \ 850 span.alpha += span.alphaStep; \ 851 } 852#include "swrast/s_tritemp.h" 853 854 855 856/* 857 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle. 858 */ 859#define NAME smooth_8R8G8B_triangle 860#define INTERP_RGB 1 861#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 862#define PIXEL_TYPE GLuint 863#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 864#define SETUP_CODE \ 865 GET_XRB(xrb); 866#define RENDER_SPAN( span ) \ 867 GLuint i; \ 868 for (i = 0; i < span.end; i++) { \ 869 pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \ 870 FixedToInt(span.green), FixedToInt(span.blue) ); \ 871 span.red += span.redStep; \ 872 span.green += span.greenStep; \ 873 span.blue += span.blueStep; \ 874 } 875#include "swrast/s_tritemp.h" 876 877 878 879/* 880 * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle. 881 */ 882#define NAME smooth_8R8G8B24_triangle 883#define INTERP_RGB 1 884#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y) 885#define PIXEL_TYPE bgr_t 886#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 887#define SETUP_CODE \ 888 GET_XRB(xrb); 889#define RENDER_SPAN( span ) \ 890 GLuint i; \ 891 PIXEL_TYPE *pixel = pRow; \ 892 for (i = 0; i < span.end; i++, pixel++) { \ 893 pixel->r = FixedToInt(span.red); \ 894 pixel->g = FixedToInt(span.green); \ 895 pixel->b = FixedToInt(span.blue); \ 896 span.red += span.redStep; \ 897 span.green += span.greenStep; \ 898 span.blue += span.blueStep; \ 899 } 900#include "swrast/s_tritemp.h" 901 902 903 904/* 905 * XImage, smooth, NON-depth-buffered, PF_TRUEDITHER triangle. 906 */ 907#define NAME smooth_TRUEDITHER_triangle 908#define INTERP_RGB 1 909#define SETUP_CODE \ 910 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 911 GET_XRB(xrb); \ 912 XMesaImage *img = xrb->ximage; 913#define RENDER_SPAN( span ) \ 914 GLuint i; \ 915 GLint x = span.x, y = YFLIP(xrb, span.y); \ 916 for (i = 0; i < span.end; i++, x++) { \ 917 unsigned long p; \ 918 PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \ 919 FixedToInt(span.green), FixedToInt(span.blue)); \ 920 XMesaPutPixel(img, x, y, p ); \ 921 span.red += span.redStep; \ 922 span.green += span.greenStep; \ 923 span.blue += span.blueStep; \ 924 } 925#include "swrast/s_tritemp.h" 926 927 928 929/* 930 * XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle. 931 */ 932#define NAME smooth_5R6G5B_triangle 933#define INTERP_RGB 1 934#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y) 935#define PIXEL_TYPE GLushort 936#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 937#define SETUP_CODE \ 938 GET_XRB(xrb); 939#define RENDER_SPAN( span ) \ 940 GLuint i; \ 941 for (i = 0; i < span.end; i++) { \ 942 pRow[i] = (PIXEL_TYPE) PACK_5R6G5B(FixedToInt(span.red), \ 943 FixedToInt(span.green), FixedToInt(span.blue)); \ 944 span.red += span.redStep; \ 945 span.green += span.greenStep; \ 946 span.blue += span.blueStep; \ 947 } 948#include "swrast/s_tritemp.h" 949 950 951 952/* 953 * XImage, smooth, NON-depth-buffered, PF_DITHER_5R6G5B triangle. 954 */ 955#define NAME smooth_DITHER_5R6G5B_triangle 956#define INTERP_RGB 1 957#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y) 958#define PIXEL_TYPE GLushort 959#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 960#define SETUP_CODE \ 961 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 962 GET_XRB(xrb); 963#define RENDER_SPAN( span ) \ 964 GLuint i; \ 965 GLint x = span.x, y = YFLIP(xrb, span.y); \ 966 for (i = 0; i < span.end; i++, x++) { \ 967 PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \ 968 FixedToInt(span.green), FixedToInt(span.blue)); \ 969 span.red += span.redStep; \ 970 span.green += span.greenStep; \ 971 span.blue += span.blueStep; \ 972 } 973#include "swrast/s_tritemp.h" 974 975 976 977/* 978 * XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle. 979 */ 980#define NAME smooth_DITHER8_triangle 981#define INTERP_RGB 1 982#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y) 983#define PIXEL_TYPE GLubyte 984#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 985#define SETUP_CODE \ 986 GET_XRB(xrb); 987#define RENDER_SPAN( span ) \ 988 GLuint i; \ 989 GLint x = span.x, y = YFLIP(xrb, span.y); \ 990 XDITHER_SETUP(y); \ 991 for (i = 0; i < span.end; i++, x++) { \ 992 pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red), \ 993 FixedToInt(span.green), FixedToInt(span.blue) ); \ 994 span.red += span.redStep; \ 995 span.green += span.greenStep; \ 996 span.blue += span.blueStep; \ 997 } 998#include "swrast/s_tritemp.h" 999 1000 1001 1002/* 1003 * XImage, smooth, NON-depth-buffered, PF_DITHER triangle. 1004 */ 1005#define NAME smooth_DITHER_triangle 1006#define INTERP_RGB 1 1007#define SETUP_CODE \ 1008 GET_XRB(xrb); \ 1009 XMesaImage *img = xrb->ximage; 1010#define RENDER_SPAN( span ) \ 1011 GLuint i; \ 1012 GLint x = span.x, y = YFLIP(xrb, span.y); \ 1013 XDITHER_SETUP(y); \ 1014 for (i = 0; i < span.end; i++, x++) { \ 1015 unsigned long p = XDITHER(x, FixedToInt(span.red), \ 1016 FixedToInt(span.green), FixedToInt(span.blue) ); \ 1017 XMesaPutPixel(img, x, y, p); \ 1018 span.red += span.redStep; \ 1019 span.green += span.greenStep; \ 1020 span.blue += span.blueStep; \ 1021 } 1022#include "swrast/s_tritemp.h" 1023 1024 1025 1026/* 1027 * XImage, smooth, NON-depth-buffered, 8-bit PF_LOOKUP triangle. 1028 */ 1029#define NAME smooth_LOOKUP8_triangle 1030#define INTERP_RGB 1 1031#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y) 1032#define PIXEL_TYPE GLubyte 1033#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 1034#define SETUP_CODE \ 1035 GET_XRB(xrb); 1036#define RENDER_SPAN( span ) \ 1037 GLuint i; \ 1038 LOOKUP_SETUP; \ 1039 for (i = 0; i < span.end; i++) { \ 1040 pRow[i] = LOOKUP(FixedToInt(span.red), \ 1041 FixedToInt(span.green), FixedToInt(span.blue)); \ 1042 span.red += span.redStep; \ 1043 span.green += span.greenStep; \ 1044 span.blue += span.blueStep; \ 1045 } 1046#include "swrast/s_tritemp.h" 1047 1048 1049 1050/* 1051 * XImage, smooth, NON-depth-buffered, 8-bit PF_HPCR triangle. 1052 */ 1053#define NAME smooth_HPCR_triangle 1054#define INTERP_RGB 1 1055#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y) 1056#define PIXEL_TYPE GLubyte 1057#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 1058#define SETUP_CODE \ 1059 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 1060 GET_XRB(xrb); 1061#define RENDER_SPAN( span ) \ 1062 GLuint i; \ 1063 GLint x = span.x, y = YFLIP(xrb, span.y); \ 1064 for (i = 0; i < span.end; i++, x++) { \ 1065 pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red), \ 1066 FixedToInt(span.green), FixedToInt(span.blue)); \ 1067 span.red += span.redStep; \ 1068 span.green += span.greenStep; \ 1069 span.blue += span.blueStep; \ 1070 } 1071#include "swrast/s_tritemp.h" 1072 1073 1074 1075/* 1076 * XImage, flat, NON-depth-buffered, PF_TRUECOLOR triangle. 1077 */ 1078#define NAME flat_TRUECOLOR_triangle 1079#define SETUP_CODE \ 1080 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 1081 GET_XRB(xrb); \ 1082 XMesaImage *img = xrb->ximage; \ 1083 unsigned long pixel; \ 1084 PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]); 1085#define RENDER_SPAN( span ) \ 1086 GLuint i; \ 1087 GLint x = span.x, y = YFLIP(xrb, span.y); \ 1088 for (i = 0; i < span.end; i++, x++) { \ 1089 XMesaPutPixel(img, x, y, pixel); \ 1090 } 1091#include "swrast/s_tritemp.h" 1092 1093 1094 1095/* 1096 * XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle. 1097 */ 1098#define NAME flat_8A8B8G8R_triangle 1099#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 1100#define PIXEL_TYPE GLuint 1101#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 1102#define SETUP_CODE \ 1103 GET_XRB(xrb); \ 1104 unsigned long p = PACK_8B8G8R( v2->color[0], \ 1105 v2->color[1], v2->color[2] ); 1106#define RENDER_SPAN( span ) \ 1107 GLuint i; \ 1108 for (i = 0; i < span.end; i++) { \ 1109 pRow[i] = (PIXEL_TYPE) p; \ 1110 } 1111#include "swrast/s_tritemp.h" 1112 1113 1114 1115/* 1116 * XImage, flat, NON-depth-buffered, PF_8A8R8G8B triangle. 1117 */ 1118#define NAME flat_8A8R8G8B_triangle 1119#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 1120#define PIXEL_TYPE GLuint 1121#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 1122#define SETUP_CODE \ 1123 GET_XRB(xrb); \ 1124 unsigned long p = PACK_8R8G8B( v2->color[0], \ 1125 v2->color[1], v2->color[2] ); 1126#define RENDER_SPAN( span ) \ 1127 GLuint i; \ 1128 for (i = 0; i < span.end; i++) { \ 1129 pRow[i] = (PIXEL_TYPE) p; \ 1130 } 1131#include "swrast/s_tritemp.h" 1132 1133 1134 1135/* 1136 * XImage, flat, NON-depth-buffered, PF_8R8G8B triangle. 1137 */ 1138#define NAME flat_8R8G8B_triangle 1139#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y) 1140#define PIXEL_TYPE GLuint 1141#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 1142#define SETUP_CODE \ 1143 GET_XRB(xrb); \ 1144 unsigned long p = PACK_8R8G8B( v2->color[0], \ 1145 v2->color[1], v2->color[2] ); 1146#define RENDER_SPAN( span ) \ 1147 GLuint i; \ 1148 for (i = 0; i < span.end; i++) { \ 1149 pRow[i] = (PIXEL_TYPE) p; \ 1150 } 1151#include "swrast/s_tritemp.h" 1152 1153 1154 1155/* 1156 * XImage, flat, NON-depth-buffered, PF_8R8G8B24 triangle. 1157 */ 1158#define NAME flat_8R8G8B24_triangle 1159#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR3(xrb, X, Y) 1160#define PIXEL_TYPE bgr_t 1161#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 1162#define SETUP_CODE \ 1163 GET_XRB(xrb); \ 1164 const GLubyte *color = v2->color; 1165#define RENDER_SPAN( span ) \ 1166 GLuint i; \ 1167 PIXEL_TYPE *pixel = pRow; \ 1168 for (i = 0; i < span.end; i++, pixel++) { \ 1169 pixel->r = color[RCOMP]; \ 1170 pixel->g = color[GCOMP]; \ 1171 pixel->b = color[BCOMP]; \ 1172 } 1173#include "swrast/s_tritemp.h" 1174 1175 1176 1177/* 1178 * XImage, flat, NON-depth-buffered, PF_TRUEDITHER triangle. 1179 */ 1180#define NAME flat_TRUEDITHER_triangle 1181#define SETUP_CODE \ 1182 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 1183 GET_XRB(xrb); \ 1184 XMesaImage *img = xrb->ximage; 1185#define RENDER_SPAN( span ) \ 1186 GLuint i; \ 1187 GLint x = span.x, y = YFLIP(xrb, span.y); \ 1188 for (i = 0; i < span.end; i++, x++) { \ 1189 unsigned long p; \ 1190 PACK_TRUEDITHER(p, x, y, v2->color[0], \ 1191 v2->color[1], v2->color[2] ); \ 1192 XMesaPutPixel(img, x, y, p); \ 1193 } 1194#include "swrast/s_tritemp.h" 1195 1196 1197 1198/* 1199 * XImage, flat, NON-depth-buffered, PF_5R6G5B triangle. 1200 */ 1201#define NAME flat_5R6G5B_triangle 1202#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y) 1203#define PIXEL_TYPE GLushort 1204#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 1205#define SETUP_CODE \ 1206 GET_XRB(xrb); \ 1207 unsigned long p = PACK_5R6G5B( v2->color[0], \ 1208 v2->color[1], v2->color[2] ); 1209#define RENDER_SPAN( span ) \ 1210 GLuint i; \ 1211 for (i = 0; i < span.end; i++) { \ 1212 pRow[i] = (PIXEL_TYPE) p; \ 1213 } 1214#include "swrast/s_tritemp.h" 1215 1216 1217 1218/* 1219 * XImage, flat, NON-depth-buffered, PF_DITHER_5R6G5B triangle. 1220 */ 1221#define NAME flat_DITHER_5R6G5B_triangle 1222#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR2(xrb, X, Y) 1223#define PIXEL_TYPE GLushort 1224#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 1225#define SETUP_CODE \ 1226 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 1227 GET_XRB(xrb); \ 1228 const GLubyte *color = v2->color; 1229#define RENDER_SPAN( span ) \ 1230 GLuint i; \ 1231 GLint x = span.x, y = YFLIP(xrb, span.y); \ 1232 for (i = 0; i < span.end; i++, x++) { \ 1233 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \ 1234 color[GCOMP], color[BCOMP]); \ 1235 } 1236#include "swrast/s_tritemp.h" 1237 1238 1239 1240/* 1241 * XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle. 1242 */ 1243#define NAME flat_DITHER8_triangle 1244#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y) 1245#define PIXEL_TYPE GLubyte 1246#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 1247#define SETUP_CODE \ 1248 GET_XRB(xrb); \ 1249 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] ); 1250#define RENDER_SPAN( span ) \ 1251 GLuint i; \ 1252 GLint x = span.x, y = YFLIP(xrb, span.y); \ 1253 FLAT_DITHER_ROW_SETUP(YFLIP(xrb, y)); \ 1254 for (i = 0; i < span.end; i++, x++) { \ 1255 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x); \ 1256 } 1257#include "swrast/s_tritemp.h" 1258 1259 1260 1261/* 1262 * XImage, flat, NON-depth-buffered, PF_DITHER triangle. 1263 */ 1264#define NAME flat_DITHER_triangle 1265#define SETUP_CODE \ 1266 GET_XRB(xrb); \ 1267 XMesaImage *img = xrb->ximage; \ 1268 FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] ); 1269#define RENDER_SPAN( span ) \ 1270 GLuint i; \ 1271 GLint x = span.x, y = YFLIP(xrb, span.y); \ 1272 FLAT_DITHER_ROW_SETUP(y); \ 1273 for (i = 0; i < span.end; i++, x++) { \ 1274 unsigned long p = FLAT_DITHER(x); \ 1275 XMesaPutPixel(img, x, y, p ); \ 1276 } 1277#include "swrast/s_tritemp.h" 1278 1279 1280 1281/* 1282 * XImage, flat, NON-depth-buffered, 8-bit PF_HPCR triangle. 1283 */ 1284#define NAME flat_HPCR_triangle 1285#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y) 1286#define PIXEL_TYPE GLubyte 1287#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 1288#define SETUP_CODE \ 1289 XMesaContext xmesa = XMESA_CONTEXT(ctx); \ 1290 GET_XRB(xrb); \ 1291 GLubyte r = v2->color[0]; \ 1292 GLubyte g = v2->color[1]; \ 1293 GLubyte b = v2->color[2]; 1294#define RENDER_SPAN( span ) \ 1295 GLuint i; \ 1296 GLint x = span.x, y = YFLIP(xrb, span.y); \ 1297 for (i = 0; i < span.end; i++, x++) { \ 1298 pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b); \ 1299 } 1300#include "swrast/s_tritemp.h" 1301 1302 1303 1304/* 1305 * XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle. 1306 */ 1307#define NAME flat_LOOKUP8_triangle 1308#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR1(xrb, X, Y) 1309#define PIXEL_TYPE GLubyte 1310#define BYTES_PER_ROW (xrb->ximage->bytes_per_line) 1311#define SETUP_CODE \ 1312 GET_XRB(xrb); \ 1313 LOOKUP_SETUP; \ 1314 GLubyte r = v2->color[0]; \ 1315 GLubyte g = v2->color[1]; \ 1316 GLubyte b = v2->color[2]; \ 1317 GLubyte p = LOOKUP(r,g,b); 1318#define RENDER_SPAN( span ) \ 1319 GLuint i; \ 1320 for (i = 0; i < span.end; i++) { \ 1321 pRow[i] = (PIXEL_TYPE) p; \ 1322 } 1323#include "swrast/s_tritemp.h" 1324 1325 1326#endif /* CHAN_BITS == 8 */ 1327 1328 1329#if defined(DEBUG) && CHAN_BITS == 8 1330extern void _xmesa_print_triangle_func( swrast_tri_func triFunc ); 1331void _xmesa_print_triangle_func( swrast_tri_func triFunc ) 1332{ 1333 _mesa_printf("XMesa tri func = "); 1334 if (triFunc ==smooth_TRUECOLOR_z_triangle) 1335 _mesa_printf("smooth_TRUECOLOR_z_triangle\n"); 1336 else if (triFunc ==smooth_8A8B8G8R_z_triangle) 1337 _mesa_printf("smooth_8A8B8G8R_z_triangle\n"); 1338 else if (triFunc ==smooth_8A8R8G8B_z_triangle) 1339 _mesa_printf("smooth_8A8R8G8B_z_triangle\n"); 1340 else if (triFunc ==smooth_8R8G8B_z_triangle) 1341 _mesa_printf("smooth_8R8G8B_z_triangle\n"); 1342 else if (triFunc ==smooth_8R8G8B24_z_triangle) 1343 _mesa_printf("smooth_8R8G8B24_z_triangle\n"); 1344 else if (triFunc ==smooth_TRUEDITHER_z_triangle) 1345 _mesa_printf("smooth_TRUEDITHER_z_triangle\n"); 1346 else if (triFunc ==smooth_5R6G5B_z_triangle) 1347 _mesa_printf("smooth_5R6G5B_z_triangle\n"); 1348 else if (triFunc ==smooth_DITHER_5R6G5B_z_triangle) 1349 _mesa_printf("smooth_DITHER_5R6G5B_z_triangle\n"); 1350 else if (triFunc ==smooth_HPCR_z_triangle) 1351 _mesa_printf("smooth_HPCR_z_triangle\n"); 1352 else if (triFunc ==smooth_DITHER8_z_triangle) 1353 _mesa_printf("smooth_DITHER8_z_triangle\n"); 1354 else if (triFunc ==smooth_LOOKUP8_z_triangle) 1355 _mesa_printf("smooth_LOOKUP8_z_triangle\n"); 1356 else if (triFunc ==flat_TRUECOLOR_z_triangle) 1357 _mesa_printf("flat_TRUECOLOR_z_triangle\n"); 1358 else if (triFunc ==flat_8A8B8G8R_z_triangle) 1359 _mesa_printf("flat_8A8B8G8R_z_triangle\n"); 1360 else if (triFunc ==flat_8A8R8G8B_z_triangle) 1361 _mesa_printf("flat_8A8R8G8B_z_triangle\n"); 1362 else if (triFunc ==flat_8R8G8B_z_triangle) 1363 _mesa_printf("flat_8R8G8B_z_triangle\n"); 1364 else if (triFunc ==flat_8R8G8B24_z_triangle) 1365 _mesa_printf("flat_8R8G8B24_z_triangle\n"); 1366 else if (triFunc ==flat_TRUEDITHER_z_triangle) 1367 _mesa_printf("flat_TRUEDITHER_z_triangle\n"); 1368 else if (triFunc ==flat_5R6G5B_z_triangle) 1369 _mesa_printf("flat_5R6G5B_z_triangle\n"); 1370 else if (triFunc ==flat_DITHER_5R6G5B_z_triangle) 1371 _mesa_printf("flat_DITHER_5R6G5B_z_triangle\n"); 1372 else if (triFunc ==flat_HPCR_z_triangle) 1373 _mesa_printf("flat_HPCR_z_triangle\n"); 1374 else if (triFunc ==flat_DITHER8_z_triangle) 1375 _mesa_printf("flat_DITHER8_z_triangle\n"); 1376 else if (triFunc ==flat_LOOKUP8_z_triangle) 1377 _mesa_printf("flat_LOOKUP8_z_triangle\n"); 1378 else if (triFunc ==smooth_TRUECOLOR_triangle) 1379 _mesa_printf("smooth_TRUECOLOR_triangle\n"); 1380 else if (triFunc ==smooth_8A8B8G8R_triangle) 1381 _mesa_printf("smooth_8A8B8G8R_triangle\n"); 1382 else if (triFunc ==smooth_8A8R8G8B_triangle) 1383 _mesa_printf("smooth_8A8R8G8B_triangle\n"); 1384 else if (triFunc ==smooth_8R8G8B_triangle) 1385 _mesa_printf("smooth_8R8G8B_triangle\n"); 1386 else if (triFunc ==smooth_8R8G8B24_triangle) 1387 _mesa_printf("smooth_8R8G8B24_triangle\n"); 1388 else if (triFunc ==smooth_TRUEDITHER_triangle) 1389 _mesa_printf("smooth_TRUEDITHER_triangle\n"); 1390 else if (triFunc ==smooth_5R6G5B_triangle) 1391 _mesa_printf("smooth_5R6G5B_triangle\n"); 1392 else if (triFunc ==smooth_DITHER_5R6G5B_triangle) 1393 _mesa_printf("smooth_DITHER_5R6G5B_triangle\n"); 1394 else if (triFunc ==smooth_HPCR_triangle) 1395 _mesa_printf("smooth_HPCR_triangle\n"); 1396 else if (triFunc ==smooth_DITHER8_triangle) 1397 _mesa_printf("smooth_DITHER8_triangle\n"); 1398 else if (triFunc ==smooth_LOOKUP8_triangle) 1399 _mesa_printf("smooth_LOOKUP8_triangle\n"); 1400 else if (triFunc ==flat_TRUECOLOR_triangle) 1401 _mesa_printf("flat_TRUECOLOR_triangle\n"); 1402 else if (triFunc ==flat_TRUEDITHER_triangle) 1403 _mesa_printf("flat_TRUEDITHER_triangle\n"); 1404 else if (triFunc ==flat_8A8B8G8R_triangle) 1405 _mesa_printf("flat_8A8B8G8R_triangle\n"); 1406 else if (triFunc ==flat_8A8R8G8B_triangle) 1407 _mesa_printf("flat_8A8R8G8B_triangle\n"); 1408 else if (triFunc ==flat_8R8G8B_triangle) 1409 _mesa_printf("flat_8R8G8B_triangle\n"); 1410 else if (triFunc ==flat_8R8G8B24_triangle) 1411 _mesa_printf("flat_8R8G8B24_triangle\n"); 1412 else if (triFunc ==flat_5R6G5B_triangle) 1413 _mesa_printf("flat_5R6G5B_triangle\n"); 1414 else if (triFunc ==flat_DITHER_5R6G5B_triangle) 1415 _mesa_printf("flat_DITHER_5R6G5B_triangle\n"); 1416 else if (triFunc ==flat_HPCR_triangle) 1417 _mesa_printf("flat_HPCR_triangle\n"); 1418 else if (triFunc ==flat_DITHER8_triangle) 1419 _mesa_printf("flat_DITHER8_triangle\n"); 1420 else if (triFunc ==flat_LOOKUP8_triangle) 1421 _mesa_printf("flat_LOOKUP8_triangle\n"); 1422 else 1423 _mesa_printf("???\n"); 1424} 1425#endif 1426 1427 1428#ifdef DEBUG 1429 1430/* record the current triangle function name */ 1431static const char *triFuncName = NULL; 1432 1433#define USE(triFunc) \ 1434do { \ 1435 triFuncName = #triFunc; \ 1436 return triFunc; \ 1437} while (0) 1438 1439#else 1440 1441#define USE(triFunc) return triFunc 1442 1443#endif 1444 1445 1446/** 1447 * Return pointer to line drawing function, or NULL if we should use a 1448 * swrast fallback. 1449 */ 1450static swrast_tri_func 1451get_triangle_func(GLcontext *ctx) 1452{ 1453#if CHAN_BITS == 8 1454 SWcontext *swrast = SWRAST_CONTEXT(ctx); 1455 XMesaContext xmesa = XMESA_CONTEXT(ctx); 1456 XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer); 1457 const int depth = GET_VISUAL_DEPTH(xmesa->xm_visual); 1458 const struct xmesa_renderbuffer *xrb; 1459 1460#ifdef DEBUG 1461 triFuncName = NULL; 1462#endif 1463 1464 /* trivial fallback tests */ 1465 if ((ctx->DrawBuffer->_ColorDrawBufferMask[0] 1466 & (BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT)) == 0) 1467 return (swrast_tri_func) NULL; 1468 if (ctx->RenderMode != GL_RENDER) 1469 return (swrast_tri_func) NULL; 1470 if (ctx->Polygon.SmoothFlag) 1471 return (swrast_tri_func) NULL; 1472 if (ctx->Texture._EnabledUnits) 1473 return (swrast_tri_func) NULL; 1474 if (swrast->_RasterMask & MULTI_DRAW_BIT) 1475 return (swrast_tri_func) NULL; 1476 if (ctx->Polygon.CullFlag && 1477 ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK) 1478 return (swrast_tri_func) NULL; 1479 if (xmbuf->swAlpha) 1480 return (swrast_tri_func) NULL; 1481 1482 xrb = xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]->Wrapped); 1483 1484 if (xrb->ximage) { 1485 if ( ctx->Light.ShadeModel==GL_SMOOTH 1486 && swrast->_RasterMask==DEPTH_BIT 1487 && ctx->Depth.Func==GL_LESS 1488 && ctx->Depth.Mask==GL_TRUE 1489 && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS 1490 && ctx->Polygon.StippleFlag==GL_FALSE) { 1491 switch (xmesa->pixelformat) { 1492 case PF_Truecolor: 1493 USE(smooth_TRUECOLOR_z_triangle); 1494 case PF_8A8B8G8R: 1495 USE(smooth_8A8B8G8R_z_triangle); 1496 case PF_8A8R8G8B: 1497 USE(smooth_8A8R8G8B_z_triangle); 1498 case PF_8R8G8B: 1499 USE(smooth_8R8G8B_z_triangle); 1500 case PF_8R8G8B24: 1501 USE(smooth_8R8G8B24_z_triangle); 1502 case PF_Dither_True: 1503 USE(smooth_TRUEDITHER_z_triangle); 1504 case PF_5R6G5B: 1505 USE(smooth_5R6G5B_z_triangle); 1506 case PF_Dither_5R6G5B: 1507 USE(smooth_DITHER_5R6G5B_z_triangle); 1508 case PF_HPCR: 1509 USE(smooth_HPCR_z_triangle); 1510 case PF_Dither: 1511 if (depth == 8) 1512 USE(smooth_DITHER8_z_triangle); 1513 else 1514 USE(smooth_DITHER_z_triangle); 1515 case PF_Lookup: 1516 if (depth == 8) 1517 USE(smooth_LOOKUP8_z_triangle); 1518 else 1519 return (swrast_tri_func) NULL; 1520 default: 1521 return (swrast_tri_func) NULL; 1522 } 1523 } 1524 if ( ctx->Light.ShadeModel==GL_FLAT 1525 && swrast->_RasterMask==DEPTH_BIT 1526 && ctx->Depth.Func==GL_LESS 1527 && ctx->Depth.Mask==GL_TRUE 1528 && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS 1529 && ctx->Polygon.StippleFlag==GL_FALSE) { 1530 switch (xmesa->pixelformat) { 1531 case PF_Truecolor: 1532 USE(flat_TRUECOLOR_z_triangle); 1533 case PF_8A8B8G8R: 1534 USE(flat_8A8B8G8R_z_triangle); 1535 case PF_8A8R8G8B: 1536 USE(flat_8A8R8G8B_z_triangle); 1537 case PF_8R8G8B: 1538 USE(flat_8R8G8B_z_triangle); 1539 case PF_8R8G8B24: 1540 USE(flat_8R8G8B24_z_triangle); 1541 case PF_Dither_True: 1542 USE(flat_TRUEDITHER_z_triangle); 1543 case PF_5R6G5B: 1544 USE(flat_5R6G5B_z_triangle); 1545 case PF_Dither_5R6G5B: 1546 USE(flat_DITHER_5R6G5B_z_triangle); 1547 case PF_HPCR: 1548 USE(flat_HPCR_z_triangle); 1549 case PF_Dither: 1550 if (depth == 8) 1551 USE(flat_DITHER8_z_triangle); 1552 else 1553 USE(flat_DITHER_z_triangle); 1554 case PF_Lookup: 1555 if (depth == 8) 1556 USE(flat_LOOKUP8_z_triangle); 1557 else 1558 return (swrast_tri_func) NULL; 1559 default: 1560 return (swrast_tri_func) NULL; 1561 } 1562 } 1563 if ( swrast->_RasterMask==0 /* no depth test */ 1564 && ctx->Light.ShadeModel==GL_SMOOTH 1565 && ctx->Polygon.StippleFlag==GL_FALSE) { 1566 switch (xmesa->pixelformat) { 1567 case PF_Truecolor: 1568 USE(smooth_TRUECOLOR_triangle); 1569 case PF_8A8B8G8R: 1570 USE(smooth_8A8B8G8R_triangle); 1571 case PF_8A8R8G8B: 1572 USE(smooth_8A8R8G8B_triangle); 1573 case PF_8R8G8B: 1574 USE(smooth_8R8G8B_triangle); 1575 case PF_8R8G8B24: 1576 USE(smooth_8R8G8B24_triangle); 1577 case PF_Dither_True: 1578 USE(smooth_TRUEDITHER_triangle); 1579 case PF_5R6G5B: 1580 USE(smooth_5R6G5B_triangle); 1581 case PF_Dither_5R6G5B: 1582 USE(smooth_DITHER_5R6G5B_triangle); 1583 case PF_HPCR: 1584 USE(smooth_HPCR_triangle); 1585 case PF_Dither: 1586 if (depth == 8) 1587 USE(smooth_DITHER8_triangle); 1588 else 1589 USE(smooth_DITHER_triangle); 1590 case PF_Lookup: 1591 if (depth == 8) 1592 USE(smooth_LOOKUP8_triangle); 1593 else 1594 return (swrast_tri_func) NULL; 1595 default: 1596 return (swrast_tri_func) NULL; 1597 } 1598 } 1599 1600 if ( swrast->_RasterMask==0 /* no depth test */ 1601 && ctx->Light.ShadeModel==GL_FLAT 1602 && ctx->Polygon.StippleFlag==GL_FALSE) { 1603 switch (xmesa->pixelformat) { 1604 case PF_Truecolor: 1605 USE(flat_TRUECOLOR_triangle); 1606 case PF_Dither_True: 1607 USE(flat_TRUEDITHER_triangle); 1608 case PF_8A8B8G8R: 1609 USE(flat_8A8B8G8R_triangle); 1610 case PF_8A8R8G8B: 1611 USE(flat_8A8R8G8B_triangle); 1612 case PF_8R8G8B: 1613 USE(flat_8R8G8B_triangle); 1614 case PF_8R8G8B24: 1615 USE(flat_8R8G8B24_triangle); 1616 case PF_5R6G5B: 1617 USE(flat_5R6G5B_triangle); 1618 case PF_Dither_5R6G5B: 1619 USE(flat_DITHER_5R6G5B_triangle); 1620 case PF_HPCR: 1621 USE(flat_HPCR_triangle); 1622 case PF_Dither: 1623 if (depth == 8) 1624 USE(flat_DITHER8_triangle); 1625 else 1626 USE(flat_DITHER_triangle); 1627 case PF_Lookup: 1628 if (depth == 8) 1629 USE(flat_LOOKUP8_triangle); 1630 else 1631 return (swrast_tri_func) NULL; 1632 default: 1633 return (swrast_tri_func) NULL; 1634 } 1635 } 1636 } 1637#endif /* CHAN_BITS == 8 */ 1638 1639 return (swrast_tri_func) NULL; 1640} 1641 1642 1643/* Override for the swrast tri-selection function. Try to use one 1644 * of our internal tri functions, otherwise fall back to the 1645 * standard swrast functions. 1646 */ 1647void xmesa_choose_triangle( GLcontext *ctx ) 1648{ 1649 SWcontext *swrast = SWRAST_CONTEXT(ctx); 1650 1651 if (!(swrast->Triangle = get_triangle_func( ctx ))) 1652 _swrast_choose_triangle( ctx ); 1653} 1654 1655