src/mesa/drivers/x11/xm_tri.c

   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/depth.h"
  34 #include "main/macros.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]->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
1330 extern void _xmesa_print_triangle_func( swrast_tri_func triFunc );
1331 void _xmesa_print_triangle_func( swrast_tri_func triFunc )
1332 {
1333    printf("XMesa tri func = ");
1334    if (triFunc ==smooth_TRUECOLOR_z_triangle)
1335       printf("smooth_TRUECOLOR_z_triangle\n");
1336    else if (triFunc ==smooth_8A8B8G8R_z_triangle)
1337       printf("smooth_8A8B8G8R_z_triangle\n");
1338    else if (triFunc ==smooth_8A8R8G8B_z_triangle)
1339       printf("smooth_8A8R8G8B_z_triangle\n");
1340    else if (triFunc ==smooth_8R8G8B_z_triangle)
1341       printf("smooth_8R8G8B_z_triangle\n");
1342    else if (triFunc ==smooth_8R8G8B24_z_triangle)
1343       printf("smooth_8R8G8B24_z_triangle\n");
1344    else if (triFunc ==smooth_TRUEDITHER_z_triangle)
1345       printf("smooth_TRUEDITHER_z_triangle\n");
1346    else if (triFunc ==smooth_5R6G5B_z_triangle)
1347       printf("smooth_5R6G5B_z_triangle\n");
1348    else if (triFunc ==smooth_DITHER_5R6G5B_z_triangle)
1349       printf("smooth_DITHER_5R6G5B_z_triangle\n");
1350    else if (triFunc ==smooth_HPCR_z_triangle)
1351       printf("smooth_HPCR_z_triangle\n");
1352    else if (triFunc ==smooth_DITHER8_z_triangle)
1353       printf("smooth_DITHER8_z_triangle\n");
1354    else if (triFunc ==smooth_LOOKUP8_z_triangle)
1355       printf("smooth_LOOKUP8_z_triangle\n");
1356    else if (triFunc ==flat_TRUECOLOR_z_triangle)
1357       printf("flat_TRUECOLOR_z_triangle\n");
1358    else if (triFunc ==flat_8A8B8G8R_z_triangle)
1359       printf("flat_8A8B8G8R_z_triangle\n");
1360    else if (triFunc ==flat_8A8R8G8B_z_triangle)
1361       printf("flat_8A8R8G8B_z_triangle\n");
1362    else if (triFunc ==flat_8R8G8B_z_triangle)
1363       printf("flat_8R8G8B_z_triangle\n");
1364    else if (triFunc ==flat_8R8G8B24_z_triangle)
1365       printf("flat_8R8G8B24_z_triangle\n");
1366    else if (triFunc ==flat_TRUEDITHER_z_triangle)
1367       printf("flat_TRUEDITHER_z_triangle\n");
1368    else if (triFunc ==flat_5R6G5B_z_triangle)
1369       printf("flat_5R6G5B_z_triangle\n");
1370    else if (triFunc ==flat_DITHER_5R6G5B_z_triangle)
1371       printf("flat_DITHER_5R6G5B_z_triangle\n");
1372    else if (triFunc ==flat_HPCR_z_triangle)
1373       printf("flat_HPCR_z_triangle\n");
1374    else if (triFunc ==flat_DITHER8_z_triangle)
1375       printf("flat_DITHER8_z_triangle\n");
1376    else if (triFunc ==flat_LOOKUP8_z_triangle)
1377       printf("flat_LOOKUP8_z_triangle\n");
1378    else if (triFunc ==smooth_TRUECOLOR_triangle)
1379       printf("smooth_TRUECOLOR_triangle\n");
1380    else if (triFunc ==smooth_8A8B8G8R_triangle)
1381       printf("smooth_8A8B8G8R_triangle\n");
1382    else if (triFunc ==smooth_8A8R8G8B_triangle)
1383       printf("smooth_8A8R8G8B_triangle\n");
1384    else if (triFunc ==smooth_8R8G8B_triangle)
1385       printf("smooth_8R8G8B_triangle\n");
1386    else if (triFunc ==smooth_8R8G8B24_triangle)
1387       printf("smooth_8R8G8B24_triangle\n");
1388    else if (triFunc ==smooth_TRUEDITHER_triangle)
1389       printf("smooth_TRUEDITHER_triangle\n");
1390    else if (triFunc ==smooth_5R6G5B_triangle)
1391       printf("smooth_5R6G5B_triangle\n");
1392    else if (triFunc ==smooth_DITHER_5R6G5B_triangle)
1393       printf("smooth_DITHER_5R6G5B_triangle\n");
1394    else if (triFunc ==smooth_HPCR_triangle)
1395       printf("smooth_HPCR_triangle\n");
1396    else if (triFunc ==smooth_DITHER8_triangle)
1397       printf("smooth_DITHER8_triangle\n");
1398    else if (triFunc ==smooth_LOOKUP8_triangle)
1399       printf("smooth_LOOKUP8_triangle\n");
1400    else if (triFunc ==flat_TRUECOLOR_triangle)
1401       printf("flat_TRUECOLOR_triangle\n");
1402    else if (triFunc ==flat_TRUEDITHER_triangle)
1403       printf("flat_TRUEDITHER_triangle\n");
1404    else if (triFunc ==flat_8A8B8G8R_triangle)
1405       printf("flat_8A8B8G8R_triangle\n");
1406    else if (triFunc ==flat_8A8R8G8B_triangle)
1407       printf("flat_8A8R8G8B_triangle\n");
1408    else if (triFunc ==flat_8R8G8B_triangle)
1409       printf("flat_8R8G8B_triangle\n");
1410    else if (triFunc ==flat_8R8G8B24_triangle)
1411       printf("flat_8R8G8B24_triangle\n");
1412    else if (triFunc ==flat_5R6G5B_triangle)
1413       printf("flat_5R6G5B_triangle\n");
1414    else if (triFunc ==flat_DITHER_5R6G5B_triangle)
1415       printf("flat_DITHER_5R6G5B_triangle\n");
1416    else if (triFunc ==flat_HPCR_triangle)
1417       printf("flat_HPCR_triangle\n");
1418    else if (triFunc ==flat_DITHER8_triangle)
1419       printf("flat_DITHER8_triangle\n");
1420    else if (triFunc ==flat_LOOKUP8_triangle)
1421       printf("flat_LOOKUP8_triangle\n");
1422    else
1423       printf("???\n");
1424 }
1425 #endif
1426
1427
1428 #ifdef DEBUG
1429
1430 /* record the current triangle function name */
1431 static const char *triFuncName = NULL;
1432
1433 #define USE(triFunc)                   \
1434 do {                                   \
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  */
1450 static swrast_tri_func
1451 get_triangle_func(struct gl_context *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->_ColorDrawBufferIndexes[0] != BUFFER_BIT_FRONT_LEFT) &&
1466        (ctx->DrawBuffer->_ColorDrawBufferIndexes[0] != BUFFER_BIT_BACK_LEFT))
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  */
1647 void xmesa_choose_triangle( struct gl_context *ctx )
1648 {
1649    SWcontext *swrast = SWRAST_CONTEXT(ctx);
1650
1651    if (!(swrast->Triangle = get_triangle_func( ctx )))
1652       _swrast_choose_triangle( ctx );
1653 }
1654