This is xmesa2.c in view mode; [Download] [Up]
/* $Id: xmesa2.c,v 1.4 1996/10/09 23:09:56 brianp Exp $ */
/*
* Mesa 3-D graphics library
* Version: 2.0
* Copyright (C) 1995-1996 Brian Paul
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/*
* $Log: xmesa2.c,v $
* Revision 1.4 1996/10/09 23:09:56 brianp
* fixed dithering bug in write_span_DITHER_pixmap()
*
* Revision 1.3 1996/09/27 01:31:42 brianp
* removed unused variables
*
* Revision 1.2 1996/09/19 03:16:04 brianp
* new X/Mesa interface with XMesaContext, XMesaVisual, and XMesaBuffer types
*
* Revision 1.1 1996/09/13 01:38:16 brianp
* Initial revision
*
*/
/*
* Mesa/X11 interface, part 2.
*
* This file contains the implementations of all the device driver functions.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <X11/Xlib.h>
#include "GL/xmesa.h"
#include "macros.h"
#include "types.h"
#include "xmesaP.h"
/*
* Abort with an error message.
*/
static void die( char *s )
{
fprintf( stderr, "%s\n", s );
abort();
}
/*
* The following functions are used to trap XGetImage() calls which
* generate BadMatch errors if the drawable isn't mapped.
*/
static int caught_xgetimage_error = 0;
static int (*old_xerror_handler)( Display *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( Display *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( Display *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;
}
/*
* Read a pixel from an X drawable.
*/
static unsigned long read_pixel( Display *dpy, Drawable d, int x, int y )
{
XImage *pixel;
unsigned long p;
int error;
catch_xgetimage_errors( dpy );
pixel = XGetImage( dpy, d, x, y, 1, 1, AllPlanes, ZPixmap );
error = check_xgetimage_errors();
if (pixel && !error) {
p = XGetPixel( pixel, 0, 0 );
}
else {
p = 0;
}
if (pixel) {
XDestroyImage( pixel );
}
return p;
}
/*
* 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Window root;
int winx, winy;
unsigned int winwidth, winheight;
unsigned int bw, d;
XGetGeometry( xmesa->display, xmesa->xm_buffer->frontbuffer, &root,
&winx, &winy, &winwidth, &winheight, &bw, &d );
*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 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
if (xmesa) {
XSync( xmesa->display, False );
}
}
static void flush( GLcontext *ctx )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
if (xmesa) {
XFlush( xmesa->display );
}
}
static GLboolean set_buffer( GLcontext *ctx, GLenum mode )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
if (mode==GL_FRONT) {
/* read/write front buffer */
xmesa->xm_buffer->buffer = xmesa->xm_buffer->frontbuffer;
xmesa_setup_DD_pointers( ctx );
return GL_TRUE;
}
else if (mode==GL_BACK && xmesa->xm_buffer->db_state) {
/* read/write back buffer */
if (xmesa->xm_buffer->backpixmap) {
xmesa->xm_buffer->buffer = xmesa->xm_buffer->backpixmap;
}
else if (xmesa->xm_buffer->backimage) {
xmesa->xm_buffer->buffer = None;
}
else {
/* just in case, probably a serious error? */
xmesa->xm_buffer->buffer = xmesa->xm_buffer->frontbuffer;
}
xmesa_setup_DD_pointers( ctx );
return GL_TRUE;
}
else {
return GL_FALSE;
}
}
static void clear_index( GLcontext *ctx, GLuint index )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
xmesa->clearpixel = (unsigned long) index;
XSetForeground( xmesa->display, xmesa->xm_buffer->cleargc,
(unsigned long) index );
}
static void clear_color( GLcontext *ctx,
GLubyte r, GLubyte g, GLubyte b, GLubyte a )
{
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 );
XSetForeground( xmesa->display, xmesa->xm_buffer->cleargc,
xmesa->clearpixel );
}
/* Set current color index */
static void set_index( GLcontext *ctx, GLuint index )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
unsigned long p = (unsigned long) index;
xmesa->pixel = p;
XSetForeground( 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 )
{
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 );;
XSetForeground( xmesa->display, xmesa->xm_buffer->gc1, xmesa->pixel );
}
/* Set index mask ala glIndexMask */
static GLboolean index_mask( GLcontext *ctx, GLuint mask )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
if (xmesa->xm_buffer->buffer==XIMAGE) {
return GL_FALSE;
}
else {
unsigned long m;
if (mask==0xffffffff) {
m = AllPlanes;
}
else {
m = (unsigned long) mask;
}
XSetPlaneMask( xmesa->display, xmesa->xm_buffer->gc1, m );
XSetPlaneMask( xmesa->display, xmesa->xm_buffer->gc2, m );
XSetPlaneMask( xmesa->display, xmesa->xm_buffer->cleargc, m );
return GL_TRUE;
}
}
/* Implements glColorMask() */
static GLboolean color_mask( GLcontext *ctx,
GLboolean rmask, GLboolean gmask,
GLboolean bmask, GLboolean amask )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
#if defined(__cplusplus) || defined(c_plusplus)
int xclass = xmesa->xm_visual->visinfo->c_class;
#else
int xclass = xmesa->xm_visual->visinfo->class;
#endif
if (xmesa->xm_buffer->buffer!=XIMAGE
&& (xclass==TrueColor || xclass==DirectColor)) {
unsigned long m;
if (rmask && gmask && bmask) {
m = AllPlanes;
}
else {
m = 0;
if (rmask) m |= xmesa->xm_visual->visinfo->red_mask;
if (gmask) m |= xmesa->xm_visual->visinfo->green_mask;
if (bmask) m |= xmesa->xm_visual->visinfo->blue_mask;
}
XSetPlaneMask( xmesa->display, xmesa->xm_buffer->gc1, m );
XSetPlaneMask( xmesa->display, xmesa->xm_buffer->gc2, m );
XSetPlaneMask( xmesa->display, xmesa->xm_buffer->cleargc, m );
return GL_TRUE;
}
else {
return GL_FALSE;
}
}
/*
* Set the pixel logic operation. Return GL_TRUE if the device driver
* can perform the operation, otherwise return GL_FALSE. GL_COPY _must_
* be operational, obviously.
*/
static GLboolean logicop( GLcontext *ctx, GLenum op )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
int func;
if (!XMesa) return GL_FALSE;
if ((xmesa->xm_buffer->buffer==XIMAGE) && op!=GL_COPY) {
/* X can't do logic ops in Ximages, except for GL_COPY */
return GL_FALSE;
}
switch (op) {
case GL_CLEAR: func = GXclear; break;
case GL_SET: func = GXset; break;
case GL_COPY: func = GXcopy; break;
case GL_COPY_INVERTED: func = GXcopyInverted; break;
case GL_NOOP: func = GXnoop; break;
case GL_INVERT: func = GXinvert; break;
case GL_AND: func = GXand; break;
case GL_NAND: func = GXnand; break;
case GL_OR: func = GXor; break;
case GL_NOR: func = GXnor; break;
case GL_XOR: func = GXxor; break;
case GL_EQUIV: func = GXequiv; break;
case GL_AND_REVERSE: func = GXandReverse; break;
case GL_AND_INVERTED: func = GXandInverted; break;
case GL_OR_REVERSE: func = GXorReverse; break;
case GL_OR_INVERTED: func = GXorInverted; break;
default: return GL_FALSE;
}
XSetFunction( xmesa->display, xmesa->xm_buffer->gc1, func );
XSetFunction( xmesa->display, xmesa->xm_buffer->gc2, func );
return GL_TRUE;
}
/*
* Enable/disable dithering
*/
static void dither( GLcontext *ctx, GLboolean enable )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
if (enable) {
xmesa->pixelformat = xmesa->xm_visual->dithered_pf;
}
else {
xmesa->pixelformat = xmesa->xm_visual->undithered_pf;
}
xmesa_setup_DD_pointers( ctx );
}
/**********************************************************************/
/*** glClear implementations ***/
/**********************************************************************/
static void clear_pixmap( GLcontext *ctx, GLboolean all,
GLint x, GLint y, GLint width, GLint height )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
if (all) {
XFillRectangle( xmesa->display, xmesa->xm_buffer->buffer,
xmesa->xm_buffer->cleargc,
0, 0,
xmesa->xm_buffer->width+1, xmesa->xm_buffer->height+1 );
}
else {
XFillRectangle( xmesa->display, xmesa->xm_buffer->buffer,
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 )
{
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( x, y+i );
MEMSET( ptr, xmesa->clearpixel, width );
}
}
}
static void clear_16bit_ximage( GLcontext *ctx, GLboolean all,
GLint x, GLint y, GLint width, GLint height )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
if (all) {
register GLuint n;
register GLushort *ptr2 =(GLushort *) xmesa->xm_buffer->backimage->data;
register GLushort pixel = (GLushort) xmesa->clearpixel;
if (xmesa->swapbytes) {
pixel = ((pixel >> 8) & 0x00ff)
| ((pixel << 8) & 0xff00);
}
if ((pixel & 0xff) == (pixel >> 8)) {
/* low and high bytes are equal so use memset() */
n = xmesa->xm_buffer->backimage->bytes_per_line
* xmesa->xm_buffer->height;
MEMSET( ptr2, pixel & 0xff, n );
}
else {
n = xmesa->xm_buffer->backimage->bytes_per_line / 2
* xmesa->xm_buffer->height;
do {
*ptr2++ = pixel;
n--;
} while (n!=0);
}
}
else {
register int i, j;
register GLushort pixel = (GLushort) xmesa->clearpixel;
for (j=0;j<height;j++) {
register GLushort *ptr2 = PIXELADDR2( x, y+j );
for (i=0;i<width;i++) {
*ptr2++ = pixel;
}
}
}
}
static void clear_32bit_ximage( GLcontext *ctx, GLboolean all,
GLint x, GLint y, GLint width, GLint height )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
if (all) {
register GLint n = xmesa->xm_buffer->width * xmesa->xm_buffer->height;
register GLuint *ptr = (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( ptr, pixel, 4*n );
}
else {
do {
*ptr++ = 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( 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *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++) {
XPutPixel( img, i, j, xmesa->clearpixel );
}
}
}
else {
/* TODO: optimize this */
register int i, j;
y = FLIP(y);
for (j=0;j<height;j++) {
for (i=0;i<width;i++) {
XPutPixel( img, x+i, y-j, xmesa->clearpixel );
}
}
}
}
/*
* 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 COLOR_SPAN_ARGS GLcontext *ctx, \
GLuint n, GLint x, GLint y, \
const GLubyte red[], const GLubyte green[], \
const GLubyte blue[], const GLubyte alpha[], \
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( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
y = FLIP(y);
if (mask) {
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XSetForeground( dpy, gc, PACK_RGB( red[i], green[i], blue[i] ) );
XDrawPoint( dpy, buffer, gc, (int) x, (int) y );
}
}
}
else {
/* draw all pixels */
XImage *rowimg = xmesa->xm_buffer->rowimage;
for (i=0;i<n;i++) {
XPutPixel( rowimg, i, 0, PACK_RGB( red[i], green[i], blue[i] ) );
}
XPutImage( 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( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
y = FLIP( y );
if (mask) {
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XSetForeground( dpy, gc,
PACK_8A8B8G8R(red[i], green[i], blue[i], alpha[i]) );
XDrawPoint( dpy, buffer, gc, (int) x, (int) y );
}
}
}
else {
/* draw all pixels */
XImage *rowimg = xmesa->xm_buffer->rowimage;
register GLuint *ptr4 = (GLuint *) rowimg->data;
for (i=0;i<n;i++) {
*ptr4++ = PACK_8A8B8G8R( red[i], green[i], blue[i], alpha[i] );
}
XPutImage( 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( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
y = FLIP( y );
if (mask) {
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XSetForeground( dpy, gc, PACK_8R8G8B( red[i], green[i], blue[i] ));
XDrawPoint( dpy, buffer, gc, (int) x, (int) y );
}
}
}
else {
/* draw all pixels */
XImage *rowimg = xmesa->xm_buffer->rowimage;
register GLuint *ptr4 = (GLuint *) rowimg->data;
for (i=0;i<n;i++) {
*ptr4++ = PACK_8R8G8B( red[i], green[i], blue[i] );
}
XPutImage( 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( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
y = FLIP( y );
if (mask) {
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XSetForeground( dpy, gc, PACK_5R6G5B( red[i], green[i], blue[i] ));
XDrawPoint( dpy, buffer, gc, (int) x, (int) y );
}
}
}
else {
/* draw all pixels */
XImage *rowimg = xmesa->xm_buffer->rowimage;
register GLushort *ptr2 = (GLushort *) rowimg->data;
for (i=0;i<n;i++) {
*ptr2++ = PACK_5R6G5B( red[i], green[i], blue[i] );
}
XPutImage( 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( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
y = FLIP( y );
if (mask) {
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XSetForeground( dpy, gc, DITHER(x, y, red[i], green[i], blue[i]) );
XDrawPoint( dpy, buffer, gc, (int) x, (int) y );
}
}
}
else {
/* draw all pixels */
XImage *rowimg = xmesa->xm_buffer->rowimage;
for (i=0;i<n;i++) {
XPutPixel( rowimg, i, 0, DITHER( x+i, y, red[i], green[i], blue[i] ) );
}
XPutImage( 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( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
y = FLIP( y );
if (mask) {
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XSetForeground( dpy, gc,
DITHER_1BIT( x, y, red[i], green[i], blue[i] ) );
XDrawPoint( dpy, buffer, gc, (int) x, (int) y );
}
}
}
else {
/* draw all pixels */
XImage *rowimg = xmesa->xm_buffer->rowimage;
for (i=0;i<n;i++) {
XPutPixel( rowimg, i, 0,
DITHER_1BIT( x+i, y, red[i], green[i], blue[i] ) );
}
XPutImage( 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( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
y = FLIP( y );
if (mask) {
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XSetForeground( dpy, gc,
DITHER_HPCR( x, y, red[i], green[i], blue[i] ) );
XDrawPoint( dpy, buffer, gc, (int) x, (int) y );
}
}
}
else {
XImage *rowimg = xmesa->xm_buffer->rowimage;
register GLubyte *ptr = (GLubyte *) xmesa->xm_buffer->rowimage->data;
for (i=0;i<n;i++) {
*ptr++ = DITHER_HPCR( (x+i), y, red[i], green[i], blue[i] );
}
XPutImage( 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( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
y = FLIP( y );
if (mask) {
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XSetForeground( dpy, gc, LOOKUP( red[i], green[i], blue[i] ) );
XDrawPoint( dpy, buffer, gc, (int) x, (int) y );
}
}
}
else {
XImage *rowimg = xmesa->xm_buffer->rowimage;
for (i=0;i<n;i++) {
XPutPixel( rowimg, i, 0, LOOKUP(red[i],green[i],blue[i]) );
}
XPutImage( 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( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
y = FLIP( y );
if (mask) {
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XSetForeground( dpy, gc, GRAY_RGB( red[i], green[i], blue[i] ) );
XDrawPoint( dpy, buffer, gc, (int) x, (int) y );
}
}
}
else {
XImage *rowimg = xmesa->xm_buffer->rowimage;
for (i=0;i<n;i++) {
XPutPixel( rowimg, i, 0, GRAY_RGB(red[i],green[i],blue[i]) );
}
XPutImage( 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( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
register GLuint i;
y = FLIP(y);
if (mask) {
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XPutPixel( img, x, y, PACK_RGB( red[i], green[i], blue[i] ) );
}
}
}
else {
/* draw all pixels */
for (i=0;i<n;i++,x++) {
XPutPixel( img, x, y, PACK_RGB( red[i], green[i], blue[i] ) );
}
}
}
/*
* Write a span of PF_8A8B8G8R-format pixels to an ximage.
*/
static void write_span_8A8B8G8R_ximage( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
register GLuint *ptr = PIXELADDR4( x, y );
if (mask) {
for (i=0;i<n;i++,ptr++) {
if (mask[i]) {
*ptr = PACK_8A8B8G8R( red[i], green[i], blue[i], alpha[i] );
}
}
}
else {
/* draw all pixels */
for (i=0;i<n;i++,ptr++) {
*ptr = PACK_8A8B8G8R( red[i], green[i], blue[i], alpha[i] );
}
}
}
/*
* Write a span of PF_8R8G8B-format pixels to an ximage.
*/
static void write_span_8R8G8B_ximage( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
register GLuint *ptr = PIXELADDR4( x, y );
if (mask) {
for (i=0;i<n;i++,ptr++) {
if (mask[i]) {
*ptr = PACK_8R8G8B( red[i], green[i], blue[i] );
}
}
}
else {
/* draw all pixels */
for (i=0;i<n;i++,ptr++) {
*ptr = PACK_8R8G8B( red[i], green[i], blue[i] );
}
}
}
/*
* Write a span of PF_5R6G5B-format pixels to an ximage.
*/
static void write_span_5R6G5B_ximage( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
register GLushort *ptr = PIXELADDR2( x, y );
if (mask) {
for (i=0;i<n;i++,ptr++) {
if (mask[i]) {
*ptr = PACK_5R6G5B( red[i], green[i], blue[i] );
}
}
}
else {
/* draw all pixels */
for (i=0;i<n;i++,ptr++) {
*ptr = PACK_5R6G5B( red[i], green[i], blue[i] );
}
}
}
/*
* Write a span of PF_DITHER pixels to an XImage.
*/
static void write_span_DITHER_ximage( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
register GLuint i;
y = FLIP(y);
if (mask) {
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XPutPixel( img, x, y, DITHER( x, y, red[i], green[i], blue[i] ) );
}
}
}
else {
/* draw all pixels */
for (i=0;i<n;i++,x++) {
XPutPixel( img, x, y, DITHER( x, y, red[i], green[i], blue[i] ) );
}
}
}
/*
* Write a span of 8-bit PF_DITHER pixels to an XImage.
*/
static void write_span_DITHER8_ximage( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
register GLubyte *ptr = PIXELADDR1( x, y );
if (mask) {
for (i=0;i<n;i++,x++,ptr++) {
if (mask[i]) {
*ptr = DITHER( x, y, red[i], green[i], blue[i] );
}
}
}
else {
for (i=0;i<n;i++,x++,ptr++) {
*ptr = DITHER( x, y, red[i], green[i], blue[i] );
}
}
}
/*
* Write a span of PF_1BIT pixels to an XImage.
*/
static void write_span_1BIT_ximage( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
register GLuint i;
y = FLIP(y);
if (mask) {
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XPutPixel(img, x, y, DITHER_1BIT(x, y, red[i], green[i], blue[i]));
}
}
}
else {
for (i=0;i<n;i++,x++) {
XPutPixel( img, x, y, DITHER_1BIT(x, y, red[i], green[i], blue[i]) );
}
}
}
/*
* Write a span of PF_HPCR pixels to an XImage.
*/
static void write_span_HPCR_ximage( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
register GLubyte *ptr = PIXELADDR1( x, y );
if (mask) {
for (i=0;i<n;i++,x++,ptr++) {
if (mask[i]) {
*ptr = DITHER_HPCR( x, y, red[i], green[i], blue[i] );
}
}
}
else {
/* draw all pixels */
for (i=0;i<n;i++,x++,ptr++) {
*ptr = DITHER_HPCR( x, y, red[i], green[i], blue[i] );
}
}
}
/*
* Write a span of PF_LOOKUP pixels to an XImage.
*/
static void write_span_LOOKUP_ximage( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
register GLuint i;
y = FLIP(y);
if (mask) {
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XPutPixel( img, x, y, LOOKUP( red[i], green[i], blue[i] ) );
}
}
}
else {
/* draw all pixels */
for (i=0;i<n;i++,x++) {
XPutPixel( img, x, y, LOOKUP( red[i], green[i], blue[i] ) );
}
}
}
/*
* Write a span of 8-bit PF_LOOKUP pixels to an XImage.
*/
static void write_span_LOOKUP8_ximage( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
register GLubyte *ptr = PIXELADDR1( x, y );
if (mask) {
for (i=0;i<n;i++,x++,ptr++) {
if (mask[i]) {
*ptr = LOOKUP( red[i], green[i], blue[i] );
}
}
}
else {
/* draw all pixels */
for (i=0;i<n;i++,x++,ptr++) {
*ptr = LOOKUP( red[i], green[i], blue[i] );
}
}
}
/*
* Write a span of PF_GRAYSCALE pixels to an XImage.
*/
static void write_span_GRAYSCALE_ximage( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
register GLuint i;
y = FLIP(y);
if (mask) {
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XPutPixel( img, x, y, GRAY_RGB( red[i], green[i], blue[i] ) );
}
}
}
else {
/* draw all pixels */
for (i=0;i<n;i++,x++) {
XPutPixel( img, x, y, GRAY_RGB( red[i], green[i], blue[i] ) );
}
}
}
/*
* Write a span of 8-bit PF_GRAYSCALE pixels to an XImage.
*/
static void write_span_GRAYSCALE8_ximage( COLOR_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
register GLubyte *ptr = PIXELADDR1( x, y );
if (mask) {
for (i=0;i<n;i++,ptr++) {
if (mask[i]) {
*ptr = GRAY_RGB( red[i], green[i], blue[i] );
}
}
}
else {
/* draw all pixels */
for (i=0;i<n;i++,ptr++) {
*ptr = GRAY_RGB( red[i], green[i], blue[i] );
}
}
}
/**********************************************************************/
/*** Write COLOR PIXEL functions ***/
/**********************************************************************/
#define COLOR_PIXEL_ARGS GLcontext *ctx, \
GLuint n, const GLint x[], const GLint y[], \
const GLubyte red[], const GLubyte green[], \
const GLubyte blue[], const GLubyte alpha[], \
const GLubyte mask[]
/*
* Write an array of PF_TRUECOLOR pixels to a pixmap.
*/
static void write_pixels_TRUECOLOR_pixmap( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XSetForeground( dpy, gc, PACK_RGB( red[i], green[i], blue[i] ) );
XDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(y[i]) );
}
}
}
/*
* Write an array of PF_8A8B8G8R pixels to a pixmap.
*/
static void write_pixels_8A8B8G8R_pixmap( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XSetForeground( dpy, gc,
PACK_8A8B8G8R( red[i], green[i], blue[i], alpha[i] ));
XDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(y[i]) );
}
}
}
/*
* Write an array of PF_8R8G8B pixels to a pixmap.
*/
static void write_pixels_8R8G8B_pixmap( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XSetForeground( dpy, gc, PACK_8R8G8B( red[i], green[i], blue[i] ) );
XDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(y[i]) );
}
}
}
/*
* Write an array of PF_5R6G5B pixels to a pixmap.
*/
static void write_pixels_5R6G5B_pixmap( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XSetForeground( dpy, gc, PACK_5R6G5B( red[i], green[i], blue[i] ) );
XDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(y[i]) );
}
}
}
/*
* Write an array of PF_DITHER pixels to a pixmap.
*/
static void write_pixels_DITHER_pixmap( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XSetForeground( dpy, gc,
DITHER(x[i], y[i], red[i], green[i], blue[i]) );
XDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(y[i]) );
}
}
}
/*
* Write an array of PF_1BIT pixels to a pixmap.
*/
static void write_pixels_1BIT_pixmap( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XSetForeground( dpy, gc,
DITHER_1BIT( x[i], y[i], red[i], green[i], blue[i] ));
XDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(y[i]) );
}
}
}
/*
* Write an array of PF_HPCR pixels to a pixmap.
*/
static void write_pixels_HPCR_pixmap( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XSetForeground( dpy, gc,
DITHER_HPCR( x[i], y[i], red[i], green[i], blue[i] ));
XDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(y[i]) );
}
}
}
/*
* Write an array of PF_LOOKUP pixels to a pixmap.
*/
static void write_pixels_LOOKUP_pixmap( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XSetForeground( dpy, gc, LOOKUP( red[i], green[i], blue[i] ) );
XDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(y[i]) );
}
}
}
/*
* Write an array of PF_GRAYSCALE pixels to a pixmap.
*/
static void write_pixels_GRAYSCALE_pixmap( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XSetForeground( dpy, gc, GRAY_RGB( red[i], green[i], blue[i] ) );
XDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(y[i]) );
}
}
}
/*
* Write an array of PF_TRUECOLOR pixels to an ximage.
*/
static void write_pixels_TRUECOLOR_ximage( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XPutPixel( img, x[i], FLIP(y[i]),
PACK_RGB( red[i], green[i], blue[i] ) );
}
}
}
/*
* Write an array of PF_8A8B8G8R pixels to an ximage.
*/
static void write_pixels_8A8B8G8R_ximage( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
GLuint *ptr = PIXELADDR4( x[i], y[i] );
*ptr = PACK_8A8B8G8R( red[i], green[i], blue[i], alpha[i] );
}
}
}
/*
* Write an array of PF_8R8G8B pixels to an ximage.
*/
static void write_pixels_8R8G8B_ximage( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
GLuint *ptr = PIXELADDR4( x[i], y[i] );
*ptr = PACK_8R8G8B( red[i], green[i], blue[i] );
}
}
}
/*
* Write an array of PF_5R6G5B pixels to an ximage.
*/
static void write_pixels_5R6G5B_ximage( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
GLushort *ptr = PIXELADDR2( x[i], y[i] );
*ptr = PACK_5R6G5B( red[i], green[i], blue[i] );
}
}
}
/*
* Write an array of PF_DITHER pixels to an XImage.
*/
static void write_pixels_DITHER_ximage( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XPutPixel( img, x[i], FLIP(y[i]),
DITHER( x[i], y[i], red[i], green[i], blue[i] ) );
}
}
}
/*
* Write an array of 8-bit PF_DITHER pixels to an XImage.
*/
static void write_pixels_DITHER8_ximage( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
GLubyte *ptr = PIXELADDR1(x[i],y[i]);
*ptr = DITHER( x[i], y[i], red[i], green[i], blue[i] );
}
}
}
/*
* Write an array of PF_1BIT pixels to an XImage.
*/
static void write_pixels_1BIT_ximage( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XPutPixel( img, x[i], FLIP(y[i]),
DITHER_1BIT( x[i], y[i], red[i], green[i], blue[i] ));
}
}
}
/*
* Write an array of PF_HPCR pixels to an XImage.
*/
static void write_pixels_HPCR_ximage( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
GLubyte *ptr = PIXELADDR1(x[i],y[i]);
*ptr = DITHER_HPCR( x[i], y[i], red[i], green[i], blue[i] );
}
}
}
/*
* Write an array of PF_LOOKUP pixels to an XImage.
*/
static void write_pixels_LOOKUP_ximage( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XPutPixel( img, x[i], FLIP(y[i]), LOOKUP(red[i], green[i], blue[i]) );
}
}
}
/*
* Write an array of 8-bit PF_LOOKUP pixels to an XImage.
*/
static void write_pixels_LOOKUP8_ximage( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
GLubyte *ptr = PIXELADDR1(x[i],y[i]);
*ptr = LOOKUP( red[i], green[i], blue[i] );
}
}
}
/*
* Write an array of PF_GRAYSCALE pixels to an XImage.
*/
static void write_pixels_GRAYSCALE_ximage( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XPutPixel( img, x[i], FLIP(y[i]),
GRAY_RGB( red[i], green[i], blue[i] ) );
}
}
}
/*
* Write an array of 8-bit PF_GRAYSCALE pixels to an XImage.
*/
static void write_pixels_GRAYSCALE8_ximage( COLOR_PIXEL_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
GLubyte *ptr = PIXELADDR1( x[i], y[i] );
*ptr = GRAY_RGB( red[i], green[i], blue[i] );
}
}
}
/**********************************************************************/
/*** Write MONO COLOR SPAN functions ***/
/**********************************************************************/
#define MONO_SPAN_ARGS 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc1;
register GLuint i;
register GLboolean write_all;
y = FLIP( y );
write_all = GL_TRUE;
for (i=0;i<n;i++) {
if (!mask[i]) {
write_all = GL_FALSE;
break;
}
}
if (write_all) {
XFillRectangle( dpy, buffer, gc, (int) x, (int) y, n, 1 );
}
else {
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XDrawPoint( dpy, buffer, gc, (int) x, (int) y );
}
}
}
}
/*
* 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
register GLubyte r, g, b;
r = xmesa->red;
g = xmesa->green;
b = xmesa->blue;
y = FLIP( y );
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XSetForeground( dpy, gc, DITHER( x, y, r, g, b ) );
XDrawPoint( dpy, buffer, gc, (int) x, (int) y );
}
}
}
/*
* 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
register GLubyte r, g, b;
r = xmesa->red;
g = xmesa->green;
b = xmesa->blue;
y = FLIP( y );
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XSetForeground( dpy, gc, DITHER_1BIT( x, y, r, g, b ) );
XDrawPoint( 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
register GLuint i;
register unsigned long p = xmesa->pixel;
y = FLIP( y );
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XPutPixel( img, x, 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
GLuint i, p, *ptr;
p = (GLuint) xmesa->pixel;
ptr = PIXELADDR4( x, y );
for (i=0;i<n;i++,ptr++) {
if (mask[i]) {
*ptr = 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
GLuint i, p, *ptr;
p = (GLuint) xmesa->pixel;
ptr = PIXELADDR4( x, y );
for (i=0;i<n;i++,ptr++) {
if (mask[i]) {
*ptr = p;
}
}
}
/*
* 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
register GLuint i;
register GLubyte r, g, b;
r = xmesa->red;
g = xmesa->green;
b = xmesa->blue;
y = FLIP(y);
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XPutPixel( img, x, y, DITHER( x, y, 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
register GLubyte *ptr = PIXELADDR1(x,y);
register GLubyte r, g, b;
r = xmesa->red;
g = xmesa->green;
b = xmesa->blue;
for (i=0;i<n;i++,ptr++,x++) {
if (mask[i]) {
*ptr = DITHER( x, y, 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
register GLubyte *ptr = PIXELADDR1(x,y);
register GLubyte pixel = xmesa->pixel;
for (i=0;i<n;i++,ptr++) {
if (mask[i]) {
*ptr = 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
register GLuint i;
register GLubyte r, g, b;
r = xmesa->red;
g = xmesa->green;
b = xmesa->blue;
y = FLIP(y);
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XPutPixel( 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
register GLubyte *ptr = PIXELADDR1(x,y);
register GLubyte r, g, b;
r = xmesa->red;
g = xmesa->green;
b = xmesa->blue;
for (i=0;i<n;i++,ptr++,x++) {
if (mask[i]) {
*ptr = 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
GLuint i;
unsigned long p = xmesa->pixel;
GLubyte *ptr = PIXELADDR1(x,y);
for (i=0;i<n;i++,ptr++) {
if (mask[i]) {
*ptr = p;
}
}
}
/**********************************************************************/
/*** Write MONO COLOR PIXELS functions ***/
/**********************************************************************/
#define MONO_PIXEL_ARGS 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc1;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC 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]) {
XSetForeground( dpy, gc, DITHER( x[i], y[i], r, g, b ) );
XDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC 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]) {
XSetForeground( dpy, gc, DITHER_1BIT( x[i], y[i], r, g, b ) );
XDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
register GLuint i;
register unsigned long p = xmesa->pixel;
for (i=0;i<n;i++) {
if (mask[i]) {
XPutPixel( img, x[i], FLIP(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 )
{
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( 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 )
{
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( x[i], y[i] );
*ptr = p;
}
}
}
/*
* 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
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]) {
XPutPixel( img, x[i], FLIP(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 )
{
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(x[i],y[i]);
*ptr = 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
register GLubyte pixel = xmesa->pixel;
for (i=0;i<n;i++) {
if (mask[i]) {
GLubyte *ptr = PIXELADDR1(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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
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]) {
XPutPixel( img, x[i], FLIP(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 )
{
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(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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
register unsigned long p = xmesa->pixel;
for (i=0;i<n;i++) {
if (mask[i]) {
GLubyte *ptr = PIXELADDR1(x[i],y[i]);
*ptr = p;
}
}
}
/**********************************************************************/
/*** Write INDEX SPAN functions ***/
/**********************************************************************/
#define INDEX_SPAN_ARGS GLcontext *ctx, \
GLuint n, GLint x, GLint y, const GLuint index[], \
const GLubyte mask[]
/*
* Write a span of CI pixels to a Pixmap.
*/
static void write_span_index_pixmap( INDEX_SPAN_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
y = FLIP(y);
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XSetForeground( dpy, gc, (unsigned long) index[i] );
XDrawPoint( 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
register GLuint i;
y = FLIP(y);
for (i=0;i<n;i++,x++) {
if (mask[i]) {
XPutPixel( img, x, y, (unsigned long) index[i] );
}
}
}
/**********************************************************************/
/*** Write INDEX PIXELS functions ***/
/**********************************************************************/
#define INDEX_PIXELS_ARGS 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 )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
GC gc = xmesa->xm_buffer->gc2;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XSetForeground( dpy, gc, (unsigned long) index[i] );
XDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(y[i]) );
}
}
}
/*
* Write an array of CI pixels to an XImage.
*/
static void write_pixels_index_ximage( INDEX_PIXELS_ARGS )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
XImage *img = xmesa->xm_buffer->backimage;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
XPutPixel( img, x[i], FLIP(y[i]), (unsigned long) index[i] );
}
}
}
/**********************************************************************/
/***** Pixel reading *****/
/**********************************************************************/
/*
* Read a horizontal span of color-index pixels.
*/
static void read_index_span( GLcontext *ctx,
GLuint n, GLint x, GLint y, GLuint index[] )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
int i;
y = FLIP(y);
if (xmesa->xm_buffer->buffer) {
XImage *span;
int error;
catch_xgetimage_errors( xmesa->display );
span = XGetImage( xmesa->display, xmesa->xm_buffer->buffer,
x, y, n, 1, AllPlanes, ZPixmap );
error = check_xgetimage_errors();
if (span && !error) {
for (i=0;i<n;i++) {
index[i] = (GLuint) XGetPixel( span, i, 0 );
}
}
else {
/* return 0 pixels */
for (i=0;i<n;i++) {
index[i] = 0;
}
}
if (span) {
XDestroyImage( span );
}
}
else if (xmesa->xm_buffer->backimage) {
XImage *img = xmesa->xm_buffer->backimage;
for (i=0;i<n;i++,x++) {
index[i] = (GLuint) XGetPixel( img, x, y );
}
}
}
/*
* Read a horizontal span of color pixels.
*/
static void read_color_span( GLcontext *ctx,
GLuint n, GLint x, GLint y,
GLubyte red[], GLubyte green[],
GLubyte blue[], GLubyte alpha[] )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
if (xmesa->xm_buffer->buffer) {
XImage *span;
int error;
catch_xgetimage_errors( xmesa->display );
span = XGetImage( xmesa->display, xmesa->xm_buffer->buffer,
x, FLIP(y), n, 1, AllPlanes, ZPixmap );
error = check_xgetimage_errors();
if (span && !error) {
switch (xmesa->pixelformat) {
case PF_TRUECOLOR:
{
GLint rshift = xmesa->xm_visual->rshift, rmult = xmesa->xm_visual->rmult;
GLint gshift = xmesa->xm_visual->gshift, gmult = xmesa->xm_visual->gmult;
GLint bshift = xmesa->xm_visual->bshift, bmult = xmesa->xm_visual->bmult;
for (i=0;i<n;i++) {
unsigned long p = XGetPixel( span, i, 0 );
red[i] = (GLubyte) ((p >> rshift) & rmult);
green[i] = (GLubyte) ((p >> gshift) & gmult);
blue[i] = (GLubyte) ((p >> bshift) & bmult);
alpha[i] = 255;
}
}
break;
case PF_8A8B8G8R:
{
GLuint *ptr4 = (GLuint *) span->data;
for (i=0;i<n;i++) {
GLuint p4 = *ptr4++;
red[i] = (GLubyte) ( p4 & 0xff);
green[i] = (GLubyte) ((p4 >> 8) & 0xff);
blue[i] = (GLubyte) ((p4 >> 16) & 0xff);
alpha[i] = (GLubyte) ((p4 >> 24) & 0xff);
}
}
break;
case PF_8R8G8B:
{
GLuint *ptr4 = (GLuint *) span->data;
for (i=0;i<n;i++) {
GLuint p4 = *ptr4++;
red[i] = (GLubyte) ((p4 >> 16) & 0xff);
green[i] = (GLubyte) ((p4 >> 8) & 0xff);
blue[i] = (GLubyte) ( p4 & 0xff);
alpha[i] = 255;
}
}
break;
case PF_5R6G5B:
{
GLushort *ptr2 = (GLushort *) span->data;
for (i=0;i<n;i++) {
GLushort p2 = *ptr2++;
red[i] = (GLubyte) ((p2 >> 11) & 0x1f);
green[i] = (GLubyte) ((p2 >> 5) & 0x3f);
blue[i] = (GLubyte) ( p2 & 0x1f);
alpha[i] = 255;
}
}
break;
case PF_HPCR:
{
GLubyte *ptr1 = (GLubyte *) span->data;
for (i=0;i<n;i++) {
GLubyte p = *ptr1++;
red[i] = p & 0xE0;
green[i] = (p & 0x1C) << 3;
blue[i] = (p & 0x03) << 6;
alpha[i] = 255;
}
}
break;
case PF_DITHER:
case PF_LOOKUP:
case PF_GRAYSCALE:
{
GLubyte *red_table = xmesa->xm_buffer->pixel_to_r;
GLubyte *green_table = xmesa->xm_buffer->pixel_to_g;
GLubyte *blue_table = xmesa->xm_buffer->pixel_to_b;
if (xmesa->xm_visual->visinfo->depth==8) {
GLubyte *ptr1 = (GLubyte *) span->data;
for (i=0;i<n;i++) {
unsigned long p = *ptr1++;
red[i] = red_table[p];
green[i] = green_table[p];
blue[i] = blue_table[p];
alpha[i] = 255;
}
}
else {
for (i=0;i<n;i++) {
unsigned long p = XGetPixel( span, i, 0 );
red[i] = red_table[p];
green[i] = green_table[p];
blue[i] = blue_table[p];
alpha[i] = 255;
}
}
}
break;
case PF_1BIT:
for (i=0;i<n;i++) {
unsigned long p = XGetPixel( span, i, 0 );
red[i] = (GLubyte) (p * 255);
green[i] = (GLubyte) (p * 255);
blue[i] = (GLubyte) (p * 255);
alpha[i] = 255;
}
break;
default:
die("Problem in DD.read_color_span (1)");
}
}
else {
/* return black pixels */
for (i=0;i<n;i++) {
red[i] = green[i] = blue[i] = alpha[i] = 0;
}
}
if (span) {
XDestroyImage( span );
}
}
else if (xmesa->xm_buffer->backimage) {
switch (xmesa->pixelformat) {
case PF_TRUECOLOR:
{
GLint rshift = xmesa->xm_visual->rshift, rmult = xmesa->xm_visual->rmult;
GLint gshift = xmesa->xm_visual->gshift, gmult = xmesa->xm_visual->gmult;
GLint bshift = xmesa->xm_visual->bshift, bmult = xmesa->xm_visual->bmult;
XImage *img = xmesa->xm_buffer->backimage;
y = FLIP(y);
for (i=0;i<n;i++,x++) {
unsigned long p = XGetPixel( img, x, y );
red[i] = (GLubyte) ((p >> rshift) & rmult);
green[i] = (GLubyte) ((p >> gshift) & gmult);
blue[i] = (GLubyte) ((p >> bshift) & bmult);
alpha[i] = 255;
}
}
break;
case PF_8A8B8G8R:
{
GLuint *ptr4 = PIXELADDR4( x, y );
for (i=0;i<n;i++) {
GLuint p4 = *ptr4++;
red[i] = (GLubyte) ( p4 & 0xff);
green[i] = (GLubyte) ((p4 >> 8) & 0xff);
blue[i] = (GLubyte) ((p4 >> 16) & 0xff);
alpha[i] = (GLint) ((p4 >> 24) & 0xff);
}
}
break;
case PF_8R8G8B:
{
GLuint *ptr4 = PIXELADDR4( x, y );
for (i=0;i<n;i++) {
GLuint p4 = *ptr4++;
red[i] = (GLubyte) ((p4 >> 16) & 0xff);
green[i] = (GLubyte) ((p4 >> 8) & 0xff);
blue[i] = (GLubyte) ( p4 & 0xff);
alpha[i] = 255;
}
}
break;
case PF_5R6G5B:
{
GLushort *ptr2 = PIXELADDR2( x, y );
for (i=0;i<n;i++) {
GLushort p2 = *ptr2++;
red[i] = (GLubyte) ((p2 >> 11) & 0x1f);
green[i] = (GLubyte) ((p2 >> 5) & 0x3f);
blue[i] = (GLubyte) ( p2 & 0x1f);
alpha[i] = 255;
}
}
break;
case PF_HPCR:
{
GLubyte *ptr1 = PIXELADDR1( x, y );
for (i=0;i<n;i++) {
GLubyte p = *ptr1++;
red[i] = p & 0xE0;
green[i] = (p & 0x1C) << 3;
blue[i] = (p & 0x03) << 6;
alpha[i] = 255;
}
}
break;
case PF_DITHER:
case PF_LOOKUP:
case PF_GRAYSCALE:
{
GLubyte *red_table = xmesa->xm_buffer->pixel_to_r;
GLubyte *green_table = xmesa->xm_buffer->pixel_to_g;
GLubyte *blue_table = xmesa->xm_buffer->pixel_to_b;
if (xmesa->xm_visual->visinfo->depth==8) {
GLubyte *ptr1 = PIXELADDR1(x,y);
for (i=0;i<n;i++) {
unsigned long p = *ptr1++;
red[i] = red_table[p];
green[i] = green_table[p];
blue[i] = blue_table[p];
alpha[i] = 255;
}
}
else {
XImage *img = xmesa->xm_buffer->backimage;
y = FLIP(y);
for (i=0;i<n;i++,x++) {
unsigned long p = XGetPixel( img, x, y );
red[i] = red_table[p];
green[i] = green_table[p];
blue[i] = blue_table[p];
alpha[i] = 255;
}
}
}
break;
case PF_1BIT:
{
XImage *img = xmesa->xm_buffer->backimage;
y = FLIP(y);
for (i=0;i<n;i++,x++) {
unsigned long p = XGetPixel( img, x, y );
red[i] = (GLubyte) (p * 255);
green[i] = (GLubyte) (p * 255);
blue[i] = (GLubyte) (p * 255);
alpha[i] = 255;
}
}
break;
default:
die("Problem in DD.read_color_span (2)");
}
}
}
/*
* Read an array of color index pixels.
*/
static void read_index_pixels( GLcontext *ctx,
GLuint n, const GLint x[], const GLint y[],
GLuint indx[], const GLubyte mask[] )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
register GLuint i;
if (xmesa->xm_buffer->buffer) {
for (i=0;i<n;i++) {
if (mask[i]) {
indx[i] = (GLuint) read_pixel( xmesa->display,
xmesa->xm_buffer->buffer,
x[i], FLIP(y[i]) );
}
}
}
else if (xmesa->xm_buffer->backimage) {
XImage *img = xmesa->xm_buffer->backimage;
for (i=0;i<n;i++) {
if (mask[i]) {
indx[i] = (GLuint) XGetPixel( img, x[i], FLIP(y[i]) );
}
}
}
}
static void read_color_pixels( GLcontext *ctx,
GLuint n, const GLint x[], const GLint y[],
GLubyte red[], GLubyte green[],
GLubyte blue[], GLubyte alpha[],
const GLubyte mask[] )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
Display *dpy = xmesa->xm_visual->display;
Drawable buffer = xmesa->xm_buffer->buffer;
register GLuint i;
if (xmesa->xm_buffer->buffer) {
switch (xmesa->pixelformat) {
case PF_TRUECOLOR:
{
GLint rshift = xmesa->xm_visual->rshift, rmult = xmesa->xm_visual->rmult;
GLint gshift = xmesa->xm_visual->gshift, gmult = xmesa->xm_visual->gmult;
GLint bshift = xmesa->xm_visual->bshift, bmult = xmesa->xm_visual->bmult;
for (i=0;i<n;i++) {
if (mask[i] ) {
unsigned long p = read_pixel( dpy, buffer,
x[i], FLIP(y[i]) );
red[i] = (GLubyte) ((p >> rshift) & rmult);
green[i] = (GLubyte) ((p >> gshift) & gmult);
blue[i] = (GLubyte) ((p >> bshift) & bmult);
alpha[i] = 255;
}
}
}
break;
case PF_8A8B8G8R:
for (i=0;i<n;i++) {
if (mask[i]) {
unsigned long p = read_pixel( dpy, buffer,
x[i], FLIP(y[i]) );
red[i] = (GLubyte) ( p & 0xff);
green[i] = (GLubyte) ((p >> 8) & 0xff);
blue[i] = (GLubyte) ((p >> 16) & 0xff);
alpha[i] = (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(y[i]) );
red[i] = (GLubyte) ((p >> 16) & 0xff);
green[i] = (GLubyte) ((p >> 8) & 0xff);
blue[i] = (GLubyte) ( p & 0xff);
alpha[i] = 255;
}
}
break;
case PF_5R6G5B:
for (i=0;i<n;i++) {
if (mask[i]) {
unsigned long p = read_pixel( dpy, buffer,
x[i], FLIP(y[i]) );
red[i] = (GLubyte) ((p >> 11) & 0x1f);
green[i] = (GLubyte) ((p >> 5) & 0x3f);
blue[i] = (GLubyte) ( p & 0x1f);
alpha[i] = 255;
}
}
break;
case PF_HPCR:
{
for (i=0;i<n;i++) {
if (mask[i]) {
unsigned long p = read_pixel( dpy, buffer,
x[i], FLIP(y[i]) );
red[i] = p & 0xE0;
green[i] = (p & 0x1C) << 3;
blue[i] = (p & 0x03) << 6;
alpha[i] = 255;
}
}
}
break;
case PF_DITHER:
case PF_LOOKUP:
case PF_GRAYSCALE:
{
GLubyte *red_table = xmesa->xm_buffer->pixel_to_r;
GLubyte *green_table = xmesa->xm_buffer->pixel_to_g;
GLubyte *blue_table = xmesa->xm_buffer->pixel_to_b;
for (i=0;i<n;i++) {
if (mask[i]) {
unsigned long p = read_pixel( dpy, buffer,
x[i], FLIP(y[i]) );
red[i] = red_table[p];
green[i] = green_table[p];
blue[i] = blue_table[p];
alpha[i] = 255;
}
}
}
break;
case PF_1BIT:
for (i=0;i<n;i++) {
if (mask[i]) {
unsigned long p = read_pixel( dpy, buffer,
x[i], FLIP(y[i]) );
red[i] = (GLubyte) (p * 255);
green[i] = (GLubyte) (p * 255);
blue[i] = (GLubyte) (p * 255);
alpha[i] = 255;
}
}
break;
default:
die("Problem in DD.read_color_pixels (1)");
}
}
else if (xmesa->xm_buffer->backimage) {
switch (xmesa->pixelformat) {
case PF_TRUECOLOR:
{
GLint rshift = xmesa->xm_visual->rshift, rmult = xmesa->xm_visual->rmult;
GLint gshift = xmesa->xm_visual->gshift, gmult = xmesa->xm_visual->gmult;
GLint bshift = xmesa->xm_visual->bshift, bmult = xmesa->xm_visual->bmult;
XImage *img = xmesa->xm_buffer->backimage;
for (i=0;i<n;i++) {
if (mask[i]) {
unsigned long p;
p = XGetPixel( img, x[i], FLIP(y[i]) );
red[i] = (GLubyte) ((p >> rshift) & rmult);
green[i] = (GLubyte) ((p >> gshift) & gmult);
blue[i] = (GLubyte) ((p >> bshift) & bmult);
alpha[i] = 255;
}
}
}
break;
case PF_8A8B8G8R:
for (i=0;i<n;i++) {
if (mask[i]) {
GLuint *ptr4 = PIXELADDR4( x[i], y[i] );
GLuint p4 = *ptr4;
red[i] = (GLubyte) ( p4 & 0xff);
green[i] = (GLubyte) ((p4 >> 8) & 0xff);
blue[i] = (GLubyte) ((p4 >> 16) & 0xff);
alpha[i] = (GLubyte) ((p4 >> 24) & 0xff);
}
}
break;
case PF_8R8G8B:
for (i=0;i<n;i++) {
if (mask[i]) {
GLuint *ptr4 = PIXELADDR4( x[i], y[i] );
GLuint p4 = *ptr4;
red[i] = (GLubyte) ((p4 >> 16) & 0xff);
green[i] = (GLubyte) ((p4 >> 8) & 0xff);
blue[i] = (GLubyte) ( p4 & 0xff);
alpha[i] = 255;
}
}
break;
case PF_5R6G5B:
for (i=0;i<n;i++) {
if (mask[i]) {
GLushort *ptr2 = PIXELADDR2( x[i], y[i] );
GLushort p2 = *ptr2;
red[i] = (GLubyte) ((p2 >> 11) & 0x1f);
green[i] = (GLubyte) ((p2 >> 5) & 0x3f);
blue[i] = (GLubyte) ( p2 & 0x1f);
alpha[i] = 255;
}
}
break;
case PF_HPCR:
for (i=0;i<n;i++) {
if (mask[i]) {
GLubyte *ptr1 = PIXELADDR1( x[i], y[i] );
GLubyte p = *ptr1;
red[i] = p & 0xE0;
green[i] = (p & 0x1C) << 3;
blue[i] = (p & 0x03) << 6;
alpha[i] = 255;
}
}
break;
case PF_DITHER:
case PF_LOOKUP:
case PF_GRAYSCALE:
{
GLubyte *red_table = xmesa->xm_buffer->pixel_to_r;
GLubyte *green_table = xmesa->xm_buffer->pixel_to_g;
GLubyte *blue_table = xmesa->xm_buffer->pixel_to_b;
XImage *img = xmesa->xm_buffer->backimage;
for (i=0;i<n;i++) {
if (mask[i]) {
unsigned long p;
p = XGetPixel( img, x[i], FLIP(y[i]) );
red[i] = red_table[p];
green[i] = green_table[p];
blue[i] = blue_table[p];
alpha[i] = 255;
}
}
}
break;
case PF_1BIT:
{
XImage *img = xmesa->xm_buffer->backimage;
for (i=0;i<n;i++) {
if (mask[i]) {
unsigned long p;
p = XGetPixel( img, x[i], FLIP(y[i]) );
red[i] = (GLubyte) (p * 255);
green[i] = (GLubyte) (p * 255);
blue[i] = (GLubyte) (p * 255);
alpha[i] = 255;
}
}
}
break;
default:
die("Problem in DD.read_color_pixels (1)");
}
}
}
/*
* Initialize all the DD.* function pointers depending on the color
* buffer configuration. This is mainly called by XMesaMakeCurrent.
*/
void xmesa_setup_DD_pointers( GLcontext *ctx )
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
/*
* Always the same:
*/
ctx->Driver.UpdateState = xmesa_setup_DD_pointers;
ctx->Driver.GetBufferSize = get_buffer_size;
ctx->Driver.Flush = flush;
ctx->Driver.Finish = finish;
ctx->Driver.SetBuffer = set_buffer;
ctx->Driver.Index = set_index;
ctx->Driver.Color = set_color;
ctx->Driver.ClearIndex = clear_index;
ctx->Driver.ClearColor = clear_color;
ctx->Driver.IndexMask = index_mask;
ctx->Driver.ColorMask = color_mask;
ctx->Driver.LogicOp = logicop;
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 );
/*
* These drawing functions depend on color buffer config:
*/
if (xmesa->xm_buffer->buffer!=XIMAGE) {
/* Writing to window or back pixmap */
ctx->Driver.Clear = clear_pixmap;
switch (xmesa->pixelformat) {
case PF_INDEX:
ctx->Driver.WriteIndexSpan = write_span_index_pixmap;
ctx->Driver.WriteMonoindexSpan = write_span_mono_pixmap;
ctx->Driver.WriteIndexPixels = write_pixels_index_pixmap;
ctx->Driver.WriteMonoindexPixels = write_pixels_mono_pixmap;
break;
case PF_TRUECOLOR:
ctx->Driver.WriteColorSpan = write_span_TRUECOLOR_pixmap;
ctx->Driver.WriteMonocolorSpan = write_span_mono_pixmap;
ctx->Driver.WriteColorPixels = write_pixels_TRUECOLOR_pixmap;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_pixmap;
break;
case PF_8A8B8G8R:
ctx->Driver.WriteColorSpan = write_span_8A8B8G8R_pixmap;
ctx->Driver.WriteMonocolorSpan = write_span_mono_pixmap;
ctx->Driver.WriteColorPixels = write_pixels_8A8B8G8R_pixmap;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_pixmap;
break;
case PF_8R8G8B:
ctx->Driver.WriteColorSpan = write_span_8R8G8B_pixmap;
ctx->Driver.WriteMonocolorSpan = write_span_mono_pixmap;
ctx->Driver.WriteColorPixels = write_pixels_8R8G8B_pixmap;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_pixmap;
break;
case PF_5R6G5B:
ctx->Driver.WriteColorSpan = write_span_5R6G5B_pixmap;
ctx->Driver.WriteMonocolorSpan = write_span_mono_pixmap;
ctx->Driver.WriteColorPixels = write_pixels_5R6G5B_pixmap;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_pixmap;
break;
case PF_DITHER:
ctx->Driver.WriteColorSpan = write_span_DITHER_pixmap;
ctx->Driver.WriteMonocolorSpan = write_span_mono_DITHER_pixmap;
ctx->Driver.WriteColorPixels = write_pixels_DITHER_pixmap;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_DITHER_pixmap;
break;
case PF_1BIT:
ctx->Driver.WriteColorSpan = write_span_1BIT_pixmap;
ctx->Driver.WriteMonocolorSpan = write_span_mono_1BIT_pixmap;
ctx->Driver.WriteColorPixels = write_pixels_1BIT_pixmap;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_1BIT_pixmap;
break;
case PF_HPCR:
ctx->Driver.WriteColorSpan = write_span_HPCR_pixmap;
ctx->Driver.WriteMonocolorSpan = write_span_mono_pixmap;
ctx->Driver.WriteColorPixels = write_pixels_HPCR_pixmap;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_pixmap;
break;
case PF_LOOKUP:
ctx->Driver.WriteColorSpan = write_span_LOOKUP_pixmap;
ctx->Driver.WriteMonocolorSpan = write_span_mono_pixmap;
ctx->Driver.WriteColorPixels = write_pixels_LOOKUP_pixmap;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_pixmap;
break;
case PF_GRAYSCALE:
ctx->Driver.WriteColorSpan = write_span_GRAYSCALE_pixmap;
ctx->Driver.WriteMonocolorSpan = write_span_mono_pixmap;
ctx->Driver.WriteColorPixels = write_pixels_GRAYSCALE_pixmap;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_pixmap;
break;
default:
die("Bad pixel format in xmesa_setup_DD_pointers (1)");
}
}
else if (xmesa->xm_buffer->buffer==XIMAGE) {
/* Writing to back XImage */
if (sizeof(GLushort)!=2 || sizeof(GLuint)!=4) {
/* Do this on Crays */
ctx->Driver.Clear = clear_nbit_ximage;
}
else {
/* Do this on most machines */
switch (xmesa->xm_buffer->backimage->bits_per_pixel) {
case 8:
ctx->Driver.Clear = clear_8bit_ximage;
break;
case 16:
ctx->Driver.Clear = clear_16bit_ximage;
break;
case 32:
ctx->Driver.Clear = clear_32bit_ximage;
break;
default:
ctx->Driver.Clear = clear_nbit_ximage;
break;
}
}
switch (xmesa->pixelformat) {
case PF_INDEX:
ctx->Driver.WriteIndexSpan = write_span_index_ximage;
ctx->Driver.WriteMonoindexSpan = write_span_mono_ximage;
ctx->Driver.WriteIndexPixels = write_pixels_index_ximage;
ctx->Driver.WriteMonoindexPixels = write_pixels_mono_ximage;
break;
case PF_TRUECOLOR:
/* Generic RGB */
ctx->Driver.WriteColorSpan = write_span_TRUECOLOR_ximage;
ctx->Driver.WriteMonocolorSpan = write_span_mono_ximage;
ctx->Driver.WriteColorPixels = write_pixels_TRUECOLOR_ximage;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_ximage;
break;
case PF_8A8B8G8R:
ctx->Driver.WriteColorSpan = write_span_8A8B8G8R_ximage;
ctx->Driver.WriteMonocolorSpan = write_span_mono_8A8B8G8R_ximage;
ctx->Driver.WriteColorPixels = write_pixels_8A8B8G8R_ximage;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_8A8B8G8R_ximage;
break;
case PF_8R8G8B:
ctx->Driver.WriteColorSpan = write_span_8R8G8B_ximage;
ctx->Driver.WriteMonocolorSpan = write_span_mono_8R8G8B_ximage;
ctx->Driver.WriteColorPixels = write_pixels_8R8G8B_ximage;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_8R8G8B_ximage;
break;
case PF_5R6G5B:
ctx->Driver.WriteColorSpan = write_span_5R6G5B_ximage;
ctx->Driver.WriteMonocolorSpan = write_span_mono_ximage;
ctx->Driver.WriteColorPixels = write_pixels_5R6G5B_ximage;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_ximage;
break;
case PF_DITHER:
if (xmesa->xm_visual->visinfo->depth==8) {
ctx->Driver.WriteColorSpan = write_span_DITHER8_ximage;
ctx->Driver.WriteMonocolorSpan = write_span_mono_DITHER8_ximage;
ctx->Driver.WriteColorPixels = write_pixels_DITHER8_ximage;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_DITHER8_ximage;
}
else {
ctx->Driver.WriteColorSpan = write_span_DITHER_ximage;
ctx->Driver.WriteMonocolorSpan = write_span_mono_DITHER_ximage;
ctx->Driver.WriteColorPixels = write_pixels_DITHER_ximage;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_DITHER_ximage;
}
break;
case PF_1BIT:
ctx->Driver.WriteColorSpan = write_span_1BIT_ximage;
ctx->Driver.WriteMonocolorSpan = write_span_mono_1BIT_ximage;
ctx->Driver.WriteColorPixels = write_pixels_1BIT_ximage;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_1BIT_ximage;
break;
case PF_HPCR:
ctx->Driver.WriteColorSpan = write_span_HPCR_ximage;
ctx->Driver.WriteMonocolorSpan = write_span_mono_HPCR_ximage;
ctx->Driver.WriteColorPixels = write_pixels_HPCR_ximage;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_HPCR_ximage;
break;
case PF_LOOKUP:
if (xmesa->xm_visual->visinfo->depth==8) {
ctx->Driver.WriteColorSpan = write_span_LOOKUP8_ximage;
ctx->Driver.WriteMonocolorSpan = write_span_mono_LOOKUP8_ximage;
ctx->Driver.WriteColorPixels = write_pixels_LOOKUP8_ximage;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_LOOKUP8_ximage;
}
else {
ctx->Driver.WriteColorSpan = write_span_LOOKUP_ximage;
ctx->Driver.WriteMonocolorSpan = write_span_mono_ximage;
ctx->Driver.WriteColorPixels = write_pixels_LOOKUP_ximage;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_ximage;
}
break;
case PF_GRAYSCALE:
if (xmesa->xm_visual->visinfo->depth==8) {
ctx->Driver.WriteColorSpan = write_span_GRAYSCALE8_ximage;
ctx->Driver.WriteMonocolorSpan = write_span_mono_GRAYSCALE8_ximage;
ctx->Driver.WriteColorPixels = write_pixels_GRAYSCALE8_ximage;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_GRAYSCALE8_ximage;
}
else {
ctx->Driver.WriteColorSpan = write_span_GRAYSCALE_ximage;
ctx->Driver.WriteMonocolorSpan = write_span_mono_ximage;
ctx->Driver.WriteColorPixels = write_pixels_GRAYSCALE_ximage;
ctx->Driver.WriteMonocolorPixels = write_pixels_mono_ximage;
}
break;
default:
die("Bad pixel format in xmesa_setup_DD_pointers (2)");
}
}
/* Pixel/span reading functions: */
ctx->Driver.ReadIndexSpan = read_index_span;
ctx->Driver.ReadColorSpan = read_color_span;
ctx->Driver.ReadIndexPixels = read_index_pixels;
ctx->Driver.ReadColorPixels = read_color_pixels;
}
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.