Subversion Repositories Kolibri OS

Rev

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