aboutsummaryrefslogtreecommitdiffstats
path: root/src/mesa/drivers/x11
diff options
context:
space:
mode:
authorBrian Paul <[email protected]>2000-09-07 15:40:30 +0000
committerBrian Paul <[email protected]>2000-09-07 15:40:30 +0000
commit693f81be4c16bcec4e017e9b3189f518d157d85f (patch)
treef3d755de6bcabd38d62cfd1b648660b92eb60c3c /src/mesa/drivers/x11
parent38d3f3d660225150715bc06f6b33e394ba803299 (diff)
newly organized Xlib driver files
Diffstat (limited to 'src/mesa/drivers/x11')
-rw-r--r--src/mesa/drivers/x11/xm_api.c2624
-rw-r--r--src/mesa/drivers/x11/xm_dd.c1006
-rw-r--r--src/mesa/drivers/x11/xm_line.c748
-rw-r--r--src/mesa/drivers/x11/xm_span.c4447
-rw-r--r--src/mesa/drivers/x11/xm_tri.c1690
5 files changed, 10515 insertions, 0 deletions
diff --git a/src/mesa/drivers/x11/xm_api.c b/src/mesa/drivers/x11/xm_api.c
new file mode 100644
index 00000000000..88650d675ad
--- /dev/null
+++ b/src/mesa/drivers/x11/xm_api.c
@@ -0,0 +1,2624 @@
+/* $Id: xm_api.c,v 1.1 2000/09/07 15:40:30 brianp Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.3
+ *
+ * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/*
+ * This file contains the implementations of all the XMesa* functions.
+ *
+ *
+ * NOTES:
+ *
+ * The window coordinate system origin (0,0) is in the lower-left corner
+ * of the window. X11's window coordinate origin is in the upper-left
+ * corner of the window. Therefore, most drawing functions in this
+ * file have to flip Y coordinates.
+ *
+ * Define USE_XSHM in the Makefile with -DUSE_XSHM if you want to compile
+ * in support for the MIT Shared Memory extension. If enabled, when you
+ * use an Ximage for the back buffer in double buffered mode, the "swap"
+ * operation will be faster. You must also link with -lXext.
+ *
+ * Byte swapping: If the Mesa host and the X display use a different
+ * byte order then there's some trickiness to be aware of when using
+ * XImages. The byte ordering used for the XImage is that of the X
+ * display, not the Mesa host.
+ * The color-to-pixel encoding for True/DirectColor must be done
+ * according to the display's visual red_mask, green_mask, and blue_mask.
+ * If XPutPixel is used to put a pixel into an XImage then XPutPixel will
+ * do byte swapping if needed. If one wants to directly "poke" the pixel
+ * into the XImage's buffer then the pixel must be byte swapped first. In
+ * Mesa, when byte swapping is needed we use the PF_TRUECOLOR pixel format
+ * and use XPutPixel everywhere except in the implementation of
+ * glClear(GL_COLOR_BUFFER_BIT). We want this function to be fast so
+ * instead of using XPutPixel we "poke" our values after byte-swapping
+ * the clear pixel value if needed.
+ *
+ */
+
+#ifdef __CYGWIN__
+#undef WIN32
+#undef __WIN32__
+#endif
+
+#include "glxheader.h"
+#include "GL/xmesa.h"
+#include "xmesaP.h"
+#include "context.h"
+#include "extensions.h"
+#include "glthread.h"
+#include "matrix.h"
+#include "mem.h"
+#include "types.h"
+#ifdef HAVE_CONFIG_H
+#include "conf.h"
+#endif
+
+
+#ifndef GLX_NONE_EXT
+#define GLX_NONE_EXT 0x8000
+#endif
+
+
+/*
+ * Global X driver lock
+ */
+_glthread_Mutex _xmesa_lock;
+
+
+
+/*
+ * Lookup tables for HPCR pixel format:
+ */
+static short hpcr_rgbTbl[3][256] = {
+{
+ 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23,
+ 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 30, 30, 31, 31,
+ 32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39,
+ 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+ 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+ 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+ 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
+128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
+144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
+160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
+176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
+208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
+224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239
+},
+{
+ 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23,
+ 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 30, 30, 31, 31,
+ 32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39,
+ 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+ 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+ 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+ 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
+128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
+144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
+160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
+176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
+208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
+224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239
+},
+{
+ 32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39,
+ 40, 40, 41, 41, 42, 42, 43, 43, 44, 44, 45, 45, 46, 46, 47, 47,
+ 48, 48, 49, 49, 50, 50, 51, 51, 52, 52, 53, 53, 54, 54, 55, 55,
+ 56, 56, 57, 57, 58, 58, 59, 59, 60, 60, 61, 61, 62, 62, 63, 63,
+ 64, 64, 65, 65, 66, 66, 67, 67, 68, 68, 69, 69, 70, 70, 71, 71,
+ 72, 72, 73, 73, 74, 74, 75, 75, 76, 76, 77, 77, 78, 78, 79, 79,
+ 80, 80, 81, 81, 82, 82, 83, 83, 84, 84, 85, 85, 86, 86, 87, 87,
+ 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+ 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
+128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
+144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
+160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
+176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
+208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223
+}
+};
+
+
+
+/**********************************************************************/
+/***** X Utility Functions *****/
+/**********************************************************************/
+
+
+/*
+ * X/Mesa error reporting function:
+ */
+static void error( const char *msg )
+{
+ if (getenv("MESA_DEBUG"))
+ fprintf( stderr, "X/Mesa error: %s\n", msg );
+}
+
+
+/*
+ * Return the host's byte order as LSBFirst or MSBFirst ala X.
+ */
+#ifndef XFree86Server
+static int host_byte_order( void )
+{
+ int i = 1;
+ char *cptr = (char *) &i;
+ return (*cptr==1) ? LSBFirst : MSBFirst;
+}
+#endif
+
+
+/*
+ * Error handling.
+ */
+#ifndef XFree86Server
+static int mesaXErrorFlag = 0;
+
+static int mesaHandleXError( XMesaDisplay *dpy, XErrorEvent *event )
+{
+ (void) dpy;
+ (void) event;
+ mesaXErrorFlag = 1;
+ return 0;
+}
+#endif
+
+
+/*
+ * Check if the X Shared Memory extension is available.
+ * Return: 0 = not available
+ * 1 = shared XImage support available
+ * 2 = shared Pixmap support available also
+ */
+#ifndef XFree86Server
+static int check_for_xshm( XMesaDisplay *display )
+{
+#ifdef USE_XSHM
+ int major, minor, ignore;
+ Bool pixmaps;
+
+ if (XQueryExtension( display, "MIT-SHM", &ignore, &ignore, &ignore )) {
+ if (XShmQueryVersion( display, &major, &minor, &pixmaps )==True) {
+ return (pixmaps==True) ? 2 : 1;
+ }
+ else {
+ return 0;
+ }
+ }
+ else {
+ return 0;
+ }
+#else
+ /* Can't compile XSHM support */
+ return 0;
+#endif
+}
+#endif
+
+
+/*
+ * Return the width and height of the given drawable.
+ */
+static void get_drawable_size( XMesaDisplay *dpy, XMesaDrawable d,
+ unsigned int *width, unsigned int *height)
+{
+#ifdef XFree86Server
+ (void) dpy;
+ *width = d->width;
+ *height = d->height;
+#else
+ Window root;
+ int x, y;
+ unsigned int bw, depth;
+
+ _glthread_LOCK_MUTEX(_xmesa_lock);
+ XGetGeometry( dpy, d, &root, &x, &y, width, height, &bw, &depth );
+ _glthread_UNLOCK_MUTEX(_xmesa_lock);
+#endif
+}
+
+
+/*
+ * Apply gamma correction to an intensity value in [0..max]. Return the
+ * new intensity value.
+ */
+static GLint gamma_adjust( GLfloat gamma, GLint value, GLint max )
+{
+ if (gamma == 1.0) {
+ return value;
+ }
+ else {
+ double x = (double) value / (double) max;
+ return (GLint) ((GLfloat) max * pow( x, 1.0F/gamma ) + 0.5F);
+ }
+}
+
+
+
+/*
+ * Return the true number of bits per pixel for XImages.
+ * For example, if we request a 24-bit deep visual we may actually need/get
+ * 32bpp XImages. This function returns the appropriate bpp.
+ * Input: dpy - the X display
+ * visinfo - desribes the visual to be used for XImages
+ * Return: true number of bits per pixel for XImages
+ */
+#define GET_BITS_PER_PIXEL(xmv) bits_per_pixel(xmv)
+
+#ifdef XFree86Server
+
+static int bits_per_pixel( XMesaVisual xmv )
+{
+ XMesaVisualInfo visinfo = xmv->visinfo;
+ const int depth = visinfo->nplanes;
+ int i;
+ for (i = 0; i < screenInfo.numPixmapFormats; i++) {
+ if (screenInfo.formats[i].depth == depth)
+ return screenInfo.formats[i].bitsPerPixel;
+ }
+ return depth; /* should never get here, but this should be safe */
+}
+
+#else
+
+static int bits_per_pixel( XMesaVisual xmv )
+{
+ XMesaDisplay *dpy = xmv->display;
+ XMesaVisualInfo visinfo = xmv->visinfo;
+ XMesaImage *img;
+ int bitsPerPixel;
+ /* Create a temporary XImage */
+ img = XCreateImage( dpy, visinfo->visual, visinfo->depth,
+ ZPixmap, 0, /*format, offset*/
+ (char*) MALLOC(8), /*data*/
+ 1, 1, /*width, height*/
+ 32, /*bitmap_pad*/
+ 0 /*bytes_per_line*/
+ );
+ assert(img);
+ /* grab the bits/pixel value */
+ bitsPerPixel = img->bits_per_pixel;
+ /* free the XImage */
+ FREE( img->data );
+ img->data = NULL;
+ XMesaDestroyImage( img );
+ return bitsPerPixel;
+}
+#endif
+
+
+
+/*
+ * Determine if a given X window ID is valid (window exists).
+ * Do this by calling XGetWindowAttributes() for the window and
+ * checking if we catch an X error.
+ * Input: dpy - the display
+ * win - the window to check for existance
+ * Return: GL_TRUE - window exists
+ * GL_FALSE - window doesn't exist
+ */
+#ifndef XFree86Server
+static GLboolean WindowExistsFlag;
+
+static int window_exists_err_handler( XMesaDisplay* dpy, XErrorEvent* xerr )
+{
+ (void) dpy;
+ if (xerr->error_code == BadWindow) {
+ WindowExistsFlag = GL_FALSE;
+ }
+ return 0;
+}
+
+static GLboolean window_exists( XMesaDisplay *dpy, Window win )
+{
+ XWindowAttributes wa;
+ int (*old_handler)( XMesaDisplay*, XErrorEvent* );
+ WindowExistsFlag = GL_TRUE;
+ old_handler = XSetErrorHandler(window_exists_err_handler);
+ XGetWindowAttributes( dpy, win, &wa ); /* dummy request */
+ XSetErrorHandler(old_handler);
+ return WindowExistsFlag;
+}
+#endif
+
+
+
+/**********************************************************************/
+/***** Linked list of XMesaBuffers *****/
+/**********************************************************************/
+
+static XMesaBuffer XMesaBufferList = NULL;
+
+
+/* Allocate a new XMesaBuffer, add to linked list */
+static XMesaBuffer alloc_xmesa_buffer(void)
+{
+ XMesaBuffer b = (XMesaBuffer) CALLOC_STRUCT(xmesa_buffer);
+ if (b) {
+ b->Next = XMesaBufferList;
+ XMesaBufferList = b;
+ }
+ return b;
+}
+
+
+/*
+ * Find an XMesaBuffer by matching X display and colormap but NOT matching
+ * the notThis buffer.
+ */
+static XMesaBuffer find_xmesa_buffer(XMesaDisplay *dpy,
+ XMesaColormap cmap,
+ XMesaBuffer notThis)
+{
+ XMesaBuffer b;
+ for (b=XMesaBufferList; b; b=b->Next) {
+ if (b->display==dpy && b->cmap==cmap && b!=notThis) {
+ return b;
+ }
+ }
+ return NULL;
+}
+
+
+/*
+ * Free an XMesaBuffer, remove from linked list, perhaps free X colormap
+ * entries.
+ */
+static void free_xmesa_buffer(int client, XMesaBuffer buffer)
+{
+ XMesaBuffer prev = NULL, b;
+ (void) client;
+ for (b=XMesaBufferList; b; b=b->Next) {
+ if (b==buffer) {
+ /* unlink bufer from list */
+ if (prev)
+ prev->Next = buffer->Next;
+ else
+ XMesaBufferList = buffer->Next;
+ /* Check to free X colors */
+ if (buffer->num_alloced>0) {
+ /* If no other buffer uses this X colormap then free the colors. */
+ if (!find_xmesa_buffer(buffer->display, buffer->cmap, buffer)) {
+#ifdef XFree86Server
+ (void)FreeColors(buffer->cmap, client,
+ buffer->num_alloced, buffer->alloced_colors,
+ 0);
+#else
+ XFreeColors(buffer->display, buffer->cmap,
+ buffer->alloced_colors, buffer->num_alloced, 0);
+#endif
+ }
+ }
+ FREE(buffer);
+ return;
+ }
+ /* continue search */
+ prev = b;
+ }
+ /* buffer not found in XMesaBufferList */
+ gl_problem(NULL,"free_xmesa_buffer() - buffer not found\n");
+}
+
+
+/* Copy X color table stuff from one XMesaBuffer to another. */
+static void copy_colortable_info(XMesaBuffer dst, const XMesaBuffer src)
+{
+ MEMCPY(dst->color_table, src->color_table, sizeof(src->color_table));
+ MEMCPY(dst->pixel_to_r, src->pixel_to_r, sizeof(src->pixel_to_r));
+ MEMCPY(dst->pixel_to_g, src->pixel_to_g, sizeof(src->pixel_to_g));
+ MEMCPY(dst->pixel_to_b, src->pixel_to_b, sizeof(src->pixel_to_b));
+ dst->num_alloced = src->num_alloced;
+ MEMCPY(dst->alloced_colors, src->alloced_colors,
+ sizeof(src->alloced_colors));
+}
+
+
+
+/**********************************************************************/
+/***** Misc Private Functions *****/
+/**********************************************************************/
+
+
+/*
+ * Return number of bits set in n.
+ */
+static int bitcount( unsigned long n )
+{
+ int bits;
+ for (bits=0; n>0; n=n>>1) {
+ if (n&1) {
+ bits++;
+ }
+ }
+ return bits;
+}
+
+
+
+/*
+ * Allocate a shared memory XImage back buffer for the given XMesaBuffer.
+ * Return: GL_TRUE if success, GL_FALSE if error
+ */
+#ifndef XFree86Server
+static GLboolean alloc_shm_back_buffer( XMesaBuffer b )
+{
+#ifdef USE_XSHM
+ /*
+ * We have to do a _lot_ of error checking here to be sure we can
+ * really use the XSHM extension. It seems different servers trigger
+ * errors at different points if the extension won't work. Therefore
+ * we have to be very careful...
+ */
+ GC gc;
+ int (*old_handler)( XMesaDisplay *, XErrorEvent * );
+
+ b->backimage = XShmCreateImage( b->xm_visual->display,
+ b->xm_visual->visinfo->visual,
+ b->xm_visual->visinfo->depth,
+ ZPixmap, NULL, &b->shminfo,
+ b->width, b->height );
+ if (b->backimage == NULL) {
+ error("alloc_back_buffer: Shared memory error (XShmCreateImage), disabling.");
+ b->shm = 0;
+ return GL_FALSE;
+ }
+
+ b->shminfo.shmid = shmget( IPC_PRIVATE, b->backimage->bytes_per_line
+ * b->backimage->height, IPC_CREAT|0777 );
+ if (b->shminfo.shmid < 0) {
+ if (getenv("MESA_DEBUG"))
+ perror("alloc_back_buffer");
+ XDestroyImage( b->backimage );
+ b->backimage = NULL;
+ error("alloc_back_buffer: Shared memory error (shmget), disabling.");
+ b->shm = 0;
+ return GL_FALSE;
+ }
+
+ b->shminfo.shmaddr = b->backimage->data
+ = (char*)shmat( b->shminfo.shmid, 0, 0 );
+ if (b->shminfo.shmaddr == (char *) -1) {
+ if (getenv("MESA_DEBUG"))
+ perror("alloc_back_buffer");
+ XDestroyImage( b->backimage );
+ shmctl( b->shminfo.shmid, IPC_RMID, 0 );
+ b->backimage = NULL;
+ error("alloc_back_buffer: Shared memory error (shmat), disabling.");
+ b->shm = 0;
+ return GL_FALSE;
+ }
+
+ b->shminfo.readOnly = False;
+ mesaXErrorFlag = 0;
+ old_handler = XSetErrorHandler( mesaHandleXError );
+ /* This may trigger the X protocol error we're ready to catch: */
+ XShmAttach( b->xm_visual->display, &b->shminfo );
+ XSync( b->xm_visual->display, False );
+
+ if (mesaXErrorFlag) {
+ /* we are on a remote display, this error is normal, don't print it */
+ XFlush( b->xm_visual->display );
+ mesaXErrorFlag = 0;
+ XDestroyImage( b->backimage );
+ shmdt( b->shminfo.shmaddr );
+ shmctl( b->shminfo.shmid, IPC_RMID, 0 );
+ b->backimage = NULL;
+ b->shm = 0;
+ (void) XSetErrorHandler( old_handler );
+ return GL_FALSE;
+ }
+
+ shmctl( b->shminfo.shmid, IPC_RMID, 0 ); /* nobody else needs it */
+
+ /* Finally, try an XShmPutImage to be really sure the extension works */
+ gc = XCreateGC( b->xm_visual->display, b->frontbuffer, 0, NULL );
+ XShmPutImage( b->xm_visual->display, b->frontbuffer, gc,
+ b->backimage, 0, 0, 0, 0, 1, 1 /*one pixel*/, False );
+ XSync( b->xm_visual->display, False );
+ XFreeGC( b->xm_visual->display, gc );
+ (void) XSetErrorHandler( old_handler );
+ if (mesaXErrorFlag) {
+ XFlush( b->xm_visual->display );
+ mesaXErrorFlag = 0;
+ XDestroyImage( b->backimage );
+ shmdt( b->shminfo.shmaddr );
+ shmctl( b->shminfo.shmid, IPC_RMID, 0 );
+ b->backimage = NULL;
+ b->shm = 0;
+ return GL_FALSE;
+ }
+
+ if (b->backimage) {
+ int height = b->backimage->height;
+ /* Needed by PIXELADDR1 macro */
+ b->ximage_width1 = b->backimage->bytes_per_line;
+ b->ximage_origin1 = (GLubyte *) b->backimage->data
+ + b->ximage_width1 * (height-1);
+ /* Needed by PIXELADDR2 macro */
+ b->ximage_width2 = b->backimage->bytes_per_line / 2;
+ b->ximage_origin2 = (GLushort *) b->backimage->data
+ + b->ximage_width2 * (height-1);
+ /* Needed by PIXELADDR3 macro */
+ b->ximage_width3 = b->backimage->bytes_per_line;
+ b->ximage_origin3 = (GLubyte *) b->backimage->data
+ + b->ximage_width3 * (height-1);
+ /* Needed by PIXELADDR4 macro */
+ b->ximage_width4 = b->backimage->width;
+ b->ximage_origin4 = (GLuint *) b->backimage->data
+ + b->ximage_width4 * (height-1);
+ }
+
+ return GL_TRUE;
+#else
+ /* Can't compile XSHM support */
+ return GL_FALSE;
+#endif
+}
+#endif
+
+
+
+/*
+ * Setup an off-screen pixmap or Ximage to use as the back buffer.
+ * Input: b - the X/Mesa buffer
+ */
+void xmesa_alloc_back_buffer( XMesaBuffer b )
+{
+ if (b->db_state==BACK_XIMAGE) {
+ /* Deallocate the old backimage, if any */
+ if (b->backimage) {
+#if defined(USE_XSHM) && !defined(XFree86Server)
+ if (b->shm) {
+ XShmDetach( b->xm_visual->display, &b->shminfo );
+ XDestroyImage( b->backimage );
+ shmdt( b->shminfo.shmaddr );
+ }
+ else
+#endif
+ XMesaDestroyImage( b->backimage );
+ b->backimage = NULL;
+ }
+
+ /* Allocate new back buffer */
+#ifdef XFree86Server
+ {
+ /* Allocate a regular XImage for the back buffer. */
+ b->backimage = XMesaCreateImage(b->xm_visual->BitsPerPixel,
+ b->width, b->height, NULL);
+#else
+ if (b->shm==0
+ || alloc_shm_back_buffer(b)==GL_FALSE
+ ) {
+ /* Allocate a regular XImage for the back buffer. */
+ b->backimage = XCreateImage( b->xm_visual->display,
+ b->xm_visual->visinfo->visual,
+ GET_VISUAL_DEPTH(b->xm_visual),
+ ZPixmap, 0, /* format, offset */
+ NULL, b->width, b->height,
+ 8, 0 ); /* pad, bytes_per_line */
+#endif
+ if (!b->backimage) {
+ error("alloc_back_buffer: XCreateImage failed.");
+ }
+ b->backimage->data = (char *) MALLOC( b->backimage->height
+ * b->backimage->bytes_per_line );
+ if (!b->backimage->data) {
+ error("alloc_back_buffer: MALLOC failed.");
+ XMesaDestroyImage( b->backimage );
+ b->backimage = NULL;
+ }
+ }
+ b->backpixmap = None;
+ }
+ else if (b->db_state==BACK_PIXMAP) {
+ XMesaPixmap old_pixmap = b->backpixmap;
+ /* Free the old back pixmap */
+ if (b->backpixmap) {
+ XMesaFreePixmap( b->xm_visual->display, b->backpixmap );
+ }
+ /* Allocate new back pixmap */
+ b->backpixmap = XMesaCreatePixmap( b->xm_visual->display, b->frontbuffer,
+ b->width, b->height,
+ GET_VISUAL_DEPTH(b->xm_visual) );
+ b->backimage = NULL;
+ /* update other references to backpixmap */
+ if (b->buffer==(XMesaDrawable)old_pixmap) {
+ b->buffer = (XMesaDrawable)b->backpixmap;
+ }
+ }
+}
+
+
+
+/*
+ * A replacement for XAllocColor. This function should never
+ * fail to allocate a color. When XAllocColor fails, we return
+ * the nearest matching color. If we have to allocate many colors
+ * this function isn't too efficient; the XQueryColors() could be
+ * done just once.
+ * Written by Michael Pichler, Brian Paul, Mark Kilgard
+ * Input: dpy - X display
+ * cmap - X colormap
+ * cmapSize - size of colormap
+ * In/Out: color - the XColor struct
+ * Output: exact - 1=exact color match, 0=closest match
+ * alloced - 1=XAlloc worked, 0=XAlloc failed
+ */
+static void
+noFaultXAllocColor( int client,
+ XMesaDisplay *dpy,
+ XMesaColormap cmap,
+ int cmapSize,
+ XMesaColor *color,
+ int *exact, int *alloced )
+{
+#ifdef XFree86Server
+ Pixel *ppixIn;
+ xrgb *ctable;
+#else
+ /* we'll try to cache ctable for better remote display performance */
+ static Display *prevDisplay = NULL;
+ static XMesaColormap prevCmap = 0;
+ static int prevCmapSize = 0;
+ static XMesaColor *ctable = NULL;
+#endif
+ XMesaColor subColor;
+ int i, bestmatch;
+ double mindist; /* 3*2^16^2 exceeds long int precision. */
+
+ (void) client;
+
+ /* First try just using XAllocColor. */
+#ifdef XFree86Server
+ if (AllocColor(cmap,
+ &color->red, &color->green, &color->blue,
+ &color->pixel,
+ client) == Success) {
+#else
+ if (XAllocColor(dpy, cmap, color)) {
+#endif
+ *exact = 1;
+ *alloced = 1;
+ return;
+ }
+
+ /* Alloc failed, search for closest match */
+
+ /* Retrieve color table entries. */
+ /* XXX alloca candidate. */
+#ifdef XFree86Server
+ ppixIn = (Pixel *) MALLOC(cmapSize * sizeof(Pixel));
+ ctable = (xrgb *) MALLOC(cmapSize * sizeof(xrgb));
+ for (i = 0; i < cmapSize; i++) {
+ ppixIn[i] = i;
+ }
+ QueryColors(cmap, cmapSize, ppixIn, ctable);
+#else
+ if (prevDisplay != dpy || prevCmap != cmap
+ || prevCmapSize != cmapSize || !ctable) {
+ /* free previously cached color table */
+ if (ctable)
+ FREE(ctable);
+ /* Get the color table from X */
+ ctable = (XMesaColor *) MALLOC(cmapSize * sizeof(XMesaColor));
+ assert(ctable);
+ for (i = 0; i < cmapSize; i++) {
+ ctable[i].pixel = i;
+ }
+ XQueryColors(dpy, cmap, ctable, cmapSize);
+ prevDisplay = dpy;
+ prevCmap = cmap;
+ prevCmapSize = cmapSize;
+ }
+#endif
+
+ /* Find best match. */
+ bestmatch = -1;
+ mindist = 0.0;
+ for (i = 0; i < cmapSize; i++) {
+ double dr = 0.30 * ((double) color->red - (double) ctable[i].red);
+ double dg = 0.59 * ((double) color->green - (double) ctable[i].green);
+ double db = 0.11 * ((double) color->blue - (double) ctable[i].blue);
+ double dist = dr * dr + dg * dg + db * db;
+ if (bestmatch < 0 || dist < mindist) {
+ bestmatch = i;
+ mindist = dist;
+ }
+ }
+
+ /* Return result. */
+ subColor.red = ctable[bestmatch].red;
+ subColor.green = ctable[bestmatch].green;
+ subColor.blue = ctable[bestmatch].blue;
+ /* Try to allocate the closest match color. This should only
+ * fail if the cell is read/write. Otherwise, we're incrementing
+ * the cell's reference count.
+ */
+#ifdef XFree86Server
+ if (AllocColor(cmap,
+ &subColor.red, &subColor.green, &subColor.blue,
+ &subColor.pixel,
+ client) == Success) {
+#else
+ if (XAllocColor(dpy, cmap, &subColor)) {
+#endif
+ *alloced = 1;
+ }
+ else {
+ /* do this to work around a problem reported by Frank Ortega */
+ subColor.pixel = (unsigned long) bestmatch;
+ subColor.red = ctable[bestmatch].red;
+ subColor.green = ctable[bestmatch].green;
+ subColor.blue = ctable[bestmatch].blue;
+ subColor.flags = DoRed | DoGreen | DoBlue;
+ *alloced = 0;
+ }
+#ifdef XFree86Server
+ FREE(ppixIn);
+ FREE(ctable);
+#else
+ /* don't free table, save it for next time */
+#endif
+
+ *color = subColor;
+ *exact = 0;
+}
+
+
+
+
+/*
+ * Do setup for PF_GRAYSCALE pixel format.
+ * Note that buffer may be NULL.
+ */
+static GLboolean setup_grayscale( int client, XMesaVisual v,
+ XMesaBuffer buffer, XMesaColormap cmap )
+{
+ if (GET_VISUAL_DEPTH(v)<4 || GET_VISUAL_DEPTH(v)>16) {
+ return GL_FALSE;
+ }
+
+ if (buffer) {
+ XMesaBuffer prevBuffer;
+
+ if (!cmap) {
+ return GL_FALSE;
+ }
+
+ prevBuffer = find_xmesa_buffer(v->display, cmap, buffer);
+ if (prevBuffer &&
+ (buffer->xm_visual->gl_visual->RGBAflag ==
+ prevBuffer->xm_visual->gl_visual->RGBAflag)) {
+ /* Copy colormap stuff from previous XMesaBuffer which uses same
+ * X colormap. Do this to avoid time spent in noFaultXAllocColor.
+ */
+ copy_colortable_info(buffer, prevBuffer);
+ }
+ else {
+ /* Allocate 256 shades of gray */
+ int gray;
+ int colorsfailed = 0;
+ for (gray=0;gray<256;gray++) {
+ GLint r = gamma_adjust( v->RedGamma, gray, 255 );
+ GLint g = gamma_adjust( v->GreenGamma, gray, 255 );
+ GLint b = gamma_adjust( v->BlueGamma, gray, 255 );
+ int exact, alloced;
+ XMesaColor xcol;
+ xcol.red = (r << 8) | r;
+ xcol.green = (g << 8) | g;
+ xcol.blue = (b << 8) | b;
+ noFaultXAllocColor( client, v->display,
+ cmap, GET_COLORMAP_SIZE(v),
+ &xcol, &exact, &alloced );
+ if (!exact) {
+ colorsfailed++;
+ }
+ if (alloced) {
+ assert(buffer->num_alloced<256);
+ buffer->alloced_colors[buffer->num_alloced] = xcol.pixel;
+ buffer->num_alloced++;
+ }
+
+ /*OLD
+ assert(gray < 576);
+ buffer->color_table[gray*3+0] = xcol.pixel;
+ buffer->color_table[gray*3+1] = xcol.pixel;
+ buffer->color_table[gray*3+2] = xcol.pixel;
+ assert(xcol.pixel < 65536);
+ buffer->pixel_to_r[xcol.pixel] = gray * 30 / 100;
+ buffer->pixel_to_g[xcol.pixel] = gray * 59 / 100;
+ buffer->pixel_to_b[xcol.pixel] = gray * 11 / 100;
+ */
+ buffer->color_table[gray] = xcol.pixel;
+ assert(xcol.pixel < 65536);
+ buffer->pixel_to_r[xcol.pixel] = gray;
+ buffer->pixel_to_g[xcol.pixel] = gray;
+ buffer->pixel_to_b[xcol.pixel] = gray;
+ }
+
+ if (colorsfailed && getenv("MESA_DEBUG")) {
+ fprintf( stderr,
+ "Note: %d out of 256 needed colors do not match exactly.\n",
+ colorsfailed );
+ }
+ }
+ }
+
+ v->dithered_pf = PF_GRAYSCALE;
+ v->undithered_pf = PF_GRAYSCALE;
+ return GL_TRUE;
+}
+
+
+
+/*
+ * Setup RGB rendering for a window with a PseudoColor, StaticColor,
+ * or 8-bit TrueColor visual visual. We try to allocate a palette of 225
+ * colors (5 red, 9 green, 5 blue) and dither to approximate a 24-bit RGB
+ * color. While this function was originally designed just for 8-bit
+ * visuals, it has also proven to work from 4-bit up to 16-bit visuals.
+ * Dithering code contributed by Bob Mercier.
+ */
+static GLboolean setup_dithered_color( int client, XMesaVisual v,
+ XMesaBuffer buffer, XMesaColormap cmap )
+{
+ if (GET_VISUAL_DEPTH(v)<4 || GET_VISUAL_DEPTH(v)>16) {
+ return GL_FALSE;
+ }
+
+ if (buffer) {
+ XMesaBuffer prevBuffer;
+
+ if (!cmap) {
+ return GL_FALSE;
+ }
+
+ prevBuffer = find_xmesa_buffer(v->display, cmap, buffer);
+ if (prevBuffer &&
+ (buffer->xm_visual->gl_visual->RGBAflag ==
+ prevBuffer->xm_visual->gl_visual->RGBAflag)) {
+ /* Copy colormap stuff from previous, matching XMesaBuffer.
+ * Do this to avoid time spent in noFaultXAllocColor.
+ */
+ copy_colortable_info(buffer, prevBuffer);
+ }
+ else {
+ /* Allocate X colors and initialize color_table[], red_table[], etc */
+ int r, g, b, i;
+ int colorsfailed = 0;
+ for (r = 0; r < _R; r++) {
+ for (g = 0; g < _G; g++) {
+ for (b = 0; b < _B; b++) {
+ XMesaColor xcol;
+ int exact, alloced;
+ xcol.red =gamma_adjust(v->RedGamma, r*65535/(_R-1),65535);
+ xcol.green=gamma_adjust(v->GreenGamma, g*65535/(_G-1),65535);
+ xcol.blue =gamma_adjust(v->BlueGamma, b*65535/(_B-1),65535);
+ noFaultXAllocColor( client, v->display,
+ cmap, GET_COLORMAP_SIZE(v),
+ &xcol, &exact, &alloced );
+ if (!exact) {
+ colorsfailed++;
+ }
+ if (alloced) {
+ assert(buffer->num_alloced<256);
+ buffer->alloced_colors[buffer->num_alloced] = xcol.pixel;
+ buffer->num_alloced++;
+ }
+ i = _MIX( r, g, b );
+ assert(i < 576);
+ buffer->color_table[i] = xcol.pixel;
+ assert(xcol.pixel < 65536);
+ buffer->pixel_to_r[xcol.pixel] = r * 255 / (_R-1);
+ buffer->pixel_to_g[xcol.pixel] = g * 255 / (_G-1);
+ buffer->pixel_to_b[xcol.pixel] = b * 255 / (_B-1);
+ }
+ }
+ }
+
+ if (colorsfailed && getenv("MESA_DEBUG")) {
+ fprintf( stderr,
+ "Note: %d out of %d needed colors do not match exactly.\n",
+ colorsfailed, _R*_G*_B );
+ }
+ }
+ }
+
+ v->dithered_pf = PF_DITHER;
+ v->undithered_pf = PF_LOOKUP;
+ return GL_TRUE;
+}
+
+
+/*
+ * Setup for Hewlett Packard Color Recovery 8-bit TrueColor mode.
+ * HPCR simulates 24-bit color fidelity with an 8-bit frame buffer.
+ * Special dithering tables have to be initialized.
+ */
+static void setup_8bit_hpcr( XMesaVisual v )
+{
+ /* HP Color Recovery contributed by: Alex De Bruyn ([email protected])
+ * To work properly, the atom _HP_RGB_SMOOTH_MAP_LIST must be defined
+ * on the root window AND the colormap obtainable by XGetRGBColormaps
+ * for that atom must be set on the window. (see also tkInitWindow)
+ * If that colormap is not set, the output will look stripy.
+ */
+
+ /* Setup color tables with gamma correction */
+ int i;
+ double g;
+
+ g = 1.0 / v->RedGamma;
+ for (i=0; i<256; i++) {
+ GLint red = (GLint) (255.0 * pow( hpcr_rgbTbl[0][i]/255.0, g ) + 0.5);
+ v->hpcr_rgbTbl[0][i] = CLAMP( red, 16, 239 );
+ }
+
+ g = 1.0 / v->GreenGamma;
+ for (i=0; i<256; i++) {
+ GLint green = (GLint) (255.0 * pow( hpcr_rgbTbl[1][i]/255.0, g ) + 0.5);
+ v->hpcr_rgbTbl[1][i] = CLAMP( green, 16, 239 );
+ }
+
+ g = 1.0 / v->BlueGamma;
+ for (i=0; i<256; i++) {
+ GLint blue = (GLint) (255.0 * pow( hpcr_rgbTbl[2][i]/255.0, g ) + 0.5);
+ v->hpcr_rgbTbl[2][i] = CLAMP( blue, 32, 223 );
+ }
+ v->undithered_pf = PF_HPCR; /* can't really disable dithering for now */
+ v->dithered_pf = PF_HPCR;
+
+ /* which method should I use to clear */
+ /* GL_FALSE: keep the ordinary method */
+ /* GL_TRUE : clear with dither pattern */
+ v->hpcr_clear_flag = getenv("MESA_HPCR_CLEAR") ? GL_TRUE : GL_FALSE;
+
+ if (v->hpcr_clear_flag) {
+ v->hpcr_clear_pixmap = XMesaCreatePixmap(v->display,
+ DefaultRootWindow(v->display),
+ 16, 2, 8);
+#ifndef XFree86Server
+ v->hpcr_clear_ximage = XGetImage(v->display, v->hpcr_clear_pixmap,
+ 0, 0, 16, 2, AllPlanes, ZPixmap);
+#endif
+ }
+}
+
+
+/*
+ * Setup RGB rendering for a window with a True/DirectColor visual.
+ */
+static void setup_truecolor( XMesaVisual v, XMesaBuffer buffer,
+ XMesaWindow window, XMesaColormap cmap )
+{
+ unsigned long rmask, gmask, bmask;
+ (void) buffer;
+ (void) window;
+ (void) cmap;
+
+ /* Compute red multiplier (mask) and bit shift */
+ v->rshift = 0;
+ rmask = GET_REDMASK(v);
+ while ((rmask & 1)==0) {
+ v->rshift++;
+ rmask = rmask >> 1;
+ }
+
+ /* Compute green multiplier (mask) and bit shift */
+ v->gshift = 0;
+ gmask = GET_GREENMASK(v);
+ while ((gmask & 1)==0) {
+ v->gshift++;
+ gmask = gmask >> 1;
+ }
+
+ /* Compute blue multiplier (mask) and bit shift */
+ v->bshift = 0;
+ bmask = GET_BLUEMASK(v);
+ while ((bmask & 1)==0) {
+ v->bshift++;
+ bmask = bmask >> 1;
+ }
+
+ /*
+ * Compute component-to-pixel lookup tables and dithering kernel
+ */
+ {
+ static GLubyte kernel[16] = {
+ 0*16, 8*16, 2*16, 10*16,
+ 12*16, 4*16, 14*16, 6*16,
+ 3*16, 11*16, 1*16, 9*16,
+ 15*16, 7*16, 13*16, 5*16,
+ };
+ GLint rBits = bitcount(rmask);
+ GLint gBits = bitcount(gmask);
+ GLint bBits = bitcount(bmask);
+ GLint minBits;
+ GLuint i;
+
+ /* convert pixel components in [0,_mask] to RGB values in [0,255] */
+ for (i=0; i<=rmask; i++)
+ v->PixelToR[i] = (unsigned char) ((i * 255) / rmask);
+ for (i=0; i<=gmask; i++)
+ v->PixelToG[i] = (unsigned char) ((i * 255) / gmask);
+ for (i=0; i<=bmask; i++)
+ v->PixelToB[i] = (unsigned char) ((i * 255) / bmask);
+
+ /* convert RGB values from [0,255] to pixel components */
+
+ for (i=0;i<256;i++) {
+ GLint r = gamma_adjust(v->RedGamma, i, 255);
+ GLint g = gamma_adjust(v->GreenGamma, i, 255);
+ GLint b = gamma_adjust(v->BlueGamma, i, 255);
+ v->RtoPixel[i] = (r >> (8-rBits)) << v->rshift;
+ v->GtoPixel[i] = (g >> (8-gBits)) << v->gshift;
+ v->BtoPixel[i] = (b >> (8-bBits)) << v->bshift;
+ }
+ /* overflow protection */
+ for (i=256;i<512;i++) {
+ v->RtoPixel[i] = v->RtoPixel[255];
+ v->GtoPixel[i] = v->GtoPixel[255];
+ v->BtoPixel[i] = v->BtoPixel[255];
+ }
+
+ /* setup dithering kernel */
+ minBits = rBits;
+ if (gBits < minBits) minBits = gBits;
+ if (bBits < minBits) minBits = bBits;
+ for (i=0;i<16;i++) {
+ v->Kernel[i] = kernel[i] >> minBits;
+ }
+
+ v->undithered_pf = PF_TRUECOLOR;
+ v->dithered_pf = (GET_VISUAL_DEPTH(v)<24) ? PF_TRUEDITHER : PF_TRUECOLOR;
+ }
+
+ /*
+ * Now check for TrueColor visuals which we can optimize.
+ */
+ if ( GET_REDMASK(v) ==0x0000ff
+ && GET_GREENMASK(v)==0x00ff00
+ && GET_BLUEMASK(v) ==0xff0000
+ && CHECK_BYTE_ORDER(v)
+ && v->BitsPerPixel==32
+ && sizeof(GLuint)==4
+ && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
+ /* common 32 bpp config used on SGI, Sun */
+ v->undithered_pf = v->dithered_pf = PF_8A8B8G8R;
+ }
+ else if (GET_REDMASK(v) ==0xff0000
+ && GET_GREENMASK(v)==0x00ff00
+ && GET_BLUEMASK(v) ==0x0000ff
+ && CHECK_BYTE_ORDER(v)
+ && v->BitsPerPixel==32
+ && sizeof(GLuint)==4
+ && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
+ /* common 32 bpp config used on Linux, HP, IBM */
+ v->undithered_pf = v->dithered_pf = PF_8R8G8B;
+ }
+ else if (GET_REDMASK(v) ==0xff0000
+ && GET_GREENMASK(v)==0x00ff00
+ && GET_BLUEMASK(v) ==0x0000ff
+ && CHECK_BYTE_ORDER(v)
+ && v->BitsPerPixel==24
+ && sizeof(GLuint)==4
+ && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
+ /* common packed 24 bpp config used on Linux */
+ v->undithered_pf = v->dithered_pf = PF_8R8G8B24;
+ }
+ else if (GET_REDMASK(v) ==0xf800
+ && GET_GREENMASK(v)==0x07e0
+ && GET_BLUEMASK(v) ==0x001f
+ && CHECK_BYTE_ORDER(v)
+ && v->BitsPerPixel==16
+ && sizeof(GLushort)==2
+ && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
+ /* 5-6-5 color weight on common PC VGA boards */
+ v->undithered_pf = PF_5R6G5B;
+ v->dithered_pf = PF_DITHER_5R6G5B;
+ }
+ else if (GET_REDMASK(v) ==0xe0
+ && GET_GREENMASK(v)==0x1c
+ && GET_BLUEMASK(v) ==0x03
+ && CHECK_FOR_HPCR(v)) {
+ setup_8bit_hpcr( v );
+ }
+}
+
+
+
+/*
+ * Setup RGB rendering for a window with a monochrome visual.
+ */
+static void setup_monochrome( XMesaVisual v, XMesaBuffer b )
+{
+ (void) b;
+ v->dithered_pf = v->undithered_pf = PF_1BIT;
+ /* if black=1 then we must flip pixel values */
+ v->bitFlip = (GET_BLACK_PIXEL(v) != 0);
+}
+
+
+
+/*
+ * When a context is "made current" for the first time, we can finally
+ * finish initializing the context's visual and buffer information.
+ * Input: v - the XMesaVisual to initialize
+ * b - the XMesaBuffer to initialize (may be NULL)
+ * rgb_flag - TRUE = RGBA mode, FALSE = color index mode
+ * window - the window/pixmap we're rendering into
+ * cmap - the colormap associated with the window/pixmap
+ * Return: GL_TRUE=success, GL_FALSE=failure
+ */
+static GLboolean initialize_visual_and_buffer( int client,
+ XMesaVisual v,
+ XMesaBuffer b,
+ GLboolean rgb_flag,
+ XMesaDrawable window,
+ XMesaColormap cmap
+ )
+{
+#ifndef XFree86Server
+ XGCValues gcvalues;
+#endif
+
+ if (b) {
+ assert(b->xm_visual == v);
+ }
+
+ /* Save true bits/pixel */
+ v->BitsPerPixel = GET_BITS_PER_PIXEL(v);
+ assert(v->BitsPerPixel > 0);
+
+
+ if (rgb_flag==GL_FALSE) {
+ /* COLOR-INDEXED WINDOW:
+ * Even if the visual is TrueColor or DirectColor we treat it as
+ * being color indexed. This is weird but might be useful to someone.
+ */
+ v->dithered_pf = v->undithered_pf = PF_INDEX;
+ v->index_bits = GET_VISUAL_DEPTH(v);
+ }
+ else {
+ /* RGB WINDOW:
+ * We support RGB rendering into almost any kind of visual.
+ */
+ int xclass;
+ xclass = GET_VISUAL_CLASS(v);
+ if (xclass==TrueColor || xclass==DirectColor) {
+ setup_truecolor( v, b, (XMesaWindow)window, cmap );
+ }
+ else if (xclass==StaticGray && GET_VISUAL_DEPTH(v)==1) {
+ setup_monochrome( v, b );
+ }
+ else if (xclass==GrayScale || xclass==StaticGray) {
+ if (!setup_grayscale( client, v, b, cmap )) {
+ return GL_FALSE;
+ }
+ }
+ else if ((xclass==PseudoColor || xclass==StaticColor)
+ && GET_VISUAL_DEPTH(v)>=4 && GET_VISUAL_DEPTH(v)<=16) {
+ if (!setup_dithered_color( client, v, b, cmap )) {
+ return GL_FALSE;
+ }
+ }
+ else {
+ error("XMesa: RGB mode rendering not supported in given visual.");
+ return GL_FALSE;
+ }
+ v->index_bits = 0;
+
+ if (getenv("MESA_NO_DITHER")) {
+ v->dithered_pf = v->undithered_pf;
+ }
+ }
+
+
+ /*
+ * If MESA_INFO env var is set print out some debugging info
+ * which can help Brian figure out what's going on when a user
+ * reports bugs.
+ */
+ if (getenv("MESA_INFO")) {
+ fprintf(stderr, "X/Mesa visual = %p\n", v);
+ fprintf(stderr, "X/Mesa dithered pf = %u\n", v->dithered_pf);
+ fprintf(stderr, "X/Mesa undithered pf = %u\n", v->undithered_pf);
+ fprintf(stderr, "X/Mesa level = %d\n", v->level);
+ fprintf(stderr, "X/Mesa depth = %d\n", GET_VISUAL_DEPTH(v));
+ fprintf(stderr, "X/Mesa bits per pixel = %d\n", v->BitsPerPixel);
+ }
+
+ if (b && window) {
+ /* Do window-specific initializations */
+
+ /* Window dimensions */
+ unsigned int w, h;
+ get_drawable_size( v->display, window, &w, &h );
+ b->width = w;
+ b->height = h;
+
+ b->frontbuffer = window;
+
+ assert( v->gl_visual );
+
+ /* Setup for single/double buffering */
+ if (v->gl_visual->DBflag) {
+ /* Double buffered */
+#ifndef XFree86Server
+ b->shm = check_for_xshm( v->display );
+#endif
+ xmesa_alloc_back_buffer( b );
+ if (b->db_state==BACK_PIXMAP) {
+ b->buffer = (XMesaDrawable)b->backpixmap;
+ }
+ else {
+ b->buffer = XIMAGE;
+ }
+ }
+ else {
+ /* Single Buffered */
+ b->buffer = b->frontbuffer;
+ }
+
+ /* X11 graphics contexts */
+#ifdef XFree86Server
+ b->gc1 = CreateScratchGC(v->display, window->depth);
+ b->gc2 = CreateScratchGC(v->display, window->depth);
+#else
+ b->gc1 = XCreateGC( v->display, window, 0, NULL );
+ b->gc2 = XCreateGC( v->display, window, 0, NULL );
+#endif
+ XMesaSetFunction( v->display, b->gc1, GXcopy );
+ XMesaSetFunction( v->display, b->gc2, GXcopy );
+
+ /*
+ * Don't generate Graphics Expose/NoExpose events in swapbuffers().
+ * Patch contributed by Michael Pichler May 15, 1995.
+ */
+#ifdef XFree86Server
+ b->cleargc = CreateScratchGC(v->display, window->depth);
+ {
+ CARD32 v[1];
+ v[0] = FALSE;
+ dixChangeGC(NullClient, b->cleargc, GCGraphicsExposures, v, NULL);
+ }
+#else
+ gcvalues.graphics_exposures = False;
+ b->cleargc = XCreateGC( v->display, window,
+ GCGraphicsExposures, &gcvalues);
+#endif
+ XMesaSetFunction( v->display, b->cleargc, GXcopy );
+ /*
+ * Set fill style and tile pixmap once for all for HPCR stuff
+ * (instead of doing it each time in clear_color_HPCR_pixmap())
+ * Initialize whole stuff
+ * Patch contributed by Jacques Leroy March 8, 1998.
+ */
+ if (v->hpcr_clear_flag && b->buffer!=XIMAGE) {
+ int i;
+ for (i=0; i<16; i++)
+ {
+ XMesaPutPixel(v->hpcr_clear_ximage, i, 0, 0);
+ XMesaPutPixel(v->hpcr_clear_ximage, i, 1, 0);
+ }
+ XMesaPutImage(b->display, (XMesaDrawable)v->hpcr_clear_pixmap,
+ b->cleargc, v->hpcr_clear_ximage, 0, 0, 0, 0, 16, 2);
+ XMesaSetFillStyle( v->display, b->cleargc, FillTiled);
+ XMesaSetTile( v->display, b->cleargc, v->hpcr_clear_pixmap );
+ }
+
+ /* Initialize the row buffer XImage for use in write_color_span() */
+#ifdef XFree86Server
+ b->rowimage = XMesaCreateImage(GET_VISUAL_DEPTH(v), MAX_WIDTH, 1,
+ (char *)MALLOC(MAX_WIDTH*4));
+#else
+ b->rowimage = XCreateImage( v->display,
+ v->visinfo->visual,
+ v->visinfo->depth,
+ ZPixmap, 0, /*format, offset*/
+ (char*) MALLOC(MAX_WIDTH*4), /*data*/
+ MAX_WIDTH, 1, /*width, height*/
+ 32, /*bitmap_pad*/
+ 0 /*bytes_per_line*/ );
+#endif
+ }
+
+ return GL_TRUE;
+}
+
+
+
+/*
+ * Convert an RGBA color to a pixel value.
+ */
+unsigned long
+xmesa_color_to_pixel( XMesaContext xmesa, GLubyte r, GLubyte g, GLubyte b, GLubyte a,
+ GLuint pixelFormat)
+{
+ switch (pixelFormat) {
+ case PF_INDEX:
+ return 0;
+ case PF_TRUECOLOR:
+ {
+ unsigned long p;
+ PACK_TRUECOLOR( p, r, g, b );
+ return p;
+ }
+ case PF_8A8B8G8R:
+ return PACK_8A8B8G8R( r, g, b, a );
+ case PF_8R8G8B:
+ /* fall through */
+ case PF_8R8G8B24:
+ return PACK_8R8G8B( r, g, b );
+ case PF_5R6G5B:
+ return PACK_5R6G5B( r, g, b );
+ case PF_DITHER:
+ {
+ DITHER_SETUP;
+ return DITHER( 1, 0, r, g, b );
+ }
+ case PF_1BIT:
+ /* 382 = (3*255)/2 */
+ return ((r+g+b) > 382) ^ xmesa->xm_visual->bitFlip;
+ case PF_HPCR:
+ return DITHER_HPCR(1, 1, r, g, b);
+ case PF_LOOKUP:
+ {
+ LOOKUP_SETUP;
+ return LOOKUP( r, g, b );
+ }
+ case PF_GRAYSCALE:
+ return GRAY_RGB( r, g, b );
+ case PF_TRUEDITHER:
+ /* fall through */
+ case PF_DITHER_5R6G5B:
+ {
+ unsigned long p;
+ PACK_TRUEDITHER(p, 1, 0, r, g, b);
+ return p;
+ }
+ default:
+ gl_problem(NULL, "Bad pixel format in xmesa_color_to_pixel");
+ }
+ return 0;
+}
+
+
+/**********************************************************************/
+/***** Public Functions *****/
+/**********************************************************************/
+
+
+/*
+ * Create a new X/Mesa visual.
+ * Input: display - X11 display
+ * visinfo - an XVisualInfo pointer
+ * rgb_flag - GL_TRUE = RGB mode,
+ * GL_FALSE = color index mode
+ * alpha_flag - alpha buffer requested?
+ * db_flag - GL_TRUE = double-buffered,
+ * GL_FALSE = single buffered
+ * stereo_flag - stereo visual?
+ * ximage_flag - GL_TRUE = use an XImage for back buffer,
+ * GL_FALSE = use an off-screen pixmap for back buffer
+ * depth_size - requested bits/depth values, or zero
+ * stencil_size - requested bits/stencil values, or zero
+ * accum_red_size - requested bits/red accum values, or zero
+ * accum_green_size - requested bits/green accum values, or zero
+ * accum_blue_size - requested bits/blue accum values, or zero
+ * accum_alpha_size - requested bits/alpha accum values, or zero
+ * num_samples - number of samples/pixel if multisampling, or zero
+ * level - visual level, usually 0
+ * visualCaveat - ala the GLX extension, usually GLX_NONE_EXT
+ * Return; a new XMesaVisual or 0 if error.
+ */
+XMesaVisual XMesaCreateVisual( XMesaDisplay *display,
+ XMesaVisualInfo visinfo,
+ GLboolean rgb_flag,
+ GLboolean alpha_flag,
+ GLboolean db_flag,
+ GLboolean stereo_flag,
+ GLboolean ximage_flag,
+ GLint depth_size,
+ GLint stencil_size,
+ GLint accum_red_size,
+ GLint accum_green_size,
+ GLint accum_blue_size,
+ GLint accum_alpha_size,
+ GLint num_samples,
+ GLint level,
+ GLint visualCaveat )
+{
+ char *gamma;
+ XMesaVisual v;
+ GLint red_bits, green_bits, blue_bits, alpha_bits;
+
+ /* For debugging only */
+ if (getenv("MESA_XSYNC")) {
+ /* This makes debugging X easier.
+ * In your debugger, set a breakpoint on _XError to stop when an
+ * X protocol error is generated.
+ */
+#ifdef XFree86Server
+ /* NOT_NEEDED */
+#else
+ XSynchronize( display, 1 );
+#endif
+ }
+
+ v = (XMesaVisual) CALLOC_STRUCT(xmesa_visual);
+ if (!v) {
+ return NULL;
+ }
+
+ /*
+ * In the X server, NULL is passed in for the display. It will have
+ * to be set before using this visual. See XMesaSetVisualDisplay()
+ * below.
+ */
+ v->display = display;
+
+ /* Save a copy of the XVisualInfo struct because the user may XFREE()
+ * the struct but we may need some of the information contained in it
+ * at a later time.
+ */
+#ifdef XFree86Server
+ v->visinfo = visinfo;
+#else
+ v->visinfo = (XVisualInfo *) MALLOC(sizeof(*visinfo));
+ if(!v->visinfo) {
+ FREE(v);
+ return NULL;
+ }
+ MEMCPY(v->visinfo, visinfo, sizeof(*visinfo));
+
+ /* Save a copy of the pointer now so we can find this visual again
+ * if we need to search for it in find_glx_visual().
+ */
+ v->vishandle = visinfo;
+#endif
+
+#ifdef XFree86Server
+ /* Initialize the depth of the screen */
+ {
+ PixmapFormatRec *format;
+
+ for (format = screenInfo.formats;
+ format->depth != display->rootDepth;
+ format++)
+ ;
+ v->screen_depth = format->bitsPerPixel;
+ }
+#endif
+
+ /* check for MESA_GAMMA environment variable */
+ gamma = getenv("MESA_GAMMA");
+ if (gamma) {
+ v->RedGamma = v->GreenGamma = v->BlueGamma = 0.0;
+ sscanf( gamma, "%f %f %f", &v->RedGamma, &v->GreenGamma, &v->BlueGamma );
+ if (v->RedGamma<=0.0) v->RedGamma = 1.0;
+ if (v->GreenGamma<=0.0) v->GreenGamma = v->RedGamma;
+ if (v->BlueGamma<=0.0) v->BlueGamma = v->RedGamma;
+ }
+ else {
+ v->RedGamma = v->GreenGamma = v->BlueGamma = 1.0;
+ }
+
+ v->ximage_flag = ximage_flag;
+ v->level = level;
+ v->VisualCaveat = visualCaveat;
+
+ (void) initialize_visual_and_buffer( 0, v, NULL, rgb_flag, 0, 0 );
+
+ {
+ int xclass;
+ xclass = GET_VISUAL_CLASS(v);
+ if (xclass==TrueColor || xclass==DirectColor) {
+ red_bits = bitcount(GET_REDMASK(v));
+ green_bits = bitcount(GET_GREENMASK(v));
+ blue_bits = bitcount(GET_BLUEMASK(v));
+ alpha_bits = 0;
+ }
+ else {
+ /* this is an approximation */
+ int depth;
+ depth = GET_VISUAL_DEPTH(v);
+ red_bits = depth / 3;
+ depth -= red_bits;
+ green_bits = depth / 2;
+ depth -= green_bits;
+ blue_bits = depth;
+ alpha_bits = 0;
+ assert( red_bits + green_bits + blue_bits == GET_VISUAL_DEPTH(v) );
+ }
+ }
+
+ if (alpha_flag && alpha_bits == 0)
+ alpha_bits = 8;
+
+ v->gl_visual = _mesa_create_visual( rgb_flag, db_flag, stereo_flag,
+ red_bits, green_bits,
+ blue_bits, alpha_bits,
+ v->index_bits,
+ depth_size,
+ stencil_size,
+ accum_red_size, accum_green_size,
+ accum_blue_size, accum_alpha_size,
+ 0 );
+ if (!v->gl_visual) {
+#ifndef XFree86Server
+ FREE(v->visinfo);
+#endif
+ FREE(v);
+ return NULL;
+ }
+
+ return v;
+}
+
+
+void XMesaSetVisualDisplay( XMesaDisplay *dpy, XMesaVisual v )
+{
+ v->display = dpy;
+}
+
+
+void XMesaDestroyVisual( XMesaVisual v )
+{
+ _mesa_destroy_visual( v->gl_visual );
+#ifndef XFree86Server
+ FREE(v->visinfo);
+#endif
+ FREE(v);
+}
+
+
+
+/*
+ * Create a new XMesaContext.
+ * Input: v - XMesaVisual
+ * share_list - another XMesaContext with which to share display
+ * lists or NULL if no sharing is wanted.
+ * Return: an XMesaContext or NULL if error.
+ */
+XMesaContext XMesaCreateContext( XMesaVisual v, XMesaContext share_list )
+{
+ XMesaContext c;
+ GLboolean direct = GL_TRUE; /* XXXX */
+ /* NOT_DONE: should this be GL_FALSE??? */
+ static GLboolean firstTime = GL_TRUE;
+
+ if (firstTime) {
+ _glthread_INIT_MUTEX(_xmesa_lock);
+ firstTime = GL_FALSE;
+ }
+
+ c = (XMesaContext) CALLOC_STRUCT(xmesa_context);
+ if (!c) {
+ return NULL;
+ }
+
+ c->gl_ctx = gl_create_context( v->gl_visual,
+ share_list ? share_list->gl_ctx : (GLcontext *) NULL,
+ (void *) c, direct );
+ if (!c->gl_ctx) {
+ FREE(c);
+ return NULL;
+ }
+
+ gl_extensions_enable(c->gl_ctx, "GL_HP_occlusion_test");
+ gl_extensions_enable(c->gl_ctx, "GL_ARB_texture_cube_map");
+ gl_extensions_enable(c->gl_ctx, "GL_EXT_texture_env_combine");
+
+ if (CHECK_BYTE_ORDER(v)) {
+ c->swapbytes = GL_FALSE;
+ }
+ else {
+ c->swapbytes = GL_TRUE;
+ }
+
+ c->xm_visual = v;
+ c->xm_buffer = NULL; /* set later by XMesaMakeCurrent */
+ c->display = v->display;
+ c->pixelformat = v->dithered_pf; /* Dithering is enabled by default */
+
+ c->gl_ctx->Driver.UpdateState = xmesa_update_state;
+
+#if defined(GLX_DIRECT_RENDERING) && !defined(XFree86Server)
+ c->driContextPriv = driContextPriv;
+#endif
+
+ /* Run the config file */
+ gl_context_initialize( c->gl_ctx );
+
+ return c;
+}
+
+
+
+
+void XMesaDestroyContext( XMesaContext c )
+{
+#ifdef FX
+ if (c->xm_buffer && c->xm_buffer->FXctx)
+ fxMesaDestroyContext(c->xm_buffer->FXctx);
+#endif
+ if (c->gl_ctx)
+ gl_destroy_context( c->gl_ctx );
+
+ /* Disassociate old buffer with this context */
+ if (c->xm_buffer)
+ c->xm_buffer->xm_context = NULL;
+
+ /* Destroy any buffers which are using this context. If we don't
+ * we may have dangling references. Hmm, maybe we should just
+ * set the buffer's context pointer to NULL instead of deleting it?
+ * Let's see if we get any bug reports...
+ * This contributed by Doug Rabson <[email protected]>
+ */
+ {
+ XMesaBuffer b, next;
+ for (b = XMesaBufferList; b; b = next) {
+ next = b->Next;
+ if (!b->pixmap_flag) {
+#ifndef XFree86Server
+ XSync(b->display, False);
+#endif
+ if (b->xm_context == c) {
+ /* found a context created for this context */
+ XMesaDestroyBuffer( b );
+ }
+ }
+ }
+ }
+
+ FREE( c );
+}
+
+
+
+/*
+ * XXX this isn't a public function! It's a hack for the 3Dfx driver.
+ * Create a new XMesaBuffer from an X window.
+ * Input: v - the XMesaVisual
+ * w - the window
+ * c - the context
+ * Return: new XMesaBuffer or NULL if error
+ */
+XMesaBuffer XMesaCreateWindowBuffer2( XMesaVisual v, XMesaWindow w,
+ XMesaContext c )
+{
+#ifndef XFree86Server
+ XWindowAttributes attr;
+#endif
+#ifdef FX
+ char *fxEnvVar;
+#endif
+ int client = 0;
+
+ XMesaBuffer b = alloc_xmesa_buffer();
+ if (!b) {
+ return NULL;
+ }
+
+ (void) c;
+
+#ifdef XFree86Server
+ client = CLIENT_ID(((XMesaDrawable)w)->id);
+#endif
+
+ assert(v);
+
+#ifdef XFree86Server
+ if (GET_VISUAL_DEPTH(v) != ((XMesaDrawable)w)->depth) {
+#else
+ XGetWindowAttributes( v->display, w, &attr );
+
+ if (GET_VISUAL_DEPTH(v) != attr.depth) {
+#endif
+ if (getenv("MESA_DEBUG")) {
+ fprintf(stderr, "XMesaCreateWindowBuffer: depth mismatch between visual and window!\n");
+ }
+ return NULL;
+ }
+
+ b->xm_context = NULL; /* Associate no context with this buffer */
+
+ b->xm_visual = v;
+ b->pixmap_flag = GL_FALSE;
+ b->display = v->display;
+#ifdef XFree86Server
+ b->cmap = (ColormapPtr)LookupIDByType(wColormap(w), RT_COLORMAP);
+#else
+ if (attr.colormap) {
+ b->cmap = attr.colormap;
+ }
+ else {
+ if (getenv("MESA_DEBUG")) {
+ fprintf(stderr, "Window %u has no colormap!\n", (unsigned int) w);
+ }
+ /* this is weird, a window w/out a colormap!? */
+ /* OK, let's just allocate a new one and hope for the best */
+ b->cmap = XCreateColormap(v->display, w, attr.visual, AllocNone);
+ }
+#endif
+
+ /* determine back buffer implementation */
+ if (v->gl_visual->DBflag) {
+ if (v->ximage_flag) {
+ b->db_state = BACK_XIMAGE;
+ }
+ else {
+ b->db_state = BACK_PIXMAP;
+ }
+ }
+ else {
+ b->db_state = 0;
+ }
+
+ b->gl_buffer = gl_create_framebuffer( v->gl_visual,
+ v->gl_visual->DepthBits > 0,
+ v->gl_visual->StencilBits > 0,
+ v->gl_visual->AccumRedBits > 0,
+ v->gl_visual->AlphaBits > 0 );
+ if (!b->gl_buffer) {
+ free_xmesa_buffer(client, b);
+ return NULL;
+ }
+
+ if (!initialize_visual_and_buffer( client, v, b, v->gl_visual->RGBAflag,
+ (XMesaDrawable)w, b->cmap )) {
+ gl_destroy_framebuffer( b->gl_buffer );
+ free_xmesa_buffer(client, b);
+ return NULL;
+ }
+
+#ifdef FX
+ fxEnvVar = getenv("MESA_GLX_FX");
+ if (fxEnvVar) {
+ if (fxEnvVar[0]!='d') {
+ int attribs[100];
+ int numAttribs = 0;
+ int hw;
+ if (v->gl_visual->DepthBits > 0) {
+ attribs[numAttribs++] = FXMESA_DEPTH_SIZE;
+ attribs[numAttribs++] = 1;
+ }
+ if (v->gl_visual->DBflag) {
+ attribs[numAttribs++] = FXMESA_DOUBLEBUFFER;
+ }
+ if (v->gl_visual->AccumRedBits > 0) {
+ attribs[numAttribs++] = FXMESA_ACCUM_SIZE;
+ attribs[numAttribs++] = v->gl_visual->AccumRedBits;
+ }
+ if (v->gl_visual->StencilBits > 0) {
+ attribs[numAttribs++] = FXMESA_STENCIL_SIZE;
+ attribs[numAttribs++] = v->gl_visual->StencilBits;
+ }
+ if (v->gl_visual->AlphaBits > 0) {
+ attribs[numAttribs++] = FXMESA_ALPHA_SIZE;
+ attribs[numAttribs++] = 1;
+ }
+ if (c->gl_ctx) {
+#define FXMESA_SHARE_CONTEXT 990099 /* keep in sync with fxapi.c! */
+ attribs[numAttribs++] = FXMESA_SHARE_CONTEXT;
+ attribs[numAttribs++] = (int) c->gl_ctx;
+ }
+ attribs[numAttribs++] = FXMESA_NONE;
+
+ if ((hw = fxQueryHardware())==GR_SSTTYPE_VOODOO) {
+ b->FXctx = fxMesaCreateBestContext(0, b->width, b->height, attribs);
+ if ((v->undithered_pf!=PF_INDEX) && (b->backimage)) {
+ b->FXisHackUsable = b->FXctx ? GL_TRUE : GL_FALSE;
+ if (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')
+ b->FXwindowHack = b->FXctx ? GL_TRUE : GL_FALSE;
+ else
+ b->FXwindowHack = GL_FALSE;
+ }
+ }
+ else {
+ if (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')
+ b->FXctx = fxMesaCreateContext(w, GR_RESOLUTION_NONE,
+ GR_REFRESH_75Hz, attribs);
+ else
+ b->FXctx = fxMesaCreateBestContext(0, b->width, b->height, attribs);
+ b->FXisHackUsable = GL_FALSE;
+ b->FXwindowHack = GL_FALSE;
+ }
+ /*
+ fprintf(stderr,
+ "voodoo %d, wid %d height %d hack: usable %d active %d\n",
+ hw, b->width, b->height, b->FXisHackUsable, b->FXwindowHack);
+ */
+ }
+ }
+ else {
+ fprintf(stderr,"WARNING: This Mesa Library includes the Glide driver but\n");
+ fprintf(stderr," you have not defined the MESA_GLX_FX env. var.\n");
+ fprintf(stderr," (check the README.3DFX file for more information).\n\n");
+ fprintf(stderr," you can disable this message with a 'export MESA_GLX_FX=disable'.\n");
+ }
+#endif
+
+#if defined(GLX_DIRECT_RENDERING) && !defined(XFree86Server)
+ b->driDrawPriv = driDrawPriv;
+#endif
+
+ return b;
+}
+
+
+XMesaBuffer XMesaCreateWindowBuffer( XMesaVisual v, XMesaWindow w )
+{
+ return XMesaCreateWindowBuffer2( v, w, NULL );
+}
+
+
+/*
+ * Create a new XMesaBuffer from an X pixmap.
+ * Input: v - the XMesaVisual
+ * p - the pixmap
+ * cmap - the colormap, may be 0 if using a TrueColor or DirectColor
+ * visual for the pixmap
+ * Return: new XMesaBuffer or NULL if error
+ */
+XMesaBuffer XMesaCreatePixmapBuffer( XMesaVisual v,
+ XMesaPixmap p, XMesaColormap cmap )
+{
+ int client = 0;
+ XMesaBuffer b = alloc_xmesa_buffer();
+ if (!b) {
+ return NULL;
+ }
+
+
+#ifdef XFree86Server
+ client = CLIENT_ID(((XMesaDrawable)p)->id);
+#endif
+
+ assert(v);
+
+ b->xm_context = NULL; /* Associate no context with this buffer */
+
+ b->xm_visual = v;
+ b->pixmap_flag = GL_TRUE;
+ b->display = v->display;
+ b->cmap = cmap;
+
+ /* determine back buffer implementation */
+ if (v->gl_visual->DBflag) {
+ if (v->ximage_flag) {
+ b->db_state = BACK_XIMAGE;
+ }
+ else {
+ b->db_state = BACK_PIXMAP;
+ }
+ }
+ else {
+ b->db_state = 0;
+ }
+
+ b->gl_buffer = gl_create_framebuffer( v->gl_visual,
+ v->gl_visual->DepthBits > 0,
+ v->gl_visual->StencilBits > 0,
+ v->gl_visual->AccumRedBits +
+ v->gl_visual->AccumGreenBits +
+ v->gl_visual->AccumBlueBits > 0,
+ v->gl_visual->AlphaBits > 0 );
+ if (!b->gl_buffer) {
+ free_xmesa_buffer(client, b);
+ return NULL;
+ }
+
+ if (!initialize_visual_and_buffer(client, v, b, v->gl_visual->RGBAflag,
+ (XMesaDrawable)p, cmap)) {
+ gl_destroy_framebuffer( b->gl_buffer );
+ free_xmesa_buffer(client, b);
+ return NULL;
+ }
+
+#if defined(GLX_DIRECT_RENDERING) && !defined(XFree86Server)
+ b->driDrawPriv = driDrawPriv;
+#endif
+
+ return b;
+}
+
+
+
+/*
+ * Deallocate an XMesaBuffer structure and all related info.
+ */
+void XMesaDestroyBuffer( XMesaBuffer b )
+{
+ int client = 0;
+
+#ifdef XFree86Server
+ if (b->frontbuffer)
+ client = CLIENT_ID(b->frontbuffer->id);
+#endif
+
+ if (b->gc1) XMesaFreeGC( b->xm_visual->display, b->gc1 );
+ if (b->gc2) XMesaFreeGC( b->xm_visual->display, b->gc2 );
+ if (b->cleargc) XMesaFreeGC( b->xm_visual->display, b->cleargc );
+
+ if (b->backimage) {
+#if defined(USE_XSHM) && !defined(XFree86Server)
+ if (b->shm) {
+ XShmDetach( b->xm_visual->display, &b->shminfo );
+ XDestroyImage( b->backimage );
+ shmdt( b->shminfo.shmaddr );
+ }
+ else
+#endif
+ XMesaDestroyImage( b->backimage );
+ }
+ if (b->backpixmap) {
+ XMesaFreePixmap( b->xm_visual->display, b->backpixmap );
+ if (b->xm_visual->hpcr_clear_flag) {
+ XMesaFreePixmap( b->xm_visual->display,
+ b->xm_visual->hpcr_clear_pixmap );
+ XMesaDestroyImage( b->xm_visual->hpcr_clear_ximage );
+ }
+ }
+ if (b->rowimage) {
+ FREE( b->rowimage->data );
+ b->rowimage->data = NULL;
+ XMesaDestroyImage( b->rowimage );
+ }
+
+ if (b->xm_context)
+ b->xm_context->xm_buffer = NULL;
+
+ gl_destroy_framebuffer( b->gl_buffer );
+ free_xmesa_buffer(client, b);
+}
+
+
+
+/*
+ * Bind buffer b to context c and make c the current rendering context.
+ */
+GLboolean XMesaMakeCurrent( XMesaContext c, XMesaBuffer b )
+{
+ return XMesaMakeCurrent2( c, b, b );
+}
+
+
+/*
+ * Bind buffer b to context c and make c the current rendering context.
+ */
+GLboolean XMesaMakeCurrent2( XMesaContext c, XMesaBuffer drawBuffer,
+ XMesaBuffer readBuffer )
+{
+ if (c) {
+ if (!drawBuffer || !readBuffer)
+ return GL_FALSE; /* must specify buffers! */
+
+#ifdef FX
+ if (drawBuffer->FXctx) {
+ fxMesaMakeCurrent(drawBuffer->FXctx);
+
+ /* Disassociate old buffer from this context */
+ if (c->xm_buffer)
+ c->xm_buffer->xm_context = NULL;
+
+ /* Associate the context with this buffer */
+ drawBuffer->xm_context = c;
+
+ c->xm_buffer = drawBuffer;
+ c->xm_read_buffer = readBuffer;
+ c->use_read_buffer = (drawBuffer != readBuffer);
+
+ return GL_TRUE;
+ }
+#endif
+ if (c->gl_ctx == gl_get_current_context()
+ && c->xm_buffer == drawBuffer
+ && c->xm_read_buffer == readBuffer
+ && c->xm_buffer->wasCurrent) {
+ /* same context and buffer, do nothing */
+ return GL_TRUE;
+ }
+
+ /* Disassociate old buffer with this context */
+ if (c->xm_buffer)
+ c->xm_buffer->xm_context = NULL;
+ drawBuffer->xm_context = c; /* Associate the context with this buffer */
+
+ c->xm_buffer = drawBuffer;
+ c->xm_read_buffer = readBuffer;
+ c->use_read_buffer = (drawBuffer != readBuffer);
+
+ gl_make_current2(c->gl_ctx, drawBuffer->gl_buffer, readBuffer->gl_buffer);
+
+ if (c->gl_ctx->Viewport.Width == 0) {
+ /* initialize viewport to window size */
+ _mesa_Viewport( 0, 0, drawBuffer->width, drawBuffer->height );
+ c->gl_ctx->Scissor.Width = drawBuffer->width;
+ c->gl_ctx->Scissor.Height = drawBuffer->height;
+ }
+
+ if (c->xm_visual->gl_visual->RGBAflag) {
+ /*
+ * Must recompute and set these pixel values because colormap
+ * can be different for different windows.
+ */
+ c->pixel = xmesa_color_to_pixel( c, c->red, c->green,
+ c->blue, c->alpha, c->pixelformat );
+ XMesaSetForeground( c->display, c->xm_buffer->gc1, c->pixel );
+ c->clearpixel = xmesa_color_to_pixel( c,
+ c->clearcolor[0],
+ c->clearcolor[1],
+ c->clearcolor[2],
+ c->clearcolor[3],
+ c->xm_visual->undithered_pf);
+ XMesaSetForeground(c->display, c->xm_buffer->cleargc, c->clearpixel);
+ }
+
+ /* Solution to Stephane Rehel's problem with glXReleaseBuffersMESA(): */
+ c->xm_buffer->wasCurrent = GL_TRUE;
+ }
+ else {
+ /* Detach */
+ gl_make_current2( NULL, NULL, NULL );
+ }
+ return GL_TRUE;
+}
+
+
+/*
+ * Unbind the context c from its buffer.
+ */
+GLboolean XMesaUnbindContext( XMesaContext c )
+{
+ /* A no-op for XFree86 integration purposes */
+ return GL_TRUE;
+}
+
+
+XMesaContext XMesaGetCurrentContext( void )
+{
+ GET_CURRENT_CONTEXT(ctx);
+ if (ctx) {
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ return xmesa;
+ }
+ else {
+ return 0;
+ }
+}
+
+
+XMesaBuffer XMesaGetCurrentBuffer( void )
+{
+ GET_CURRENT_CONTEXT(ctx);
+ if (ctx) {
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ return xmesa->xm_buffer;
+ }
+ else {
+ return 0;
+ }
+}
+
+
+/* New in Mesa 3.1 */
+XMesaBuffer XMesaGetCurrentReadBuffer( void )
+{
+ GET_CURRENT_CONTEXT(ctx);
+ if (ctx) {
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ return xmesa->xm_buffer;
+ }
+ else {
+ return 0;
+ }
+}
+
+
+GLboolean XMesaForceCurrent(XMesaContext c)
+{
+ if (c) {
+ if (c->gl_ctx != gl_get_current_context()) {
+ gl_make_current(c->gl_ctx, c->xm_buffer->gl_buffer);
+ }
+ }
+ else {
+ gl_make_current(NULL, NULL);
+ }
+ return GL_TRUE;
+}
+
+
+GLboolean XMesaLoseCurrent(XMesaContext c)
+{
+ (void) c;
+ gl_make_current(NULL, NULL);
+ return GL_TRUE;
+}
+
+
+/*
+ * Switch 3Dfx support hack between window and full-screen mode.
+ */
+GLboolean XMesaSetFXmode( GLint mode )
+{
+#ifdef FX
+ const char *fx = getenv("MESA_GLX_FX");
+ if (fx && fx[0] != 'd') {
+ GET_CURRENT_CONTEXT(ctx);
+ GrHwConfiguration hw;
+ if (!FX_grSstQueryHardware(&hw)) {
+ /*fprintf(stderr, "!grSstQueryHardware\n");*/
+ return GL_FALSE;
+ }
+ if (hw.num_sst < 1) {
+ /*fprintf(stderr, "hw.num_sst < 1\n");*/
+ return GL_FALSE;
+ }
+ if (ctx) {
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ if (mode == XMESA_FX_WINDOW) {
+ if (xmesa->xm_buffer->FXisHackUsable) {
+ FX_grSstControl(GR_CONTROL_DEACTIVATE);
+ xmesa->xm_buffer->FXwindowHack = GL_TRUE;
+ return GL_TRUE;
+ }
+ }
+ else if (mode == XMESA_FX_FULLSCREEN) {
+ FX_grSstControl(GR_CONTROL_ACTIVATE);
+ xmesa->xm_buffer->FXwindowHack = GL_FALSE;
+ return GL_TRUE;
+ }
+ else {
+ /* Error: Bad mode value */
+ }
+ }
+ }
+ /*fprintf(stderr, "fallthrough\n");*/
+#else
+ (void) mode;
+#endif
+ return GL_FALSE;
+}
+
+
+
+#ifdef FX
+/*
+ * Read image from VooDoo frame buffer into X/Mesa's back XImage.
+ */
+static void FXgetImage( XMesaBuffer b )
+{
+ static unsigned short pixbuf[MAX_WIDTH];
+ int x, y;
+ XMesaWindow root;
+ unsigned int bw, depth, width, height;
+ XMesaContext xmesa = (XMesaContext) b->xm_context->gl_ctx->DriverCtx;
+
+ assert(xmesa->xm_buffer->FXctx);
+
+#ifdef XFree86Server
+ x = b->frontbuffer->x;
+ y = b->frontbuffer->y;
+ width = b->frontbuffer->width;
+ height = b->frontbuffer->height;
+ depth = b->frontbuffer->depth;
+#else
+ XGetGeometry( xmesa->xm_visual->display, b->frontbuffer,
+ &root, &x, &y, &width, &height, &bw, &depth);
+#endif
+ if (b->width != width || b->height != height) {
+ b->width = MIN2((int)width, xmesa->xm_buffer->FXctx->width);
+ b->height = MIN2((int)height, xmesa->xm_buffer->FXctx->height);
+ if (b->width & 1)
+ b->width--; /* prevent odd width */
+ xmesa_alloc_back_buffer( b );
+ }
+
+ grLfbWriteColorFormat(GR_COLORFORMAT_ARGB);
+ if (xmesa->xm_visual->undithered_pf==PF_5R6G5B) {
+ /* Special case: 16bpp RGB */
+ grLfbReadRegion( GR_BUFFER_FRONTBUFFER, /* src buffer */
+ 0, xmesa->xm_buffer->FXctx->height - b->height, /*pos*/
+ b->width, b->height, /* size */
+ b->width * sizeof(GLushort), /* stride */
+ b->backimage->data); /* dest buffer */
+ }
+ else if (xmesa->xm_visual->dithered_pf==PF_DITHER
+ && GET_VISUAL_DEPTH(xmesa->xm_visual)==8) {
+ /* Special case: 8bpp RGB */
+ for (y=0;y<b->height;y++) {
+ GLubyte *ptr = (GLubyte*) xmesa->xm_buffer->backimage->data
+ + xmesa->xm_buffer->backimage->bytes_per_line * y;
+ XDITHER_SETUP(y);
+
+ /* read row from 3Dfx frame buffer */
+ grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
+ 0, xmesa->xm_buffer->FXctx->height-(b->height-y),
+ b->width, 1,
+ 0,
+ pixbuf );
+
+ /* write to XImage back buffer */
+ for (x=0;x<b->width;x++) {
+ GLubyte r = (pixbuf[x] & 0xf800) >> 8;
+ GLubyte g = (pixbuf[x] & 0x07e0) >> 3;
+ GLubyte b = (pixbuf[x] & 0x001f) << 3;
+ *ptr++ = XDITHER( x, r, g, b);
+ }
+ }
+ }
+ else {
+ /* General case: slow! */
+ for (y=0;y<b->height;y++) {
+ /* read row from 3Dfx frame buffer */
+ grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
+ 0, xmesa->xm_buffer->FXctx->height-(b->height-y),
+ b->width, 1,
+ 0,
+ pixbuf );
+
+ /* write to XImage back buffer */
+ for (x=0;x<b->width;x++) {
+ XMesaPutPixel(b->backimage,x,y,
+ xmesa_color_to_pixel(xmesa,
+ (pixbuf[x] & 0xf800) >> 8,
+ (pixbuf[x] & 0x07e0) >> 3,
+ (pixbuf[x] & 0x001f) << 3,
+ 0xff, xmesa->pixelformat));
+ }
+ }
+ }
+ grLfbWriteColorFormat(GR_COLORFORMAT_ABGR);
+}
+#endif
+
+
+/*
+ * Copy the back buffer to the front buffer. If there's no back buffer
+ * this is a no-op.
+ */
+void XMesaSwapBuffers( XMesaBuffer b )
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ /* If we're swapping the buffer associated with the current context
+ * we have to flush any pending rendering commands first.
+ */
+ if (b->xm_context && b->xm_context->gl_ctx == ctx)
+ _mesa_swapbuffers(ctx);
+
+ if (b->db_state) {
+#ifdef FX
+ if (b->FXctx) {
+ fxMesaSwapBuffers();
+
+ if (b->FXwindowHack)
+ FXgetImage(b);
+ else
+ return;
+ }
+#endif
+ if (b->backimage) {
+ /* Copy Ximage from host's memory to server's window */
+#if defined(USE_XSHM) && !defined(XFree86Server)
+ if (b->shm) {
+ /*_glthread_LOCK_MUTEX(_xmesa_lock);*/
+ XShmPutImage( b->xm_visual->display, b->frontbuffer,
+ b->cleargc,
+ b->backimage, 0, 0,
+ 0, 0, b->width, b->height, False );
+ /*_glthread_UNLOCK_MUTEX(_xmesa_lock);*/
+ }
+ else
+#endif
+ {
+#if defined(GLX_DIRECT_RENDERING) && !defined(XFree86Server)
+ XMesaDriSwapBuffers( b );
+#else
+ /*_glthread_LOCK_MUTEX(_xmesa_lock);*/
+ XMesaPutImage( b->xm_visual->display, b->frontbuffer,
+ b->cleargc,
+ b->backimage, 0, 0,
+ 0, 0, b->width, b->height );
+ /*_glthread_UNLOCK_MUTEX(_xmesa_lock);*/
+#endif
+ }
+ }
+ else {
+ /* Copy pixmap to window on server */
+ /*_glthread_LOCK_MUTEX(_xmesa_lock);*/
+ XMesaCopyArea( b->xm_visual->display,
+ b->backpixmap, /* source drawable */
+ b->frontbuffer, /* dest. drawable */
+ b->cleargc,
+ 0, 0, b->width, b->height, /* source region */
+ 0, 0 /* dest region */
+ );
+ /*_glthread_UNLOCK_MUTEX(_xmesa_lock);*/
+ }
+ }
+#if !defined(GLX_DIRECT_RENDERING) && !defined(XFree86Server)
+ XSync( b->xm_visual->display, False );
+#endif
+}
+
+
+
+/*
+ * Copy sub-region of back buffer to front buffer
+ */
+void XMesaCopySubBuffer( XMesaBuffer b, int x, int y, int width, int height )
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ /* If we're swapping the buffer associated with the current context
+ * we have to flush any pending rendering commands first.
+ */
+ if (b->xm_context->gl_ctx == ctx)
+ _mesa_swapbuffers(ctx);
+
+ if (b->db_state) {
+ int yTop = b->bottom - y - height;
+#ifdef FX
+ if (b->FXctx) {
+ fxMesaSwapBuffers();
+ if (b->FXwindowHack)
+ FXgetImage(b);
+ else
+ return;
+ }
+#endif
+ if (b->backimage) {
+ /* Copy Ximage from host's memory to server's window */
+#if defined(USE_XSHM) && !defined(XFree86Server)
+ if (b->shm) {
+ /* XXX assuming width and height aren't too large! */
+ XShmPutImage( b->xm_visual->display, b->frontbuffer,
+ b->cleargc,
+ b->backimage, x, yTop,
+ x, yTop, width, height, False );
+ /* wait for finished event??? */
+ }
+ else
+#endif
+ {
+ /* XXX assuming width and height aren't too large! */
+ XMesaPutImage( b->xm_visual->display, b->frontbuffer,
+ b->cleargc,
+ b->backimage, x, yTop,
+ x, yTop, width, height );
+ }
+ }
+ else {
+ /* Copy pixmap to window on server */
+ XMesaCopyArea( b->xm_visual->display,
+ b->backpixmap, /* source drawable */
+ b->frontbuffer, /* dest. drawable */
+ b->cleargc,
+ x, yTop, width, height, /* source region */
+ x, yTop /* dest region */
+ );
+ }
+ }
+}
+
+
+/*
+ * Return a pointer to the XMesa backbuffer Pixmap or XImage. This function
+ * is a way to get "under the hood" of X/Mesa so one can manipulate the
+ * back buffer directly.
+ * Output: pixmap - pointer to back buffer's Pixmap, or 0
+ * ximage - pointer to back buffer's XImage, or NULL
+ * Return: GL_TRUE = context is double buffered
+ * GL_FALSE = context is single buffered
+ */
+GLboolean XMesaGetBackBuffer( XMesaBuffer b,
+ XMesaPixmap *pixmap,
+ XMesaImage **ximage )
+{
+ if (b->db_state) {
+ if (pixmap) *pixmap = b->backpixmap;
+ if (ximage) *ximage = b->backimage;
+ return GL_TRUE;
+ }
+ else {
+ *pixmap = 0;
+ *ximage = NULL;
+ return GL_FALSE;
+ }
+}
+
+
+/*
+ * Return the depth buffer associated with an XMesaBuffer.
+ * Input: b - the XMesa buffer handle
+ * Output: width, height - size of buffer in pixels
+ * bytesPerValue - bytes per depth value (2 or 4)
+ * buffer - pointer to depth buffer values
+ * Return: GL_TRUE or GL_FALSE to indicate success or failure.
+ */
+GLboolean XMesaGetDepthBuffer( XMesaBuffer b, GLint *width, GLint *height,
+ GLint *bytesPerValue, void **buffer )
+{
+ if ((!b->gl_buffer) || (!b->gl_buffer->DepthBuffer)) {
+ *width = 0;
+ *height = 0;
+ *bytesPerValue = 0;
+ *buffer = 0;
+ return GL_FALSE;
+ }
+ else {
+ *width = b->gl_buffer->Width;
+ *height = b->gl_buffer->Height;
+ *bytesPerValue = sizeof(GLdepth);
+ *buffer = b->gl_buffer->DepthBuffer;
+ return GL_TRUE;
+ }
+}
+
+
+void XMesaFlush( XMesaContext c )
+{
+ if (c && c->xm_visual) {
+#ifdef XFree86Server
+ /* NOT_NEEDED */
+#else
+ XSync( c->xm_visual->display, False );
+#endif
+ }
+}
+
+
+
+const char *XMesaGetString( XMesaContext c, int name )
+{
+ (void) c;
+ if (name==XMESA_VERSION) {
+ return "3.1";
+ }
+ else if (name==XMESA_EXTENSIONS) {
+ return "";
+ }
+ else {
+ return NULL;
+ }
+}
+
+
+
+XMesaBuffer XMesaFindBuffer( XMesaDisplay *dpy, XMesaDrawable d )
+{
+ XMesaBuffer b;
+ for (b=XMesaBufferList; b; b=b->Next) {
+ if (b->frontbuffer==d && b->display==dpy) {
+ return b;
+ }
+ }
+ return NULL;
+}
+
+
+
+/*
+ * Look for XMesaBuffers whose X window has been destroyed.
+ * Deallocate any such XMesaBuffers.
+ */
+void XMesaGarbageCollect( void )
+{
+ XMesaBuffer b, next;
+ for (b=XMesaBufferList; b; b=next) {
+ next = b->Next;
+ if (!b->pixmap_flag) {
+#ifdef XFree86Server
+ /* NOT_NEEDED */
+#else
+ XSync(b->display, False);
+ if (!window_exists( b->display, b->frontbuffer )) {
+ /* found a dead window, free the ancillary info */
+ XMesaDestroyBuffer( b );
+ }
+#endif
+ }
+ }
+}
+
+
+void XMesaReset( void )
+{
+ while (XMesaBufferList)
+ XMesaDestroyBuffer(XMesaBufferList);
+
+ XMesaBufferList = NULL;
+}
+
+
+unsigned long XMesaDitherColor( XMesaContext xmesa, GLint x, GLint y,
+ GLfloat red, GLfloat green,
+ GLfloat blue, GLfloat alpha )
+{
+ GLint r = (GLint) (red * 255.0F);
+ GLint g = (GLint) (green * 255.0F);
+ GLint b = (GLint) (blue * 255.0F);
+ GLint a = (GLint) (alpha * 255.0F);
+
+ switch (xmesa->pixelformat) {
+ case PF_INDEX:
+ return 0;
+ case PF_TRUECOLOR:
+ {
+ unsigned long p;
+ PACK_TRUECOLOR( p, r, g, b );
+ return p;
+ }
+ case PF_8A8B8G8R:
+ return PACK_8A8B8G8R( r, g, b, a );
+ case PF_8R8G8B:
+ return PACK_8R8G8B( r, g, b );
+ case PF_5R6G5B:
+ return PACK_5R6G5B( r, g, b );
+ case PF_DITHER:
+ {
+ DITHER_SETUP;
+ return DITHER( x, y, r, g, b );
+ }
+ case PF_1BIT:
+ /* 382 = (3*255)/2 */
+ return ((r+g+b) > 382) ^ xmesa->xm_visual->bitFlip;
+ case PF_HPCR:
+ return DITHER_HPCR(x, y, r, g, b);
+ case PF_LOOKUP:
+ {
+ LOOKUP_SETUP;
+ return LOOKUP( r, g, b );
+ }
+ case PF_GRAYSCALE:
+ return GRAY_RGB( r, g, b );
+ case PF_DITHER_5R6G5B:
+ /* fall through */
+ case PF_TRUEDITHER:
+ {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x, y, r, g, b);
+ return p;
+ }
+ default:
+ gl_problem(NULL, "Bad pixel format in XMesaDitherColor");
+ }
+ return 0;
+}
+
+
diff --git a/src/mesa/drivers/x11/xm_dd.c b/src/mesa/drivers/x11/xm_dd.c
new file mode 100644
index 00000000000..271cb13f083
--- /dev/null
+++ b/src/mesa/drivers/x11/xm_dd.c
@@ -0,0 +1,1006 @@
+/* $Id: xm_dd.c,v 1.1 2000/09/07 15:40:30 brianp Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.3
+ *
+ * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+#include "glxheader.h"
+#include "context.h"
+#include "drawpix.h"
+#include "mem.h"
+#include "state.h"
+#include "depth.h"
+#include "macros.h"
+#include "vb.h"
+#include "types.h"
+#include "xmesaP.h"
+#include "extensions.h"
+
+
+/*
+ * Return the size (width,height of the current color buffer.
+ * This function should be called by the glViewport function because
+ * glViewport is often called when the window gets resized. We need to
+ * update some X/Mesa stuff when that happens.
+ * Output: width - width of buffer in pixels.
+ * height - height of buffer in pixels.
+ */
+static void
+get_buffer_size( GLcontext *ctx, GLuint *width, GLuint *height )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ unsigned int winwidth, winheight;
+#ifndef XFree86Server
+ Window root;
+ int winx, winy;
+ unsigned int bw, d;
+
+ _glthread_LOCK_MUTEX(_xmesa_lock);
+ XGetGeometry( xmesa->display, xmesa->xm_buffer->frontbuffer, &root,
+ &winx, &winy, &winwidth, &winheight, &bw, &d );
+ _glthread_UNLOCK_MUTEX(_xmesa_lock);
+#else
+
+ winwidth = xmesa->xm_buffer->frontbuffer->width;
+ winheight = xmesa->xm_buffer->frontbuffer->height;
+#endif
+
+ *width = winwidth;
+ *height = winheight;
+
+ if ( winwidth!=xmesa->xm_buffer->width
+ || winheight!=xmesa->xm_buffer->height) {
+ xmesa->xm_buffer->width = winwidth;
+ xmesa->xm_buffer->height = winheight;
+ xmesa_alloc_back_buffer( xmesa->xm_buffer );
+ }
+
+ /* Needed by FLIP macro */
+ xmesa->xm_buffer->bottom = (int) winheight - 1;
+
+ if (xmesa->xm_buffer->backimage) {
+ /* Needed by PIXELADDR1 macro */
+ xmesa->xm_buffer->ximage_width1
+ = xmesa->xm_buffer->backimage->bytes_per_line;
+ xmesa->xm_buffer->ximage_origin1
+ = (GLubyte *) xmesa->xm_buffer->backimage->data
+ + xmesa->xm_buffer->ximage_width1 * (winheight-1);
+
+ /* Needed by PIXELADDR2 macro */
+ xmesa->xm_buffer->ximage_width2
+ = xmesa->xm_buffer->backimage->bytes_per_line / 2;
+ xmesa->xm_buffer->ximage_origin2
+ = (GLushort *) xmesa->xm_buffer->backimage->data
+ + xmesa->xm_buffer->ximage_width2 * (winheight-1);
+
+ /* Needed by PIXELADDR3 macro */
+ xmesa->xm_buffer->ximage_width3
+ = xmesa->xm_buffer->backimage->bytes_per_line;
+ xmesa->xm_buffer->ximage_origin3
+ = (GLubyte *) xmesa->xm_buffer->backimage->data
+ + xmesa->xm_buffer->ximage_width3 * (winheight-1);
+
+ /* Needed by PIXELADDR4 macro */
+ xmesa->xm_buffer->ximage_width4 = xmesa->xm_buffer->backimage->width;
+ xmesa->xm_buffer->ximage_origin4
+ = (GLuint *) xmesa->xm_buffer->backimage->data
+ + xmesa->xm_buffer->ximage_width4 * (winheight-1);
+ }
+}
+
+
+static void
+finish( GLcontext *ctx )
+{
+#ifdef XFree86Server
+ /* NOT_NEEDED */
+#else
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ if (xmesa) {
+ _glthread_LOCK_MUTEX(_xmesa_lock);
+ XSync( xmesa->display, False );
+ _glthread_UNLOCK_MUTEX(_xmesa_lock);
+ }
+#endif
+}
+
+
+static void
+flush( GLcontext *ctx )
+{
+#ifdef XFree86Server
+ /* NOT_NEEDED */
+#else
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ if (xmesa) {
+ _glthread_LOCK_MUTEX(_xmesa_lock);
+ XFlush( xmesa->display );
+ _glthread_UNLOCK_MUTEX(_xmesa_lock);
+ }
+#endif
+}
+
+
+#if 0
+static GLboolean
+set_buffer( GLcontext *ctx, GLenum mode )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ if (mode == GL_FRONT_LEFT) {
+ /* read/write front buffer */
+ xmesa->xm_buffer->buffer = xmesa->xm_buffer->frontbuffer;
+ ctx->NewState |= NEW_RASTER_OPS;
+ gl_update_state(ctx);
+ return GL_TRUE;
+ }
+ else if (mode==GL_BACK_LEFT && xmesa->xm_buffer->db_state) {
+ /* read/write back buffer */
+ if (xmesa->xm_buffer->backpixmap) {
+ xmesa->xm_buffer->buffer =
+ (XMesaDrawable)xmesa->xm_buffer->backpixmap;
+ }
+ else if (xmesa->xm_buffer->backimage) {
+ xmesa->xm_buffer->buffer = None;
+ }
+ else {
+ /* just in case there wasn't enough memory for back buffer */
+ xmesa->xm_buffer->buffer = xmesa->xm_buffer->frontbuffer;
+ }
+ ctx->NewState |= NEW_RASTER_OPS;
+ gl_update_state(ctx);
+ return GL_TRUE;
+ }
+ else {
+ return GL_FALSE;
+ }
+}
+#endif
+
+
+static GLboolean
+set_draw_buffer( GLcontext *ctx, GLenum mode )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ if (mode == GL_FRONT_LEFT) {
+ /* write to front buffer */
+ xmesa->xm_buffer->buffer = xmesa->xm_buffer->frontbuffer;
+ xmesa_update_span_funcs(ctx);
+ return GL_TRUE;
+ }
+ else if (mode==GL_BACK_LEFT && xmesa->xm_buffer->db_state) {
+ /* write to back buffer */
+ if (xmesa->xm_buffer->backpixmap) {
+ xmesa->xm_buffer->buffer =
+ (XMesaDrawable)xmesa->xm_buffer->backpixmap;
+ }
+ else if (xmesa->xm_buffer->backimage) {
+ xmesa->xm_buffer->buffer = None;
+ }
+ else {
+ /* just in case there wasn't enough memory for back buffer */
+ xmesa->xm_buffer->buffer = xmesa->xm_buffer->frontbuffer;
+ }
+ xmesa_update_span_funcs(ctx);
+ return GL_TRUE;
+ }
+ else {
+ return GL_FALSE;
+ }
+}
+
+
+static void
+set_read_buffer( GLcontext *ctx, GLframebuffer *buffer, GLenum mode )
+{
+ XMesaBuffer target;
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+
+ if (buffer == ctx->DrawBuffer) {
+ target = xmesa->xm_buffer;
+ xmesa->use_read_buffer = GL_FALSE;
+ }
+ else {
+ ASSERT(buffer == ctx->ReadBuffer);
+ target = xmesa->xm_read_buffer;
+ xmesa->use_read_buffer = GL_TRUE;
+ }
+
+ if (mode == GL_FRONT_LEFT) {
+ target->buffer = target->frontbuffer;
+ xmesa_update_span_funcs(ctx);
+ }
+ else if (mode==GL_BACK_LEFT && xmesa->xm_read_buffer->db_state) {
+ if (target->backpixmap) {
+ target->buffer = (XMesaDrawable)xmesa->xm_buffer->backpixmap;
+ }
+ else if (target->backimage) {
+ target->buffer = None;
+ }
+ else {
+ /* just in case there wasn't enough memory for back buffer */
+ target->buffer = target->frontbuffer;
+ }
+ xmesa_update_span_funcs(ctx);
+ }
+ else {
+ gl_problem(ctx, "invalid buffer in set_read_buffer() in xmesa2.c");
+ }
+}
+
+
+
+static void
+clear_index( GLcontext *ctx, GLuint index )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ xmesa->clearpixel = (unsigned long) index;
+ XMesaSetForeground( xmesa->display, xmesa->xm_buffer->cleargc,
+ (unsigned long) index );
+}
+
+
+static void
+clear_color( GLcontext *ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ xmesa->clearcolor[0] = r;
+ xmesa->clearcolor[1] = g;
+ xmesa->clearcolor[2] = b;
+ xmesa->clearcolor[3] = a;
+ xmesa->clearpixel = xmesa_color_to_pixel( xmesa, r, g, b, a,
+ xmesa->xm_visual->undithered_pf );
+ _glthread_LOCK_MUTEX(_xmesa_lock);
+ XMesaSetForeground( xmesa->display, xmesa->xm_buffer->cleargc,
+ xmesa->clearpixel );
+ _glthread_UNLOCK_MUTEX(_xmesa_lock);
+}
+
+
+
+/* Set current color index */
+static void
+set_index( GLcontext *ctx, GLuint index )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ unsigned long p = (unsigned long) index;
+ xmesa->pixel = p;
+ XMesaSetForeground( xmesa->display, xmesa->xm_buffer->gc1, p );
+}
+
+
+
+/* Set current drawing color */
+static void
+set_color( GLcontext *ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ xmesa->red = r;
+ xmesa->green = g;
+ xmesa->blue = b;
+ xmesa->alpha = a;
+ xmesa->pixel = xmesa_color_to_pixel( xmesa, r, g, b, a, xmesa->pixelformat );;
+ XMesaSetForeground( xmesa->display, xmesa->xm_buffer->gc1, xmesa->pixel );
+}
+
+
+
+/* Set index mask ala glIndexMask */
+static void
+index_mask( GLcontext *ctx, GLuint mask )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ if (xmesa->xm_buffer->buffer != XIMAGE) {
+ unsigned long m;
+ if (mask==0xffffffff) {
+ m = ((unsigned long)~0L);
+ }
+ else {
+ m = (unsigned long) mask;
+ }
+ XMesaSetPlaneMask( xmesa->display, xmesa->xm_buffer->cleargc, m );
+ }
+}
+
+
+/* Implements glColorMask() */
+static void
+color_mask(GLcontext *ctx,
+ GLboolean rmask, GLboolean gmask, GLboolean bmask, GLboolean amask)
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ int xclass = GET_VISUAL_CLASS(xmesa->xm_visual);
+ (void) amask;
+
+ if (xmesa->xm_buffer->buffer != XIMAGE
+ && (xclass == TrueColor || xclass == DirectColor)) {
+ unsigned long m;
+ if (rmask && gmask && bmask) {
+ m = ((unsigned long)~0L);
+ }
+ else {
+ m = 0;
+ if (rmask) m |= GET_REDMASK(xmesa->xm_visual);
+ if (gmask) m |= GET_GREENMASK(xmesa->xm_visual);
+ if (bmask) m |= GET_BLUEMASK(xmesa->xm_visual);
+ }
+ XMesaSetPlaneMask( xmesa->display, xmesa->xm_buffer->cleargc, m );
+ }
+}
+
+
+/*
+ * Enable/disable dithering
+ */
+static void
+dither( GLcontext *ctx, GLboolean enable )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ if (enable) {
+ xmesa->pixelformat = xmesa->xm_visual->dithered_pf;
+ }
+ else {
+ xmesa->pixelformat = xmesa->xm_visual->undithered_pf;
+ }
+}
+
+
+
+/**********************************************************************/
+/*** glClear implementations ***/
+/**********************************************************************/
+
+
+static void
+clear_front_pixmap( GLcontext *ctx, GLboolean all,
+ GLint x, GLint y, GLint width, GLint height )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ if (all) {
+ XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->frontbuffer,
+ xmesa->xm_buffer->cleargc,
+ 0, 0,
+ xmesa->xm_buffer->width+1,
+ xmesa->xm_buffer->height+1 );
+ }
+ else {
+ XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->frontbuffer,
+ xmesa->xm_buffer->cleargc,
+ x, xmesa->xm_buffer->height - y - height,
+ width, height );
+ }
+}
+
+
+static void
+clear_back_pixmap( GLcontext *ctx, GLboolean all,
+ GLint x, GLint y, GLint width, GLint height )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ if (all) {
+ XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->backpixmap,
+ xmesa->xm_buffer->cleargc,
+ 0, 0,
+ xmesa->xm_buffer->width+1,
+ xmesa->xm_buffer->height+1 );
+ }
+ else {
+ XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->backpixmap,
+ xmesa->xm_buffer->cleargc,
+ x, xmesa->xm_buffer->height - y - height,
+ width, height );
+ }
+}
+
+
+static void
+clear_8bit_ximage( GLcontext *ctx, GLboolean all,
+ GLint x, GLint y, GLint width, GLint height )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ if (all) {
+ size_t n = xmesa->xm_buffer->backimage->bytes_per_line
+ * xmesa->xm_buffer->backimage->height;
+ MEMSET( xmesa->xm_buffer->backimage->data, xmesa->clearpixel, n );
+ }
+ else {
+ GLint i;
+ for (i=0;i<height;i++) {
+ GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y+i );
+ MEMSET( ptr, xmesa->clearpixel, width );
+ }
+ }
+}
+
+
+static void
+clear_HPCR_ximage( GLcontext *ctx, GLboolean all,
+ GLint x, GLint y, GLint width, GLint height )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ if (all) {
+ GLint i, c16 = (xmesa->xm_buffer->backimage->bytes_per_line>>4)<<4;
+ GLubyte *ptr = (GLubyte *)xmesa->xm_buffer->backimage->data;
+ for (i=0; i<xmesa->xm_buffer->backimage->height; i++) {
+ GLint j;
+ GLubyte *sptr = xmesa->xm_visual->hpcr_clear_ximage_pattern[0];
+ if (i&1) {
+ sptr += 16;
+ }
+ for (j=0; j<c16; j+=16) {
+ ptr[0] = sptr[0];
+ ptr[1] = sptr[1];
+ ptr[2] = sptr[2];
+ ptr[3] = sptr[3];
+ ptr[4] = sptr[4];
+ ptr[5] = sptr[5];
+ ptr[6] = sptr[6];
+ ptr[7] = sptr[7];
+ ptr[8] = sptr[8];
+ ptr[9] = sptr[9];
+ ptr[10] = sptr[10];
+ ptr[11] = sptr[11];
+ ptr[12] = sptr[12];
+ ptr[13] = sptr[13];
+ ptr[14] = sptr[14];
+ ptr[15] = sptr[15];
+ ptr += 16;
+ }
+ for (; j<xmesa->xm_buffer->backimage->bytes_per_line; j++) {
+ *ptr = sptr[j&15];
+ ptr++;
+ }
+ }
+ }
+ else {
+ GLint i;
+ for (i=y; i<y+height; i++) {
+ GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, i );
+ int j;
+ GLubyte *sptr = xmesa->xm_visual->hpcr_clear_ximage_pattern[0];
+ if (i&1) {
+ sptr += 16;
+ }
+ for (j=x; j<x+width; j++) {
+ *ptr = sptr[j&15];
+ ptr++;
+ }
+ }
+ }
+}
+
+
+static void
+clear_16bit_ximage( GLcontext *ctx, GLboolean all,
+ GLint x, GLint y, GLint width, GLint height )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint pixel = (GLuint) xmesa->clearpixel;
+ if (xmesa->swapbytes) {
+ pixel = ((pixel >> 8) & 0x00ff) | ((pixel << 8) & 0xff00);
+ }
+ if (all) {
+ register GLuint n;
+ register GLuint *ptr4 = (GLuint *) xmesa->xm_buffer->backimage->data;
+ if ((pixel & 0xff) == ((pixel >> 8) & 0xff)) {
+ /* low and high bytes are equal so use memset() */
+ n = xmesa->xm_buffer->backimage->bytes_per_line
+ * xmesa->xm_buffer->height;
+ MEMSET( ptr4, pixel & 0xff, n );
+ }
+ else {
+ pixel = pixel | (pixel<<16);
+ n = xmesa->xm_buffer->backimage->bytes_per_line
+ * xmesa->xm_buffer->height / 4;
+ do {
+ *ptr4++ = pixel;
+ n--;
+ } while (n!=0);
+
+ if ((xmesa->xm_buffer->backimage->bytes_per_line *
+ xmesa->xm_buffer->height) & 0x2)
+ *(GLushort *)ptr4 = pixel & 0xffff;
+ }
+ }
+ else {
+ register int i, j;
+ for (j=0;j<height;j++) {
+ register GLushort *ptr2 = PIXELADDR2( xmesa->xm_buffer, x, y+j );
+ for (i=0;i<width;i++) {
+ *ptr2++ = pixel;
+ }
+ }
+ }
+}
+
+
+/* Optimized code provided by Nozomi Ytow <[email protected]> */
+static void
+clear_24bit_ximage( GLcontext *ctx, GLboolean all,
+ GLint x, GLint y, GLint width, GLint height )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte r = xmesa->clearcolor[0];
+ const GLubyte g = xmesa->clearcolor[1];
+ const GLubyte b = xmesa->clearcolor[2];
+ register GLuint clearPixel;
+ if (xmesa->swapbytes) {
+ clearPixel = (b << 16) | (g << 8) | r;
+ }
+ else {
+ clearPixel = (r << 16) | (g << 8) | b;
+ }
+
+ if (all) {
+ if (r==g && g==b) {
+ /* same value for all three components (gray) */
+ const GLint w3 = xmesa->xm_buffer->width * 3;
+ const GLint h = xmesa->xm_buffer->height;
+ GLint i;
+ for (i = 0; i < h; i++) {
+ bgr_t *ptr3 = PIXELADDR3(xmesa->xm_buffer, 0, i);
+ MEMSET(ptr3, r, w3);
+ }
+ }
+ else {
+ /* the usual case */
+ const GLint w = xmesa->xm_buffer->width;
+ const GLint h = xmesa->xm_buffer->height;
+ GLint i, j;
+ for (i = 0; i < h; i++) {
+ bgr_t *ptr3 = PIXELADDR3(xmesa->xm_buffer, 0, i);
+ for (j = 0; j < w; j++) {
+ ptr3->r = r;
+ ptr3->g = g;
+ ptr3->b = b;
+ ptr3++;
+ }
+ }
+#if 0 /* this code doesn't work for all window widths */
+ register GLuint *ptr4 = (GLuint *) ptr3;
+ register GLuint px;
+ GLuint pixel4[3];
+ register GLuint *p = pixel4;
+ pixel4[0] = clearPixel | (clearPixel << 24);
+ pixel4[1] = (clearPixel << 16) | (clearPixel >> 8);
+ pixel4[2] = (clearPixel << 8) | (clearPixel >> 16);
+ switch (3 & (int)(ptr3 - (bgr_t*) ptr4)){
+ case 0:
+ break;
+ case 1:
+ px = *ptr4 & 0x00ffffff;
+ px |= pixel4[0] & 0xff000000;
+ *ptr4++ = px;
+ px = *ptr4 & 0xffff0000;
+ px |= pixel4[2] & 0x0000ffff;
+ *ptr4 = px;
+ if (0 == --n)
+ break;
+ case 2:
+ px = *ptr4 & 0x0000fffff;
+ px |= pixel4[1] & 0xffff0000;
+ *ptr4++ = px;
+ px = *ptr4 & 0xffffff00;
+ px |= pixel4[2] & 0x000000ff;
+ *ptr4 = px;
+ if (0 == --n)
+ break;
+ case 3:
+ px = *ptr4 & 0x000000ff;
+ px |= pixel4[2] & 0xffffff00;
+ *ptr4++ = px;
+ --n;
+ break;
+ }
+ while (n > 3) {
+ p = pixel4;
+ *ptr4++ = *p++;
+ *ptr4++ = *p++;
+ *ptr4++ = *p++;
+ n -= 4;
+ }
+ switch (n) {
+ case 3:
+ p = pixel4;
+ *ptr4++ = *p++;
+ *ptr4++ = *p++;
+ px = *ptr4 & 0xffffff00;
+ px |= clearPixel & 0xff;
+ *ptr4 = px;
+ break;
+ case 2:
+ p = pixel4;
+ *ptr4++ = *p++;
+ px = *ptr4 & 0xffff0000;
+ px |= *p & 0xffff;
+ *ptr4 = px;
+ break;
+ case 1:
+ px = *ptr4 & 0xff000000;
+ px |= *p & 0xffffff;
+ *ptr4 = px;
+ break;
+ case 0:
+ break;
+ }
+#endif
+ }
+ }
+ else {
+ /* only clear subrect of color buffer */
+ if (r==g && g==b) {
+ /* same value for all three components (gray) */
+ GLint j;
+ for (j=0;j<height;j++) {
+ bgr_t *ptr3 = PIXELADDR3( xmesa->xm_buffer, x, y+j );
+ MEMSET(ptr3, r, 3 * width);
+ }
+ }
+ else {
+ /* non-gray clear color */
+ GLint i, j;
+ for (j = 0; j < height; j++) {
+ bgr_t *ptr3 = PIXELADDR3( xmesa->xm_buffer, x, y+j );
+ for (i = 0; i < width; i++) {
+ ptr3->r = r;
+ ptr3->g = g;
+ ptr3->b = b;
+ ptr3++;
+ }
+ }
+#if 0 /* this code might not always (seems ptr3 always == ptr4) */
+ GLint j;
+ GLuint pixel4[3];
+ pixel4[0] = clearPixel | (clearPixel << 24);
+ pixel4[1] = (clearPixel << 16) | (clearPixel >> 8);
+ pixel4[2] = (clearPixel << 8) | (clearPixel >> 16);
+ for (j=0;j<height;j++) {
+ bgr_t *ptr3 = PIXELADDR3( xmesa->xm_buffer, x, y+j );
+ register GLuint *ptr4 = (GLuint *)ptr3;
+ register GLuint *p, px;
+ GLuint w = width;
+ switch (3 & (int)(ptr3 - (bgr_t*) ptr4)){
+ case 0:
+ break;
+ case 1:
+ px = *ptr4 & 0x00ffffff;
+ px |= pixel4[0] & 0xff000000;
+ *ptr4++ = px;
+ px = *ptr4 & 0xffff0000;
+ px |= pixel4[2] & 0x0000ffff;
+ *ptr4 = px;
+ if (0 == --w)
+ break;
+ case 2:
+ px = *ptr4 & 0x0000fffff;
+ px |= pixel4[1] & 0xffff0000;
+ *ptr4++ = px;
+ px = *ptr4 & 0xffffff00;
+ px |= pixel4[2] & 0x000000ff;
+ *ptr4 = px;
+ if (0 == --w)
+ break;
+ case 3:
+ px = *ptr4 & 0x000000ff;
+ px |= pixel4[2] & 0xffffff00;
+ *ptr4++ = px;
+ --w;
+ break;
+ }
+ while (w > 3){
+ p = pixel4;
+ *ptr4++ = *p++;
+ *ptr4++ = *p++;
+ *ptr4++ = *p++;
+ w -= 4;
+ }
+ switch (w) {
+ case 3:
+ p = pixel4;
+ *ptr4++ = *p++;
+ *ptr4++ = *p++;
+ px = *ptr4 & 0xffffff00;
+ px |= *p & 0xff;
+ *ptr4 = px;
+ break;
+ case 2:
+ p = pixel4;
+ *ptr4++ = *p++;
+ px = *ptr4 & 0xffff0000;
+ px |= *p & 0xffff;
+ *ptr4 = px;
+ break;
+ case 1:
+ px = *ptr4 & 0xff000000;
+ px |= pixel4[0] & 0xffffff;
+ *ptr4 = px;
+ break;
+ case 0:
+ break;
+ }
+ }
+#endif
+ }
+ }
+}
+
+
+static void
+clear_32bit_ximage( GLcontext *ctx, GLboolean all,
+ GLint x, GLint y, GLint width, GLint height )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ if (all) {
+ register GLint n = xmesa->xm_buffer->width * xmesa->xm_buffer->height;
+ register GLuint *ptr4 = (GLuint *) xmesa->xm_buffer->backimage->data;
+ register GLuint pixel = (GLuint) xmesa->clearpixel;
+ if (xmesa->swapbytes) {
+ pixel = ((pixel >> 24) & 0x000000ff)
+ | ((pixel >> 8) & 0x0000ff00)
+ | ((pixel << 8) & 0x00ff0000)
+ | ((pixel << 24) & 0xff000000);
+ }
+ if (pixel==0) {
+ MEMSET( ptr4, pixel, 4*n );
+ }
+ else {
+ do {
+ *ptr4++ = pixel;
+ n--;
+ } while (n!=0);
+ }
+ }
+ else {
+ register int i, j;
+ register GLuint pixel = (GLuint) xmesa->clearpixel;
+ for (j=0;j<height;j++) {
+ register GLuint *ptr4 = PIXELADDR4( xmesa->xm_buffer, x, y+j );
+ for (i=0;i<width;i++) {
+ *ptr4++ = pixel;
+ }
+ }
+ }
+}
+
+
+static void
+clear_nbit_ximage( GLcontext *ctx, GLboolean all,
+ GLint x, GLint y, GLint width, GLint height )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ if (all) {
+ register int i, j;
+ width = xmesa->xm_buffer->width;
+ height = xmesa->xm_buffer->height;
+ for (j=0;j<height;j++) {
+ for (i=0;i<width;i++) {
+ XMesaPutPixel( img, i, j, xmesa->clearpixel );
+ }
+ }
+ }
+ else {
+ /* TODO: optimize this */
+ register int i, j;
+ y = FLIP(xmesa->xm_buffer, y);
+ for (j=0;j<height;j++) {
+ for (i=0;i<width;i++) {
+ XMesaPutPixel( img, x+i, y-j, xmesa->clearpixel );
+ }
+ }
+ }
+}
+
+
+
+static GLbitfield
+clear_buffers( GLcontext *ctx, GLbitfield mask,
+ GLboolean all, GLint x, GLint y, GLint width, GLint height )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLuint *colorMask = (GLuint *) &ctx->Color.ColorMask;
+
+ /* we can't handle color or index masking */
+ if (mask & (DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT)) {
+ if (*colorMask != 0xffffffff || ctx->Color.IndexMask != 0xffffffff)
+ return mask;
+ }
+
+ if (mask & DD_FRONT_LEFT_BIT) {
+ ASSERT(xmesa->xm_buffer->front_clear_func);
+ (*xmesa->xm_buffer->front_clear_func)( ctx, all, x, y, width, height );
+ }
+ if (mask & DD_BACK_LEFT_BIT) {
+ ASSERT(xmesa->xm_buffer->back_clear_func);
+ (*xmesa->xm_buffer->back_clear_func)( ctx, all, x, y, width, height );
+ }
+ return mask & (~(DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT));
+}
+
+
+
+#ifndef XFree86Server
+/*
+ * This function implements glDrawPixels() with an XPutImage call when
+ * drawing to the front buffer (X Window drawable).
+ * The image format must be GL_BGRA to match the PF_8R8G8B pixel format.
+ * XXX top/bottom edge clipping is broken!
+ */
+static GLboolean
+drawpixels_8R8G8B( GLcontext *ctx,
+ GLint x, GLint y, GLsizei width, GLsizei height,
+ GLenum format, GLenum type,
+ const struct gl_pixelstore_attrib *unpack,
+ const GLvoid *pixels )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc1;
+ assert(dpy);
+ assert(buffer);
+ assert(gc);
+
+ /* XXX also check for pixel scale/bias/lookup/zooming! */
+ if (format == GL_BGRA && type == GL_UNSIGNED_BYTE) {
+ int dstX = x;
+ int dstY = y;
+ int w = width;
+ int h = height;
+ int srcX = unpack->SkipPixels;
+ int srcY = unpack->SkipRows;
+ if (_mesa_clip_pixelrect(ctx, &dstX, &dstY, &w, &h, &srcX, &srcY)) {
+ XMesaImage ximage;
+ MEMSET(&ximage, 0, sizeof(XMesaImage));
+ ximage.width = width;
+ ximage.height = height;
+ ximage.format = ZPixmap;
+ ximage.data = (char *) pixels + (height - 1) * width * 4;
+ ximage.byte_order = LSBFirst;
+ ximage.bitmap_unit = 32;
+ ximage.bitmap_bit_order = LSBFirst;
+ ximage.bitmap_pad = 32;
+ ximage.depth = 24;
+ ximage.bytes_per_line = -width * 4;
+ ximage.bits_per_pixel = 32;
+ ximage.red_mask = 0xff0000;
+ ximage.green_mask = 0x00ff00;
+ ximage.blue_mask = 0x0000ff;
+ dstY = FLIP(xmesa->xm_buffer,dstY) - height + 1;
+ XPutImage(dpy, buffer, gc, &ximage, srcX, srcY, dstX, dstY, w, h);
+ return GL_TRUE;
+ }
+ }
+ return GL_FALSE;
+}
+#endif
+
+
+
+static const GLubyte *
+get_string( GLcontext *ctx, GLenum name )
+{
+ (void) ctx;
+ switch (name) {
+ case GL_RENDERER:
+#ifdef XFree86Server
+ return (const GLubyte *) "Mesa GLX Indirect";
+#else
+ return (const GLubyte *) "Mesa X11";
+#endif
+ case GL_VENDOR:
+#ifdef XFree86Server
+ return (const GLubyte *) "VA Linux Systems, Inc.";
+#else
+ return NULL;
+#endif
+ default:
+ return NULL;
+ }
+}
+
+
+/*
+ * Initialize all the DD.* function pointers depending on the color
+ * buffer configuration. This is mainly called by XMesaMakeCurrent.
+ */
+void
+xmesa_update_state( GLcontext *ctx )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ /*int depth=GET_VISUAL_DEPTH(xmesa->xm_visual);*/
+
+ (void) DitherValues; /* silenced unused var warning */
+#ifndef XFree86Server
+ (void) drawpixels_8R8G8B;
+#endif
+
+ /*
+ * Always the same:
+ */
+ ctx->Driver.GetString = get_string;
+ ctx->Driver.UpdateState = xmesa_update_state;
+ ctx->Driver.GetBufferSize = get_buffer_size;
+ ctx->Driver.Flush = flush;
+ ctx->Driver.Finish = finish;
+
+ ctx->Driver.RenderStart = 0;
+ ctx->Driver.RenderFinish = 0;
+
+ ctx->Driver.SetDrawBuffer = set_draw_buffer;
+ ctx->Driver.SetReadBuffer = set_read_buffer;
+
+ ctx->Driver.Index = set_index;
+ ctx->Driver.Color = set_color;
+ ctx->Driver.ClearIndex = clear_index;
+ ctx->Driver.ClearColor = clear_color;
+ ctx->Driver.Clear = clear_buffers;
+ ctx->Driver.IndexMask = index_mask;
+ ctx->Driver.ColorMask = color_mask;
+ ctx->Driver.Dither = dither;
+
+ ctx->Driver.PointsFunc = xmesa_get_points_func( ctx );
+ ctx->Driver.LineFunc = xmesa_get_line_func( ctx );
+ ctx->Driver.TriangleFunc = xmesa_get_triangle_func( ctx );
+
+/* ctx->Driver.TriangleCaps = DD_TRI_CULL; */
+
+ /* setup pointers to front and back buffer clear functions */
+ /* XXX this bit of code could be moved to a one-time init */
+ xmesa->xm_buffer->front_clear_func = clear_front_pixmap;
+ if (xmesa->xm_buffer->backpixmap != XIMAGE) {
+ /* back buffer is a pixmap */
+ xmesa->xm_buffer->back_clear_func = clear_back_pixmap;
+ }
+ else if (sizeof(GLushort)!=2 || sizeof(GLuint)!=4) {
+ /* Do this on Crays */
+ xmesa->xm_buffer->back_clear_func = clear_nbit_ximage;
+ }
+ else {
+ /* Do this on most machines */
+ switch (xmesa->xm_visual->BitsPerPixel) {
+ case 8:
+ if (xmesa->xm_visual->hpcr_clear_flag) {
+ xmesa->xm_buffer->back_clear_func = clear_HPCR_ximage;
+ }
+ else {
+ xmesa->xm_buffer->back_clear_func = clear_8bit_ximage;
+ }
+ break;
+ case 16:
+ xmesa->xm_buffer->back_clear_func = clear_16bit_ximage;
+ break;
+ case 24:
+ xmesa->xm_buffer->back_clear_func = clear_24bit_ximage;
+ break;
+ case 32:
+ xmesa->xm_buffer->back_clear_func = clear_32bit_ximage;
+ break;
+ default:
+ xmesa->xm_buffer->back_clear_func = clear_nbit_ximage;
+ break;
+ }
+ }
+
+ xmesa_update_span_funcs(ctx);
+}
diff --git a/src/mesa/drivers/x11/xm_line.c b/src/mesa/drivers/x11/xm_line.c
new file mode 100644
index 00000000000..8312a2f23d0
--- /dev/null
+++ b/src/mesa/drivers/x11/xm_line.c
@@ -0,0 +1,748 @@
+/* $Id: xm_line.c,v 1.1 2000/09/07 15:40:30 brianp Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.3
+ *
+ * Copyright (C) 1999 Brian Paul All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/*
+ * This file contains "accelerated" point, line, and triangle functions.
+ * It should be fairly easy to write new special-purpose point, line or
+ * triangle functions and hook them into this module.
+ */
+
+
+#include "glxheader.h"
+#include "depth.h"
+#include "macros.h"
+#include "vb.h"
+#include "types.h"
+#include "xmesaP.h"
+
+
+
+/**********************************************************************/
+/*** Point rendering ***/
+/**********************************************************************/
+
+
+/*
+ * Render an array of points into a pixmap, any pixel format.
+ */
+static void draw_points_ANY_pixmap( GLcontext *ctx, GLuint first, GLuint last )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ struct vertex_buffer *VB = ctx->VB;
+ register GLuint i;
+
+ if (xmesa->xm_visual->gl_visual->RGBAflag) {
+ /* RGB mode */
+ for (i=first;i<=last;i++) {
+ if (VB->ClipMask[i]==0) {
+ register int x, y;
+ const GLubyte *color = VB->ColorPtr->data[i];
+ unsigned long pixel = xmesa_color_to_pixel( xmesa,
+ color[0], color[1], color[2], color[3], xmesa->pixelformat);
+ XMesaSetForeground( dpy, gc, pixel );
+ x = (GLint) VB->Win.data[i][0];
+ y = FLIP( xmesa->xm_buffer, (GLint) VB->Win.data[i][1] );
+ XMesaDrawPoint( dpy, buffer, gc, x, y);
+ }
+ }
+ }
+ else {
+ /* Color index mode */
+ for (i=first;i<=last;i++) {
+ if (VB->ClipMask[i]==0) {
+ register int x, y;
+ XMesaSetForeground( dpy, gc, VB->IndexPtr->data[i] );
+ x = (GLint) VB->Win.data[i][0];
+ y = FLIP( xmesa->xm_buffer, (GLint) VB->Win.data[i][1] );
+ XMesaDrawPoint( dpy, buffer, gc, x, y);
+ }
+ }
+ }
+}
+
+
+
+/*
+ * Analyze context state to see if we can provide a fast points drawing
+ * function, like those in points.c. Otherwise, return NULL.
+ */
+points_func xmesa_get_points_func( GLcontext *ctx )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+
+ if (ctx->Point.Size==1.0F && !ctx->Point.SmoothFlag && ctx->RasterMask==0
+ && !ctx->Texture.Enabled) {
+ if (xmesa->xm_buffer->buffer==XIMAGE) {
+ return NULL; /*draw_points_ximage;*/
+ }
+ else {
+ return draw_points_ANY_pixmap;
+ }
+ }
+ else {
+ return NULL;
+ }
+}
+
+
+
+/**********************************************************************/
+/*** Line rendering ***/
+/**********************************************************************/
+
+
+#if 0
+/*
+ * Render a line into a pixmap, any pixel format.
+ */
+static void flat_pixmap_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ struct vertex_buffer *VB = ctx->VB;
+ register int x0, y0, x1, y1;
+ XMesaGC gc;
+ unsigned long pixel;
+ if (xmesa->xm_visual->gl_visual->RGBAflag) {
+ const GLubyte *color = VB->ColorPtr->data[pv];
+ pixel = xmesa_color_to_pixel( xmesa, color[0], color[1], color[2], color[3],
+ xmesa->pixelformat );
+ }
+ else {
+ pixel = VB->IndexPtr->data[pv];
+ }
+ gc = xmesa->xm_buffer->gc2;
+ XMesaSetForeground( xmesa->display, gc, pixel );
+
+ x0 = (GLint) VB->Win.data[vert0][0];
+ y0 = FLIP( xmesa->xm_buffer, (GLint) VB->Win.data[vert0][1] );
+ x1 = (GLint) VB->Win.data[vert1][0];
+ y1 = FLIP( xmesa->xm_buffer, (GLint) VB->Win.data[vert1][1] );
+ XMesaDrawLine( xmesa->display, xmesa->xm_buffer->buffer, gc,
+ x0, y0, x1, y1 );
+}
+#endif
+
+
+/*
+ * Draw a flat-shaded, PF_TRUECOLOR line into an XImage.
+ */
+static void flat_TRUECOLOR_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ unsigned long pixel;
+ PACK_TRUECOLOR( pixel, color[0], color[1], color[2] );
+
+#define INTERP_XY 1
+#define CLIP_HACK 1
+#define PLOT(X,Y) XMesaPutPixel( img, X, FLIP(xmesa->xm_buffer, Y), pixel );
+
+#include "linetemp.h"
+}
+
+
+
+/*
+ * Draw a flat-shaded, PF_8A8B8G8R line into an XImage.
+ */
+static void flat_8A8B8G8R_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+ GLuint pixel = PACK_8B8G8R( color[0], color[1], color[2] );
+
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) *pixelPtr = pixel;
+
+#include "linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, PF_8R8G8B line into an XImage.
+ */
+static void flat_8R8G8B_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+ GLuint pixel = PACK_8R8G8B( color[0], color[1], color[2] );
+
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) *pixelPtr = pixel;
+
+#include "linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, PF_8R8G8B24 line into an XImage.
+ */
+static void flat_8R8G8B24_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+
+#define PIXEL_TYPE bgr_t
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) { \
+ pixelPtr->r = color[RCOMP]; \
+ pixelPtr->g = color[GCOMP]; \
+ pixelPtr->b = color[BCOMP]; \
+}
+
+#include "linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, PF_5R6G5B line into an XImage.
+ */
+static void flat_5R6G5B_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+ GLushort pixel = PACK_5R6G5B( color[0], color[1], color[2] );
+
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) *pixelPtr = pixel;
+
+#include "linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, PF_DITHER_5R6G5B line into an XImage.
+ */
+static void flat_DITHER_5R6G5B_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) PACK_TRUEDITHER( *pixelPtr, X, Y, color[0], color[1], color[2] );
+
+#include "linetemp.h"
+}
+
+
+
+/*
+ * Draw a flat-shaded, PF_DITHER 8-bit line into an XImage.
+ */
+static void flat_DITHER8_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+ GLint r = color[0], g = color[1], b = color[2];
+ DITHER_SETUP;
+
+#define INTERP_XY 1
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) *pixelPtr = DITHER(X,Y,r,g,b);
+
+#include "linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, PF_LOOKUP 8-bit line into an XImage.
+ */
+static void flat_LOOKUP8_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+ GLubyte pixel;
+ LOOKUP_SETUP;
+ pixel = (GLubyte) LOOKUP( color[0], color[1], color[2] );
+
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) *pixelPtr = pixel;
+
+#include "linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, PF_HPCR line into an XImage.
+ */
+static void flat_HPCR_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+ GLint r = color[0], g = color[1], b = color[2];
+
+#define INTERP_XY 1
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) *pixelPtr = (GLubyte) DITHER_HPCR(X,Y,r,g,b);
+
+#include "linetemp.h"
+}
+
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_TRUECOLOR line into an XImage.
+ */
+static void flat_TRUECOLOR_z_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ unsigned long pixel;
+ PACK_TRUECOLOR( pixel, color[0], color[1], color[2] );
+
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define CLIP_HACK 1
+#define PLOT(X,Y) \
+ if (Z < *zPtr) { \
+ *zPtr = Z; \
+ XMesaPutPixel( img, X, FLIP(xmesa->xm_buffer, Y), pixel ); \
+ }
+
+#include "linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_8A8B8G8R line into an XImage.
+ */
+static void flat_8A8B8G8R_z_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+ GLuint pixel = PACK_8B8G8R( color[0], color[1], color[2] );
+
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) \
+ if (Z < *zPtr) { \
+ *zPtr = Z; \
+ *pixelPtr = pixel; \
+ }
+
+#include "linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_8R8G8B line into an XImage.
+ */
+static void flat_8R8G8B_z_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+ GLuint pixel = PACK_8R8G8B( color[0], color[1], color[2] );
+
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) \
+ if (Z < *zPtr) { \
+ *zPtr = Z; \
+ *pixelPtr = pixel; \
+ }
+
+#include "linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_8R8G8B24 line into an XImage.
+ */
+static void flat_8R8G8B24_z_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_TYPE bgr_t
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) \
+ if (Z < *zPtr) { \
+ *zPtr = Z; \
+ pixelPtr->r = color[RCOMP]; \
+ pixelPtr->g = color[GCOMP]; \
+ pixelPtr->b = color[BCOMP]; \
+ }
+
+#include "linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_5R6G5B line into an XImage.
+ */
+static void flat_5R6G5B_z_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+ GLushort pixel = PACK_5R6G5B( color[0], color[1], color[2] );
+
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) \
+ if (Z < *zPtr) { \
+ *zPtr = Z; \
+ *pixelPtr = pixel; \
+ }
+#include "linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_DITHER_5R6G5B line into an XImage.
+ */
+static void flat_DITHER_5R6G5B_z_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) \
+ if (Z < *zPtr) { \
+ *zPtr = Z; \
+ PACK_TRUEDITHER(*pixelPtr, X, Y, color[0], color[1], color[2]); \
+ }
+#include "linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_DITHER 8-bit line into an XImage.
+ */
+static void flat_DITHER8_z_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+ GLint r = color[0], g = color[1], b = color[2];
+ DITHER_SETUP;
+
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) \
+ if (Z < *zPtr) { \
+ *zPtr = Z; \
+ *pixelPtr = (GLubyte) DITHER( X, Y, r, g, b); \
+ }
+#include "linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_LOOKUP 8-bit line into an XImage.
+ */
+static void flat_LOOKUP8_z_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+ GLubyte pixel;
+ LOOKUP_SETUP;
+ pixel = (GLubyte) LOOKUP( color[0], color[1], color[2] );
+
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) \
+ if (Z < *zPtr) { \
+ *zPtr = Z; \
+ *pixelPtr = pixel; \
+ }
+
+#include "linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_HPCR line into an XImage.
+ */
+static void flat_HPCR_z_line( GLcontext *ctx,
+ GLuint vert0, GLuint vert1, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+ GLint r = color[0], g = color[1], b = color[2];
+
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) \
+ if (Z < *zPtr) { \
+ *zPtr = Z; \
+ *pixelPtr = (GLubyte) DITHER_HPCR( X, Y, r, g, b); \
+ }
+
+#include "linetemp.h"
+}
+
+
+#if 0
+/*
+ * Examine ctx->Line attributes and set xmesa->xm_buffer->gc1
+ * and xmesa->xm_buffer->gc2 appropriately.
+ */
+static void setup_x_line_options( GLcontext *ctx )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ int i, state, state0, new_state, len, offs;
+ int tbit;
+ char *dptr;
+ int n_segments = 0;
+ char dashes[20];
+ int line_width, line_style;
+
+ /*** Line Stipple ***/
+ if (ctx->Line.StippleFlag) {
+ const int pattern = ctx->Line.StipplePattern;
+
+ dptr = dashes;
+ state0 = state = ((pattern & 1) != 0);
+
+ /* Decompose the pattern */
+ for (i=1,tbit=2,len=1;i<16;++i,tbit=(tbit<<1))
+ {
+ new_state = ((tbit & pattern) != 0);
+ if (state != new_state)
+ {
+ *dptr++ = ctx->Line.StippleFactor * len;
+ len = 1;
+ state = new_state;
+ }
+ else
+ ++len;
+ }
+ *dptr = ctx->Line.StippleFactor * len;
+ n_segments = 1 + (dptr - dashes);
+
+ /* ensure an even no. of segments, or X may toggle on/off for consecutive patterns */
+ /* if (n_segments & 1) dashes [n_segments++] = 0; value of 0 not allowed in dash list */
+
+ /* Handle case where line style starts OFF */
+ if (state0 == 0)
+ offs = dashes[0];
+ else
+ offs = 0;
+
+#if 0
+fprintf (stderr, "input pattern: 0x%04x, offset %d, %d segments:", pattern, offs, n_segments);
+for (i = 0; i < n_segments; i++)
+fprintf (stderr, " %d", dashes[i]);
+fprintf (stderr, "\n");
+#endif
+
+ XMesaSetDashes( xmesa->display, xmesa->xm_buffer->gc1,
+ offs, dashes, n_segments );
+ XMesaSetDashes( xmesa->display, xmesa->xm_buffer->gc2,
+ offs, dashes, n_segments );
+
+ line_style = LineOnOffDash;
+ }
+ else {
+ line_style = LineSolid;
+ }
+
+ /*** Line Width ***/
+ line_width = (int) (ctx->Line.Width+0.5F);
+ if (line_width < 2) {
+ /* Use fast lines when possible */
+ line_width = 0;
+ }
+
+ /*** Set GC attributes ***/
+ XMesaSetLineAttributes( xmesa->display, xmesa->xm_buffer->gc1,
+ line_width, line_style, CapButt, JoinBevel);
+ XMesaSetLineAttributes( xmesa->display, xmesa->xm_buffer->gc2,
+ line_width, line_style, CapButt, JoinBevel);
+ XMesaSetFillStyle( xmesa->display, xmesa->xm_buffer->gc1, FillSolid );
+ XMesaSetFillStyle( xmesa->display, xmesa->xm_buffer->gc2, FillSolid );
+}
+#endif
+
+
+
+/*
+ * Analyze context state to see if we can provide a fast line drawing
+ * function, like those in lines.c. Otherwise, return NULL.
+ */
+line_func xmesa_get_line_func( GLcontext *ctx )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
+
+ (void) DitherValues; /* silence unused var warning */
+ (void) kernel1; /* silence unused var warning */
+
+ if (ctx->Line.SmoothFlag) return NULL;
+ if (ctx->Texture.Enabled) return NULL;
+ if (ctx->Light.ShadeModel!=GL_FLAT) return NULL;
+ /* X line stippling doesn't match OpenGL stippling */
+ if (ctx->Line.StippleFlag==GL_TRUE) return NULL;
+
+ if (xmesa->xm_buffer->buffer==XIMAGE
+ && ctx->RasterMask==DEPTH_BIT
+ && ctx->Depth.Func==GL_LESS
+ && ctx->Depth.Mask==GL_TRUE
+ && ctx->Visual->DepthBits == DEFAULT_SOFTWARE_DEPTH_BITS
+ && ctx->Line.Width==1.0F) {
+ switch (xmesa->pixelformat) {
+ case PF_TRUECOLOR:
+ return flat_TRUECOLOR_z_line;
+ case PF_8A8B8G8R:
+ return flat_8A8B8G8R_z_line;
+ case PF_8R8G8B:
+ return flat_8R8G8B_z_line;
+ case PF_8R8G8B24:
+ return flat_8R8G8B24_z_line;
+ case PF_5R6G5B:
+ return flat_5R6G5B_z_line;
+ case PF_DITHER_5R6G5B:
+ return flat_DITHER_5R6G5B_z_line;
+ case PF_DITHER:
+ return (depth==8) ? flat_DITHER8_z_line : NULL;
+ case PF_LOOKUP:
+ return (depth==8) ? flat_LOOKUP8_z_line : NULL;
+ case PF_HPCR:
+ return flat_HPCR_z_line;
+ default:
+ return NULL;
+ }
+ }
+ if (xmesa->xm_buffer->buffer==XIMAGE
+ && ctx->RasterMask==0
+ && ctx->Line.Width==1.0F) {
+ switch (xmesa->pixelformat) {
+ case PF_TRUECOLOR:
+ return flat_TRUECOLOR_line;
+ case PF_8A8B8G8R:
+ return flat_8A8B8G8R_line;
+ case PF_8R8G8B:
+ return flat_8R8G8B_line;
+ case PF_8R8G8B24:
+ return flat_8R8G8B24_line;
+ case PF_5R6G5B:
+ return flat_5R6G5B_line;
+ case PF_DITHER_5R6G5B:
+ return flat_DITHER_5R6G5B_line;
+ case PF_DITHER:
+ return (depth==8) ? flat_DITHER8_line : NULL;
+ case PF_LOOKUP:
+ return (depth==8) ? flat_LOOKUP8_line : NULL;
+ case PF_HPCR:
+ return flat_HPCR_line;
+ default:
+ return NULL;
+ }
+ }
+#if 0
+ /* XXX have to disable this because X's rasterization rules don't match
+ * software Mesa's. This causes the linehv.c conformance test to fail.
+ * In the future, we might provide a config option to enable this.
+ */
+ if (xmesa->xm_buffer->buffer!=XIMAGE && ctx->RasterMask==0) {
+ setup_x_line_options( ctx );
+ return flat_pixmap_line;
+ }
+#endif
+ return NULL;
+}
diff --git a/src/mesa/drivers/x11/xm_span.c b/src/mesa/drivers/x11/xm_span.c
new file mode 100644
index 00000000000..3542f9275a4
--- /dev/null
+++ b/src/mesa/drivers/x11/xm_span.c
@@ -0,0 +1,4447 @@
+/* $Id: xm_span.c,v 1.1 2000/09/07 15:40:30 brianp Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.3
+ *
+ * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+#include "glxheader.h"
+#include "context.h"
+#include "drawpix.h"
+#include "mem.h"
+#include "state.h"
+#include "depth.h"
+#include "macros.h"
+#include "vb.h"
+#include "types.h"
+#include "xmesaP.h"
+#include "extensions.h"
+
+
+
+
+/*
+ * The following functions are used to trap XGetImage() calls which
+ * generate BadMatch errors if the drawable isn't mapped.
+ */
+
+#ifndef XFree86Server
+static int caught_xgetimage_error = 0;
+static int (*old_xerror_handler)( XMesaDisplay *dpy, XErrorEvent *ev );
+static unsigned long xgetimage_serial;
+
+/*
+ * This is the error handler which will be called if XGetImage fails.
+ */
+static int xgetimage_error_handler( XMesaDisplay *dpy, XErrorEvent *ev )
+{
+ if (ev->serial==xgetimage_serial && ev->error_code==BadMatch) {
+ /* caught the expected error */
+ caught_xgetimage_error = 0;
+ }
+ else {
+ /* call the original X error handler, if any. otherwise ignore */
+ if (old_xerror_handler) {
+ (*old_xerror_handler)( dpy, ev );
+ }
+ }
+ return 0;
+}
+
+
+/*
+ * Call this right before XGetImage to setup error trap.
+ */
+static void catch_xgetimage_errors( XMesaDisplay *dpy )
+{
+ xgetimage_serial = NextRequest( dpy );
+ old_xerror_handler = XSetErrorHandler( xgetimage_error_handler );
+ caught_xgetimage_error = 0;
+}
+
+
+/*
+ * Call this right after XGetImage to check if an error occured.
+ */
+static int check_xgetimage_errors( void )
+{
+ /* restore old handler */
+ (void) XSetErrorHandler( old_xerror_handler );
+ /* return 0=no error, 1=error caught */
+ return caught_xgetimage_error;
+}
+#endif
+
+
+/*
+ * Read a pixel from an X drawable.
+ */
+static unsigned long read_pixel( XMesaDisplay *dpy,
+ XMesaDrawable d, int x, int y )
+{
+ unsigned long p;
+#ifndef XFree86Server
+ XMesaImage *pixel = NULL;
+ int error;
+
+ catch_xgetimage_errors( dpy );
+ pixel = XGetImage( dpy, d, x, y, 1, 1, AllPlanes, ZPixmap );
+ error = check_xgetimage_errors();
+ if (pixel && !error) {
+ p = XMesaGetPixel( pixel, 0, 0 );
+ }
+ else {
+ p = 0;
+ }
+ if (pixel) {
+ XMesaDestroyImage( pixel );
+ }
+#else
+ (*dpy->GetImage)(d, x, y, 1, 1, ZPixmap, ~0L, (pointer)&p);
+#endif
+ return p;
+}
+
+
+
+/*
+ * The Mesa library needs to be able to draw pixels in a number of ways:
+ * 1. RGB vs Color Index
+ * 2. as horizontal spans (polygons, images) vs random locations (points,
+ * lines)
+ * 3. different color per-pixel or same color for all pixels
+ *
+ * Furthermore, the X driver needs to support rendering to 3 possible
+ * "buffers", usually one, but sometimes two at a time:
+ * 1. The front buffer as an X window
+ * 2. The back buffer as a Pixmap
+ * 3. The back buffer as an XImage
+ *
+ * Finally, if the back buffer is an XImage, we can avoid using XPutPixel and
+ * optimize common cases such as 24-bit and 8-bit modes.
+ *
+ * By multiplication, there's at least 48 possible combinations of the above.
+ *
+ * Below are implementations of the most commonly used combinations. They are
+ * accessed through function pointers which get initialized here and are used
+ * directly from the Mesa library. The 8 function pointers directly correspond
+ * to the first 3 cases listed above.
+ *
+ *
+ * The function naming convention is:
+ *
+ * write_[span|pixels]_[mono]_[format]_[pixmap|ximage]
+ *
+ * New functions optimized for specific cases can be added without too much
+ * trouble. An example might be the 24-bit TrueColor mode 8A8R8G8B which is
+ * found on IBM RS/6000 X servers.
+ */
+
+
+
+
+/**********************************************************************/
+/*** Write COLOR SPAN functions ***/
+/**********************************************************************/
+
+
+#define RGBA_SPAN_ARGS const GLcontext *ctx, \
+ GLuint n, GLint x, GLint y, \
+ CONST GLubyte rgba[][4], const GLubyte mask[]
+
+#define RGB_SPAN_ARGS const GLcontext *ctx, \
+ GLuint n, GLint x, GLint y, \
+ CONST GLubyte rgb[][3], const GLubyte mask[]
+
+
+/* NOTE: if mask==NULL, draw all pixels */
+
+
+/*
+ * Write a span of PF_TRUECOLOR pixels to a pixmap.
+ */
+static void write_span_TRUECOLOR_pixmap( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ XMesaSetForeground( dpy, gc, p );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ for (i=0;i<n;i++) {
+ unsigned long p;
+ PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ XMesaPutPixel( rowimg, i, 0, p );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_TRUECOLOR pixels to a pixmap.
+ */
+static void write_span_rgb_TRUECOLOR_pixmap( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUECOLOR( p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ XMesaSetForeground( dpy, gc, p );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ for (i=0;i<n;i++) {
+ unsigned long p;
+ PACK_TRUECOLOR( p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ XMesaPutPixel( rowimg, i, 0, p );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_TRUEDITHER pixels to a pixmap.
+ */
+static void write_span_TRUEDITHER_pixmap( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+ XMesaSetForeground( dpy, gc, p );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ for (i=0;i<n;i++) {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x+i, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+ XMesaPutPixel( rowimg, i, 0, p );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_TRUEDITHER pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_TRUEDITHER_pixmap( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+ XMesaSetForeground( dpy, gc, p );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ for (i=0;i<n;i++) {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x+i, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+ XMesaPutPixel( rowimg, i, 0, p );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+
+/*
+ * Write a span of PF_8A8B8G8R pixels to a pixmap.
+ */
+static void write_span_8A8B8G8R_pixmap( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc,
+ PACK_8A8B8G8R(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP]) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ register GLuint *ptr4 = (GLuint *) rowimg->data;
+ for (i=0;i<n;i++) {
+ *ptr4++ = PACK_8A8B8G8R( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_8A8B8G8R pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_8A8B8G8R_pixmap( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc,
+ PACK_8B8G8R(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ register GLuint *ptr4 = (GLuint *) rowimg->data;
+ for (i=0;i<n;i++) {
+ *ptr4++ = PACK_8B8G8R(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_8R8G8B pixels to a pixmap.
+ */
+static void write_span_8R8G8B_pixmap( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ register GLuint *ptr4 = (GLuint *) rowimg->data;
+ for (i=0;i<n;i++) {
+ *ptr4++ = PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_8R8G8B24 pixels to a pixmap.
+ */
+static void write_span_8R8G8B24_pixmap( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ register GLuint i;
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc,
+ PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ register GLuint *ptr4 = (GLuint *) rowimg->data;
+ register GLuint pixel;
+ static const GLuint shift[4] = {0, 8, 16, 24};
+ register GLuint i = 0;
+ int w = n;
+ while (w > 3) {
+ pixel = rgba[i][BCOMP] /* << shift[0]*/;
+ pixel |= rgba[i][GCOMP] << shift[1];
+ pixel |= rgba[i++][RCOMP] << shift[2];
+ pixel |= rgba[i][BCOMP] << shift[3];
+ *ptr4++ = pixel;
+
+ pixel = rgba[i][GCOMP] /* << shift[0]*/;
+ pixel |= rgba[i++][RCOMP] << shift[1];
+ pixel |= rgba[i][BCOMP] << shift[2];
+ pixel |= rgba[i][GCOMP] << shift[3];
+ *ptr4++ = pixel;
+
+ pixel = rgba[i++][RCOMP]/* << shift[0]*/;
+ pixel |= rgba[i][BCOMP] << shift[1];
+ pixel |= rgba[i][GCOMP] << shift[2];
+ pixel |= rgba[i++][RCOMP] << shift[3];
+ *ptr4++ = pixel;
+
+ w -= 4;
+ }
+ switch (w) {
+ case 3:
+ pixel = 0;
+ pixel |= rgba[i][BCOMP] /*<< shift[0]*/;
+ pixel |= rgba[i][GCOMP] << shift[1];
+ pixel |= rgba[i++][RCOMP] << shift[2];
+ pixel |= rgba[i][BCOMP] << shift[3];
+ *ptr4++ = pixel;
+ pixel = 0;
+ pixel |= rgba[i][GCOMP] /*<< shift[0]*/;
+ pixel |= rgba[i++][RCOMP] << shift[1];
+ pixel |= rgba[i][BCOMP] << shift[2];
+ pixel |= rgba[i][GCOMP] << shift[3];
+ *ptr4++ = pixel;
+ pixel = 0xffffff00 & *ptr4;
+ pixel |= rgba[i][RCOMP] /*<< shift[0]*/;
+ *ptr4 = pixel;
+ break;
+ case 2:
+ pixel = 0;
+ pixel |= rgba[i][BCOMP] /*<< shift[0]*/;
+ pixel |= rgba[i][GCOMP] << shift[1];
+ pixel |= rgba[i++][RCOMP] << shift[2];
+ pixel |= rgba[i][BCOMP] << shift[3];
+ *ptr4++ = pixel;
+ pixel = 0xffff0000 & *ptr4;
+ pixel |= rgba[i][GCOMP] /*<< shift[0]*/;
+ pixel |= rgba[i][RCOMP] << shift[1];
+ *ptr4 = pixel;
+ break;
+ case 1:
+ pixel = 0xff000000 & *ptr4;
+ pixel |= rgba[i][BCOMP] /*<< shift[0]*/;
+ pixel |= rgba[i][GCOMP] << shift[1];
+ pixel |= rgba[i][RCOMP] << shift[2];
+ *ptr4 = pixel;
+ break;
+ case 0:
+ break;
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_8R8G8B pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_8R8G8B_pixmap( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, PACK_8R8G8B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ));
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ register GLuint *ptr4 = (GLuint *) rowimg->data;
+ for (i=0;i<n;i++) {
+ *ptr4++ = PACK_8R8G8B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_8R8G8B24 pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_8R8G8B24_pixmap( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ register GLuint i;
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc,
+ PACK_8R8G8B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ));
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ register GLuint *ptr4 = (GLuint *) rowimg->data;
+ register GLuint pixel;
+ static const GLuint shift[4] = {0, 8, 16, 24};
+ unsigned w = n;
+ register GLuint i = 0;
+ while (w > 3) {
+ pixel = 0;
+ pixel |= rgb[i][BCOMP]/* << shift[0]*/;
+ pixel |= rgb[i][GCOMP] << shift[1];
+ pixel |= rgb[i++][RCOMP] << shift[2];
+ pixel |= rgb[i][BCOMP] <<shift[3];
+ *ptr4++ = pixel;
+
+ pixel = 0;
+ pixel |= rgb[i][GCOMP]/* << shift[0]*/;
+ pixel |= rgb[i++][RCOMP] << shift[1];
+ pixel |= rgb[i][BCOMP] << shift[2];
+ pixel |= rgb[i][GCOMP] << shift[3];
+ *ptr4++ = pixel;
+
+ pixel = 0;
+ pixel |= rgb[i++][RCOMP]/* << shift[0]*/;
+ pixel |= rgb[i][BCOMP] << shift[1];
+ pixel |= rgb[i][GCOMP] << shift[2];
+ pixel |= rgb[i++][RCOMP] << shift[3];
+ *ptr4++ = pixel;
+ w -= 4;
+ }
+ switch (w) {
+ case 3:
+ pixel = 0;
+ pixel |= rgb[i][BCOMP]/* << shift[0]*/;
+ pixel |= rgb[i][GCOMP] << shift[1];
+ pixel |= rgb[i++][RCOMP] << shift[2];
+ pixel |= rgb[i][BCOMP] << shift[3];
+ *ptr4++ = pixel;
+ pixel = 0;
+ pixel |= rgb[i][GCOMP]/* << shift[0]*/;
+ pixel |= rgb[i++][RCOMP] << shift[1];
+ pixel |= rgb[i][BCOMP] << shift[2];
+ pixel |= rgb[i][GCOMP] << shift[3];
+ *ptr4++ = pixel;
+ pixel = *ptr4;
+ pixel &= 0xffffff00;
+ pixel |= rgb[i++][RCOMP]/* << shift[0]*/;
+ *ptr4++ = pixel;
+ break;
+ case 2:
+ pixel = 0;
+ pixel |= rgb[i][BCOMP]/* << shift[0]*/;
+ pixel |= rgb[i][GCOMP] << shift[1];
+ pixel |= rgb[i++][RCOMP] << shift[2];
+ pixel |= rgb[i][BCOMP] << shift[3];
+ *ptr4++ = pixel;
+ pixel = *ptr4;
+ pixel &= 0xffff0000;
+ pixel |= rgb[i][GCOMP]/* << shift[0]*/;
+ pixel |= rgb[i++][RCOMP] << shift[1];
+ *ptr4++ = pixel;
+ break;
+ case 1:
+ pixel = *ptr4;
+ pixel &= 0xff000000;
+ pixel |= rgb[i][BCOMP]/* << shift[0]*/;
+ pixel |= rgb[i][GCOMP] << shift[1];
+ pixel |= rgb[i++][RCOMP] << shift[2];
+ *ptr4++ = pixel;
+ break;
+ case 0:
+ break;
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_5R6G5B pixels to a pixmap.
+ */
+static void write_span_5R6G5B_pixmap( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, PACK_5R6G5B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ register GLushort *ptr2 = (GLushort *) rowimg->data;
+ for (i=0;i<n;i++) {
+ ptr2[i] = PACK_5R6G5B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_DITHER_5R6G5B pixels to a pixmap.
+ */
+static void write_span_DITHER_5R6G5B_pixmap( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+ XMesaSetForeground( dpy, gc, p );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ register GLushort *ptr2 = (GLushort *) rowimg->data;
+ for (i=0;i<n;i++) {
+ PACK_TRUEDITHER( ptr2[i], x+i, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_5R6G5B pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_5R6G5B_pixmap( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, PACK_5R6G5B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ));
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ register GLushort *ptr2 = (GLushort *) rowimg->data;
+ for (i=0;i<n;i++) {
+ ptr2[i] = PACK_5R6G5B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_DITHER_5R6G5B pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_DITHER_5R6G5B_pixmap( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+ XMesaSetForeground( dpy, gc, p );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ register GLushort *ptr2 = (GLushort *) rowimg->data;
+ for (i=0;i<n;i++) {
+ PACK_TRUEDITHER( ptr2[i], x+i, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+
+/*
+ * Write a span of PF_DITHER pixels to a pixmap.
+ */
+static void write_span_DITHER_pixmap( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ XDITHER_SETUP(y);
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, XDITHER(x, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ for (i=0;i<n;i++) {
+ XMesaPutPixel( rowimg, i, 0, XDITHER(x+i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]) );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_DITHER pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_DITHER_pixmap( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ XDITHER_SETUP(y);
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, XDITHER(x, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ for (i=0;i<n;i++) {
+ XMesaPutPixel( rowimg, i, 0, XDITHER(x+i, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_1BIT pixels to a pixmap.
+ */
+static void write_span_1BIT_pixmap( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ SETUP_1BIT;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc,
+ DITHER_1BIT( x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ for (i=0;i<n;i++) {
+ XMesaPutPixel( rowimg, i, 0,
+ DITHER_1BIT( x+i, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_1BIT pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_1BIT_pixmap( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ SETUP_1BIT;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc,
+ DITHER_1BIT(x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ for (i=0;i<n;i++) {
+ XMesaPutPixel( rowimg, i, 0,
+ DITHER_1BIT(x+i, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_HPCR pixels to a pixmap.
+ */
+static void write_span_HPCR_pixmap( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc,
+ DITHER_HPCR( x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ register GLubyte *ptr = (GLubyte *) xmesa->xm_buffer->rowimage->data;
+ for (i=0;i<n;i++) {
+ ptr[i] = DITHER_HPCR( (x+i), y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_HPCR pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_HPCR_pixmap( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc,
+ DITHER_HPCR(x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ register GLubyte *ptr = (GLubyte *) xmesa->xm_buffer->rowimage->data;
+ for (i=0;i<n;i++) {
+ ptr[i] = DITHER_HPCR( (x+i), y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_LOOKUP pixels to a pixmap.
+ */
+static void write_span_LOOKUP_pixmap( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ LOOKUP_SETUP;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ for (i=0;i<n;i++) {
+ XMesaPutPixel( rowimg, i, 0, LOOKUP(rgba[i][RCOMP],rgba[i][GCOMP],rgba[i][BCOMP]) );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_LOOKUP pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_LOOKUP_pixmap( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ LOOKUP_SETUP;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, LOOKUP( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ for (i=0;i<n;i++) {
+ XMesaPutPixel( rowimg, i, 0, LOOKUP(rgb[i][RCOMP],rgb[i][GCOMP],rgb[i][BCOMP]) );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+
+/*
+ * Write a span of PF_GRAYSCALE pixels to a pixmap.
+ */
+static void write_span_GRAYSCALE_pixmap( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ for (i=0;i<n;i++) {
+ XMesaPutPixel( rowimg, i, 0, GRAY_RGB(rgba[i][RCOMP],rgba[i][GCOMP],rgba[i][BCOMP]) );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_GRAYSCALE pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_GRAYSCALE_pixmap( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, GRAY_RGB( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+ else {
+ XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ for (i=0;i<n;i++) {
+ XMesaPutPixel( rowimg, i, 0, GRAY_RGB(rgb[i][RCOMP],rgb[i][GCOMP],rgb[i][BCOMP]) );
+ }
+ XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+ }
+}
+
+
+/*
+ * Write a span of PF_TRUECOLOR pixels to an XImage.
+ */
+static void write_span_TRUECOLOR_ximage( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ XMesaPutPixel( img, x, y, p );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++,x++) {
+ unsigned long p;
+ PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ XMesaPutPixel( img, x, y, p );
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_TRUECOLOR pixels to an XImage (no alpha).
+ */
+static void write_span_rgb_TRUECOLOR_ximage( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUECOLOR( p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ XMesaPutPixel( img, x, y, p );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++,x++) {
+ unsigned long p;
+ PACK_TRUECOLOR( p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ XMesaPutPixel( img, x, y, p );
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_TRUEDITHER pixels to an XImage.
+ */
+static void write_span_TRUEDITHER_ximage( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+ XMesaPutPixel( img, x, y, p );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++,x++) {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+ XMesaPutPixel( img, x, y, p );
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_TRUEDITHER pixels to an XImage (no alpha).
+ */
+static void write_span_rgb_TRUEDITHER_ximage( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+ XMesaPutPixel( img, x, y, p );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++,x++) {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+ XMesaPutPixel( img, x, y, p );
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_8A8B8G8R-format pixels to an ximage.
+ */
+static void write_span_8A8B8G8R_ximage( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
+ if (mask) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ ptr[i] = PACK_8A8B8G8R( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++) {
+ ptr[i] = PACK_8A8B8G8R( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_8A8B8G8R-format pixels to an ximage (no alpha).
+ */
+static void write_span_rgb_8A8B8G8R_ximage( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
+ if (mask) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ ptr[i] = PACK_8A8B8G8R( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255 );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++) {
+ ptr[i] = PACK_8A8B8G8R( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255 );
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_8R8G8B-format pixels to an ximage.
+ */
+static void write_span_8R8G8B_ximage( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
+ if (mask) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ ptr[i] = PACK_8R8G8B(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++) {
+ ptr[i] = PACK_8R8G8B(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_8R8G8B24-format pixels to an ximage.
+ */
+static void write_span_8R8G8B24_ximage( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte *ptr = (GLubyte *) PIXELADDR3( xmesa->xm_buffer, x, y );
+ if (mask) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLuint *ptr4 = (GLuint *) ptr;
+ register GLuint pixel = *ptr4;
+ switch (3 & (int)(ptr - (GLubyte*)ptr4)) {
+ case 0:
+ pixel &= 0xff000000;
+ pixel |= rgba[i][BCOMP];
+ pixel |= rgba[i][GCOMP] << 8;
+ pixel |= rgba[i][RCOMP] << 16;
+ *ptr4 = pixel;
+ break;
+ case 3:
+ pixel &= 0x00ffffff;
+ pixel |= rgba[i][BCOMP] << 24;
+ *ptr4++ = pixel;
+ pixel = *ptr4 && 0xffff0000;
+ pixel |= rgba[i][GCOMP];
+ pixel |= rgba[i][RCOMP] << 8;
+ *ptr4 = pixel;
+ break;
+ case 2:
+ pixel &= 0x0000ffff;
+ pixel |= rgba[i][BCOMP] << 16;
+ pixel |= rgba[i][GCOMP] << 24;
+ *ptr4++ = pixel;
+ pixel = *ptr4 && 0xffffff00;
+ pixel |= rgba[i][RCOMP];
+ *ptr4 = pixel;
+ break;
+ case 1:
+ pixel &= 0x000000ff;
+ pixel |= rgba[i][BCOMP] << 8;
+ pixel |= rgba[i][GCOMP] << 16;
+ pixel |= rgba[i][RCOMP] << 24;
+ *ptr4 = pixel;
+ break;
+ }
+ }
+ ptr += 3;
+ }
+ }
+ else {
+ /* write all pixels */
+ int w = n;
+ GLuint *ptr4 = (GLuint *) ptr;
+ register GLuint pixel = *ptr4;
+ int index = (int)(ptr - (GLubyte *)ptr4);
+ register GLuint i = 0;
+ switch (index) {
+ case 0:
+ break;
+ case 1:
+ pixel &= 0x00ffffff;
+ pixel |= rgba[i][BCOMP] << 24;
+ *ptr4++ = pixel;
+ pixel = *ptr4 && 0xffff0000;
+ pixel |= rgba[i][GCOMP];
+ pixel |= rgba[i++][RCOMP] << 8;
+ *ptr4 = pixel;
+ if (0 == --w)
+ break;
+ case 2:
+ pixel &= 0x0000ffff;
+ pixel |= rgba[i][BCOMP] << 16;
+ pixel |= rgba[i][GCOMP] << 24;
+ *ptr4++ = pixel;
+ pixel = *ptr4 && 0xffffff00;
+ pixel |= rgba[i++][RCOMP];
+ *ptr4 = pixel;
+ if (0 == --w)
+ break;
+ case 3:
+ pixel &= 0x000000ff;
+ pixel |= rgba[i][BCOMP] << 8;
+ pixel |= rgba[i][GCOMP] << 16;
+ pixel |= rgba[i++][RCOMP] << 24;
+ *ptr4++ = pixel;
+ if (0 == --w)
+ break;
+ break;
+ }
+ while (w > 3) {
+ pixel = rgba[i][BCOMP];
+ pixel |= rgba[i][GCOMP] << 8;
+ pixel |= rgba[i++][RCOMP] << 16;
+ pixel |= rgba[i][BCOMP] << 24;
+ *ptr4++ = pixel;
+ pixel = rgba[i][GCOMP];
+ pixel |= rgba[i++][RCOMP] << 8;
+ pixel |= rgba[i][BCOMP] << 16;
+ pixel |= rgba[i][GCOMP] << 24;
+ *ptr4++ = pixel;
+ pixel = rgba[i++][RCOMP];
+ pixel |= rgba[i][BCOMP] << 8;
+ pixel |= rgba[i][GCOMP] << 16;
+ pixel |= rgba[i++][RCOMP] << 24;
+ *ptr4++ = pixel;
+ w -= 4;
+ }
+ switch (w) {
+ case 0:
+ break;
+ case 1:
+ pixel = *ptr4 & 0xff000000;
+ pixel |= rgba[i][BCOMP];
+ pixel |= rgba[i][GCOMP] << 8;
+ pixel |= rgba[i][RCOMP] << 16;
+ *ptr4 = pixel;
+ break;
+ case 2:
+ pixel = rgba[i][BCOMP];
+ pixel |= rgba[i][GCOMP] << 8;
+ pixel |= rgba[i++][RCOMP] << 16;
+ pixel |= rgba[i][BCOMP] << 24;
+ *ptr4++ = pixel;
+ pixel = *ptr4 & 0xffff0000;
+ pixel |= rgba[i][GCOMP];
+ pixel |= rgba[i][RCOMP] << 8;
+ *ptr4 = pixel;
+ break;
+ case 3:
+ pixel = rgba[i][BCOMP];
+ pixel |= rgba[i][GCOMP] << 8;
+ pixel |= rgba[i++][RCOMP] << 16;
+ pixel |= rgba[i][BCOMP] << 24;
+ *ptr4++ = pixel;
+ pixel = rgba[i][GCOMP];
+ pixel |= rgba[i++][RCOMP] << 8;
+ pixel |= rgba[i][BCOMP] << 16;
+ pixel |= rgba[i][GCOMP] << 24;
+ *ptr4++ = pixel;
+ pixel = *ptr4 & 0xffffff00;
+ pixel |= rgba[i][RCOMP];
+ *ptr4 = pixel;
+ break;
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_8R8G8B-format pixels to an ximage (no alpha).
+ */
+static void write_span_rgb_8R8G8B_ximage( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
+ if (mask) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ ptr[i] = PACK_8R8G8B(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++) {
+ ptr[i] = PACK_8R8G8B(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_8R8G8B24-format pixels to an ximage (no alpha).
+ */
+static void write_span_rgb_8R8G8B24_ximage( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte *ptr = (GLubyte *) PIXELADDR3( xmesa->xm_buffer, x, y );
+ if (mask) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ *ptr++ = rgb[i][BCOMP];
+ *ptr++ = rgb[i][GCOMP];
+ *ptr++ = rgb[i][RCOMP];
+ }
+ else {
+ ptr += 3;
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++) {
+ *ptr++ = rgb[i][BCOMP];
+ *ptr++ = rgb[i][GCOMP];
+ *ptr++ = rgb[i][RCOMP];
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_5R6G5B-format pixels to an ximage.
+ */
+static void write_span_5R6G5B_ximage( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x, y );
+ if (mask) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ ptr[i] = PACK_5R6G5B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+#if defined(__i386__) /* word stores don't have to be on 4-byte boundaries */
+ GLuint *ptr32 = (GLuint *) ptr;
+ GLuint extraPixel = (n & 1);
+ n -= extraPixel;
+ for (i = 0; i < n; i += 2) {
+ GLuint p0, p1;
+ p0 = PACK_5R6G5B(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+ p1 = PACK_5R6G5B(rgba[i+1][RCOMP], rgba[i+1][GCOMP], rgba[i+1][BCOMP]);
+ *ptr32++ = (p1 << 16) | p0;
+ }
+ if (extraPixel) {
+ ptr[n] = PACK_5R6G5B(rgba[n][RCOMP], rgba[n][GCOMP], rgba[n][BCOMP]);
+ }
+#else
+ for (i = 0; i < n; i++) {
+ ptr[i] = PACK_5R6G5B(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+ }
+#endif
+ }
+}
+
+
+/*
+ * Write a span of PF_DITHER_5R6G5B-format pixels to an ximage.
+ */
+static void write_span_DITHER_5R6G5B_ximage( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x, y );
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ PACK_TRUEDITHER( ptr[i], x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+#if defined(__i386__) /* word stores don't have to be on 4-byte boundaries */
+ GLuint *ptr32 = (GLuint *) ptr;
+ GLuint extraPixel = (n & 1);
+ n -= extraPixel;
+ for (i = 0; i < n; i += 2, x += 2) {
+ GLuint p0, p1;
+ PACK_TRUEDITHER( p0, x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ PACK_TRUEDITHER( p1, x+1, y, rgba[i+1][RCOMP], rgba[i+1][GCOMP], rgba[i+1][BCOMP] );
+ *ptr32++ = (p1 << 16) | p0;
+ }
+ if (extraPixel) {
+ PACK_TRUEDITHER( ptr[n], x+n, y, rgba[n][RCOMP], rgba[n][GCOMP], rgba[n][BCOMP]);
+ }
+#else
+ for (i = 0; i < n; i++, x++) {
+ PACK_TRUEDITHER( ptr[i], x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+ }
+#endif
+ }
+}
+
+
+/*
+ * Write a span of PF_5R6G5B-format pixels to an ximage (no alpha).
+ */
+static void write_span_rgb_5R6G5B_ximage( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x, y );
+ if (mask) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ ptr[i] = PACK_5R6G5B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+#if defined(__i386__) /* word stores don't have to be on 4-byte boundaries */
+ GLuint *ptr32 = (GLuint *) ptr;
+ GLuint extraPixel = (n & 1);
+ n -= extraPixel;
+ for (i = 0; i < n; i += 2) {
+ GLuint p0, p1;
+ p0 = PACK_5R6G5B(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+ p1 = PACK_5R6G5B(rgb[i+1][RCOMP], rgb[i+1][GCOMP], rgb[i+1][BCOMP]);
+ *ptr32++ = (p1 << 16) | p0;
+ }
+ if (extraPixel) {
+ ptr[n] = PACK_5R6G5B(rgb[n][RCOMP], rgb[n][GCOMP], rgb[n][BCOMP]);
+ }
+#else
+ for (i=0;i<n;i++) {
+ ptr[i] = PACK_5R6G5B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ }
+#endif
+ }
+}
+
+
+/*
+ * Write a span of PF_DITHER_5R6G5B-format pixels to an ximage (no alpha).
+ */
+static void write_span_rgb_DITHER_5R6G5B_ximage( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x, y );
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ PACK_TRUEDITHER( ptr[i], x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+#if defined(__i386__) /* word stores don't have to be on 4-byte boundaries */
+ GLuint *ptr32 = (GLuint *) ptr;
+ GLuint extraPixel = (n & 1);
+ n -= extraPixel;
+ for (i = 0; i < n; i += 2, x += 2) {
+ GLuint p0, p1;
+ PACK_TRUEDITHER( p0, x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ PACK_TRUEDITHER( p1, x+1, y, rgb[i+1][RCOMP], rgb[i+1][GCOMP], rgb[i+1][BCOMP] );
+ *ptr32++ = (p1 << 16) | p0;
+ }
+ if (extraPixel) {
+ PACK_TRUEDITHER( ptr[n], x+n, y, rgb[n][RCOMP], rgb[n][GCOMP], rgb[n][BCOMP]);
+ }
+#else
+ for (i=0;i<n;i++,x++) {
+ PACK_TRUEDITHER( ptr[i], x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ }
+#endif
+ }
+}
+
+
+/*
+ * Write a span of PF_DITHER pixels to an XImage.
+ */
+static void write_span_DITHER_ximage( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ int yy = FLIP(xmesa->xm_buffer, y);
+ XDITHER_SETUP(yy);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x, yy, XDITHER( x, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++,x++) {
+ XMesaPutPixel( img, x, yy, XDITHER( x, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_DITHER pixels to an XImage (no alpha).
+ */
+static void write_span_rgb_DITHER_ximage( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ int yy = FLIP(xmesa->xm_buffer, y);
+ XDITHER_SETUP(yy);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x, yy, XDITHER( x, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++,x++) {
+ XMesaPutPixel( img, x, yy, XDITHER( x, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
+ }
+ }
+}
+
+
+
+/*
+ * Write a span of 8-bit PF_DITHER pixels to an XImage.
+ */
+static void write_span_DITHER8_ximage( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
+ XDITHER_SETUP(y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ ptr[i] = (GLubyte) XDITHER( x, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++,x++) {
+ ptr[i] = (GLubyte) XDITHER( x, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+}
+
+
+static void write_span_rgb_DITHER8_ximage( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
+ XDITHER_SETUP(y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ ptr[i] = (GLubyte) XDITHER( x, rgb[i][0], rgb[i][1], rgb[i][2] );
+ }
+ }
+ }
+ else {
+ const GLubyte *data = (GLubyte *) rgb;
+ for (i=0;i<n;i++,x++) {
+ /*ptr[i] = XDITHER( x, rgb[i][0], rgb[i][1], rgb[i][2] );*/
+ ptr[i] = (GLubyte) XDITHER( x, data[i+i+i], data[i+i+i+1], data[i+i+i+2] );
+ }
+ }
+}
+
+
+
+/*
+ * Write a span of PF_1BIT pixels to an XImage.
+ */
+static void write_span_1BIT_ximage( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ SETUP_1BIT;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaPutPixel(img, x, y, DITHER_1BIT(x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++,x++) {
+ XMesaPutPixel( img, x, y, DITHER_1BIT(x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]) );
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_1BIT pixels to an XImage (no alpha).
+ */
+static void write_span_rgb_1BIT_ximage( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ SETUP_1BIT;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaPutPixel(img, x, y, DITHER_1BIT(x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]));
+ }
+ }
+ }
+ else {
+ for (i=0;i<n;i++,x++) {
+ XMesaPutPixel( img, x, y, DITHER_1BIT(x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_HPCR pixels to an XImage.
+ */
+static void write_span_HPCR_ximage( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ ptr[i] = DITHER_HPCR( x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++,x++) {
+ ptr[i] = DITHER_HPCR( x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_HPCR pixels to an XImage (no alpha).
+ */
+static void write_span_rgb_HPCR_ximage( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ ptr[i] = DITHER_HPCR( x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++,x++) {
+ ptr[i] = DITHER_HPCR( x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_LOOKUP pixels to an XImage.
+ */
+static void write_span_LOOKUP_ximage( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ LOOKUP_SETUP;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x, y, LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++,x++) {
+ XMesaPutPixel( img, x, y, LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_LOOKUP pixels to an XImage (no alpha).
+ */
+static void write_span_rgb_LOOKUP_ximage( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ LOOKUP_SETUP;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x, y, LOOKUP( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++,x++) {
+ XMesaPutPixel( img, x, y, LOOKUP( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
+ }
+ }
+}
+
+
+/*
+ * Write a span of 8-bit PF_LOOKUP pixels to an XImage.
+ */
+static void write_span_LOOKUP8_ximage( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
+ LOOKUP_SETUP;
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ ptr[i] = (GLubyte) LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++,x++) {
+ ptr[i] = (GLubyte) LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+}
+
+
+static void write_rgb_LOOKUP8_ximage( const GLcontext *ctx,
+ GLuint n, GLint x, GLint y,
+ CONST GLubyte rgb[][3],
+ const GLubyte mask[] )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
+ LOOKUP_SETUP;
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ ptr[i] = (GLubyte) LOOKUP( rgb[i][0], rgb[i][1], rgb[i][2] );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ const GLubyte *data = (GLubyte *) rgb;
+ for (i=0;i<n;i++,x++) {
+ /*ptr[i] = LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );*/
+ ptr[i] = (GLubyte) LOOKUP( data[i+i+i], data[i+i+i+1], data[i+i+i+2] );
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_GRAYSCALE pixels to an XImage.
+ */
+static void write_span_GRAYSCALE_ximage( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x, y, GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++,x++) {
+ XMesaPutPixel( img, x, y, GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_GRAYSCALE pixels to an XImage (no alpha).
+ */
+static void write_span_rgb_GRAYSCALE_ximage( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ if (mask) {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x, y, GRAY_RGB( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++,x++) {
+ XMesaPutPixel( img, x, y, GRAY_RGB( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
+ }
+ }
+}
+
+
+/*
+ * Write a span of 8-bit PF_GRAYSCALE pixels to an XImage.
+ */
+static void write_span_GRAYSCALE8_ximage( RGBA_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
+ if (mask) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ ptr[i] = (GLubyte) GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++) {
+ ptr[i] = (GLubyte) GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+}
+
+
+/*
+ * Write a span of 8-bit PF_GRAYSCALE pixels to an XImage (no alpha).
+ */
+static void write_span_rgb_GRAYSCALE8_ximage( RGB_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
+ if (mask) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ ptr[i] = (GLubyte) GRAY_RGB( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ }
+ }
+ }
+ else {
+ /* draw all pixels */
+ for (i=0;i<n;i++) {
+ ptr[i] = (GLubyte) GRAY_RGB( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+ }
+ }
+}
+
+
+
+
+/**********************************************************************/
+/*** Write COLOR PIXEL functions ***/
+/**********************************************************************/
+
+
+#define RGBA_PIXEL_ARGS const GLcontext *ctx, \
+ GLuint n, const GLint x[], const GLint y[], \
+ CONST GLubyte rgba[][4], const GLubyte mask[]
+
+
+/*
+ * Write an array of PF_TRUECOLOR pixels to a pixmap.
+ */
+static void write_pixels_TRUECOLOR_pixmap( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ XMesaSetForeground( dpy, gc, p );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_TRUEDITHER pixels to a pixmap.
+ */
+static void write_pixels_TRUEDITHER_pixmap( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+ XMesaSetForeground( dpy, gc, p );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_8A8B8G8R pixels to a pixmap.
+ */
+static void write_pixels_8A8B8G8R_pixmap( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc,
+ PACK_8A8B8G8R( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] ));
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_8R8G8B pixels to a pixmap.
+ */
+static void write_pixels_8R8G8B_pixmap( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_8R8G8B24 pixels to a pixmap.
+ */
+static void write_pixels_8R8G8B24_pixmap( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_5R6G5B pixels to a pixmap.
+ */
+static void write_pixels_5R6G5B_pixmap( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, PACK_5R6G5B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_DITHER_5R6G5B pixels to a pixmap.
+ */
+static void write_pixels_DITHER_5R6G5B_pixmap( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ XMesaSetForeground( dpy, gc, p );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_DITHER pixels to a pixmap.
+ */
+static void write_pixels_DITHER_pixmap( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ DITHER_SETUP;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc,
+ DITHER(x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_1BIT pixels to a pixmap.
+ */
+static void write_pixels_1BIT_pixmap( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ SETUP_1BIT;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc,
+ DITHER_1BIT( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_HPCR pixels to a pixmap.
+ */
+static void write_pixels_HPCR_pixmap( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc,
+ DITHER_HPCR( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_LOOKUP pixels to a pixmap.
+ */
+static void write_pixels_LOOKUP_pixmap( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ LOOKUP_SETUP;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_GRAYSCALE pixels to a pixmap.
+ */
+static void write_pixels_GRAYSCALE_pixmap( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_TRUECOLOR pixels to an ximage.
+ */
+static void write_pixels_TRUECOLOR_ximage( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), p );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_TRUEDITHER pixels to an XImage.
+ */
+static void write_pixels_TRUEDITHER_ximage( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x[i], FLIP(xmesa->xm_buffer, y[i]), rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+ XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), p );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_8A8B8G8R pixels to an ximage.
+ */
+static void write_pixels_8A8B8G8R_ximage( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x[i], y[i] );
+ *ptr = PACK_8A8B8G8R( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_8R8G8B pixels to an ximage.
+ */
+static void write_pixels_8R8G8B_ximage( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x[i], y[i] );
+ *ptr = PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_8R8G8B24 pixels to an ximage.
+ */
+static void write_pixels_8R8G8B24_ximage( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ bgr_t *ptr = PIXELADDR3( xmesa->xm_buffer, x[i], y[i] );
+ ptr->r = rgba[i][RCOMP];
+ ptr->g = rgba[i][GCOMP];
+ ptr->b = rgba[i][BCOMP];
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_5R6G5B pixels to an ximage.
+ */
+static void write_pixels_5R6G5B_ximage( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x[i], y[i] );
+ *ptr = PACK_5R6G5B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_DITHER_5R6G5B pixels to an ximage.
+ */
+static void write_pixels_DITHER_5R6G5B_ximage( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x[i], y[i] );
+ PACK_TRUEDITHER( *ptr, x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_DITHER pixels to an XImage.
+ */
+static void write_pixels_DITHER_ximage( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ DITHER_SETUP;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]),
+ DITHER( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of 8-bit PF_DITHER pixels to an XImage.
+ */
+static void write_pixels_DITHER8_ximage( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ DITHER_SETUP;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
+ *ptr = (GLubyte) DITHER( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_1BIT pixels to an XImage.
+ */
+static void write_pixels_1BIT_ximage( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ SETUP_1BIT;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]),
+ DITHER_1BIT( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_HPCR pixels to an XImage.
+ */
+static void write_pixels_HPCR_ximage( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
+ *ptr = (GLubyte) DITHER_HPCR( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_LOOKUP pixels to an XImage.
+ */
+static void write_pixels_LOOKUP_ximage( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ LOOKUP_SETUP;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), LOOKUP(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of 8-bit PF_LOOKUP pixels to an XImage.
+ */
+static void write_pixels_LOOKUP8_ximage( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ LOOKUP_SETUP;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
+ *ptr = (GLubyte) LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_GRAYSCALE pixels to an XImage.
+ */
+static void write_pixels_GRAYSCALE_ximage( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]),
+ GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of 8-bit PF_GRAYSCALE pixels to an XImage.
+ */
+static void write_pixels_GRAYSCALE8_ximage( RGBA_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x[i], y[i] );
+ *ptr = (GLubyte) GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+ }
+ }
+}
+
+
+
+
+/**********************************************************************/
+/*** Write MONO COLOR SPAN functions ***/
+/**********************************************************************/
+
+#define MONO_SPAN_ARGS const GLcontext *ctx, \
+ GLuint n, GLint x, GLint y, const GLubyte mask[]
+
+
+/*
+ * Write a span of identical pixels to a pixmap. The pixel value is
+ * the one set by DD.color() or DD.index().
+ */
+static void write_span_mono_pixmap( MONO_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc1;
+ register GLuint i;
+ register GLboolean write_all;
+ y = FLIP(xmesa->xm_buffer, y);
+ write_all = GL_TRUE;
+ for (i=0;i<n;i++) {
+ if (!mask[i]) {
+ write_all = GL_FALSE;
+ break;
+ }
+ }
+ if (write_all) {
+ XMesaFillRectangle( dpy, buffer, gc, (int) x, (int) y, n, 1 );
+ }
+ else {
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_TRUEDITHER pixels to a pixmap. The pixel value is
+ * the one set by DD.color() or DD.index().
+ */
+static void write_span_mono_TRUEDITHER_pixmap( MONO_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ register GLubyte r, g, b;
+ int yy = FLIP(xmesa->xm_buffer, y);
+ r = xmesa->red;
+ g = xmesa->green;
+ b = xmesa->blue;
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x, yy, r, g, b);
+ XMesaSetForeground( dpy, gc, p );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) yy );
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_DITHER pixels to a pixmap. The pixel value is
+ * the one set by DD.color() or DD.index().
+ */
+static void write_span_mono_DITHER_pixmap( MONO_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ register GLubyte r, g, b;
+ int yy = FLIP(xmesa->xm_buffer, y);
+ XDITHER_SETUP(yy);
+ r = xmesa->red;
+ g = xmesa->green;
+ b = xmesa->blue;
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, XDITHER( x, r, g, b ) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) yy );
+ }
+ }
+}
+
+
+/*
+ * Write a span of PF_1BIT pixels to a pixmap. The pixel value is
+ * the one set by DD.color() or DD.index().
+ */
+static void write_span_mono_1BIT_pixmap( MONO_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ register GLubyte r, g, b;
+ SETUP_1BIT;
+ r = xmesa->red;
+ g = xmesa->green;
+ b = xmesa->blue;
+ y = FLIP(xmesa->xm_buffer, y);
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, DITHER_1BIT( x, y, r, g, b ) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+}
+
+
+/*
+ * Write a span of identical pixels to an XImage. The pixel value is
+ * the one set by DD.color() or DD.index().
+ */
+static void write_span_mono_ximage( MONO_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ register unsigned long p = xmesa->pixel;
+ y = FLIP(xmesa->xm_buffer, y);
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x, y, p );
+ }
+ }
+}
+
+
+/*
+ * Write a span of identical PF_TRUEDITHER pixels to an XImage. The pixel
+ * value is the one set by DD.color().
+ */
+static void write_span_mono_TRUEDITHER_ximage( MONO_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ GLuint i;
+ GLint r = xmesa->red;
+ GLint g = xmesa->green;
+ GLint b = xmesa->blue;
+ y = FLIP(xmesa->xm_buffer, y);
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUEDITHER( p, x+i, y, r, g, b);
+ XMesaPutPixel( img, x+i, y, p );
+ }
+ }
+}
+
+
+/*
+ * Write a span of identical 8A8B8G8R pixels to an XImage. The pixel
+ * value is the one set by DD.color().
+ */
+static void write_span_mono_8A8B8G8R_ximage( MONO_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ GLuint i, p, *ptr;
+ p = (GLuint) xmesa->pixel;
+ ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ ptr[i] = p;
+ }
+ }
+}
+
+
+/*
+ * Write a span of identical 8R8G8B pixels to an XImage. The pixel
+ * value is the one set by DD.color().
+ */
+static void write_span_mono_8R8G8B_ximage( MONO_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ GLuint i, p, *ptr;
+ p = (GLuint) xmesa->pixel;
+ ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ ptr[i] = p;
+ }
+ }
+}
+
+
+/*
+ * Write a span of identical 8R8G8B pixels to an XImage. The pixel
+ * value is the one set by DD.color().
+ */
+static void write_span_mono_8R8G8B24_ximage( MONO_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte r = (GLubyte) ((xmesa->pixel >> 16) & 0xff);
+ const GLubyte g = (GLubyte) ((xmesa->pixel >> 8 ) & 0xff);
+ const GLubyte b = (GLubyte) ((xmesa->pixel ) & 0xff);
+ GLuint i;
+ bgr_t *ptr = PIXELADDR3( xmesa->xm_buffer, x, y );
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ ptr[i].r = r;
+ ptr[i].g = g;
+ ptr[i].b = b;
+ }
+ }
+}
+
+
+/*
+ * Write a span of identical DITHER pixels to an XImage. The pixel
+ * value is the one set by DD.color().
+ */
+static void write_span_mono_DITHER_ximage( MONO_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ register GLubyte r, g, b;
+ int yy = FLIP(xmesa->xm_buffer, y);
+ XDITHER_SETUP(yy);
+ r = xmesa->red;
+ g = xmesa->green;
+ b = xmesa->blue;
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x, yy, XDITHER( x, r, g, b ) );
+ }
+ }
+}
+
+
+/*
+ * Write a span of identical 8-bit DITHER pixels to an XImage. The pixel
+ * value is the one set by DD.color().
+ */
+static void write_span_mono_DITHER8_ximage( MONO_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x,y);
+ register GLubyte r, g, b;
+ XDITHER_SETUP(y);
+ r = xmesa->red;
+ g = xmesa->green;
+ b = xmesa->blue;
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ ptr[i] = (GLubyte) XDITHER( x, r, g, b );
+ }
+ }
+}
+
+
+/*
+ * Write a span of identical 8-bit LOOKUP pixels to an XImage. The pixel
+ * value is the one set by DD.color().
+ */
+static void write_span_mono_LOOKUP8_ximage( MONO_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x,y);
+ register GLubyte pixel = (GLubyte) xmesa->pixel;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ ptr[i] = pixel;
+ }
+ }
+}
+
+
+/*
+ * Write a span of identical PF_1BIT pixels to an XImage. The pixel
+ * value is the one set by DD.color().
+ */
+static void write_span_mono_1BIT_ximage( MONO_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ register GLubyte r, g, b;
+ SETUP_1BIT;
+ r = xmesa->red;
+ g = xmesa->green;
+ b = xmesa->blue;
+ y = FLIP(xmesa->xm_buffer, y);
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x, y, DITHER_1BIT( x, y, r, g, b ) );
+ }
+ }
+}
+
+
+/*
+ * Write a span of identical HPCR pixels to an XImage. The pixel
+ * value is the one set by DD.color().
+ */
+static void write_span_mono_HPCR_ximage( MONO_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x,y);
+ register GLubyte r, g, b;
+ r = xmesa->red;
+ g = xmesa->green;
+ b = xmesa->blue;
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ ptr[i] = DITHER_HPCR( x, y, r, g, b );
+ }
+ }
+}
+
+
+/*
+ * Write a span of identical 8-bit GRAYSCALE pixels to an XImage. The pixel
+ * value is the one set by DD.color().
+ */
+static void write_span_mono_GRAYSCALE8_ximage( MONO_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ GLuint i;
+ GLubyte p = (GLubyte) xmesa->pixel;
+ GLubyte *ptr = (GLubyte *) PIXELADDR1( xmesa->xm_buffer,x,y);
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ ptr[i] = p;
+ }
+ }
+}
+
+
+
+/*
+ * Write a span of identical PF_DITHER_5R6G5B pixels to an XImage. The pixel
+ * value is the one set by DD.color().
+ */
+static void write_span_mono_DITHER_5R6G5B_ximage( MONO_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x, y );
+ GLuint i;
+ GLint r = xmesa->red;
+ GLint g = xmesa->green;
+ GLint b = xmesa->blue;
+ y = FLIP(xmesa->xm_buffer, y);
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ PACK_TRUEDITHER(ptr[i], x+i, y, r, g, b);
+ }
+ }
+}
+
+
+
+/**********************************************************************/
+/*** Write MONO COLOR PIXELS functions ***/
+/**********************************************************************/
+
+#define MONO_PIXEL_ARGS const GLcontext *ctx, \
+ GLuint n, const GLint x[], const GLint y[], \
+ const GLubyte mask[]
+
+/*
+ * Write an array of identical pixels to a pixmap. The pixel value is
+ * the one set by DD.color() or DD.index.
+ */
+static void write_pixels_mono_pixmap( MONO_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc1;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_TRUEDITHER pixels to a pixmap. The pixel value is
+ * the one set by DD.color() or DD.index.
+ */
+static void write_pixels_mono_TRUEDITHER_pixmap( MONO_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ register GLubyte r, g, b;
+ r = xmesa->red;
+ g = xmesa->green;
+ b = xmesa->blue;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x[i], y[i], r, g, b);
+ XMesaSetForeground( dpy, gc, p );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_DITHER pixels to a pixmap. The pixel value is
+ * the one set by DD.color() or DD.index.
+ */
+static void write_pixels_mono_DITHER_pixmap( MONO_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ register GLubyte r, g, b;
+ DITHER_SETUP;
+ r = xmesa->red;
+ g = xmesa->green;
+ b = xmesa->blue;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, DITHER( x[i], y[i], r, g, b ) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of PF_1BIT pixels to a pixmap. The pixel value is
+ * the one set by DD.color() or DD.index.
+ */
+static void write_pixels_mono_1BIT_pixmap( MONO_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ register GLubyte r, g, b;
+ SETUP_1BIT;
+ r = xmesa->red;
+ g = xmesa->green;
+ b = xmesa->blue;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, DITHER_1BIT( x[i], y[i], r, g, b ) );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of identical pixels to an XImage. The pixel value is
+ * the one set by DD.color() or DD.index.
+ */
+static void write_pixels_mono_ximage( MONO_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ register unsigned long p = xmesa->pixel;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), p );
+ }
+ }
+}
+
+
+/*
+ * Write an array of identical TRUEDITHER pixels to an XImage.
+ * The pixel value is the one set by DD.color() or DD.index.
+ */
+static void write_pixels_mono_TRUEDITHER_ximage( MONO_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ int r = xmesa->red;
+ int g = xmesa->green;
+ int b = xmesa->blue;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p;
+ PACK_TRUEDITHER(p, x[i], FLIP(xmesa->xm_buffer, y[i]), r, g, b);
+ XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), p );
+ }
+ }
+}
+
+
+
+/*
+ * Write an array of identical 8A8B8G8R pixels to an XImage. The pixel value
+ * is the one set by DD.color().
+ */
+static void write_pixels_mono_8A8B8G8R_ximage( MONO_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLuint p = (GLuint) xmesa->pixel;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x[i], y[i] );
+ *ptr = p;
+ }
+ }
+}
+
+
+/*
+ * Write an array of identical 8R8G8B pixels to an XImage. The pixel value
+ * is the one set by DD.color().
+ */
+static void write_pixels_mono_8R8G8B_ximage( MONO_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLuint p = (GLuint) xmesa->pixel;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x[i], y[i] );
+ *ptr = p;
+ }
+ }
+}
+
+
+/*
+ * Write an array of identical 8R8G8B pixels to an XImage. The pixel value
+ * is the one set by DD.color().
+ */
+static void write_pixels_mono_8R8G8B24_ximage( MONO_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte r = (GLubyte) ((xmesa->pixel >> 16) & 0xff);
+ const GLubyte g = (GLubyte) ((xmesa->pixel >> 8 ) & 0xff);
+ const GLubyte b = (GLubyte) ((xmesa->pixel ) & 0xff);
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ bgr_t *ptr = PIXELADDR3( xmesa->xm_buffer, x[i], y[i] );
+ ptr->r = r;
+ ptr->g = g;
+ ptr->b = b;
+ }
+ }
+}
+
+
+/*
+ * Write an array of identical PF_DITHER pixels to an XImage. The pixel
+ * value is the one set by DD.color().
+ */
+static void write_pixels_mono_DITHER_ximage( MONO_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ register GLubyte r, g, b;
+ DITHER_SETUP;
+ r = xmesa->red;
+ g = xmesa->green;
+ b = xmesa->blue;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), DITHER( x[i], y[i], r, g, b ) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of identical 8-bit PF_DITHER pixels to an XImage. The
+ * pixel value is the one set by DD.color().
+ */
+static void write_pixels_mono_DITHER8_ximage( MONO_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte r, g, b;
+ DITHER_SETUP;
+ r = xmesa->red;
+ g = xmesa->green;
+ b = xmesa->blue;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
+ *ptr = (GLubyte) DITHER( x[i], y[i], r, g, b );
+ }
+ }
+}
+
+
+/*
+ * Write an array of identical 8-bit PF_LOOKUP pixels to an XImage. The
+ * pixel value is the one set by DD.color().
+ */
+static void write_pixels_mono_LOOKUP8_ximage( MONO_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte pixel = (GLubyte) xmesa->pixel;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
+ *ptr = pixel;
+ }
+ }
+}
+
+
+
+/*
+ * Write an array of identical PF_1BIT pixels to an XImage. The pixel
+ * value is the one set by DD.color().
+ */
+static void write_pixels_mono_1BIT_ximage( MONO_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ register GLubyte r, g, b;
+ SETUP_1BIT;
+ r = xmesa->red;
+ g = xmesa->green;
+ b = xmesa->blue;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), DITHER_1BIT( x[i], y[i], r, g, b ));
+ }
+ }
+}
+
+
+/*
+ * Write an array of identical PF_HPCR pixels to an XImage. The
+ * pixel value is the one set by DD.color().
+ */
+static void write_pixels_mono_HPCR_ximage( MONO_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte r, g, b;
+ r = xmesa->red;
+ g = xmesa->green;
+ b = xmesa->blue;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
+ *ptr = DITHER_HPCR( x[i], y[i], r, g, b );
+ }
+ }
+}
+
+
+/*
+ * Write an array of identical 8-bit PF_GRAYSCALE pixels to an XImage. The
+ * pixel value is the one set by DD.color().
+ */
+static void write_pixels_mono_GRAYSCALE8_ximage( MONO_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ register GLubyte p = (GLubyte) xmesa->pixel;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
+ *ptr = p;
+ }
+ }
+}
+
+
+/*
+ * Write an array of identical PF_DITHER_5R6G5B pixels to an XImage.
+ * The pixel value is the one set by DD.color() or DD.index.
+ */
+static void write_pixels_mono_DITHER_5R6G5B_ximage( MONO_PIXEL_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ int r = xmesa->red;
+ int g = xmesa->green;
+ int b = xmesa->blue;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x[i], y[i] );
+ PACK_TRUEDITHER(*ptr, x[i], y[i], r, g, b);
+ }
+ }
+}
+
+
+
+/**********************************************************************/
+/*** Write INDEX SPAN functions ***/
+/**********************************************************************/
+
+#define INDEX_SPAN_ARGS const GLcontext *ctx, \
+ GLuint n, GLint x, GLint y, const GLuint index[], \
+ const GLubyte mask[]
+
+#define INDEX8_SPAN_ARGS const GLcontext *ctx, \
+ GLuint n, GLint x, GLint y, const GLubyte index[], \
+ const GLubyte mask[]
+
+
+/*
+ * Write a span of CI pixels to a Pixmap.
+ */
+static void write_span_index_pixmap( INDEX_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, (unsigned long) index[i] );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+}
+
+
+/*
+ * Write a span of 8-bit CI pixels to a Pixmap.
+ */
+static void write_span_index8_pixmap( INDEX8_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, (unsigned long) index[i] );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+ }
+ }
+}
+
+
+/*
+ * Write a span of CI pixels to an XImage.
+ */
+static void write_span_index_ximage( INDEX_SPAN_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ y = FLIP(xmesa->xm_buffer, y);
+ for (i=0;i<n;i++,x++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x, y, (unsigned long) index[i] );
+ }
+ }
+}
+
+
+/*
+ * Write a span of 8-bit CI pixels to a non 8-bit XImage.
+ */
+static void write_span_index8_ximage( const GLcontext *ctx, GLuint n,
+ GLint x, GLint y, const GLubyte index[],
+ const GLubyte mask[] )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ if (mask) {
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaPutPixel(xmesa->xm_buffer->backimage, x+i, y, index[i]);
+ }
+ }
+ }
+ else {
+ GLuint i;
+ for (i=0;i<n;i++) {
+ XMesaPutPixel(xmesa->xm_buffer->backimage, x+i, y, index[i]);
+ }
+ }
+}
+
+/*
+ * Write a span of 8-bit CI pixels to an 8-bit XImage.
+ */
+static void write_span_index8_ximage8( const GLcontext *ctx, GLuint n,
+ GLint x, GLint y, const GLubyte index[],
+ const GLubyte mask[] )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ GLubyte *dst = PIXELADDR1( xmesa->xm_buffer,x,y);
+ if (mask) {
+ GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ dst[i] = index[i];
+ }
+ }
+ }
+ else {
+ MEMCPY( dst, index, n );
+ }
+}
+
+
+
+/**********************************************************************/
+/*** Write INDEX PIXELS functions ***/
+/**********************************************************************/
+
+#define INDEX_PIXELS_ARGS const GLcontext *ctx, \
+ GLuint n, const GLint x[], const GLint y[], \
+ const GLuint index[], const GLubyte mask[]
+
+
+/*
+ * Write an array of CI pixels to a Pixmap.
+ */
+static void write_pixels_index_pixmap( INDEX_PIXELS_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+ XMesaGC gc = xmesa->xm_buffer->gc2;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaSetForeground( dpy, gc, (unsigned long) index[i] );
+ XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+ }
+ }
+}
+
+
+/*
+ * Write an array of CI pixels to an XImage.
+ */
+static void write_pixels_index_ximage( INDEX_PIXELS_ARGS )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ register GLuint i;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), (unsigned long) index[i] );
+ }
+ }
+}
+
+
+
+
+/**********************************************************************/
+/***** Pixel reading *****/
+/**********************************************************************/
+
+
+
+/*
+ * Read a horizontal span of color-index pixels.
+ */
+static void read_index_span( const GLcontext *ctx,
+ GLuint n, GLint x, GLint y, GLuint index[] )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaBuffer source;
+ GLuint i;
+
+ if (xmesa->use_read_buffer)
+ source = xmesa->xm_read_buffer;
+ else
+ source = xmesa->xm_buffer;
+
+ y = FLIP(source, y);
+
+ if (source->buffer) {
+#ifndef XFree86Server
+ XMesaImage *span = NULL;
+ int error;
+ catch_xgetimage_errors( xmesa->display );
+ span = XGetImage( xmesa->display, source->buffer,
+ x, y, n, 1, AllPlanes, ZPixmap );
+ error = check_xgetimage_errors();
+ if (span && !error) {
+ for (i=0;i<n;i++) {
+ index[i] = (GLuint) XMesaGetPixel( span, i, 0 );
+ }
+ }
+ else {
+ /* return 0 pixels */
+ for (i=0;i<n;i++) {
+ index[i] = 0;
+ }
+ }
+ if (span) {
+ XMesaDestroyImage( span );
+ }
+#else
+ (*xmesa->display->GetImage)(source->buffer,
+ x, y, n, 1, ZPixmap,
+ ~0L, (pointer)index);
+#endif
+ }
+ else if (source->backimage) {
+ XMesaImage *img = source->backimage;
+ for (i=0;i<n;i++,x++) {
+ index[i] = (GLuint) XMesaGetPixel( img, x, y );
+ }
+ }
+}
+
+
+
+/*
+ * Read a horizontal span of color pixels.
+ */
+static void read_color_span( const GLcontext *ctx,
+ GLuint n, GLint x, GLint y,
+ GLubyte rgba[][4] )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaBuffer source;
+
+ if (xmesa->use_read_buffer)
+ source = xmesa->xm_read_buffer;
+ else
+ source = xmesa->xm_buffer;
+
+ if (source->buffer) {
+ /* Read from Pixmap or Window */
+ XMesaImage *span = NULL;
+ int error;
+#ifdef XFree86Server
+ span = XMesaCreateImage(xmesa->xm_visual->BitsPerPixel, n, 1, NULL);
+ span->data = (char *)MALLOC(span->height * span->bytes_per_line);
+ error = (!span->data);
+ (*xmesa->display->GetImage)(source->buffer,
+ x, FLIP(source, y), n, 1, ZPixmap,
+ ~0L, (pointer)span->data);
+#else
+ catch_xgetimage_errors( xmesa->display );
+ span = XGetImage( xmesa->display, source->buffer,
+ x, FLIP(source, y), n, 1, AllPlanes, ZPixmap );
+ error = check_xgetimage_errors();
+#endif
+ if (span && !error) {
+ switch (xmesa->pixelformat) {
+ case PF_TRUECOLOR:
+ case PF_TRUEDITHER:
+ {
+ const GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
+ const GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
+ const GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
+ unsigned long rMask = GET_REDMASK(xmesa->xm_visual);
+ unsigned long gMask = GET_GREENMASK(xmesa->xm_visual);
+ unsigned long bMask = GET_BLUEMASK(xmesa->xm_visual);
+ GLint rShift = xmesa->xm_visual->rshift;
+ GLint gShift = xmesa->xm_visual->gshift;
+ GLint bShift = xmesa->xm_visual->bshift;
+ GLuint i;
+ for (i=0;i<n;i++) {
+ unsigned long p;
+ p = XMesaGetPixel( span, i, 0 );
+ rgba[i][RCOMP] = pixelToR[(p & rMask) >> rShift];
+ rgba[i][GCOMP] = pixelToG[(p & gMask) >> gShift];
+ rgba[i][BCOMP] = pixelToB[(p & bMask) >> bShift];
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ break;
+ case PF_5R6G5B:
+ case PF_DITHER_5R6G5B:
+ {
+ const GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
+ const GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
+ const GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
+ GLuint i;
+ for (i=0;i<n;i++) {
+ unsigned long p = XMesaGetPixel( span, i, 0 );
+ /* fast, but not quite accurate
+ rgba[i][RCOMP] = ((p >> 8) & 0xf8);
+ rgba[i][GCOMP] = ((p >> 3) & 0xfc);
+ rgba[i][BCOMP] = ((p << 3) & 0xff);
+ */
+ rgba[i][RCOMP] = pixelToR[p >> 11];
+ rgba[i][GCOMP] = pixelToG[(p >> 5) & 0x3f];
+ rgba[i][BCOMP] = pixelToB[p & 0x1f];
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ break;
+ case PF_8A8B8G8R:
+ {
+ const GLuint *ptr4 = (GLuint *) span->data;
+ GLuint i;
+ for (i=0;i<n;i++) {
+ GLuint p4 = *ptr4++;
+ rgba[i][RCOMP] = (GLubyte) ( p4 & 0xff);
+ rgba[i][GCOMP] = (GLubyte) ((p4 >> 8) & 0xff);
+ rgba[i][BCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
+ rgba[i][ACOMP] = (GLubyte) ((p4 >> 24) & 0xff);
+ }
+ }
+ break;
+ case PF_8R8G8B:
+ {
+ const GLuint *ptr4 = (GLuint *) span->data;
+ GLuint i;
+ for (i=0;i<n;i++) {
+ GLuint p4 = *ptr4++;
+ rgba[i][RCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
+ rgba[i][GCOMP] = (GLubyte) ((p4 >> 8) & 0xff);
+ rgba[i][BCOMP] = (GLubyte) ( p4 & 0xff);
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ break;
+ case PF_8R8G8B24:
+ {
+ const bgr_t *ptr3 = (bgr_t *) span->data;
+ GLuint i;
+ for (i=0;i<n;i++) {
+ rgba[i][RCOMP] = ptr3[i].r;
+ rgba[i][GCOMP] = ptr3[i].g;
+ rgba[i][BCOMP] = ptr3[i].b;
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ break;
+ case PF_HPCR:
+ {
+ GLubyte *ptr1 = (GLubyte *) span->data;
+ GLuint i;
+ for (i=0;i<n;i++) {
+ GLubyte p = *ptr1++;
+ rgba[i][RCOMP] = p & 0xE0;
+ rgba[i][GCOMP] = (p & 0x1C) << 3;
+ rgba[i][BCOMP] = (p & 0x03) << 6;
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ break;
+ case PF_DITHER:
+ case PF_LOOKUP:
+ case PF_GRAYSCALE:
+ {
+ GLubyte *rTable = source->pixel_to_r;
+ GLubyte *gTable = source->pixel_to_g;
+ GLubyte *bTable = source->pixel_to_b;
+ if (GET_VISUAL_DEPTH(xmesa->xm_visual)==8) {
+ const GLubyte *ptr1 = (GLubyte *) span->data;
+ GLuint i;
+ for (i=0;i<n;i++) {
+ unsigned long p = *ptr1++;
+ rgba[i][RCOMP] = rTable[p];
+ rgba[i][GCOMP] = gTable[p];
+ rgba[i][BCOMP] = bTable[p];
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ else {
+ GLuint i;
+ for (i=0;i<n;i++) {
+ unsigned long p = XMesaGetPixel( span, i, 0 );
+ rgba[i][RCOMP] = rTable[p];
+ rgba[i][GCOMP] = gTable[p];
+ rgba[i][BCOMP] = bTable[p];
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ }
+ break;
+ case PF_1BIT:
+ {
+ int bitFlip = xmesa->xm_visual->bitFlip;
+ GLuint i;
+ for (i=0;i<n;i++) {
+ unsigned long p;
+ p = XMesaGetPixel( span, i, 0 ) ^ bitFlip;
+ rgba[i][RCOMP] = (GLubyte) (p * 255);
+ rgba[i][GCOMP] = (GLubyte) (p * 255);
+ rgba[i][BCOMP] = (GLubyte) (p * 255);
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ break;
+ default:
+ gl_problem(NULL,"Problem in DD.read_color_span (1)");
+ return;
+ }
+ }
+ else {
+ /* return black pixels */
+ GLuint i;
+ for (i=0;i<n;i++) {
+ rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = rgba[i][ACOMP] = 0;
+ }
+ }
+ if (span) {
+ XMesaDestroyImage( span );
+ }
+ }
+ else if (source->backimage) {
+ /* Read from XImage back buffer */
+ switch (xmesa->pixelformat) {
+ case PF_TRUECOLOR:
+ case PF_TRUEDITHER:
+ {
+ const GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
+ const GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
+ const GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
+ unsigned long rMask = GET_REDMASK(xmesa->xm_visual);
+ unsigned long gMask = GET_GREENMASK(xmesa->xm_visual);
+ unsigned long bMask = GET_BLUEMASK(xmesa->xm_visual);
+ GLint rShift = xmesa->xm_visual->rshift;
+ GLint gShift = xmesa->xm_visual->gshift;
+ GLint bShift = xmesa->xm_visual->bshift;
+ XMesaImage *img = source->backimage;
+ GLuint i;
+ y = FLIP(source, y);
+ for (i=0;i<n;i++) {
+ unsigned long p;
+ p = XMesaGetPixel( img, x+i, y );
+ rgba[i][RCOMP] = pixelToR[(p & rMask) >> rShift];
+ rgba[i][GCOMP] = pixelToG[(p & gMask) >> gShift];
+ rgba[i][BCOMP] = pixelToB[(p & bMask) >> bShift];
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ break;
+ case PF_5R6G5B:
+ case PF_DITHER_5R6G5B:
+ {
+ const GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
+ const GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
+ const GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
+ const GLushort *ptr2 = PIXELADDR2( source, x, y );
+ const GLuint *ptr4 = (const GLuint *) ptr2;
+ GLuint i;
+#if defined(__i386__) /* word stores don't have to be on 4-byte boundaries */
+ GLuint extraPixel = (n & 1);
+ n -= extraPixel;
+ for (i = 0; i < n; i += 2) {
+ const GLuint p = *ptr4++;
+ const GLuint p0 = p & 0xffff;
+ const GLuint p1 = p >> 16;
+ /* fast, but not quite accurate
+ rgba[i][RCOMP] = ((p >> 8) & 0xf8);
+ rgba[i][GCOMP] = ((p >> 3) & 0xfc);
+ rgba[i][BCOMP] = ((p << 3) & 0xff);
+ */
+ rgba[i][RCOMP] = pixelToR[p0 >> 11];
+ rgba[i][GCOMP] = pixelToG[(p0 >> 5) & 0x3f];
+ rgba[i][BCOMP] = pixelToB[p0 & 0x1f];
+ rgba[i][ACOMP] = 255;
+ rgba[i+1][RCOMP] = pixelToR[p1 >> 11];
+ rgba[i+1][GCOMP] = pixelToG[(p1 >> 5) & 0x3f];
+ rgba[i+1][BCOMP] = pixelToB[p1 & 0x1f];
+ rgba[i+1][ACOMP] = 255;
+ }
+ if (extraPixel) {
+ GLushort p = ptr2[n];
+ rgba[n][RCOMP] = pixelToR[p >> 11];
+ rgba[n][GCOMP] = pixelToG[(p >> 5) & 0x3f];
+ rgba[n][BCOMP] = pixelToB[p & 0x1f];
+ rgba[n][ACOMP] = 255;
+ }
+#else
+ for (i = 0; i < n; i++) {
+ const GLushort p = ptr2[i];
+ rgba[i][RCOMP] = pixelToR[p >> 11];
+ rgba[i][GCOMP] = pixelToG[(p >> 5) & 0x3f];
+ rgba[i][BCOMP] = pixelToB[p & 0x1f];
+ rgba[i][ACOMP] = 255;
+ }
+#endif
+ }
+ break;
+ case PF_8A8B8G8R:
+ {
+ const GLuint *ptr4 = PIXELADDR4( source, x, y );
+ GLuint i;
+ for (i=0;i<n;i++) {
+ GLuint p4 = *ptr4++;
+ rgba[i][RCOMP] = (GLubyte) ( p4 & 0xff);
+ rgba[i][GCOMP] = (GLubyte) ((p4 >> 8) & 0xff);
+ rgba[i][BCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
+ rgba[i][ACOMP] = (GLint) ((p4 >> 24) & 0xff);
+ }
+ }
+ break;
+ case PF_8R8G8B:
+ {
+ const GLuint *ptr4 = PIXELADDR4( source, x, y );
+ GLuint i;
+ for (i=0;i<n;i++) {
+ GLuint p4 = *ptr4++;
+ rgba[i][RCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
+ rgba[i][GCOMP] = (GLubyte) ((p4 >> 8) & 0xff);
+ rgba[i][BCOMP] = (GLubyte) ( p4 & 0xff);
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ break;
+ case PF_8R8G8B24:
+ {
+ const bgr_t *ptr3 = PIXELADDR3( source, x, y );
+ GLuint i;
+ for (i=0;i<n;i++) {
+ rgba[i][RCOMP] = ptr3[i].r;
+ rgba[i][GCOMP] = ptr3[i].g;
+ rgba[i][BCOMP] = ptr3[i].b;
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ break;
+ case PF_HPCR:
+ {
+ const GLubyte *ptr1 = PIXELADDR1( source, x, y );
+ GLuint i;
+ for (i=0;i<n;i++) {
+ GLubyte p = *ptr1++;
+ rgba[i][RCOMP] = p & 0xE0;
+ rgba[i][GCOMP] = (p & 0x1C) << 3;
+ rgba[i][BCOMP] = (p & 0x03) << 6;
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ break;
+ case PF_DITHER:
+ case PF_LOOKUP:
+ case PF_GRAYSCALE:
+ {
+ const GLubyte *rTable = source->pixel_to_r;
+ const GLubyte *gTable = source->pixel_to_g;
+ const GLubyte *bTable = source->pixel_to_b;
+ if (GET_VISUAL_DEPTH(xmesa->xm_visual)==8) {
+ GLubyte *ptr1 = PIXELADDR1( source, x, y );
+ GLuint i;
+ for (i=0;i<n;i++) {
+ unsigned long p = *ptr1++;
+ rgba[i][RCOMP] = rTable[p];
+ rgba[i][GCOMP] = gTable[p];
+ rgba[i][BCOMP] = bTable[p];
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ else {
+ XMesaImage *img = source->backimage;
+ GLuint i;
+ y = FLIP(source, y);
+ for (i=0;i<n;i++,x++) {
+ unsigned long p = XMesaGetPixel( img, x, y );
+ rgba[i][RCOMP] = rTable[p];
+ rgba[i][GCOMP] = gTable[p];
+ rgba[i][BCOMP] = bTable[p];
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ }
+ break;
+ case PF_1BIT:
+ {
+ XMesaImage *img = source->backimage;
+ int bitFlip = xmesa->xm_visual->bitFlip;
+ GLuint i;
+ y = FLIP(source, y);
+ for (i=0;i<n;i++,x++) {
+ unsigned long p;
+ p = XMesaGetPixel( img, x, y ) ^ bitFlip;
+ rgba[i][RCOMP] = (GLubyte) (p * 255);
+ rgba[i][GCOMP] = (GLubyte) (p * 255);
+ rgba[i][BCOMP] = (GLubyte) (p * 255);
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ break;
+ default:
+ gl_problem(NULL,"Problem in DD.read_color_span (2)");
+ return;
+ }
+ }
+}
+
+
+
+/*
+ * Read an array of color index pixels.
+ */
+static void read_index_pixels( const GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLuint indx[], const GLubyte mask[] )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ register GLuint i;
+ XMesaBuffer source;
+
+ if (xmesa->use_read_buffer)
+ source = xmesa->xm_read_buffer;
+ else
+ source = xmesa->xm_buffer;
+
+ if (source->buffer) {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ indx[i] = (GLuint) read_pixel( xmesa->display,
+ source->buffer,
+ x[i], FLIP(source, y[i]) );
+ }
+ }
+ }
+ else if (source->backimage) {
+ XMesaImage *img = source->backimage;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ indx[i] = (GLuint) XMesaGetPixel( img, x[i], FLIP(source, y[i]) );
+ }
+ }
+ }
+}
+
+
+
+static void read_color_pixels( const GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLubyte rgba[][4], const GLubyte mask[] )
+{
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaDisplay *dpy = xmesa->xm_visual->display;
+ register GLuint i;
+ XMesaBuffer source;
+ XMesaDrawable buffer;
+
+ if (xmesa->use_read_buffer)
+ source = xmesa->xm_read_buffer;
+ else
+ source = xmesa->xm_buffer;
+
+ buffer = source->buffer; /* the X drawable */
+
+ if (source->buffer) {
+ switch (xmesa->pixelformat) {
+ case PF_TRUECOLOR:
+ case PF_TRUEDITHER:
+ case PF_5R6G5B:
+ case PF_DITHER_5R6G5B:
+ {
+ unsigned long rMask = GET_REDMASK(xmesa->xm_visual);
+ unsigned long gMask = GET_GREENMASK(xmesa->xm_visual);
+ unsigned long bMask = GET_BLUEMASK(xmesa->xm_visual);
+ GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
+ GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
+ GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
+ GLint rShift = xmesa->xm_visual->rshift;
+ GLint gShift = xmesa->xm_visual->gshift;
+ GLint bShift = xmesa->xm_visual->bshift;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p = read_pixel( dpy, buffer,
+ x[i], FLIP(source, y[i]) );
+ rgba[i][RCOMP] = pixelToR[(p & rMask) >> rShift];
+ rgba[i][GCOMP] = pixelToG[(p & gMask) >> gShift];
+ rgba[i][BCOMP] = pixelToB[(p & bMask) >> bShift];
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ }
+ break;
+ case PF_8A8B8G8R:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p = read_pixel( dpy, buffer,
+ x[i], FLIP(source, y[i]) );
+ rgba[i][RCOMP] = (GLubyte) ( p & 0xff);
+ rgba[i][GCOMP] = (GLubyte) ((p >> 8) & 0xff);
+ rgba[i][BCOMP] = (GLubyte) ((p >> 16) & 0xff);
+ rgba[i][ACOMP] = (GLubyte) ((p >> 24) & 0xff);
+ }
+ }
+ break;
+ case PF_8R8G8B:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p = read_pixel( dpy, buffer,
+ x[i], FLIP(source, y[i]) );
+ rgba[i][RCOMP] = (GLubyte) ((p >> 16) & 0xff);
+ rgba[i][GCOMP] = (GLubyte) ((p >> 8) & 0xff);
+ rgba[i][BCOMP] = (GLubyte) ( p & 0xff);
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ break;
+ case PF_8R8G8B24:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p = read_pixel( dpy, buffer,
+ x[i], FLIP(source, y[i]) );
+ rgba[i][RCOMP] = (GLubyte) ((p >> 16) & 0xff);
+ rgba[i][GCOMP] = (GLubyte) ((p >> 8) & 0xff);
+ rgba[i][BCOMP] = (GLubyte) ( p & 0xff);
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ break;
+ case PF_HPCR:
+ {
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p = read_pixel( dpy, buffer,
+ x[i], FLIP(source, y[i]) );
+ rgba[i][RCOMP] = (GLubyte) ( p & 0xE0 );
+ rgba[i][GCOMP] = (GLubyte) ((p & 0x1C) << 3);
+ rgba[i][BCOMP] = (GLubyte) ((p & 0x03) << 6);
+ rgba[i][ACOMP] = (GLubyte) 255;
+ }
+ }
+ }
+ break;
+ case PF_DITHER:
+ case PF_LOOKUP:
+ case PF_GRAYSCALE:
+ {
+ GLubyte *rTable = source->pixel_to_r;
+ GLubyte *gTable = source->pixel_to_g;
+ GLubyte *bTable = source->pixel_to_b;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p = read_pixel( dpy, buffer,
+ x[i], FLIP(source, y[i]) );
+ rgba[i][RCOMP] = rTable[p];
+ rgba[i][GCOMP] = gTable[p];
+ rgba[i][BCOMP] = bTable[p];
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ }
+ break;
+ case PF_1BIT:
+ {
+ int bitFlip = xmesa->xm_visual->bitFlip;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p = read_pixel( dpy, buffer,
+ x[i], FLIP(source, y[i])) ^ bitFlip;
+ rgba[i][RCOMP] = (GLubyte) (p * 255);
+ rgba[i][GCOMP] = (GLubyte) (p * 255);
+ rgba[i][BCOMP] = (GLubyte) (p * 255);
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ }
+ break;
+ default:
+ gl_problem(NULL,"Problem in DD.read_color_pixels (1)");
+ return;
+ }
+ }
+ else if (source->backimage) {
+ switch (xmesa->pixelformat) {
+ case PF_TRUECOLOR:
+ case PF_TRUEDITHER:
+ case PF_5R6G5B:
+ case PF_DITHER_5R6G5B:
+ {
+ unsigned long rMask = GET_REDMASK(xmesa->xm_visual);
+ unsigned long gMask = GET_GREENMASK(xmesa->xm_visual);
+ unsigned long bMask = GET_BLUEMASK(xmesa->xm_visual);
+ GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
+ GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
+ GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
+ GLint rShift = xmesa->xm_visual->rshift;
+ GLint gShift = xmesa->xm_visual->gshift;
+ GLint bShift = xmesa->xm_visual->bshift;
+ XMesaImage *img = source->backimage;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p;
+ p = XMesaGetPixel( img, x[i], FLIP(source, y[i]) );
+ rgba[i][RCOMP] = pixelToR[(p & rMask) >> rShift];
+ rgba[i][GCOMP] = pixelToG[(p & gMask) >> gShift];
+ rgba[i][BCOMP] = pixelToB[(p & bMask) >> bShift];
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ }
+ break;
+ case PF_8A8B8G8R:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLuint *ptr4 = PIXELADDR4( source, x[i], y[i] );
+ GLuint p4 = *ptr4;
+ rgba[i][RCOMP] = (GLubyte) ( p4 & 0xff);
+ rgba[i][GCOMP] = (GLubyte) ((p4 >> 8) & 0xff);
+ rgba[i][BCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
+ rgba[i][ACOMP] = (GLubyte) ((p4 >> 24) & 0xff);
+ }
+ }
+ break;
+ case PF_8R8G8B:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLuint *ptr4 = PIXELADDR4( source, x[i], y[i] );
+ GLuint p4 = *ptr4;
+ rgba[i][RCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
+ rgba[i][GCOMP] = (GLubyte) ((p4 >> 8) & 0xff);
+ rgba[i][BCOMP] = (GLubyte) ( p4 & 0xff);
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ break;
+ case PF_8R8G8B24:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ bgr_t *ptr3 = PIXELADDR3( source, x[i], y[i] );
+ rgba[i][RCOMP] = ptr3->r;
+ rgba[i][GCOMP] = ptr3->g;
+ rgba[i][BCOMP] = ptr3->b;
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ break;
+ case PF_HPCR:
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ GLubyte *ptr1 = PIXELADDR1( source, x[i], y[i] );
+ GLubyte p = *ptr1;
+ rgba[i][RCOMP] = p & 0xE0;
+ rgba[i][GCOMP] = (p & 0x1C) << 3;
+ rgba[i][BCOMP] = (p & 0x03) << 6;
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ break;
+ case PF_DITHER:
+ case PF_LOOKUP:
+ case PF_GRAYSCALE:
+ {
+ GLubyte *rTable = source->pixel_to_r;
+ GLubyte *gTable = source->pixel_to_g;
+ GLubyte *bTable = source->pixel_to_b;
+ XMesaImage *img = source->backimage;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p;
+ p = XMesaGetPixel( img, x[i], FLIP(source, y[i]) );
+ rgba[i][RCOMP] = rTable[p];
+ rgba[i][GCOMP] = gTable[p];
+ rgba[i][BCOMP] = bTable[p];
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ }
+ break;
+ case PF_1BIT:
+ {
+ XMesaImage *img = source->backimage;
+ int bitFlip = xmesa->xm_visual->bitFlip;
+ for (i=0;i<n;i++) {
+ if (mask[i]) {
+ unsigned long p;
+ p = XMesaGetPixel( img, x[i], FLIP(source, y[i]) ) ^ bitFlip;
+ rgba[i][RCOMP] = (GLubyte) (p * 255);
+ rgba[i][GCOMP] = (GLubyte) (p * 255);
+ rgba[i][BCOMP] = (GLubyte) (p * 255);
+ rgba[i][ACOMP] = 255;
+ }
+ }
+ }
+ break;
+ default:
+ gl_problem(NULL,"Problem in DD.read_color_pixels (1)");
+ return;
+ }
+ }
+}
+
+
+static void
+clear_color_HPCR_ximage( GLcontext *ctx,
+ GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+{
+ int i;
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ xmesa->clearcolor[0] = r;
+ xmesa->clearcolor[1] = g;
+ xmesa->clearcolor[2] = b;
+ xmesa->clearcolor[3] = a;
+
+ if (r == 0 && g == 0 && b == 0) {
+ /* black is black */
+ MEMSET( xmesa->xm_visual->hpcr_clear_ximage_pattern, 0x0 ,
+ sizeof(xmesa->xm_visual->hpcr_clear_ximage_pattern));
+ }
+ else {
+ /* build clear pattern */
+ for (i=0; i<16; i++) {
+ xmesa->xm_visual->hpcr_clear_ximage_pattern[0][i] =
+ DITHER_HPCR(i, 0, r, g, b);
+ xmesa->xm_visual->hpcr_clear_ximage_pattern[1][i] =
+ DITHER_HPCR(i, 1, r, g, b);
+ }
+ }
+}
+
+
+static void
+clear_color_HPCR_pixmap( GLcontext *ctx,
+ GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+{
+ int i;
+ const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ xmesa->clearcolor[0] = r;
+ xmesa->clearcolor[1] = g;
+ xmesa->clearcolor[2] = b;
+ xmesa->clearcolor[3] = a;
+
+
+ if (0x0==r && 0x0==g && 0x0==b) {
+ /* black is black */
+ for (i=0; i<16; i++) {
+ XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0, 0);
+ XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1, 0);
+ }
+ }
+ else {
+ for (i=0; i<16; i++) {
+ XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0, DITHER_HPCR(i, 0, r, g, b));
+ XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1, DITHER_HPCR(i, 1, r, g, b));
+ }
+ }
+ /* change tile pixmap content */
+ XMesaPutImage(xmesa->display,
+ (XMesaDrawable)xmesa->xm_visual->hpcr_clear_pixmap,
+ xmesa->xm_buffer->cleargc,
+ xmesa->xm_visual->hpcr_clear_ximage, 0, 0, 0, 0, 16, 2);
+}
+
+
+
+void xmesa_update_span_funcs( GLcontext *ctx )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ int depth=GET_VISUAL_DEPTH(xmesa->xm_visual);
+
+ /*
+ * These drawing functions depend on color buffer config:
+ */
+ if (xmesa->xm_buffer->buffer!=XIMAGE) {
+ /* Writing to window or back pixmap */
+ switch (xmesa->pixelformat) {
+ case PF_INDEX:
+ ctx->Driver.WriteCI32Span = write_span_index_pixmap;
+ ctx->Driver.WriteCI8Span = write_span_index8_pixmap;
+ ctx->Driver.WriteMonoCISpan = write_span_mono_pixmap;
+ ctx->Driver.WriteCI32Pixels = write_pixels_index_pixmap;
+ ctx->Driver.WriteMonoCIPixels = write_pixels_mono_pixmap;
+ break;
+ case PF_TRUECOLOR:
+ ctx->Driver.WriteRGBASpan = write_span_TRUECOLOR_pixmap;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_TRUECOLOR_pixmap;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_pixmap;
+ ctx->Driver.WriteRGBAPixels = write_pixels_TRUECOLOR_pixmap;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_pixmap;
+ break;
+ case PF_TRUEDITHER:
+ ctx->Driver.WriteRGBASpan = write_span_TRUEDITHER_pixmap;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_TRUEDITHER_pixmap;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_TRUEDITHER_pixmap;
+ ctx->Driver.WriteRGBAPixels = write_pixels_TRUEDITHER_pixmap;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_TRUEDITHER_pixmap;
+ break;
+ case PF_8A8B8G8R:
+ ctx->Driver.WriteRGBASpan = write_span_8A8B8G8R_pixmap;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_8A8B8G8R_pixmap;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_pixmap;
+ ctx->Driver.WriteRGBAPixels = write_pixels_8A8B8G8R_pixmap;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_pixmap;
+ break;
+ case PF_8R8G8B:
+ ctx->Driver.WriteRGBASpan = write_span_8R8G8B_pixmap;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_8R8G8B_pixmap;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_pixmap;
+ ctx->Driver.WriteRGBAPixels = write_pixels_8R8G8B_pixmap;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_pixmap;
+ ctx->Driver.DrawPixels = NULL; /*drawpixels_8R8G8B;*/
+ break;
+ case PF_8R8G8B24:
+ ctx->Driver.WriteRGBASpan = write_span_8R8G8B24_pixmap;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_8R8G8B24_pixmap;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_pixmap;
+ ctx->Driver.WriteRGBAPixels = write_pixels_8R8G8B24_pixmap;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_pixmap;
+ break;
+ case PF_5R6G5B:
+ ctx->Driver.WriteRGBASpan = write_span_5R6G5B_pixmap;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_5R6G5B_pixmap;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_pixmap;
+ ctx->Driver.WriteRGBAPixels = write_pixels_5R6G5B_pixmap;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_pixmap;
+ break;
+ case PF_DITHER_5R6G5B:
+ ctx->Driver.WriteRGBASpan = write_span_DITHER_5R6G5B_pixmap;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_DITHER_5R6G5B_pixmap;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_TRUEDITHER_pixmap;
+ ctx->Driver.WriteRGBAPixels = write_pixels_DITHER_5R6G5B_pixmap;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_TRUEDITHER_pixmap;
+ break;
+ case PF_DITHER:
+ ctx->Driver.WriteRGBASpan = write_span_DITHER_pixmap;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_DITHER_pixmap;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_DITHER_pixmap;
+ ctx->Driver.WriteRGBAPixels = write_pixels_DITHER_pixmap;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_DITHER_pixmap;
+ break;
+ case PF_1BIT:
+ ctx->Driver.WriteRGBASpan = write_span_1BIT_pixmap;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_1BIT_pixmap;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_1BIT_pixmap;
+ ctx->Driver.WriteRGBAPixels = write_pixels_1BIT_pixmap;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_1BIT_pixmap;
+ break;
+ case PF_HPCR:
+ ctx->Driver.WriteRGBASpan = write_span_HPCR_pixmap;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_HPCR_pixmap;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_pixmap;
+ ctx->Driver.WriteRGBAPixels = write_pixels_HPCR_pixmap;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_pixmap;
+ if (xmesa->xm_visual->hpcr_clear_flag) {
+ ctx->Driver.ClearColor = clear_color_HPCR_pixmap;
+ }
+ break;
+ case PF_LOOKUP:
+ ctx->Driver.WriteRGBASpan = write_span_LOOKUP_pixmap;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_LOOKUP_pixmap;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_pixmap;
+ ctx->Driver.WriteRGBAPixels = write_pixels_LOOKUP_pixmap;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_pixmap;
+ break;
+ case PF_GRAYSCALE:
+ ctx->Driver.WriteRGBASpan = write_span_GRAYSCALE_pixmap;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_GRAYSCALE_pixmap;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_pixmap;
+ ctx->Driver.WriteRGBAPixels = write_pixels_GRAYSCALE_pixmap;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_pixmap;
+ break;
+ default:
+ gl_problem(NULL,"Bad pixel format in xmesa_update_state (1)");
+ return;
+ }
+ }
+ else if (xmesa->xm_buffer->buffer==XIMAGE) {
+ /* Writing to back XImage */
+ switch (xmesa->pixelformat) {
+ case PF_INDEX:
+ ctx->Driver.WriteCI32Span = write_span_index_ximage;
+ if (depth==8)
+ ctx->Driver.WriteCI8Span = write_span_index8_ximage8;
+ else
+ ctx->Driver.WriteCI8Span = write_span_index8_ximage;
+ ctx->Driver.WriteMonoCISpan = write_span_mono_ximage;
+ ctx->Driver.WriteCI32Pixels = write_pixels_index_ximage;
+ ctx->Driver.WriteMonoCIPixels = write_pixels_mono_ximage;
+ break;
+ case PF_TRUECOLOR:
+ /* Generic RGB */
+ ctx->Driver.WriteRGBASpan = write_span_TRUECOLOR_ximage;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_TRUECOLOR_ximage;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_ximage;
+ ctx->Driver.WriteRGBAPixels = write_pixels_TRUECOLOR_ximage;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_ximage;
+ break;
+ case PF_TRUEDITHER:
+ ctx->Driver.WriteRGBASpan = write_span_TRUEDITHER_ximage;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_TRUEDITHER_ximage;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_TRUEDITHER_ximage;
+ ctx->Driver.WriteRGBAPixels = write_pixels_TRUEDITHER_ximage;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_TRUEDITHER_ximage;
+ break;
+ case PF_8A8B8G8R:
+ ctx->Driver.WriteRGBASpan = write_span_8A8B8G8R_ximage;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_8A8B8G8R_ximage;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_8A8B8G8R_ximage;
+ ctx->Driver.WriteRGBAPixels = write_pixels_8A8B8G8R_ximage;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_8A8B8G8R_ximage;
+ break;
+ case PF_8R8G8B:
+ ctx->Driver.WriteRGBASpan = write_span_8R8G8B_ximage;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_8R8G8B_ximage;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_8R8G8B_ximage;
+ ctx->Driver.WriteRGBAPixels = write_pixels_8R8G8B_ximage;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_8R8G8B_ximage;
+ ctx->Driver.DrawPixels = NULL;
+ break;
+ case PF_8R8G8B24:
+ ctx->Driver.WriteRGBASpan = write_span_8R8G8B24_ximage;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_8R8G8B24_ximage;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_8R8G8B24_ximage;
+ ctx->Driver.WriteRGBAPixels = write_pixels_8R8G8B24_ximage;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_8R8G8B24_ximage;
+ break;
+ case PF_5R6G5B:
+ ctx->Driver.WriteRGBASpan = write_span_5R6G5B_ximage;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_5R6G5B_ximage;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_ximage;
+ ctx->Driver.WriteRGBAPixels = write_pixels_5R6G5B_ximage;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_ximage;
+ break;
+ case PF_DITHER_5R6G5B:
+ ctx->Driver.WriteRGBASpan = write_span_DITHER_5R6G5B_ximage;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_DITHER_5R6G5B_ximage;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_DITHER_5R6G5B_ximage;
+ ctx->Driver.WriteRGBAPixels = write_pixels_DITHER_5R6G5B_ximage;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_DITHER_5R6G5B_ximage;
+ break;
+ case PF_DITHER:
+ if (depth==8) {
+ ctx->Driver.WriteRGBASpan = write_span_DITHER8_ximage;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_DITHER8_ximage;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_DITHER8_ximage;
+ ctx->Driver.WriteRGBAPixels = write_pixels_DITHER8_ximage;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_DITHER8_ximage;
+ }
+ else {
+ ctx->Driver.WriteRGBASpan = write_span_DITHER_ximage;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_DITHER_ximage;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_DITHER_ximage;
+ ctx->Driver.WriteRGBAPixels = write_pixels_DITHER_ximage;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_DITHER_ximage;
+ }
+ break;
+ case PF_1BIT:
+ ctx->Driver.WriteRGBASpan = write_span_1BIT_ximage;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_1BIT_ximage;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_1BIT_ximage;
+ ctx->Driver.WriteRGBAPixels = write_pixels_1BIT_ximage;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_1BIT_ximage;
+ break;
+ case PF_HPCR:
+ ctx->Driver.WriteRGBASpan = write_span_HPCR_ximage;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_HPCR_ximage;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_HPCR_ximage;
+ ctx->Driver.WriteRGBAPixels = write_pixels_HPCR_ximage;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_HPCR_ximage;
+ if (xmesa->xm_visual->hpcr_clear_flag) {
+ ctx->Driver.ClearColor = clear_color_HPCR_ximage;
+ }
+ break;
+ case PF_LOOKUP:
+ if (depth==8) {
+ ctx->Driver.WriteRGBASpan = write_span_LOOKUP8_ximage;
+ ctx->Driver.WriteRGBSpan = write_rgb_LOOKUP8_ximage;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_LOOKUP8_ximage;
+ ctx->Driver.WriteRGBAPixels = write_pixels_LOOKUP8_ximage;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_LOOKUP8_ximage;
+ }
+ else {
+ ctx->Driver.WriteRGBASpan = write_span_LOOKUP_ximage;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_LOOKUP_ximage;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_ximage;
+ ctx->Driver.WriteRGBAPixels = write_pixels_LOOKUP_ximage;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_ximage;
+ }
+ break;
+ case PF_GRAYSCALE:
+ if (depth==8) {
+ ctx->Driver.WriteRGBASpan = write_span_GRAYSCALE8_ximage;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_GRAYSCALE8_ximage;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_GRAYSCALE8_ximage;
+ ctx->Driver.WriteRGBAPixels = write_pixels_GRAYSCALE8_ximage;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_GRAYSCALE8_ximage;
+ }
+ else {
+ ctx->Driver.WriteRGBASpan = write_span_GRAYSCALE_ximage;
+ ctx->Driver.WriteRGBSpan = write_span_rgb_GRAYSCALE_ximage;
+ ctx->Driver.WriteMonoRGBASpan = write_span_mono_ximage;
+ ctx->Driver.WriteRGBAPixels = write_pixels_GRAYSCALE_ximage;
+ ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_ximage;
+ }
+ break;
+ default:
+ gl_problem(NULL,"Bad pixel format in xmesa_update_state (2)");
+ return;
+ }
+ }
+
+ /* Pixel/span reading functions: */
+ ctx->Driver.ReadCI32Span = read_index_span;
+ ctx->Driver.ReadRGBASpan = read_color_span;
+ ctx->Driver.ReadCI32Pixels = read_index_pixels;
+ ctx->Driver.ReadRGBAPixels = read_color_pixels;
+}
diff --git a/src/mesa/drivers/x11/xm_tri.c b/src/mesa/drivers/x11/xm_tri.c
new file mode 100644
index 00000000000..02b186a0b5e
--- /dev/null
+++ b/src/mesa/drivers/x11/xm_tri.c
@@ -0,0 +1,1690 @@
+/* $Id: xm_tri.c,v 1.1 2000/09/07 15:40:30 brianp Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 3.3
+ *
+ * Copyright (C) 1999 Brian Paul All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/*
+ * This file contains "accelerated" triangle functions. It should be
+ * fairly easy to write new special-purpose triangle functions and hook
+ * them into this module.
+ */
+
+
+#include "glxheader.h"
+#include "depth.h"
+#include "macros.h"
+#include "vb.h"
+#include "types.h"
+#include "xmesaP.h"
+
+
+
+
+/**********************************************************************/
+/*** Triangle rendering ***/
+/**********************************************************************/
+
+
+#if 0
+/*
+ * Render a triangle into a pixmap, any pixel format, flat shaded and
+ * no raster ops.
+ */
+static void flat_pixmap_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ struct vertex_buffer *VB = ctx->VB;
+ XMesaPoint p[3];
+ XMesaGC gc;
+
+ if (0 /*VB->MonoColor*/) {
+ gc = xmesa->xm_buffer->gc1; /* use current color */
+ }
+ else {
+ unsigned long pixel;
+ if (xmesa->xm_visual->gl_visual->RGBAflag) {
+ pixel = xmesa_color_to_pixel( xmesa,
+ VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1],
+ VB->ColorPtr->data[pv][2], VB->ColorPtr->data[pv][3],
+ xmesa->pixelformat );
+ }
+ else {
+ pixel = VB->IndexPtr->data[pv];
+ }
+ gc = xmesa->xm_buffer->gc2;
+ XMesaSetForeground( xmesa->display, gc, pixel );
+ }
+ p[0].x = (GLint) (VB->Win.data[v0][0] + 0.5f);
+ p[0].y = FLIP( xmesa->xm_buffer, (GLint) (VB->Win.data[v0][1] - 0.5f) );
+ p[1].x = (GLint) (VB->Win.data[v1][0] + 0.5f);
+ p[1].y = FLIP( xmesa->xm_buffer, (GLint) (VB->Win.data[v1][1] - 0.5f) );
+ p[2].x = (GLint) (VB->Win.data[v2][0] + 0.5f);
+ p[2].y = FLIP( xmesa->xm_buffer, (GLint) (VB->Win.data[v2][1] - 0.5f) );
+ XMesaFillPolygon( xmesa->display, xmesa->xm_buffer->buffer, gc,
+ p, 3, Convex, CoordModeOrigin );
+}
+#endif
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_TRUECOLOR triangle.
+ */
+static void smooth_TRUECOLOR_z_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2,
+ GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ (void) pv;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer, Y); \
+ GLint len = RIGHT-LEFT; \
+ for (i=0;i<len;i++,xx++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ unsigned long p; \
+ PACK_TRUECOLOR(p, FixedToInt(ffr), FixedToInt(ffg), FixedToInt(ffb));\
+ XMesaPutPixel( img, xx, yy, p ); \
+ zRow[i] = z; \
+ } \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.
+ */
+static void smooth_8A8B8G8R_z_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2,
+ GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ (void) pv;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg), \
+ FixedToInt(ffb) ); \
+ zRow[i] = z; \
+ } \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_8R8G8B triangle.
+ */
+static void smooth_8R8G8B_z_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2,
+ GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ (void) pv;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg), \
+ FixedToInt(ffb) ); \
+ zRow[i] = z; \
+ } \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_8R8G8B24 triangle.
+ */
+static void smooth_8R8G8B24_z_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2,
+ GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ (void) pv;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE bgr_t
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ PIXEL_TYPE *ptr = pRow + i; \
+ ptr->r = FixedToInt(ffr); \
+ ptr->g = FixedToInt(ffg); \
+ ptr->b = FixedToInt(ffb); \
+ zRow[i] = z; \
+ } \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_TRUEDITHER triangle.
+ */
+static void smooth_TRUEDITHER_z_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2,
+ GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ (void) pv;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT; \
+ for (i=0;i<len;i++,xx++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ unsigned long p; \
+ PACK_TRUEDITHER( p, xx, yy, FixedToInt(ffr), \
+ FixedToInt(ffg), FixedToInt(ffb) ); \
+ XMesaPutPixel( img, xx, yy, p ); \
+ zRow[i] = z; \
+ } \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_5R6G5B triangle.
+ */
+static void smooth_5R6G5B_z_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2,
+ GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ (void) pv;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ DEPTH_TYPE z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = PACK_5R6G5B( FixedToInt(ffr), FixedToInt(ffg), \
+ FixedToInt(ffb) ); \
+ zRow[i] = z; \
+ } \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_DITHER_5R6G5B triangle.
+ */
+static void smooth_DITHER_5R6G5B_z_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2,
+ GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ (void) pv;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ PACK_TRUEDITHER(pRow[i], LEFT+i, Y, FixedToInt(ffr), \
+ FixedToInt(ffg), FixedToInt(ffb) ); \
+ zRow[i] = z; \
+ } \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, 8-bit, PF_DITHER8 triangle.
+ */
+static void smooth_DITHER8_z_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2,
+ GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ (void) pv;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT; \
+ XDITHER_SETUP(yy); \
+ for (i=0;i<len;i++,xx++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = (PIXEL_TYPE) XDITHER( xx, FixedToInt(ffr), \
+ FixedToInt(ffg), FixedToInt(ffb) ); \
+ zRow[i] = z; \
+ } \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_DITHER triangle.
+ */
+static void smooth_DITHER_z_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2,
+ GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ (void) pv;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT; \
+ XDITHER_SETUP(yy); \
+ for (i=0;i<len;i++,xx++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ unsigned long p = XDITHER( xx, FixedToInt(ffr), \
+ FixedToInt(ffg), FixedToInt(ffb) ); \
+ XMesaPutPixel( img, xx, yy, p ); \
+ zRow[i] = z; \
+ } \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, 8-bit PF_LOOKUP triangle.
+ */
+static void smooth_LOOKUP8_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ (void) pv;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, len = RIGHT-LEFT; \
+ LOOKUP_SETUP; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = LOOKUP( FixedToInt(ffr), FixedToInt(ffg), \
+ FixedToInt(ffb) ); \
+ zRow[i] = z; \
+ } \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+
+/*
+ * XImage, smooth, depth-buffered, 8-bit PF_HPCR triangle.
+ */
+static void smooth_HPCR_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ (void) pv;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT; \
+ for (i=0;i<len;i++,xx++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = DITHER_HPCR( xx, yy, FixedToInt(ffr), \
+ FixedToInt(ffg), FixedToInt(ffb) ); \
+ zRow[i] = z; \
+ } \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_TRUECOLOR triangle.
+ */
+static void flat_TRUECOLOR_z_triangle( GLcontext *ctx,
+ GLuint v0, GLuint v1, GLuint v2,
+ GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define SETUP_CODE \
+ unsigned long pixel; \
+ PACK_TRUECOLOR(pixel, VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2]);
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT; \
+ for (i=0;i<len;i++,xx++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ XMesaPutPixel( img, xx, yy, pixel ); \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_8A8B8G8R triangle.
+ */
+static void flat_8A8B8G8R_z_triangle( GLcontext *ctx, GLuint v0,
+ GLuint v1, GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE \
+ unsigned long p = PACK_8B8G8R( VB->ColorPtr->data[pv][0], \
+ VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = (PIXEL_TYPE) p; \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_8R8G8B triangle.
+ */
+static void flat_8R8G8B_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE \
+ unsigned long p = PACK_8R8G8B( VB->ColorPtr->data[pv][0], \
+ VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = (PIXEL_TYPE) p; \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_8R8G8B24 triangle.
+ */
+static void flat_8R8G8B24_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE bgr_t
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ PIXEL_TYPE *ptr = pRow+i; \
+ ptr->r = color[RCOMP]; \
+ ptr->g = color[GCOMP]; \
+ ptr->b = color[BCOMP]; \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_TRUEDITHER triangle.
+ */
+static void flat_TRUEDITHER_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT; \
+ for (i=0;i<len;i++,xx++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ unsigned long p; \
+ PACK_TRUEDITHER( p, xx, yy, VB->ColorPtr->data[pv][0], \
+ VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] ); \
+ XMesaPutPixel( img, xx, yy, p ); \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_5R6G5B triangle.
+ */
+static void flat_5R6G5B_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE \
+ unsigned long p = PACK_5R6G5B( VB->ColorPtr->data[pv][0], \
+ VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ DEPTH_TYPE z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = (PIXEL_TYPE) p; \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_DITHER_5R6G5B triangle.
+ */
+static void flat_DITHER_5R6G5B_z_triangle( GLcontext *ctx, GLuint v0,
+ GLuint v1, GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ DEPTH_TYPE z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ PACK_TRUEDITHER(pRow[i], LEFT+i, Y, color[RCOMP], \
+ color[GCOMP], color[BCOMP]); \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, 8-bit PF_DITHER triangle.
+ */
+static void flat_DITHER8_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE \
+ FLAT_DITHER_SETUP( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, xx = LEFT, len = RIGHT-LEFT; \
+ FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, Y)); \
+ for (i=0;i<len;i++,xx++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = (PIXEL_TYPE) FLAT_DITHER(xx); \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_DITHER triangle.
+ */
+static void flat_DITHER_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define SETUP_CODE \
+ FLAT_DITHER_SETUP( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT; \
+ FLAT_DITHER_ROW_SETUP(yy); \
+ for (i=0;i<len;i++,xx++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ unsigned long p = FLAT_DITHER(xx); \
+ XMesaPutPixel( img, xx, yy, p ); \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, 8-bit PF_HPCR triangle.
+ */
+static void flat_HPCR_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE \
+ GLubyte r = VB->ColorPtr->data[pv][0]; \
+ GLubyte g = VB->ColorPtr->data[pv][1]; \
+ GLubyte b = VB->ColorPtr->data[pv][2];
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT; \
+ for (i=0;i<len;i++,xx++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = (PIXEL_TYPE) DITHER_HPCR( xx, yy, r, g, b ); \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle.
+ */
+static void flat_LOOKUP8_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE \
+ LOOKUP_SETUP; \
+ GLubyte r = VB->ColorPtr->data[pv][0]; \
+ GLubyte g = VB->ColorPtr->data[pv][1]; \
+ GLubyte b = VB->ColorPtr->data[pv][2]; \
+ GLubyte p = LOOKUP(r,g,b);
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint i, len = RIGHT-LEFT; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ pRow[i] = p; \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle.
+ */
+static void smooth_TRUECOLOR_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ (void) pv;
+#define INTERP_RGB 1
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
+ for (xx=LEFT;xx<RIGHT;xx++) { \
+ unsigned long p; \
+ PACK_TRUECOLOR(p, FixedToInt(ffr), FixedToInt(ffg), FixedToInt(ffb));\
+ XMesaPutPixel( img, xx, yy, p ); \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.
+ */
+static void smooth_8A8B8G8R_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ (void) pv;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg), \
+ FixedToInt(ffb) ); \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
+ */
+static void smooth_8R8G8B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ (void) pv;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg), \
+ FixedToInt(ffb) ); \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
+ */
+static void smooth_8R8G8B24_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ (void) pv;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE bgr_t
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++) { \
+ pixel->r = FixedToInt(ffr); \
+ pixel->g = FixedToInt(ffg); \
+ pixel->b = FixedToInt(ffb); \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ pixel++; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_TRUEDITHER triangle.
+ */
+static void smooth_TRUEDITHER_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ (void) pv;
+#define INTERP_RGB 1
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
+ for (xx=LEFT;xx<RIGHT;xx++) { \
+ unsigned long p; \
+ PACK_TRUEDITHER( p, xx, yy, FixedToInt(ffr), FixedToInt(ffg), \
+ FixedToInt(ffb) ); \
+ XMesaPutPixel( img, xx, yy, p ); \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.
+ */
+static void smooth_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ (void) pv;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = (PIXEL_TYPE) PACK_5R6G5B( FixedToInt(ffr), \
+ FixedToInt(ffg), FixedToInt(ffb) ); \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
+ */
+static void smooth_DITHER_5R6G5B_triangle( GLcontext *ctx, GLuint v0,
+ GLuint v1, GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ (void) pv;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ PACK_TRUEDITHER(*pixel, xx, Y, FixedToInt(ffr), \
+ FixedToInt(ffg), FixedToInt(ffb) ); \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle.
+ */
+static void smooth_DITHER8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ (void) pv;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
+ PIXEL_TYPE *pixel = pRow; \
+ XDITHER_SETUP(yy); \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = (PIXEL_TYPE) XDITHER( xx, FixedToInt(ffr), \
+ FixedToInt(ffg), FixedToInt(ffb) ); \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_DITHER triangle.
+ */
+static void smooth_DITHER_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+ (void) pv;
+#define INTERP_RGB 1
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
+ XDITHER_SETUP(yy); \
+ for (xx=LEFT;xx<RIGHT;xx++) { \
+ unsigned long p = XDITHER( xx, FixedToInt(ffr), \
+ FixedToInt(ffg), FixedToInt(ffb) ); \
+ XMesaPutPixel( img, xx, yy, p ); \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
+ */
+static void smooth_LOOKUP8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ (void) pv;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ LOOKUP_SETUP; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = LOOKUP( FixedToInt(ffr), FixedToInt(ffg), \
+ FixedToInt(ffb) ); \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, 8-bit PF_HPCR triangle.
+ */
+static void smooth_HPCR_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ (void) pv;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = DITHER_HPCR( xx, yy, FixedToInt(ffr), \
+ FixedToInt(ffg), FixedToInt(ffb) ); \
+ ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_TRUECOLOR triangle.
+ */
+static void flat_TRUECOLOR_triangle( GLcontext *ctx, GLuint v0,
+ GLuint v1, GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+#define SETUP_CODE \
+ unsigned long pixel; \
+ PACK_TRUECOLOR(pixel, VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2]);
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
+ for (xx=LEFT;xx<RIGHT;xx++) { \
+ XMesaPutPixel( img, xx, yy, pixel ); \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.
+ */
+static void flat_8A8B8G8R_triangle( GLcontext *ctx, GLuint v0,
+ GLuint v1, GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE \
+ unsigned long p = PACK_8B8G8R( VB->ColorPtr->data[pv][0], \
+ VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = (PIXEL_TYPE) p; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.
+ */
+static void flat_8R8G8B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE \
+ unsigned long p = PACK_8R8G8B( VB->ColorPtr->data[pv][0], \
+ VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = (PIXEL_TYPE) p; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_8R8G8B24 triangle.
+ */
+static void flat_8R8G8B24_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE bgr_t
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++) { \
+ pixel->r = color[RCOMP]; \
+ pixel->g = color[GCOMP]; \
+ pixel->b = color[BCOMP]; \
+ pixel++; \
+ } \
+}
+#include "tritemp.h"
+}
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_TRUEDITHER triangle.
+ */
+static void flat_TRUEDITHER_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
+ for (xx=LEFT;xx<RIGHT;xx++) { \
+ unsigned long p; \
+ PACK_TRUEDITHER( p, xx, yy, VB->ColorPtr->data[pv][0], \
+ VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] ); \
+ XMesaPutPixel( img, xx, yy, p ); \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.
+ */
+static void flat_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE \
+ unsigned long p = PACK_5R6G5B( VB->ColorPtr->data[pv][0], \
+ VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = (PIXEL_TYPE) p; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
+ */
+static void flat_DITHER_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ const GLubyte *color = ctx->VB->ColorPtr->data[pv];
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ PACK_TRUEDITHER(*pixel, xx, Y, color[RCOMP], \
+ color[GCOMP], color[BCOMP]); \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle.
+ */
+static void flat_DITHER8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE \
+ FLAT_DITHER_SETUP( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, Y)); \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = (PIXEL_TYPE) FLAT_DITHER(xx); \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_DITHER triangle.
+ */
+static void flat_DITHER_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ XMesaImage *img = xmesa->xm_buffer->backimage;
+#define SETUP_CODE \
+ FLAT_DITHER_SETUP( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
+ FLAT_DITHER_ROW_SETUP(yy); \
+ for (xx=LEFT;xx<RIGHT;xx++) { \
+ unsigned long p = FLAT_DITHER(xx); \
+ XMesaPutPixel( img, xx, yy, p ); \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, 8-bit PF_HPCR triangle.
+ */
+static void flat_HPCR_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE \
+ GLubyte r = VB->ColorPtr->data[pv][0]; \
+ GLubyte g = VB->ColorPtr->data[pv][1]; \
+ GLubyte b = VB->ColorPtr->data[pv][2];
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx, yy = FLIP(xmesa->xm_buffer, Y); \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = (PIXEL_TYPE) DITHER_HPCR( xx, yy, r, g, b ); \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
+ */
+static void flat_LOOKUP8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+ GLuint v2, GLuint pv )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE \
+ LOOKUP_SETUP; \
+ GLubyte r = VB->ColorPtr->data[pv][0]; \
+ GLubyte g = VB->ColorPtr->data[pv][1]; \
+ GLubyte b = VB->ColorPtr->data[pv][2]; \
+ GLubyte p = LOOKUP(r,g,b);
+#define INNER_LOOP( LEFT, RIGHT, Y ) \
+{ \
+ GLint xx; \
+ PIXEL_TYPE *pixel = pRow; \
+ for (xx=LEFT;xx<RIGHT;xx++,pixel++) { \
+ *pixel = p; \
+ } \
+}
+#include "tritemp.h"
+}
+
+
+
+#if 0
+/*
+ * This function is called if we're about to render triangles into an
+ * X window/pixmap. It sets the polygon stipple pattern if enabled.
+ */
+static void setup_x_polygon_options( GLcontext *ctx )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ int fill_type;
+
+ if (ctx->Polygon.StippleFlag) {
+ if (xmesa->xm_buffer->stipple_pixmap == 0) {
+ /* Allocate polygon stippling stuff once for this context. */
+ XMesaBuffer b = xmesa->xm_buffer;
+ b->stipple_pixmap = XMesaCreatePixmap( xmesa->display,
+ b->buffer, 32, 32, 1 );
+#ifdef XFree86Server
+ b->stipple_gc = CreateScratchGC(xmesa->display, 1);
+#else
+ b->stipple_gc = XCreateGC(xmesa->display, b->stipple_pixmap, 0, NULL);
+#endif
+ XMesaSetFunction(xmesa->display, b->stipple_gc, GXcopy);
+ XMesaSetForeground(xmesa->display, b->stipple_gc, 1);
+ XMesaSetBackground(xmesa->display, b->stipple_gc, 0);
+ }
+
+ /*
+ * NOTE: We don't handle the following here!
+ * GL_UNPACK_SWAP_BYTES
+ * GL_UNPACK_LSB_FIRST
+ */
+ /* Copy Mesa stipple pattern to an XImage then to Pixmap */
+ {
+ XMesaImage *stipple_ximage;
+ GLuint stipple[32];
+ int i;
+ int shift = xmesa->xm_buffer->height % 32;
+ for (i=0;i<32;i++) {
+ stipple[31-i] = ctx->PolygonStipple[(i+shift) % 32];
+ }
+#ifdef XFree86Server
+ stipple_ximage = XMesaCreateImage(1, 32, 32, (char *)stipple);
+#else
+ stipple_ximage = XCreateImage( xmesa->display,
+ xmesa->xm_visual->visinfo->visual,
+ 1, ZPixmap, 0,
+ (char *)stipple,
+ 32, 32, 8, 0 );
+ stipple_ximage->byte_order = LSBFirst;
+ stipple_ximage->bitmap_bit_order = LSBFirst;
+ stipple_ximage->bitmap_unit = 32;
+#endif
+ XMesaPutImage( xmesa->display,
+ (XMesaDrawable)xmesa->xm_buffer->stipple_pixmap,
+ xmesa->xm_buffer->stipple_gc,
+ stipple_ximage, 0, 0, 0, 0, 32, 32 );
+ stipple_ximage->data = NULL;
+ XMesaDestroyImage( stipple_ximage );
+ }
+
+ XMesaSetStipple( xmesa->display, xmesa->xm_buffer->gc1,
+ xmesa->xm_buffer->stipple_pixmap );
+ XMesaSetStipple( xmesa->display, xmesa->xm_buffer->gc2,
+ xmesa->xm_buffer->stipple_pixmap );
+ fill_type = FillStippled;
+ }
+ else {
+ fill_type = FillSolid;
+ }
+
+ XMesaSetFillStyle( xmesa->display, xmesa->xm_buffer->gc1, fill_type );
+ XMesaSetFillStyle( xmesa->display, xmesa->xm_buffer->gc2, fill_type );
+}
+#endif
+
+
+#ifdef DEBUG
+void
+_xmesa_print_triangle_func( triangle_func triFunc )
+{
+ printf("XMesa tri func = ");
+ if (triFunc ==smooth_TRUECOLOR_z_triangle)
+ printf("smooth_TRUECOLOR_z_triangle\n");
+ else if (triFunc ==smooth_8A8B8G8R_z_triangle)
+ printf("smooth_8A8B8G8R_z_triangle\n");
+ else if (triFunc ==smooth_8R8G8B_z_triangle)
+ printf("smooth_8R8G8B_z_triangle\n");
+ else if (triFunc ==smooth_8R8G8B24_z_triangle)
+ printf("smooth_8R8G8B24_z_triangle\n");
+ else if (triFunc ==smooth_TRUEDITHER_z_triangle)
+ printf("smooth_TRUEDITHER_z_triangle\n");
+ else if (triFunc ==smooth_5R6G5B_z_triangle)
+ printf("smooth_5R6G5B_z_triangle\n");
+ else if (triFunc ==smooth_DITHER_5R6G5B_z_triangle)
+ printf("smooth_DITHER_5R6G5B_z_triangle\n");
+ else if (triFunc ==smooth_HPCR_z_triangle)
+ printf("smooth_HPCR_z_triangle\n");
+ else if (triFunc ==smooth_DITHER8_z_triangle)
+ printf("smooth_DITHER8_z_triangle\n");
+ else if (triFunc ==smooth_LOOKUP8_z_triangle)
+ printf("smooth_LOOKUP8_z_triangle\n");
+ else if (triFunc ==flat_TRUECOLOR_z_triangle)
+ printf("flat_TRUECOLOR_z_triangle\n");
+ else if (triFunc ==flat_8A8B8G8R_z_triangle)
+ printf("flat_8A8B8G8R_z_triangle\n");
+ else if (triFunc ==flat_8R8G8B_z_triangle)
+ printf("flat_8R8G8B_z_triangle\n");
+ else if (triFunc ==flat_8R8G8B24_z_triangle)
+ printf("flat_8R8G8B24_z_triangle\n");
+ else if (triFunc ==flat_TRUEDITHER_z_triangle)
+ printf("flat_TRUEDITHER_z_triangle\n");
+ else if (triFunc ==flat_5R6G5B_z_triangle)
+ printf("flat_5R6G5B_z_triangle\n");
+ else if (triFunc ==flat_DITHER_5R6G5B_z_triangle)
+ printf("flat_DITHER_5R6G5B_z_triangle\n");
+ else if (triFunc ==flat_HPCR_z_triangle)
+ printf("flat_HPCR_z_triangle\n");
+ else if (triFunc ==flat_DITHER8_z_triangle)
+ printf("flat_DITHER8_z_triangle\n");
+ else if (triFunc ==flat_LOOKUP8_z_triangle)
+ printf("flat_LOOKUP8_z_triangle\n");
+ else if (triFunc ==smooth_TRUECOLOR_triangle)
+ printf("smooth_TRUECOLOR_triangle\n");
+ else if (triFunc ==smooth_8A8B8G8R_triangle)
+ printf("smooth_8A8B8G8R_triangle\n");
+ else if (triFunc ==smooth_8R8G8B_triangle)
+ printf("smooth_8R8G8B_triangle\n");
+ else if (triFunc ==smooth_8R8G8B24_triangle)
+ printf("smooth_8R8G8B24_triangle\n");
+ else if (triFunc ==smooth_TRUEDITHER_triangle)
+ printf("smooth_TRUEDITHER_triangle\n");
+ else if (triFunc ==smooth_5R6G5B_triangle)
+ printf("smooth_5R6G5B_triangle\n");
+ else if (triFunc ==smooth_DITHER_5R6G5B_triangle)
+ printf("smooth_DITHER_5R6G5B_triangle\n");
+ else if (triFunc ==smooth_HPCR_triangle)
+ printf("smooth_HPCR_triangle\n");
+ else if (triFunc ==smooth_DITHER8_triangle)
+ printf("smooth_DITHER8_triangle\n");
+ else if (triFunc ==smooth_LOOKUP8_triangle)
+ printf("smooth_LOOKUP8_triangle\n");
+ else if (triFunc ==flat_TRUECOLOR_triangle)
+ printf("flat_TRUECOLOR_triangle\n");
+ else if (triFunc ==flat_TRUEDITHER_triangle)
+ printf("flat_TRUEDITHER_triangle\n");
+ else if (triFunc ==flat_8A8B8G8R_triangle)
+ printf("flat_8A8B8G8R_triangle\n");
+ else if (triFunc ==flat_8R8G8B_triangle)
+ printf("flat_8R8G8B_triangle\n");
+ else if (triFunc ==flat_8R8G8B24_triangle)
+ printf("flat_8R8G8B24_triangle\n");
+ else if (triFunc ==flat_5R6G5B_triangle)
+ printf("flat_5R6G5B_triangle\n");
+ else if (triFunc ==flat_DITHER_5R6G5B_triangle)
+ printf("flat_DITHER_5R6G5B_triangle\n");
+ else if (triFunc ==flat_HPCR_triangle)
+ printf("flat_HPCR_triangle\n");
+ else if (triFunc ==flat_DITHER8_triangle)
+ printf("flat_DITHER8_triangle\n");
+ else if (triFunc ==flat_LOOKUP8_triangle)
+ printf("flat_LOOKUP8_triangle\n");
+ else
+ printf("???\n");
+}
+#endif
+
+
+triangle_func xmesa_get_triangle_func( GLcontext *ctx )
+{
+ XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+ int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
+
+ (void) kernel1;
+
+ if (ctx->Polygon.SmoothFlag) return NULL;
+ if (ctx->Texture.Enabled) return NULL;
+
+ if (xmesa->xm_buffer->buffer==XIMAGE) {
+ if ( ctx->Light.ShadeModel==GL_SMOOTH
+ && ctx->RasterMask==DEPTH_BIT
+ && ctx->Depth.Func==GL_LESS
+ && ctx->Depth.Mask==GL_TRUE
+ && ctx->Visual->DepthBits == DEFAULT_SOFTWARE_DEPTH_BITS
+ && ctx->Polygon.StippleFlag==GL_FALSE) {
+ switch (xmesa->pixelformat) {
+ case PF_TRUECOLOR:
+ return smooth_TRUECOLOR_z_triangle;
+ case PF_8A8B8G8R:
+ return smooth_8A8B8G8R_z_triangle;
+ case PF_8R8G8B:
+ return smooth_8R8G8B_z_triangle;
+ case PF_8R8G8B24:
+ return smooth_8R8G8B24_z_triangle;
+ case PF_TRUEDITHER:
+ return smooth_TRUEDITHER_z_triangle;
+ case PF_5R6G5B:
+ return smooth_5R6G5B_z_triangle;
+ case PF_DITHER_5R6G5B:
+ return smooth_DITHER_5R6G5B_z_triangle;
+ case PF_HPCR:
+ return smooth_HPCR_z_triangle;
+ case PF_DITHER:
+ return (depth==8) ? smooth_DITHER8_z_triangle
+ : smooth_DITHER_z_triangle;
+ case PF_LOOKUP:
+ return (depth==8) ? smooth_LOOKUP8_z_triangle : NULL;
+ default:
+ return NULL;
+ }
+ }
+ if ( ctx->Light.ShadeModel==GL_FLAT
+ && ctx->RasterMask==DEPTH_BIT
+ && ctx->Depth.Func==GL_LESS
+ && ctx->Depth.Mask==GL_TRUE
+ && ctx->Visual->DepthBits == DEFAULT_SOFTWARE_DEPTH_BITS
+ && ctx->Polygon.StippleFlag==GL_FALSE) {
+ switch (xmesa->pixelformat) {
+ case PF_TRUECOLOR:
+ return flat_TRUECOLOR_z_triangle;
+ case PF_8A8B8G8R:
+ return flat_8A8B8G8R_z_triangle;
+ case PF_8R8G8B:
+ return flat_8R8G8B_z_triangle;
+ case PF_8R8G8B24:
+ return flat_8R8G8B24_z_triangle;
+ case PF_TRUEDITHER:
+ return flat_TRUEDITHER_z_triangle;
+ case PF_5R6G5B:
+ return flat_5R6G5B_z_triangle;
+ case PF_DITHER_5R6G5B:
+ return flat_DITHER_5R6G5B_z_triangle;
+ case PF_HPCR:
+ return flat_HPCR_z_triangle;
+ case PF_DITHER:
+ return (depth==8) ? flat_DITHER8_z_triangle
+ : flat_DITHER_z_triangle;
+ case PF_LOOKUP:
+ return (depth==8) ? flat_LOOKUP8_z_triangle : NULL;
+ default:
+ return NULL;
+ }
+ }
+ if ( ctx->RasterMask==0 /* no depth test */
+ && ctx->Light.ShadeModel==GL_SMOOTH
+ && ctx->Polygon.StippleFlag==GL_FALSE) {
+ switch (xmesa->pixelformat) {
+ case PF_TRUECOLOR:
+ return smooth_TRUECOLOR_triangle;
+ case PF_8A8B8G8R:
+ return smooth_8A8B8G8R_triangle;
+ case PF_8R8G8B:
+ return smooth_8R8G8B_triangle;
+ case PF_8R8G8B24:
+ return smooth_8R8G8B24_triangle;
+ case PF_TRUEDITHER:
+ return smooth_TRUEDITHER_triangle;
+ case PF_5R6G5B:
+ return smooth_5R6G5B_triangle;
+ case PF_DITHER_5R6G5B:
+ return smooth_DITHER_5R6G5B_triangle;
+ case PF_HPCR:
+ return smooth_HPCR_triangle;
+ case PF_DITHER:
+ return (depth==8) ? smooth_DITHER8_triangle
+ : smooth_DITHER_triangle;
+ case PF_LOOKUP:
+ return (depth==8) ? smooth_LOOKUP8_triangle : NULL;
+ default:
+ return NULL;
+ }
+ }
+
+ if ( ctx->RasterMask==0 /* no depth test */
+ && ctx->Light.ShadeModel==GL_FLAT
+ && ctx->Polygon.StippleFlag==GL_FALSE) {
+ switch (xmesa->pixelformat) {
+ case PF_TRUECOLOR:
+ return flat_TRUECOLOR_triangle;
+ case PF_TRUEDITHER:
+ return flat_TRUEDITHER_triangle;
+ case PF_8A8B8G8R:
+ return flat_8A8B8G8R_triangle;
+ case PF_8R8G8B:
+ return flat_8R8G8B_triangle;
+ case PF_8R8G8B24:
+ return flat_8R8G8B24_triangle;
+ case PF_5R6G5B:
+ return flat_5R6G5B_triangle;
+ case PF_DITHER_5R6G5B:
+ return flat_DITHER_5R6G5B_triangle;
+ case PF_HPCR:
+ return flat_HPCR_triangle;
+ case PF_DITHER:
+ return (depth==8) ? flat_DITHER8_triangle
+ : flat_DITHER_triangle;
+ case PF_LOOKUP:
+ return (depth==8) ? flat_LOOKUP8_triangle : NULL;
+ default:
+ return NULL;
+ }
+ }
+
+ return NULL;
+ }
+ else {
+ /* draw to pixmap */
+#if 0
+ /* XXX have to disable this because X's rasterization rules
+ * don't match software Mesa's. This causes a buffer invariance
+ * test failure in the conformance tests.
+ * In the future, we might provide a config option to enable this.
+ */
+ if (ctx->Light.ShadeModel==GL_FLAT && ctx->RasterMask==0) {
+ if (ctx->Color.DitherFlag && depth < 24)
+ return NULL;
+ setup_x_polygon_options( ctx );
+ return flat_pixmap_triangle;
+ }
+#endif
+ return NULL;
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-01 18:19:55 +0000