home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 5 / MA_Cover_5.iso / ppc / mesa / src / xmesa4.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-31  |  35.6 KB  |  1,201 lines
  1. /* $Id: xmesa4.c,v 1.4 1997/06/03 02:00:23 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  2.3
  6.  * Copyright (C) 1995-1997  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: xmesa4.c,v $
  26.  * Revision 1.4  1997/06/03 02:00:23  brianp
  27.  * fixed problem with polygon stippling
  28.  *
  29.  * Revision 1.3  1997/05/26 20:34:57  brianp
  30.  * renamed PACK_RGB to PACK_TRUECOLOR
  31.  *
  32.  * Revision 1.2  1997/03/16 02:16:32  brianp
  33.  * moved PACK_8B8G8R macro to xmesaP.h
  34.  *
  35.  * Revision 1.1  1997/03/16 02:14:45  brianp
  36.  * Initial revision
  37.  *
  38.  */
  39.  
  40.  
  41. /*
  42.  * Mesa/X11 interface, part 4.
  43.  *
  44.  * This file contains "accelerated" triangle functions.  It should be
  45.  * fairly easy to write new special-purpose triangle functions and hook
  46.  * them into this module.
  47.  */
  48.  
  49.  
  50. #include <sys/time.h>
  51. #include <assert.h>
  52. #include <stdlib.h>
  53. #include <stdio.h>
  54. #include <X11/Xlib.h>
  55. #include "depth.h"
  56. #include "macros.h"
  57. #include "vb.h"
  58. #include "types.h"
  59. #include "xmesaP.h"
  60.  
  61.  
  62.  
  63.  
  64. /**********************************************************************/
  65. /***                   Triangle rendering                           ***/
  66. /**********************************************************************/
  67.  
  68. /*
  69.  * Render a triangle into a pixmap, any pixel format, flat shaded and
  70.  * no raster ops.
  71.  */
  72. void flat_pixmap_triangle( GLcontext *ctx,
  73.                         GLuint v0, GLuint v1, GLuint v2, GLuint pv )
  74. {
  75.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  76.    struct vertex_buffer *VB = ctx->VB;
  77.    XPoint p[3];
  78.    GC gc;
  79.    if (VB->MonoColor) {
  80.       gc = xmesa->xm_buffer->gc1;  /* use current color */
  81.    }
  82.    else {
  83.       unsigned long pixel;
  84.       if (xmesa->xm_visual->gl_visual->RGBAflag) {
  85.          pixel = xmesa_color_to_pixel( xmesa,
  86.                                        VB->Color[pv][0], VB->Color[pv][1],
  87.                                        VB->Color[pv][2], VB->Color[pv][3] );
  88.       }
  89.       else {
  90.          pixel = VB->Index[pv];
  91.       }
  92.       gc = xmesa->xm_buffer->gc2;
  93.       XSetForeground( xmesa->display, gc, pixel );
  94.    }
  95.    p[0].x =       (GLint) (VB->Win[v0][0] + 0.5f);
  96.    p[0].y = FLIP( (GLint) (VB->Win[v0][1] - 0.5f) );
  97.    p[1].x =       (GLint) (VB->Win[v1][0] + 0.5f);
  98.    p[1].y = FLIP( (GLint) (VB->Win[v1][1] - 0.5f) );
  99.    p[2].x =       (GLint) (VB->Win[v2][0] + 0.5f);
  100.    p[2].y = FLIP( (GLint) (VB->Win[v2][1] - 0.5f) );
  101.    XFillPolygon( xmesa->display, xmesa->xm_buffer->buffer, gc,
  102.          p, 3, Convex, CoordModeOrigin );
  103. }
  104.  
  105.  
  106.  
  107. /*
  108.  * XImage, smooth, depth-buffered, PF_TRUECOLOR triangle.
  109.  */
  110. static void smooth_TRUECOLOR_z_triangle( GLcontext *ctx,
  111.                                          GLuint v0, GLuint v1, GLuint v2,
  112.                                          GLuint pv )
  113. {
  114.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  115.    XImage *img = xmesa->xm_buffer->backimage;
  116. #define INTERP_Z 1
  117. #define INTERP_RGB 1
  118. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  119. {                                    \
  120.    GLint i, xx = LEFT, yy = FLIP(Y), len = RIGHT-LEFT;            \
  121.    for (i=0;i<len;i++,xx++) {                        \
  122.       GLdepth z = FixedToDepth(ffz);                    \
  123.       if (z < zRow[i]) {                        \
  124.          unsigned long p;                        \
  125.          PACK_TRUECOLOR(p, FixedToInt(ffr), FixedToInt(ffg), FixedToInt(ffb));\
  126.          XPutPixel( img, xx, yy, p );                    \
  127.          zRow[i] = z;                            \
  128.       }                                    \
  129.       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;            \
  130.       ffz += fdzdx;                            \
  131.    }                                    \
  132. }
  133. #include "tritemp.h"
  134. }
  135.  
  136.  
  137.  
  138. /*
  139.  * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.
  140.  */
  141. static void smooth_8A8B8G8R_z_triangle( GLcontext *ctx,
  142.                                          GLuint v0, GLuint v1, GLuint v2,
  143.                                          GLuint pv )
  144. {
  145.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  146. #define INTERP_Z 1
  147. #define INTERP_RGB 1
  148. #define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
  149. #define PIXEL_TYPE GLuint
  150. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  151. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  152. {                                    \
  153.    GLint i, len = RIGHT-LEFT;                        \
  154.    for (i=0;i<len;i++) {                        \
  155.       GLdepth z = FixedToDepth(ffz);                    \
  156.       if (z < zRow[i]) {                        \
  157.          pRow[i] = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg),    \
  158.                  FixedToInt(ffb) );            \
  159.          zRow[i] = z;                            \
  160.       }                                    \
  161.       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;            \
  162.       ffz += fdzdx;                            \
  163.    }                                    \
  164. }
  165. #include "tritemp.h"
  166. }
  167.  
  168.  
  169. /*
  170.  * XImage, smooth, depth-buffered, PF_8R8G8B triangle.
  171.  */
  172. static void smooth_8R8G8B_z_triangle( GLcontext *ctx,
  173.                                          GLuint v0, GLuint v1, GLuint v2,
  174.                                          GLuint pv )
  175. {
  176.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  177. #define INTERP_Z 1
  178. #define INTERP_RGB 1
  179. #define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
  180. #define PIXEL_TYPE GLuint
  181. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  182. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  183. {                                    \
  184.    GLint i, len = RIGHT-LEFT;                        \
  185.    for (i=0;i<len;i++) {                        \
  186.       GLdepth z = FixedToDepth(ffz);                    \
  187.       if (z < zRow[i]) {                        \
  188.          pRow[i] = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg),    \
  189.                  FixedToInt(ffb) );            \
  190.          zRow[i] = z;                            \
  191.       }                                    \
  192.       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;            \
  193.       ffz += fdzdx;                            \
  194.    }                                    \
  195. }
  196. #include "tritemp.h"
  197. }
  198.  
  199.  
  200.  
  201. /*
  202.  * XImage, smooth, depth-buffered, PF_5R6G5B triangle.
  203.  */
  204. static void smooth_5R6G5B_z_triangle( GLcontext *ctx,
  205.                                          GLuint v0, GLuint v1, GLuint v2,
  206.                                          GLuint pv )
  207. {
  208.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  209. #define INTERP_Z 1
  210. #define INTERP_RGB 1
  211. #define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)
  212. #define PIXEL_TYPE GLushort
  213. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  214. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  215. {                                    \
  216.    GLint i, len = RIGHT-LEFT;                        \
  217.    for (i=0;i<len;i++) {                        \
  218.       GLdepth z = FixedToDepth(ffz);                    \
  219.       if (z < zRow[i]) {                        \
  220.          pRow[i] = PACK_5R6G5B( FixedToInt(ffr), FixedToInt(ffg),    \
  221.                  FixedToInt(ffb) );            \
  222.          zRow[i] = z;                            \
  223.       }                                    \
  224.       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;            \
  225.       ffz += fdzdx;                            \
  226.    }                                    \
  227. }
  228. #include "tritemp.h"
  229. }
  230.  
  231.  
  232. /*
  233.  * XImage, smooth, depth-buffered, 8-bit, PF_DITHER8 triangle.
  234.  */
  235. static void smooth_DITHER8_z_triangle( GLcontext *ctx,
  236.                                        GLuint v0, GLuint v1, GLuint v2,
  237.                                        GLuint pv )
  238. {
  239.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  240. #define INTERP_Z 1
  241. #define INTERP_RGB 1
  242. #define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
  243. #define PIXEL_TYPE GLubyte
  244. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  245. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  246. {                                    \
  247.    GLint i, xx = LEFT, yy = FLIP(Y), len = RIGHT-LEFT;            \
  248.    XDITHER_SETUP(yy);                            \
  249.    for (i=0;i<len;i++,xx++) {                        \
  250.       GLdepth z = FixedToDepth(ffz);                    \
  251.       if (z < zRow[i]) {                        \
  252.          pRow[i] = XDITHER( xx, FixedToInt(ffr), FixedToInt(ffg),    \
  253.                 FixedToInt(ffb) );            \
  254.          zRow[i] = z;                            \
  255.       }                                    \
  256.       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;            \
  257.       ffz += fdzdx;                            \
  258.    }                                    \
  259. }
  260. #include "tritemp.h"
  261. }
  262.  
  263.  
  264.  
  265. /*
  266.  * XImage, smooth, depth-buffered, PF_DITHER triangle.
  267.  */
  268. static void smooth_DITHER_z_triangle( GLcontext *ctx,
  269.                                        GLuint v0, GLuint v1, GLuint v2,
  270.                                        GLuint pv )
  271. {
  272.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  273.    XImage *img = xmesa->xm_buffer->backimage;
  274. #define INTERP_Z 1
  275. #define INTERP_RGB 1
  276. #define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
  277. #define PIXEL_TYPE GLubyte
  278. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  279. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  280. {                                    \
  281.    GLint i, xx = LEFT, yy = FLIP(Y), len = RIGHT-LEFT;            \
  282.    XDITHER_SETUP(yy);                            \
  283.    for (i=0;i<len;i++,xx++) {                        \
  284.       GLdepth z = FixedToDepth(ffz);                    \
  285.       if (z < zRow[i]) {                        \
  286.      unsigned long p = XDITHER( xx, FixedToInt(ffr),        \
  287.                  FixedToInt(ffg), FixedToInt(ffb) );    \
  288.      XPutPixel( img, xx, yy, p );                    \
  289.          zRow[i] = z;                            \
  290.       }                                    \
  291.       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;            \
  292.       ffz += fdzdx;                            \
  293.    }                                    \
  294. }
  295. #include "tritemp.h"
  296. }
  297.  
  298.  
  299. /*
  300.  * XImage, smooth, depth-buffered, 8-bit PF_LOOKUP triangle.
  301.  */
  302. static void smooth_LOOKUP8_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  303.                                        GLuint v2, GLuint pv )
  304. {
  305.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  306. #define INTERP_Z 1
  307. #define INTERP_RGB 1
  308. #define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
  309. #define PIXEL_TYPE GLubyte
  310. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  311. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  312. {                                    \
  313.    GLint i, len = RIGHT-LEFT;                        \
  314.    LOOKUP_SETUP;                            \
  315.    for (i=0;i<len;i++) {                        \
  316.       GLdepth z = FixedToDepth(ffz);                    \
  317.       if (z < zRow[i]) {                        \
  318.          pRow[i] = LOOKUP( FixedToInt(ffr), FixedToInt(ffg),        \
  319.                  FixedToInt(ffb) );            \
  320.          zRow[i] = z;                            \
  321.       }                                    \
  322.       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;            \
  323.       ffz += fdzdx;                            \
  324.    }                                    \
  325. }
  326. #include "tritemp.h"
  327. }
  328.  
  329.  
  330.  
  331. /*
  332.  * XImage, smooth, depth-buffered, 8-bit PF_HPCR triangle.
  333.  */
  334. static void smooth_HPCR_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  335.                                     GLuint v2, GLuint pv )
  336. {
  337.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  338. #define INTERP_Z 1
  339. #define INTERP_RGB 1
  340. #define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
  341. #define PIXEL_TYPE GLubyte
  342. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  343. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  344. {                                    \
  345.    GLint i, xx = LEFT, yy = FLIP(Y), len = RIGHT-LEFT;            \
  346.    for (i=0;i<len;i++,xx++) {                        \
  347.       GLdepth z = FixedToDepth(ffz);                    \
  348.       if (z < zRow[i]) {                        \
  349.          pRow[i] = DITHER_HPCR( xx, yy, FixedToInt(ffr),        \
  350.                  FixedToInt(ffg), FixedToInt(ffb) );    \
  351.          zRow[i] = z;                            \
  352.       }                                    \
  353.       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;            \
  354.       ffz += fdzdx;                            \
  355.    }                                    \
  356. }
  357. #include "tritemp.h"
  358. }
  359.  
  360.  
  361.  
  362. /*
  363.  * XImage, flat, depth-buffered, PF_TRUECOLOR triangle.
  364.  */
  365. static void flat_TRUECOLOR_z_triangle( GLcontext *ctx,
  366.                                    GLuint v0, GLuint v1, GLuint v2,
  367.                                        GLuint pv )
  368. {
  369.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  370.    XImage *img = xmesa->xm_buffer->backimage;
  371. #define INTERP_Z 1
  372. #define SETUP_CODE                        \
  373.    unsigned long pixel;                        \
  374.    PACK_TRUECOLOR(pixel, VB->Color[pv][0], VB->Color[pv][1], VB->Color[pv][2]);
  375.  
  376. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  377. {                                    \
  378.    GLint i, xx = LEFT, yy = FLIP(Y), len = RIGHT-LEFT;            \
  379.    for (i=0;i<len;i++,xx++) {                        \
  380.       GLdepth z = FixedToDepth(ffz);                    \
  381.       if (z < zRow[i]) {                        \
  382.          XPutPixel( img, xx, yy, pixel );                \
  383.          zRow[i] = z;                            \
  384.       }                                    \
  385.       ffz += fdzdx;                            \
  386.    }                                    \
  387. }
  388. #include "tritemp.h"
  389. }
  390.  
  391.  
  392. /*
  393.  * XImage, flat, depth-buffered, PF_8A8B8G8R triangle.
  394.  */
  395. static void flat_8A8B8G8R_z_triangle( GLcontext *ctx, GLuint v0,
  396.                                   GLuint v1, GLuint v2, GLuint pv )
  397. {
  398.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  399. #define INTERP_Z 1
  400. #define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
  401. #define PIXEL_TYPE GLuint
  402. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  403. #define SETUP_CODE                    \
  404.    unsigned long p = PACK_8B8G8R( VB->Color[pv][0],    \
  405.          VB->Color[pv][1], VB->Color[pv][2] );
  406. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  407. {                                    \
  408.    GLint i, len = RIGHT-LEFT;                        \
  409.    for (i=0;i<len;i++) {                        \
  410.       GLdepth z = FixedToDepth(ffz);                    \
  411.       if (z < zRow[i]) {                        \
  412.      pRow[i] = p;                            \
  413.          zRow[i] = z;                            \
  414.       }                                    \
  415.       ffz += fdzdx;                            \
  416.    }                                    \
  417. }
  418. #include "tritemp.h"
  419. }
  420.  
  421.  
  422. /*
  423.  * XImage, flat, depth-buffered, PF_8R8G8B triangle.
  424.  */
  425. static void flat_8R8G8B_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  426.                                     GLuint v2, GLuint pv )
  427. {
  428.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  429. #define INTERP_Z 1
  430. #define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
  431. #define PIXEL_TYPE GLuint
  432. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  433. #define SETUP_CODE                    \
  434.    unsigned long p = PACK_8R8G8B( VB->Color[pv][0],    \
  435.          VB->Color[pv][1], VB->Color[pv][2] );
  436. #define INNER_LOOP( LEFT, RIGHT, Y )            \
  437. {                            \
  438.    GLint i, len = RIGHT-LEFT;                \
  439.    for (i=0;i<len;i++) {                \
  440.       GLdepth z = FixedToDepth(ffz);            \
  441.       if (z < zRow[i]) {                \
  442.      pRow[i] = p;                    \
  443.          zRow[i] = z;                    \
  444.       }                            \
  445.       ffz += fdzdx;                    \
  446.    }                            \
  447. }
  448. #include "tritemp.h"
  449. }
  450.  
  451.  
  452. /*
  453.  * XImage, flat, depth-buffered, PF_5R6G5B triangle.
  454.  */
  455. static void flat_5R6G5B_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  456.                                     GLuint v2, GLuint pv )
  457. {
  458.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  459. #define INTERP_Z 1
  460. #define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)
  461. #define PIXEL_TYPE GLushort
  462. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  463. #define SETUP_CODE                    \
  464.    unsigned long p = PACK_5R6G5B( VB->Color[pv][0],    \
  465.          VB->Color[pv][1], VB->Color[pv][2] );
  466. #define INNER_LOOP( LEFT, RIGHT, Y )            \
  467. {                            \
  468.    GLint i, len = RIGHT-LEFT;                \
  469.    for (i=0;i<len;i++) {                \
  470.       GLdepth z = FixedToDepth(ffz);            \
  471.       if (z < zRow[i]) {                \
  472.      pRow[i] = p;                    \
  473.          zRow[i] = z;                    \
  474.       }                            \
  475.       ffz += fdzdx;                    \
  476.    }                            \
  477. }
  478. #include "tritemp.h"
  479. }
  480.  
  481.  
  482. /*
  483.  * XImage, flat, depth-buffered, 8-bit PF_DITHER triangle.
  484.  */
  485. static void flat_DITHER8_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  486.                                      GLuint v2, GLuint pv )
  487. {
  488.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  489. #define INTERP_Z 1
  490. #define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
  491. #define PIXEL_TYPE GLubyte
  492. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  493. #define SETUP_CODE    \
  494.    FLAT_DITHER_SETUP( VB->Color[pv][0], VB->Color[pv][1], VB->Color[pv][2] );
  495.  
  496. #define INNER_LOOP( LEFT, RIGHT, Y )                \
  497. {                                \
  498.    GLint i, xx = LEFT, len = RIGHT-LEFT;            \
  499.    FLAT_DITHER_ROW_SETUP(FLIP(Y));                \
  500.    for (i=0;i<len;i++,xx++) {                    \
  501.       GLdepth z = FixedToDepth(ffz);                \
  502.       if (z < zRow[i]) {                    \
  503.      pRow[i] = FLAT_DITHER(xx);                \
  504.          zRow[i] = z;                        \
  505.       }                                \
  506.       ffz += fdzdx;                        \
  507.    }                                \
  508. }
  509. #include "tritemp.h"
  510. }
  511.  
  512.  
  513. /*
  514.  * XImage, flat, depth-buffered, PF_DITHER triangle.
  515.  */
  516. static void flat_DITHER_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  517.                                     GLuint v2, GLuint pv )
  518. {
  519.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  520.    XImage *img = xmesa->xm_buffer->backimage;
  521. #define INTERP_Z 1
  522. #define SETUP_CODE    \
  523.    FLAT_DITHER_SETUP( VB->Color[pv][0], VB->Color[pv][1], VB->Color[pv][2] );
  524.  
  525. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  526. {                                    \
  527.    GLint i, xx = LEFT, yy = FLIP(Y), len = RIGHT-LEFT;            \
  528.    FLAT_DITHER_ROW_SETUP(yy);                        \
  529.    for (i=0;i<len;i++,xx++) {                        \
  530.       GLdepth z = FixedToDepth(ffz);                    \
  531.       if (z < zRow[i]) {                        \
  532.          unsigned long p = FLAT_DITHER(xx);                \
  533.      XPutPixel( img, xx, yy, p );                    \
  534.          zRow[i] = z;                            \
  535.       }                                    \
  536.       ffz += fdzdx;                            \
  537.    }                                    \
  538. }
  539. #include "tritemp.h"
  540. }
  541.  
  542.  
  543. /*
  544.  * XImage, flat, depth-buffered, 8-bit PF_HPCR triangle.
  545.  */
  546. static void flat_HPCR_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  547.                                   GLuint v2, GLuint pv )
  548. {
  549.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  550. #define INTERP_Z 1
  551. #define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
  552. #define PIXEL_TYPE GLubyte
  553. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  554. #define SETUP_CODE                \
  555.    GLubyte r = VB->Color[pv][0];        \
  556.    GLubyte g = VB->Color[pv][1];        \
  557.    GLubyte b = VB->Color[pv][2];
  558. #define INNER_LOOP( LEFT, RIGHT, Y )                \
  559. {                                \
  560.    GLint i, xx = LEFT, yy = FLIP(Y), len = RIGHT-LEFT;        \
  561.    for (i=0;i<len;i++,xx++) {                    \
  562.       GLdepth z = FixedToDepth(ffz);                \
  563.       if (z < zRow[i]) {                    \
  564.      pRow[i] = DITHER_HPCR( xx, yy, r, g, b );        \
  565.          zRow[i] = z;                        \
  566.       }                                \
  567.       ffz += fdzdx;                        \
  568.    }                                \
  569. }
  570. #include "tritemp.h"
  571. }
  572.  
  573.  
  574.  
  575. /*
  576.  * XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle.
  577.  */
  578. static void flat_LOOKUP8_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  579.                                  GLuint v2, GLuint pv )
  580. {
  581.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  582. #define INTERP_Z 1
  583. #define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
  584. #define PIXEL_TYPE GLubyte
  585. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  586. #define SETUP_CODE                \
  587.    LOOKUP_SETUP;                \
  588.    GLubyte r = VB->Color[pv][0];        \
  589.    GLubyte g = VB->Color[pv][1];        \
  590.    GLubyte b = VB->Color[pv][2];        \
  591.    GLubyte p = LOOKUP(r,g,b);
  592. #define INNER_LOOP( LEFT, RIGHT, Y )            \
  593. {                            \
  594.    GLint i, len = RIGHT-LEFT;                \
  595.    for (i=0;i<len;i++) {                \
  596.       GLdepth z = FixedToDepth(ffz);            \
  597.       if (z < zRow[i]) {                \
  598.      pRow[i] = p;                    \
  599.          zRow[i] = z;                    \
  600.       }                            \
  601.       ffz += fdzdx;                    \
  602.    }                            \
  603. }
  604. #include "tritemp.h"
  605. }
  606.  
  607.  
  608.  
  609. /*
  610.  * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle.
  611.  */
  612. static void smooth_TRUECOLOR_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  613.                                        GLuint v2, GLuint pv )
  614. {
  615.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  616.    XImage *img = xmesa->xm_buffer->backimage;
  617. #define INTERP_RGB 1
  618. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  619. {                                    \
  620.    GLint xx, yy = FLIP(Y);                        \
  621.    for (xx=LEFT;xx<RIGHT;xx++) {                    \
  622.       unsigned long p;                            \
  623.       PACK_TRUECOLOR(p, FixedToInt(ffr), FixedToInt(ffg), FixedToInt(ffb));\
  624.       XPutPixel( img, xx, yy, p );                    \
  625.       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;            \
  626.    }                                    \
  627. }
  628. #include "tritemp.h"
  629. }
  630.  
  631.  
  632. /*
  633.  * XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.
  634.  */
  635. static void smooth_8A8B8G8R_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  636.                       GLuint v2, GLuint pv )
  637. {
  638.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  639. #define INTERP_RGB 1
  640. #define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
  641. #define PIXEL_TYPE GLuint
  642. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  643. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  644. {                                    \
  645.    GLint xx;                                \
  646.    PIXEL_TYPE *pixel = pRow;                        \
  647.    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {                \
  648.       *pixel = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg),        \
  649.                 FixedToInt(ffb) );            \
  650.       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;            \
  651.    }                                    \
  652. }
  653. #include "tritemp.h"
  654. }
  655.  
  656.  
  657. /*
  658.  * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
  659.  */
  660. static void smooth_8R8G8B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  661.                                     GLuint v2, GLuint pv )
  662. {
  663.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  664. #define INTERP_RGB 1
  665. #define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
  666. #define PIXEL_TYPE GLuint
  667. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  668. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  669. {                                    \
  670.    GLint xx;                                \
  671.    PIXEL_TYPE *pixel = pRow;                        \
  672.    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {                \
  673.       *pixel = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg),        \
  674.                 FixedToInt(ffb) );            \
  675.       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;            \
  676.    }                                    \
  677. }
  678. #include "tritemp.h"
  679. }
  680.  
  681.  
  682. /*
  683.  * XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.
  684.  */
  685. static void smooth_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  686.                     GLuint v2, GLuint pv )
  687. {
  688.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  689. #define INTERP_RGB 1
  690. #define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)
  691. #define PIXEL_TYPE GLushort
  692. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  693. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  694. {                                    \
  695.    GLint xx;                                \
  696.    PIXEL_TYPE *pixel = pRow;                        \
  697.    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {                \
  698.       *pixel = PACK_5R6G5B( FixedToInt(ffr), FixedToInt(ffg),        \
  699.                 FixedToInt(ffb) );            \
  700.       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;            \
  701.    }                                    \
  702. }
  703. #include "tritemp.h"
  704. }
  705.  
  706.  
  707. /*
  708.  * XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle.
  709.  */
  710. static void smooth_DITHER8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  711.                      GLuint v2, GLuint pv )
  712. {
  713.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  714. #define INTERP_RGB 1
  715. #define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
  716. #define PIXEL_TYPE GLubyte
  717. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  718. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  719. {                                    \
  720.    GLint xx, yy = FLIP(Y);                        \
  721.    PIXEL_TYPE *pixel = pRow;                        \
  722.    XDITHER_SETUP(yy);                            \
  723.    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {                \
  724.       *pixel = XDITHER( xx, FixedToInt(ffr), FixedToInt(ffg),        \
  725.                 FixedToInt(ffb) );            \
  726.       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;            \
  727.    }                                    \
  728. }
  729. #include "tritemp.h"
  730. }
  731.  
  732.  
  733. /*
  734.  * XImage, smooth, NON-depth-buffered, PF_DITHER triangle.
  735.  */
  736. static void smooth_DITHER_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  737.                                     GLuint v2, GLuint pv )
  738. {
  739.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  740.    XImage *img = xmesa->xm_buffer->backimage;
  741. #define INTERP_RGB 1
  742. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  743. {                                    \
  744.    GLint xx, yy = FLIP(Y);                        \
  745.    XDITHER_SETUP(yy);                            \
  746.    for (xx=LEFT;xx<RIGHT;xx++) {                    \
  747.       unsigned long p = XDITHER( xx, FixedToInt(ffr),            \
  748.                 FixedToInt(ffg), FixedToInt(ffb) );    \
  749.       XPutPixel( img, xx, yy, p );                    \
  750.       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;            \
  751.    }                                    \
  752. }
  753. #include "tritemp.h"
  754. }
  755.  
  756.  
  757. /*
  758.  * XImage, smooth, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
  759.  */
  760. static void smooth_LOOKUP8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  761.                                      GLuint v2, GLuint pv )
  762. {
  763.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  764. #define INTERP_RGB 1
  765. #define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
  766. #define PIXEL_TYPE GLubyte
  767. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  768. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  769. {                                    \
  770.    GLint xx;                                \
  771.    PIXEL_TYPE *pixel = pRow;                        \
  772.    LOOKUP_SETUP;                            \
  773.    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {                \
  774.       *pixel = LOOKUP( FixedToInt(ffr), FixedToInt(ffg),        \
  775.             FixedToInt(ffb) );                \
  776.       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;            \
  777.    }                                    \
  778. }
  779. #include "tritemp.h"
  780. }
  781.  
  782.  
  783.  
  784. /*
  785.  * XImage, smooth, NON-depth-buffered, 8-bit PF_HPCR triangle.
  786.  */
  787. static void smooth_HPCR_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  788.                                   GLuint v2, GLuint pv )
  789. {
  790.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  791. #define INTERP_RGB 1
  792. #define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
  793. #define PIXEL_TYPE GLubyte
  794. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  795. #define INNER_LOOP( LEFT, RIGHT, Y )                    \
  796. {                                    \
  797.    GLint xx, yy = FLIP(Y);                        \
  798.    PIXEL_TYPE *pixel = pRow;                        \
  799.    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {                \
  800.       *pixel = DITHER_HPCR( xx, yy, FixedToInt(ffr),            \
  801.                 FixedToInt(ffg), FixedToInt(ffb) );    \
  802.       ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;            \
  803.    }                                    \
  804. }
  805. #include "tritemp.h"
  806. }
  807.  
  808.  
  809. /*
  810.  * XImage, flat, NON-depth-buffered, PF_TRUECOLOR triangle.
  811.  */
  812. static void flat_TRUECOLOR_triangle( GLcontext *ctx, GLuint v0,
  813.                                      GLuint v1, GLuint v2, GLuint pv )
  814. {
  815.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  816.    XImage *img = xmesa->xm_buffer->backimage;
  817. #define SETUP_CODE                        \
  818.    unsigned long pixel;                        \
  819.    PACK_TRUECOLOR(pixel, VB->Color[pv][0], VB->Color[pv][1], VB->Color[pv][2]);
  820.  
  821. #define INNER_LOOP( LEFT, RIGHT, Y )                \
  822. {                                \
  823.    GLint xx, yy = FLIP(Y);                    \
  824.    for (xx=LEFT;xx<RIGHT;xx++) {                \
  825.       XPutPixel( img, xx, yy, pixel );                \
  826.    }                                \
  827. }
  828. #include "tritemp.h"
  829. }
  830.  
  831.  
  832. /*
  833.  * XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.
  834.  */
  835. static void flat_8A8B8G8R_triangle( GLcontext *ctx, GLuint v0,
  836.                                 GLuint v1, GLuint v2, GLuint pv )
  837. {
  838.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  839. #define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
  840. #define PIXEL_TYPE GLuint
  841. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  842. #define SETUP_CODE                    \
  843.    unsigned long p = PACK_8B8G8R( VB->Color[pv][0],    \
  844.          VB->Color[pv][1], VB->Color[pv][2] );
  845. #define INNER_LOOP( LEFT, RIGHT, Y )            \
  846. {                            \
  847.    GLint xx;                        \
  848.    PIXEL_TYPE *pixel = pRow;                \
  849.    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {        \
  850.       *pixel = p;                    \
  851.    }                            \
  852. }
  853. #include "tritemp.h"
  854. }
  855.  
  856.  
  857. /*
  858.  * XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.
  859.  */
  860. static void flat_8R8G8B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  861.                                   GLuint v2, GLuint pv )
  862. {
  863.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  864. #define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
  865. #define PIXEL_TYPE GLuint
  866. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  867. #define SETUP_CODE                    \
  868.    unsigned long p = PACK_8R8G8B( VB->Color[pv][0],    \
  869.          VB->Color[pv][1], VB->Color[pv][2] );
  870. #define INNER_LOOP( LEFT, RIGHT, Y )            \
  871. {                            \
  872.    GLint xx;                        \
  873.    PIXEL_TYPE *pixel = pRow;                \
  874.    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {        \
  875.       *pixel = p;                    \
  876.    }                            \
  877. }
  878. #include "tritemp.h"
  879. }
  880.  
  881.  
  882. /*
  883.  * XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.
  884.  */
  885. static void flat_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  886.                                   GLuint v2, GLuint pv )
  887. {
  888.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  889. #define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)
  890. #define PIXEL_TYPE GLushort
  891. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  892. #define SETUP_CODE                    \
  893.    unsigned long p = PACK_5R6G5B( VB->Color[pv][0],    \
  894.          VB->Color[pv][1], VB->Color[pv][2] );
  895. #define INNER_LOOP( LEFT, RIGHT, Y )            \
  896. {                            \
  897.    GLint xx;                        \
  898.    PIXEL_TYPE *pixel = pRow;                \
  899.    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {        \
  900.       *pixel = p;                    \
  901.    }                            \
  902. }
  903. #include "tritemp.h"
  904. }
  905.  
  906.  
  907. /*
  908.  * XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle.
  909.  */
  910. static void flat_DITHER8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  911.                                    GLuint v2, GLuint pv )
  912. {
  913.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  914. #define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
  915. #define PIXEL_TYPE GLubyte
  916. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  917. #define SETUP_CODE    \
  918.    FLAT_DITHER_SETUP( VB->Color[pv][0], VB->Color[pv][1], VB->Color[pv][2] );
  919.  
  920. #define INNER_LOOP( LEFT, RIGHT, Y )            \
  921. {                            \
  922.    GLint xx;                        \
  923.    PIXEL_TYPE *pixel = pRow;                \
  924.    FLAT_DITHER_ROW_SETUP(FLIP(Y));            \
  925.    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {        \
  926.       *pixel = FLAT_DITHER(xx);                \
  927.    }                            \
  928. }
  929. #include "tritemp.h"
  930. }
  931.  
  932.  
  933. /*
  934.  * XImage, flat, NON-depth-buffered, PF_DITHER triangle.
  935.  */
  936. static void flat_DITHER_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  937.                                   GLuint v2, GLuint pv )
  938. {
  939.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  940.    XImage *img = xmesa->xm_buffer->backimage;
  941. #define SETUP_CODE    \
  942.    FLAT_DITHER_SETUP( VB->Color[pv][0], VB->Color[pv][1], VB->Color[pv][2] );
  943.  
  944. #define INNER_LOOP( LEFT, RIGHT, Y )            \
  945. {                            \
  946.    GLint xx, yy = FLIP(Y);                \
  947.    FLAT_DITHER_ROW_SETUP(yy);                \
  948.    for (xx=LEFT;xx<RIGHT;xx++) {            \
  949.       unsigned long p = FLAT_DITHER(xx);        \
  950.       XPutPixel( img, xx, yy, p );            \
  951.    }                            \
  952. }
  953. #include "tritemp.h"
  954. }
  955.  
  956.  
  957. /*
  958.  * XImage, flat, NON-depth-buffered, 8-bit PF_HPCR triangle.
  959.  */
  960. static void flat_HPCR_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  961.                                 GLuint v2, GLuint pv )
  962. {
  963.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  964. #define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
  965. #define PIXEL_TYPE GLubyte
  966. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  967. #define SETUP_CODE                \
  968.    GLubyte r = VB->Color[pv][0];        \
  969.    GLubyte g = VB->Color[pv][1];        \
  970.    GLubyte b = VB->Color[pv][2];
  971. #define INNER_LOOP( LEFT, RIGHT, Y )        \
  972. {                        \
  973.    GLint xx, yy = FLIP(Y);            \
  974.    PIXEL_TYPE *pixel = pRow;            \
  975.    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {    \
  976.       *pixel = DITHER_HPCR( xx, yy, r, g, b );    \
  977.    }                        \
  978. }
  979. #include "tritemp.h"
  980. }
  981.  
  982.  
  983. /*
  984.  * XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
  985.  */
  986. static void flat_LOOKUP8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
  987.                                GLuint v2, GLuint pv )
  988. {
  989.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  990. #define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
  991. #define PIXEL_TYPE GLubyte
  992. #define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
  993. #define SETUP_CODE                \
  994.    LOOKUP_SETUP;                \
  995.    GLubyte r = VB->Color[pv][0];        \
  996.    GLubyte g = VB->Color[pv][1];        \
  997.    GLubyte b = VB->Color[pv][2];        \
  998.    GLubyte p = LOOKUP(r,g,b);
  999. #define INNER_LOOP( LEFT, RIGHT, Y )        \
  1000. {                        \
  1001.    GLint xx;                    \
  1002.    PIXEL_TYPE *pixel = pRow;            \
  1003.    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {    \
  1004.       *pixel = p;                \
  1005.    }                        \
  1006. }
  1007. #include "tritemp.h"
  1008. }
  1009.  
  1010.  
  1011.  
  1012.  
  1013. /*
  1014.  * This function is called if we're about to render triangles into an
  1015.  * X window/pixmap.  It sets the polygon stipple pattern if enabled.
  1016.  */
  1017. static void setup_x_polygon_options( GLcontext *ctx )
  1018. {
  1019.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  1020.    int fill_type;
  1021.  
  1022.    if (ctx->Polygon.StippleFlag) {
  1023.       if (xmesa->xm_buffer->stipple_pixmap == 0) {
  1024.          /* Allocate polygon stippling stuff once for this context. */
  1025.          XGCValues values;
  1026.          XMesaBuffer b = xmesa->xm_buffer;
  1027.          b->stipple_pixmap = XCreatePixmap( xmesa->display,
  1028.                                             b->buffer, 32, 32, 1 );
  1029.          values.function = GXcopy;
  1030.          values.foreground = 1;
  1031.          values.background = 0;
  1032.          b->stipple_gc = XCreateGC( xmesa->display, b->stipple_pixmap,
  1033.                                     (GCFunction|GCForeground|GCBackground),
  1034.                                     &values );
  1035.       }
  1036.  
  1037.       /*
  1038.        * NOTE: We don't handle the following here!
  1039.        *    GL_UNPACK_SWAP_BYTES
  1040.        *    GL_UNPACK_LSB_FIRST
  1041.        */
  1042.       /* Copy Mesa stipple pattern to an XImage then to Pixmap */
  1043.       {
  1044.          XImage *stipple_ximage;
  1045.          GLuint stipple[32];
  1046.          int i;
  1047.          int shift = xmesa->xm_buffer->height % 32;
  1048.          for (i=0;i<32;i++) {
  1049.             stipple[31-i] = ctx->PolygonStipple[(i+shift) % 32];
  1050.          }
  1051.          stipple_ximage = XCreateImage( xmesa->display,
  1052.                                         xmesa->xm_visual->visinfo->visual,
  1053.                                         1, ZPixmap, 0,
  1054.                                         (char *)stipple,
  1055.                                         32, 32, 8, 0 );
  1056.          stipple_ximage->byte_order = LSBFirst;
  1057.          stipple_ximage->bitmap_bit_order = LSBFirst;
  1058.          stipple_ximage->bitmap_unit = 32;
  1059.          XPutImage( xmesa->display,
  1060.                     xmesa->xm_buffer->stipple_pixmap,
  1061.                     xmesa->xm_buffer->stipple_gc,
  1062.                     stipple_ximage, 0, 0, 0, 0, 32, 32 );
  1063.          stipple_ximage->data = NULL;
  1064.          XDestroyImage( stipple_ximage );
  1065.       }
  1066.  
  1067.       XSetStipple( xmesa->display, xmesa->xm_buffer->gc1,
  1068.                    xmesa->xm_buffer->stipple_pixmap );
  1069.       XSetStipple( xmesa->display, xmesa->xm_buffer->gc2,
  1070.                    xmesa->xm_buffer->stipple_pixmap );
  1071.       fill_type = FillStippled;
  1072.    }
  1073.    else {
  1074.       fill_type = FillSolid;
  1075.    }
  1076.  
  1077.    XSetFillStyle( xmesa->display, xmesa->xm_buffer->gc1, fill_type );
  1078.    XSetFillStyle( xmesa->display, xmesa->xm_buffer->gc2, fill_type );
  1079. }
  1080.  
  1081.  
  1082.  
  1083. triangle_func xmesa_get_triangle_func( GLcontext *ctx )
  1084. {
  1085.    XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
  1086.    int depth = xmesa->xm_visual->visinfo->depth;
  1087.  
  1088.    if (ctx->Polygon.SmoothFlag)     return NULL;
  1089.    if (ctx->Texture.Enabled)        return NULL;
  1090.  
  1091.    if (xmesa->xm_buffer->buffer==XIMAGE) {
  1092.       if (   ctx->Light.ShadeModel==GL_SMOOTH
  1093.           && ctx->RasterMask==DEPTH_BIT
  1094.           && ctx->Depth.Func==GL_LESS
  1095.           && ctx->Depth.Mask==GL_TRUE
  1096.           && ctx->Polygon.StippleFlag==GL_FALSE) {
  1097.          switch (xmesa->pixelformat) {
  1098.             case PF_TRUECOLOR:
  1099.            return smooth_TRUECOLOR_z_triangle;
  1100.             case PF_8A8B8G8R:
  1101.                return smooth_8A8B8G8R_z_triangle;
  1102.             case PF_8R8G8B:
  1103.                return smooth_8R8G8B_z_triangle;
  1104.             case PF_5R6G5B:
  1105.                return smooth_5R6G5B_z_triangle;
  1106.             case PF_HPCR:
  1107.            return smooth_HPCR_z_triangle;
  1108.             case PF_DITHER:
  1109.                return (depth==8) ? smooth_DITHER8_z_triangle
  1110.                                         : smooth_DITHER_z_triangle;
  1111.             case PF_LOOKUP:
  1112.                return (depth==8) ? smooth_LOOKUP8_z_triangle : NULL;
  1113.             default:
  1114.                return NULL;
  1115.          }
  1116.       }
  1117.       if (   ctx->Light.ShadeModel==GL_FLAT
  1118.           && ctx->RasterMask==DEPTH_BIT
  1119.           && ctx->Depth.Func==GL_LESS
  1120.           && ctx->Depth.Mask==GL_TRUE
  1121.           && ctx->Polygon.StippleFlag==GL_FALSE) {
  1122.          switch (xmesa->pixelformat) {
  1123.             case PF_TRUECOLOR:
  1124.            return flat_TRUECOLOR_z_triangle;
  1125.             case PF_8A8B8G8R:
  1126.                return flat_8A8B8G8R_z_triangle;
  1127.             case PF_8R8G8B:
  1128.                return flat_8R8G8B_z_triangle;
  1129.             case PF_5R6G5B:
  1130.                return flat_5R6G5B_z_triangle;
  1131.             case PF_HPCR:
  1132.            return flat_HPCR_z_triangle;
  1133.             case PF_DITHER:
  1134.                return (depth==8) ? flat_DITHER8_z_triangle
  1135.                                         : flat_DITHER_z_triangle;
  1136.             case PF_LOOKUP:
  1137.                return (depth==8) ? flat_LOOKUP8_z_triangle : NULL;
  1138.             default:
  1139.                return NULL;
  1140.          }
  1141.       }
  1142.       if (   ctx->RasterMask==0   /* no depth test */
  1143.           && ctx->Light.ShadeModel==GL_SMOOTH
  1144.           && ctx->Polygon.StippleFlag==GL_FALSE) {
  1145.          switch (xmesa->pixelformat) {
  1146.             case PF_TRUECOLOR:
  1147.            return smooth_TRUECOLOR_triangle;
  1148.             case PF_8A8B8G8R:
  1149.                return smooth_8A8B8G8R_triangle;
  1150.             case PF_8R8G8B:
  1151.                return smooth_8R8G8B_triangle;
  1152.             case PF_5R6G5B:
  1153.                return smooth_5R6G5B_triangle;
  1154.             case PF_HPCR:
  1155.            return smooth_HPCR_triangle;
  1156.             case PF_DITHER:
  1157.                return (depth==8) ? smooth_DITHER8_triangle
  1158.                                         : smooth_DITHER_triangle;
  1159.             case PF_LOOKUP:
  1160.                return (depth==8) ? smooth_LOOKUP8_triangle : NULL;
  1161.             default:
  1162.                return NULL;
  1163.          }
  1164.       }
  1165.  
  1166.       if (   ctx->RasterMask==0   /* no depth test */
  1167.           && ctx->Light.ShadeModel==GL_FLAT
  1168.           && ctx->Polygon.StippleFlag==GL_FALSE) {
  1169.          switch (xmesa->pixelformat) {
  1170.             case PF_TRUECOLOR:
  1171.            return flat_TRUECOLOR_triangle;
  1172.             case PF_8A8B8G8R:
  1173.                return flat_8A8B8G8R_triangle;
  1174.             case PF_8R8G8B:
  1175.                return flat_8R8G8B_triangle;
  1176.             case PF_5R6G5B:
  1177.                return flat_5R6G5B_triangle;
  1178.             case PF_HPCR:
  1179.            return flat_HPCR_triangle;
  1180.             case PF_DITHER:
  1181.                return (depth==8) ? flat_DITHER8_triangle
  1182.                                         : flat_DITHER_triangle;
  1183.             case PF_LOOKUP:
  1184.                return (depth==8) ? flat_LOOKUP8_triangle : NULL;
  1185.             default:
  1186.                return NULL;
  1187.          }
  1188.       }
  1189.  
  1190.       return NULL;
  1191.    }
  1192.    else {
  1193.       /* pixmap */
  1194.       if (ctx->Light.ShadeModel==GL_FLAT && ctx->RasterMask==0) {
  1195.          setup_x_polygon_options( ctx );
  1196.          return flat_pixmap_triangle;
  1197.       }
  1198.       return NULL;
  1199.    }
  1200. }
  1201.