-/* $Id: xm_span.c,v 1.9 2001/02/22 17:50:13 brianp Exp $ */
+/* $Id: xm_span.c,v 1.17 2002/10/24 23:57:23 brianp Exp $ */
/*
* Mesa 3-D graphics library
* 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.
*/
-
+/* $XFree86: xc/extras/Mesa/src/X/xm_span.c,v 1.3 2002/02/27 21:07:54 tsi Exp $ */
#include "glxheader.h"
+#include "colormac.h"
#include "context.h"
-#include "drawpix.h"
-#include "mem.h"
-#include "state.h"
#include "depth.h"
+#include "drawpix.h"
+#include "extensions.h"
#include "macros.h"
+#include "imports.h"
#include "mtypes.h"
+#include "state.h"
#include "xmesaP.h"
-#include "extensions.h"
-
+#include "swrast/swrast.h"
/*
XMesaDrawable buffer = xmesa->xm_buffer->buffer;
XMesaGC gc = xmesa->xm_buffer->gc;
register GLuint i;
+
+ (void)DitherValues; /* Muffle compiler */
+
y = FLIP(xmesa->xm_buffer, y);
if (mask) {
for (i=0;i<n;i++,x++) {
XMesaGC gc = xmesa->xm_buffer->gc;
const unsigned long pixel = xmesa_color_to_pixel(xmesa, color[RCOMP],
color[GCOMP], color[BCOMP], color[ACOMP], xmesa->pixelformat);
- register GLboolean write_all;
register GLuint i;
XMesaSetForeground( xmesa->display, gc, pixel );
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 );
- }
- }
+
+ /* New code contributed by Jeff Epler and cleaned up by Keith
+ * Whitwell.
+ */
+ for (i = 0; i < n; ) {
+ GLuint start = i;
+
+ /* Identify and emit contiguous rendered pixels
+ */
+ while (i < n && mask[i])
+ i++;
+
+ if (start < i)
+ XMesaFillRectangle( dpy, buffer, gc,
+ (int)(x+start), (int) y,
+ (int)(i-start), 1);
+
+ /* Eat up non-rendered pixels
+ */
+ while (i < n && !mask[i])
+ i++;
}
}
+
static void write_span_mono_index_pixmap( const GLcontext *ctx, GLuint n,
GLint x, GLint y, GLuint colorIndex,
const GLubyte mask[] )
XMesaDisplay *dpy = xmesa->xm_visual->display;
XMesaDrawable buffer = xmesa->xm_buffer->buffer;
XMesaGC gc = xmesa->xm_buffer->gc;
- register GLboolean write_all;
register GLuint i;
XMesaSetForeground( xmesa->display, gc, colorIndex );
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 );
- }
- }
+
+ for (i = 0 ; i < n ;) {
+ GLuint start = i;
+
+ /* Identify and emit contiguous rendered pixels
+ */
+ while (i < n && mask[i])
+ i++;
+
+ if (start < i)
+ XMesaFillRectangle( dpy, buffer, gc,
+ (int)(x+start), (int) y,
+ (int)(i-start), 1);
+
+ /* Eat up non-rendered pixels
+ */
+ while (i < n && !mask[i])
+ i++;
}
}
GLuint n, GLint x, GLint y, GLuint index[] )
{
const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
- XMesaBuffer source;
+ XMesaBuffer source = xmesa->xm_buffer;
GLuint i;
- if (xmesa->use_read_buffer)
- source = xmesa->xm_read_buffer;
- else
- source = xmesa->xm_buffer;
-
y = FLIP(source, y);
if (source->buffer) {
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;
+ XMesaBuffer source = xmesa->xm_buffer;
if (source->buffer) {
/* Read from Pixmap or Window */
}
break;
default:
- gl_problem(NULL,"Problem in DD.read_color_span (1)");
+ _mesa_problem(NULL,"Problem in DD.read_color_span (1)");
return;
}
}
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 */
+ const GLuint *ptr4 = (const GLuint *) ptr2;
GLuint extraPixel = (n & 1);
n -= extraPixel;
for (i = 0; i < n; i += 2) {
}
break;
default:
- gl_problem(NULL,"Problem in DD.read_color_span (2)");
+ _mesa_problem(NULL,"Problem in DD.read_color_span (2)");
return;
}
}
{
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;
+ XMesaBuffer source = xmesa->xm_buffer;
if (source->buffer) {
for (i=0;i<n;i++) {
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 */
+ XMesaBuffer source = xmesa->xm_buffer;
+ XMesaDrawable buffer = source->buffer; /* the X drawable */
if (source->buffer) {
switch (xmesa->pixelformat) {
}
break;
default:
- gl_problem(NULL,"Problem in DD.read_color_pixels (1)");
+ _mesa_problem(NULL,"Problem in DD.read_color_pixels (1)");
return;
}
}
}
break;
default:
- gl_problem(NULL,"Problem in DD.read_color_pixels (1)");
+ _mesa_problem(NULL,"Problem in DD.read_color_pixels (1)");
return;
}
}
static void
-clear_color_HPCR_ximage( GLcontext *ctx, const GLchan color[4] )
+clear_color_HPCR_ximage( GLcontext *ctx, const GLfloat color[4] )
{
int i;
const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
- COPY_4V(xmesa->clearcolor, color);
+ CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[0], color[0]);
+ CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[1], color[1]);
+ CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[2], color[2]);
+ CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[3], color[3]);
- if (color[0] == 0 && color[1] == 0 && color[2] == 0) {
+ if (color[0] == 0.0 && color[1] == 0.0 && color[2] == 0.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, color[0], color[1], color[2]);
+ xmesa->xm_visual->hpcr_clear_ximage_pattern[0][i] =
+ DITHER_HPCR(i, 0,
+ xmesa->clearcolor[0],
+ xmesa->clearcolor[1],
+ xmesa->clearcolor[2]);
xmesa->xm_visual->hpcr_clear_ximage_pattern[1][i] =
- DITHER_HPCR(i, 1, color[0], color[1], color[2]);
+ DITHER_HPCR(i, 1,
+ xmesa->clearcolor[0],
+ xmesa->clearcolor[1],
+ xmesa->clearcolor[2]);
}
}
}
static void
-clear_color_HPCR_pixmap( GLcontext *ctx, const GLchan color[4] )
+clear_color_HPCR_pixmap( GLcontext *ctx, const GLfloat color[4] )
{
int i;
const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
- COPY_4V(xmesa->clearcolor, color);
+ CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[0], color[0]);
+ CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[1], color[1]);
+ CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[2], color[2]);
+ CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[3], color[3]);
- if (color[0] == 0 && color[1] == 0 && color[2] == 0) {
+ if (color[0] == 0.0 && color[1] == 0.0 && color[2] == 0.0) {
/* black is black */
for (i=0; i<16; i++) {
XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0, 0);
else {
for (i=0; i<16; i++) {
XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0,
- DITHER_HPCR(i, 0, color[0], color[1], color[2]));
+ DITHER_HPCR(i, 0,
+ xmesa->clearcolor[0],
+ xmesa->clearcolor[1],
+ xmesa->clearcolor[2]));
XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1,
- DITHER_HPCR(i, 1, color[0], color[1], color[2]));
+ DITHER_HPCR(i, 1,
+ xmesa->clearcolor[0],
+ xmesa->clearcolor[1],
+ xmesa->clearcolor[2]));
}
}
/* change tile pixmap content */
{
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
int depth=GET_VISUAL_DEPTH(xmesa->xm_visual);
+ struct swrast_device_driver *dd = _swrast_GetDeviceDriverReference( ctx );
/*
* These drawing functions depend on color buffer config:
/* 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_index_pixmap;
- ctx->Driver.WriteCI32Pixels = write_pixels_index_pixmap;
- ctx->Driver.WriteMonoCIPixels = write_pixels_mono_index_pixmap;
+ dd->WriteCI32Span = write_span_index_pixmap;
+ dd->WriteCI8Span = write_span_index8_pixmap;
+ dd->WriteMonoCISpan = write_span_mono_index_pixmap;
+ dd->WriteCI32Pixels = write_pixels_index_pixmap;
+ dd->WriteMonoCIPixels = write_pixels_mono_index_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;
+ dd->WriteRGBASpan = write_span_TRUECOLOR_pixmap;
+ dd->WriteRGBSpan = write_span_rgb_TRUECOLOR_pixmap;
+ dd->WriteMonoRGBASpan = write_span_mono_pixmap;
+ dd->WriteRGBAPixels = write_pixels_TRUECOLOR_pixmap;
+ dd->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;
+ dd->WriteRGBASpan = write_span_TRUEDITHER_pixmap;
+ dd->WriteRGBSpan = write_span_rgb_TRUEDITHER_pixmap;
+ dd->WriteMonoRGBASpan = write_span_mono_TRUEDITHER_pixmap;
+ dd->WriteRGBAPixels = write_pixels_TRUEDITHER_pixmap;
+ dd->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;
+ dd->WriteRGBASpan = write_span_8A8B8G8R_pixmap;
+ dd->WriteRGBSpan = write_span_rgb_8A8B8G8R_pixmap;
+ dd->WriteMonoRGBASpan = write_span_mono_pixmap;
+ dd->WriteRGBAPixels = write_pixels_8A8B8G8R_pixmap;
+ dd->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;
+ dd->WriteRGBASpan = write_span_8R8G8B_pixmap;
+ dd->WriteRGBSpan = write_span_rgb_8R8G8B_pixmap;
+ dd->WriteMonoRGBASpan = write_span_mono_pixmap;
+ dd->WriteRGBAPixels = write_pixels_8R8G8B_pixmap;
+ dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
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;
+ dd->WriteRGBASpan = write_span_8R8G8B24_pixmap;
+ dd->WriteRGBSpan = write_span_rgb_8R8G8B24_pixmap;
+ dd->WriteMonoRGBASpan = write_span_mono_pixmap;
+ dd->WriteRGBAPixels = write_pixels_8R8G8B24_pixmap;
+ dd->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;
+ dd->WriteRGBASpan = write_span_5R6G5B_pixmap;
+ dd->WriteRGBSpan = write_span_rgb_5R6G5B_pixmap;
+ dd->WriteMonoRGBASpan = write_span_mono_pixmap;
+ dd->WriteRGBAPixels = write_pixels_5R6G5B_pixmap;
+ dd->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;
+ dd->WriteRGBASpan = write_span_DITHER_5R6G5B_pixmap;
+ dd->WriteRGBSpan = write_span_rgb_DITHER_5R6G5B_pixmap;
+ dd->WriteMonoRGBASpan = write_span_mono_TRUEDITHER_pixmap;
+ dd->WriteRGBAPixels = write_pixels_DITHER_5R6G5B_pixmap;
+ dd->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;
+ dd->WriteRGBASpan = write_span_DITHER_pixmap;
+ dd->WriteRGBSpan = write_span_rgb_DITHER_pixmap;
+ dd->WriteMonoRGBASpan = write_span_mono_DITHER_pixmap;
+ dd->WriteRGBAPixels = write_pixels_DITHER_pixmap;
+ dd->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;
+ dd->WriteRGBASpan = write_span_1BIT_pixmap;
+ dd->WriteRGBSpan = write_span_rgb_1BIT_pixmap;
+ dd->WriteMonoRGBASpan = write_span_mono_1BIT_pixmap;
+ dd->WriteRGBAPixels = write_pixels_1BIT_pixmap;
+ dd->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;
+ dd->WriteRGBASpan = write_span_HPCR_pixmap;
+ dd->WriteRGBSpan = write_span_rgb_HPCR_pixmap;
+ dd->WriteMonoRGBASpan = write_span_mono_pixmap;
+ dd->WriteRGBAPixels = write_pixels_HPCR_pixmap;
+ dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
if (xmesa->xm_visual->hpcr_clear_flag) {
- ctx->Driver.ClearColor = clear_color_HPCR_pixmap;
+ 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;
+ dd->WriteRGBASpan = write_span_LOOKUP_pixmap;
+ dd->WriteRGBSpan = write_span_rgb_LOOKUP_pixmap;
+ dd->WriteMonoRGBASpan = write_span_mono_pixmap;
+ dd->WriteRGBAPixels = write_pixels_LOOKUP_pixmap;
+ dd->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;
+ dd->WriteRGBASpan = write_span_GRAYSCALE_pixmap;
+ dd->WriteRGBSpan = write_span_rgb_GRAYSCALE_pixmap;
+ dd->WriteMonoRGBASpan = write_span_mono_pixmap;
+ dd->WriteRGBAPixels = write_pixels_GRAYSCALE_pixmap;
+ dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
break;
default:
- gl_problem(NULL,"Bad pixel format in xmesa_update_state (1)");
+ _mesa_problem(NULL,"Bad pixel format in xmesa_update_state (1)");
return;
}
}
/* Writing to back XImage */
switch (xmesa->pixelformat) {
case PF_INDEX:
- ctx->Driver.WriteCI32Span = write_span_index_ximage;
+ dd->WriteCI32Span = write_span_index_ximage;
if (depth==8)
- ctx->Driver.WriteCI8Span = write_span_index8_ximage8;
+ dd->WriteCI8Span = write_span_index8_ximage8;
else
- ctx->Driver.WriteCI8Span = write_span_index8_ximage;
- ctx->Driver.WriteMonoCISpan = write_span_mono_index_ximage;
- ctx->Driver.WriteCI32Pixels = write_pixels_index_ximage;
- ctx->Driver.WriteMonoCIPixels = write_pixels_mono_index_ximage;
+ dd->WriteCI8Span = write_span_index8_ximage;
+ dd->WriteMonoCISpan = write_span_mono_index_ximage;
+ dd->WriteCI32Pixels = write_pixels_index_ximage;
+ dd->WriteMonoCIPixels = write_pixels_mono_index_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;
+ dd->WriteRGBASpan = write_span_TRUECOLOR_ximage;
+ dd->WriteRGBSpan = write_span_rgb_TRUECOLOR_ximage;
+ dd->WriteMonoRGBASpan = write_span_mono_ximage;
+ dd->WriteRGBAPixels = write_pixels_TRUECOLOR_ximage;
+ dd->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;
+ dd->WriteRGBASpan = write_span_TRUEDITHER_ximage;
+ dd->WriteRGBSpan = write_span_rgb_TRUEDITHER_ximage;
+ dd->WriteMonoRGBASpan = write_span_mono_TRUEDITHER_ximage;
+ dd->WriteRGBAPixels = write_pixels_TRUEDITHER_ximage;
+ dd->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;
+ dd->WriteRGBASpan = write_span_8A8B8G8R_ximage;
+ dd->WriteRGBSpan = write_span_rgb_8A8B8G8R_ximage;
+ dd->WriteMonoRGBASpan = write_span_mono_8A8B8G8R_ximage;
+ dd->WriteRGBAPixels = write_pixels_8A8B8G8R_ximage;
+ dd->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;
+ dd->WriteRGBASpan = write_span_8R8G8B_ximage;
+ dd->WriteRGBSpan = write_span_rgb_8R8G8B_ximage;
+ dd->WriteMonoRGBASpan = write_span_mono_8R8G8B_ximage;
+ dd->WriteRGBAPixels = write_pixels_8R8G8B_ximage;
+ dd->WriteMonoRGBAPixels = write_pixels_mono_8R8G8B_ximage;
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;
+ dd->WriteRGBASpan = write_span_8R8G8B24_ximage;
+ dd->WriteRGBSpan = write_span_rgb_8R8G8B24_ximage;
+ dd->WriteMonoRGBASpan = write_span_mono_8R8G8B24_ximage;
+ dd->WriteRGBAPixels = write_pixels_8R8G8B24_ximage;
+ dd->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;
+ dd->WriteRGBASpan = write_span_5R6G5B_ximage;
+ dd->WriteRGBSpan = write_span_rgb_5R6G5B_ximage;
+ dd->WriteMonoRGBASpan = write_span_mono_ximage;
+ dd->WriteRGBAPixels = write_pixels_5R6G5B_ximage;
+ dd->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;
+ dd->WriteRGBASpan = write_span_DITHER_5R6G5B_ximage;
+ dd->WriteRGBSpan = write_span_rgb_DITHER_5R6G5B_ximage;
+ dd->WriteMonoRGBASpan = write_span_mono_DITHER_5R6G5B_ximage;
+ dd->WriteRGBAPixels = write_pixels_DITHER_5R6G5B_ximage;
+ dd->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;
+ dd->WriteRGBASpan = write_span_DITHER8_ximage;
+ dd->WriteRGBSpan = write_span_rgb_DITHER8_ximage;
+ dd->WriteMonoRGBASpan = write_span_mono_DITHER8_ximage;
+ dd->WriteRGBAPixels = write_pixels_DITHER8_ximage;
+ dd->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;
+ dd->WriteRGBASpan = write_span_DITHER_ximage;
+ dd->WriteRGBSpan = write_span_rgb_DITHER_ximage;
+ dd->WriteMonoRGBASpan = write_span_mono_DITHER_ximage;
+ dd->WriteRGBAPixels = write_pixels_DITHER_ximage;
+ dd->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;
+ dd->WriteRGBASpan = write_span_1BIT_ximage;
+ dd->WriteRGBSpan = write_span_rgb_1BIT_ximage;
+ dd->WriteMonoRGBASpan = write_span_mono_1BIT_ximage;
+ dd->WriteRGBAPixels = write_pixels_1BIT_ximage;
+ dd->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;
+ dd->WriteRGBASpan = write_span_HPCR_ximage;
+ dd->WriteRGBSpan = write_span_rgb_HPCR_ximage;
+ dd->WriteMonoRGBASpan = write_span_mono_HPCR_ximage;
+ dd->WriteRGBAPixels = write_pixels_HPCR_ximage;
+ dd->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;
+ dd->WriteRGBASpan = write_span_LOOKUP8_ximage;
+ dd->WriteRGBSpan = write_rgb_LOOKUP8_ximage;
+ dd->WriteMonoRGBASpan = write_span_mono_LOOKUP8_ximage;
+ dd->WriteRGBAPixels = write_pixels_LOOKUP8_ximage;
+ dd->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;
+ dd->WriteRGBASpan = write_span_LOOKUP_ximage;
+ dd->WriteRGBSpan = write_span_rgb_LOOKUP_ximage;
+ dd->WriteMonoRGBASpan = write_span_mono_ximage;
+ dd->WriteRGBAPixels = write_pixels_LOOKUP_ximage;
+ dd->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;
+ dd->WriteRGBASpan = write_span_GRAYSCALE8_ximage;
+ dd->WriteRGBSpan = write_span_rgb_GRAYSCALE8_ximage;
+ dd->WriteMonoRGBASpan = write_span_mono_GRAYSCALE8_ximage;
+ dd->WriteRGBAPixels = write_pixels_GRAYSCALE8_ximage;
+ dd->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;
+ dd->WriteRGBASpan = write_span_GRAYSCALE_ximage;
+ dd->WriteRGBSpan = write_span_rgb_GRAYSCALE_ximage;
+ dd->WriteMonoRGBASpan = write_span_mono_ximage;
+ dd->WriteRGBAPixels = write_pixels_GRAYSCALE_ximage;
+ dd->WriteMonoRGBAPixels = write_pixels_mono_ximage;
}
break;
default:
- gl_problem(NULL,"Bad pixel format in xmesa_update_state (2)");
+ _mesa_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;
+ dd->ReadCI32Span = read_index_span;
+ dd->ReadRGBASpan = read_color_span;
+ dd->ReadCI32Pixels = read_index_pixels;
+ dd->ReadRGBAPixels = read_color_pixels;
}