Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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