X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fdrivers%2Fosmesa%2Fosmesa.c;h=0473717a0dc135ad17e4d14e83a5591b09d6e9dc;hb=95e02a210ed339ad20b0c16284dcdcf9af2dc755;hp=a5a71bfc2dcefeaecc68203e6e61be79a91f8bd9;hpb=c26d81842a9e074d059a802033d3311ac628aa8e;p=mesa.git diff --git a/src/mesa/drivers/osmesa/osmesa.c b/src/mesa/drivers/osmesa/osmesa.c index a5a71bfc2dc..0473717a0dc 100644 --- a/src/mesa/drivers/osmesa/osmesa.c +++ b/src/mesa/drivers/osmesa/osmesa.c @@ -1,21 +1,21 @@ -/* $Id: osmesa.c,v 1.9 2000/01/15 06:13:26 rjfrank Exp $ */ +/* $Id: osmesa.c,v 1.50 2001/03/08 17:33:33 brianp Exp $ */ /* * Mesa 3-D graphics library - * Version: 3.3 - * - * Copyright (C) 1999-2000 Brian Paul All Rights Reserved. - * + * Version: 3.5 + * + * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. + * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. - * + * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL @@ -30,24 +30,32 @@ * * Note on thread safety: this driver is thread safe. All * functions are reentrant. The notion of current context is - * managed by the core gl_make_current() and gl_get_current_context() + * managed by the core _mesa_make_current() and _mesa_get_current_context() * functions. Those functions are thread-safe. */ -#ifdef PC_HEADER -#include "all.h" -#else -#include -#include +#include "glheader.h" #include "GL/osmesa.h" #include "context.h" +#include "colormac.h" #include "depth.h" -#include "mem.h" +#include "extensions.h" +#include "macros.h" #include "matrix.h" -#include "types.h" -#include "vb.h" -#endif +#include "mem.h" +#include "mmath.h" +#include "mtypes.h" +#include "texstore.h" +#include "array_cache/acache.h" +#include "swrast/swrast.h" +#include "swrast_setup/swrast_setup.h" +#include "swrast/s_context.h" +#include "swrast/s_depth.h" +#include "swrast/s_lines.h" +#include "swrast/s_triangle.h" +#include "tnl/tnl.h" + /* @@ -64,23 +72,25 @@ struct osmesa_context { GLenum format; /* either GL_RGBA or GL_COLOR_INDEX */ void *buffer; /* the image buffer */ GLint width, height; /* size of image buffer */ - GLuint pixel; /* current color index or RGBA pixel value */ - GLuint clearpixel; /* pixel for clearing the color buffer */ GLint rowlength; /* number of pixels per row */ GLint userRowLength; /* user-specified number of pixels per row */ GLint rshift, gshift; /* bit shifts for RGBA formats */ GLint bshift, ashift; - GLint rind, gind, bind; /* index offsets for RGBA formats */ - void *rowaddr[MAX_HEIGHT]; /* address of first pixel in each image row */ + GLint rInd, gInd, bInd, aInd;/* index offsets for RGBA formats */ + GLchan *rowaddr[MAX_HEIGHT]; /* address of first pixel in each image row */ GLboolean yup; /* TRUE -> Y increases upward */ /* FALSE -> Y increases downward */ - GLboolean bVisible; /* TRUE if geometry is visible */ }; /* A forward declaration: */ -static void osmesa_update_state( GLcontext *ctx ); +static void osmesa_update_state( GLcontext *ctx, GLuint newstate ); +static void osmesa_register_swrast_functions( GLcontext *ctx ); + + + +#define OSMESA_CONTEXT(ctx) ((OSMesaContext) (ctx->DriverCtx)) @@ -100,19 +110,34 @@ static void osmesa_update_state( GLcontext *ctx ); */ OSMesaContext GLAPIENTRY OSMesaCreateContext( GLenum format, OSMesaContext sharelist ) +{ + return OSMesaCreateContextExt(format, DEFAULT_SOFTWARE_DEPTH_BITS, + 8, 16, sharelist); +} + + + +/* + * New in Mesa 3.5 + * + * Create context and specify size of ancillary buffers. + */ +OSMesaContext GLAPIENTRY +OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits, + GLint accumBits, OSMesaContext sharelist ) { OSMesaContext osmesa; GLint rshift, gshift, bshift, ashift; - GLint rind, gind, bind; - GLint indexBits, alphaBits; + GLint rind, gind, bind, aind; + GLint indexBits, redBits, greenBits, blueBits, alphaBits; GLboolean rgbmode; GLboolean swalpha; - GLuint i4 = 1; - GLubyte *i1 = (GLubyte *) &i4; - GLint little_endian = *i1; + const GLuint i4 = 1; + const GLubyte *i1 = (GLubyte *) &i4; + const GLint little_endian = *i1; swalpha = GL_FALSE; - rind = gind = bind = 0; + rind = gind = bind = aind = 0; if (format==OSMESA_COLOR_INDEX) { indexBits = 8; rshift = gshift = bshift = ashift = 0; @@ -120,7 +145,14 @@ OSMesaCreateContext( GLenum format, OSMesaContext sharelist ) } else if (format==OSMESA_RGBA) { indexBits = 0; - alphaBits = 8; + redBits = CHAN_BITS; + greenBits = CHAN_BITS; + blueBits = CHAN_BITS; + alphaBits = CHAN_BITS; + rind = 0; + gind = 1; + bind = 2; + aind = 3; if (little_endian) { rshift = 0; gshift = 8; @@ -137,7 +169,14 @@ OSMesaCreateContext( GLenum format, OSMesaContext sharelist ) } else if (format==OSMESA_BGRA) { indexBits = 0; - alphaBits = 8; + redBits = CHAN_BITS; + greenBits = CHAN_BITS; + blueBits = CHAN_BITS; + alphaBits = CHAN_BITS; + rind = 2; + gind = 1; + bind = 0; + aind = 3; if (little_endian) { ashift = 0; rshift = 8; @@ -154,7 +193,14 @@ OSMesaCreateContext( GLenum format, OSMesaContext sharelist ) } else if (format==OSMESA_ARGB) { indexBits = 0; - alphaBits = 8; + redBits = CHAN_BITS; + greenBits = CHAN_BITS; + blueBits = CHAN_BITS; + alphaBits = CHAN_BITS; + rind = 1; + gind = 2; + bind = 3; + aind = 0; if (little_endian) { bshift = 0; gshift = 8; @@ -171,27 +217,33 @@ OSMesaCreateContext( GLenum format, OSMesaContext sharelist ) } else if (format==OSMESA_RGB) { indexBits = 0; + redBits = CHAN_BITS; + greenBits = CHAN_BITS; + blueBits = CHAN_BITS; alphaBits = 0; bshift = 0; gshift = 8; rshift = 16; ashift = 24; - bind = 2; - gind = 1; rind = 0; + gind = 1; + bind = 2; rgbmode = GL_TRUE; swalpha = GL_TRUE; } else if (format==OSMESA_BGR) { indexBits = 0; + redBits = CHAN_BITS; + greenBits = CHAN_BITS; + blueBits = CHAN_BITS; alphaBits = 0; bshift = 0; gshift = 8; rshift = 16; ashift = 24; - bind = 0; - gind = 1; rind = 2; + gind = 1; + bind = 0; rgbmode = GL_TRUE; swalpha = GL_TRUE; } @@ -202,39 +254,48 @@ OSMesaCreateContext( GLenum format, OSMesaContext sharelist ) osmesa = (OSMesaContext) CALLOC_STRUCT(osmesa_context); if (osmesa) { - osmesa->gl_visual = gl_create_visual( rgbmode, - swalpha, /* software alpha */ - GL_FALSE, /* double buffer */ - GL_FALSE, /* stereo */ - DEPTH_BITS, - STENCIL_BITS, - rgbmode ? ACCUM_BITS : 0, - indexBits, - 8, 8, 8, alphaBits ); + osmesa->gl_visual = _mesa_create_visual( rgbmode, + GL_FALSE, /* double buffer */ + GL_FALSE, /* stereo */ + redBits, + greenBits, + blueBits, + alphaBits, + indexBits, + depthBits, + stencilBits, + accumBits, + accumBits, + accumBits, + alphaBits ? accumBits : 0, + 1 /* num samples */ + ); if (!osmesa->gl_visual) { + FREE(osmesa); return NULL; } - if (!gl_initialize_context_data(&osmesa->gl_ctx, - osmesa->gl_visual, - sharelist ? &sharelist->gl_ctx - : (GLcontext *) NULL, - (void *) osmesa, GL_TRUE )) { - gl_destroy_visual( osmesa->gl_visual ); + if (!_mesa_initialize_context(&osmesa->gl_ctx, + osmesa->gl_visual, + sharelist ? &sharelist->gl_ctx + : (GLcontext *) NULL, + (void *) osmesa, GL_TRUE )) { + _mesa_destroy_visual( osmesa->gl_visual ); FREE(osmesa); return NULL; } + _mesa_enable_sw_extensions(&(osmesa->gl_ctx)); - osmesa->gl_buffer = gl_create_framebuffer( osmesa->gl_visual, - osmesa->gl_visual->DepthBits > 0, - osmesa->gl_visual->StencilBits > 0, - osmesa->gl_visual->AccumBits > 0, - osmesa->gl_visual->AlphaBits > 0 ); + osmesa->gl_buffer = _mesa_create_framebuffer( osmesa->gl_visual, + osmesa->gl_visual->depthBits > 0, + osmesa->gl_visual->stencilBits > 0, + osmesa->gl_visual->accumRedBits > 0, + osmesa->gl_visual->alphaBits > 0 ); if (!osmesa->gl_buffer) { - gl_destroy_visual( osmesa->gl_visual ); - gl_free_context_data( &osmesa->gl_ctx ); + _mesa_destroy_visual( osmesa->gl_visual ); + _mesa_free_context_data( &osmesa->gl_ctx ); FREE(osmesa); return NULL; } @@ -242,8 +303,6 @@ OSMesaCreateContext( GLenum format, OSMesaContext sharelist ) osmesa->buffer = NULL; osmesa->width = 0; osmesa->height = 0; - osmesa->pixel = 0; - osmesa->clearpixel = 0; osmesa->userRowLength = 0; osmesa->rowlength = 0; osmesa->yup = GL_TRUE; @@ -251,16 +310,31 @@ OSMesaCreateContext( GLenum format, OSMesaContext sharelist ) osmesa->gshift = gshift; osmesa->bshift = bshift; osmesa->ashift = ashift; - osmesa->rind = rind; - osmesa->gind = gind; - osmesa->bind = bind; - osmesa->bVisible = GL_FALSE; + osmesa->rInd = rind; + osmesa->gInd = gind; + osmesa->bInd = bind; + osmesa->aInd = aind; + + + /* Initialize the software rasterizer and helper modules. + */ + { + GLcontext *ctx = &osmesa->gl_ctx; + + _swrast_CreateContext( ctx ); + _ac_CreateContext( ctx ); + _tnl_CreateContext( ctx ); + _swsetup_CreateContext( ctx ); + + osmesa_register_swrast_functions( ctx ); + } } return osmesa; } + /* * Destroy an Off-Screen Mesa rendering context. * @@ -269,9 +343,9 @@ OSMesaCreateContext( GLenum format, OSMesaContext sharelist ) void GLAPIENTRY OSMesaDestroyContext( OSMesaContext ctx ) { if (ctx) { - gl_destroy_visual( ctx->gl_visual ); - gl_destroy_framebuffer( ctx->gl_buffer ); - gl_free_context_data( &ctx->gl_ctx ); + _mesa_destroy_visual( ctx->gl_visual ); + _mesa_destroy_framebuffer( ctx->gl_buffer ); + _mesa_free_context_data( &ctx->gl_ctx ); FREE( ctx ); } } @@ -283,56 +357,35 @@ void GLAPIENTRY OSMesaDestroyContext( OSMesaContext ctx ) */ static void compute_row_addresses( OSMesaContext ctx ) { - GLint i; + GLint bytesPerPixel, bytesPerRow, i; + GLubyte *origin = (GLubyte *) ctx->buffer; + + if (ctx->format == OSMESA_COLOR_INDEX) { + /* CI mode */ + bytesPerPixel = 1 * sizeof(GLchan); + } + else if ((ctx->format == OSMESA_RGB) || (ctx->format == OSMESA_BGR)) { + /* RGB mode */ + bytesPerPixel = 3 * sizeof(GLchan); + } + else { + /* RGBA mode */ + bytesPerPixel = 4 * sizeof(GLchan); + } + + bytesPerRow = ctx->rowlength * bytesPerPixel; if (ctx->yup) { /* Y=0 is bottom line of window */ - if (ctx->format==OSMESA_COLOR_INDEX) { - /* 1-byte CI mode */ - GLubyte *origin = (GLubyte *) ctx->buffer; - for (i=0;irowaddr[i] = origin + i * ctx->rowlength; - } - } - else { - if ((ctx->format==OSMESA_RGB) || (ctx->format==OSMESA_BGR)) { - /* 3-byte RGB mode */ - GLubyte *origin = (GLubyte *) ctx->buffer; - for (i=0;irowaddr[i] = origin + (i * (ctx->rowlength*3)); - } - } else { - /* 4-byte RGBA mode */ - GLuint *origin = (GLuint *) ctx->buffer; - for (i=0;irowaddr[i] = origin + i * ctx->rowlength; - } - } + for (i = 0; i < MAX_HEIGHT; i++) { + ctx->rowaddr[i] = (GLchan *) ((GLubyte *) origin + i * bytesPerRow); } } else { /* Y=0 is top line of window */ - if (ctx->format==OSMESA_COLOR_INDEX) { - /* 1-byte CI mode */ - GLubyte *origin = (GLubyte *) ctx->buffer; - for (i=0;irowaddr[i] = origin + (ctx->height-i-1) * ctx->rowlength; - } - } - else { - if ((ctx->format==OSMESA_RGB) || (ctx->format==OSMESA_BGR)) { - /* 3-byte RGB mode */ - GLubyte *origin = (GLubyte *) ctx->buffer; - for (i=0;irowaddr[i] = origin + ((ctx->height-i-1) * (ctx->rowlength*3)); - } - } else { - /* 4-byte RGBA mode */ - GLuint *origin = (GLuint *) ctx->buffer; - for (i=0;irowaddr[i] = origin + (ctx->height-i-1) * ctx->rowlength; - } - } + for (i = 0; i < MAX_HEIGHT; i++) { + GLint j = ctx->height - i - 1; + ctx->rowaddr[i] = (GLchan *) ((GLubyte *) origin + j * bytesPerRow); } } } @@ -369,13 +422,14 @@ GLboolean GLAPIENTRY OSMesaMakeCurrent( OSMesaContext ctx, void *buffer, GLenum type, GLsizei width, GLsizei height ) { - if (!ctx || !buffer || type!=GL_UNSIGNED_BYTE - || width<1 || height<1 || width>MAX_WIDTH || height>MAX_HEIGHT) { + if (!ctx || !buffer || type != CHAN_TYPE || + width < 1 || height < 1 || + width > MAX_WIDTH || height > MAX_HEIGHT) { return GL_FALSE; } - osmesa_update_state( &ctx->gl_ctx ); - gl_make_current( &ctx->gl_ctx, ctx->gl_buffer ); + osmesa_update_state( &ctx->gl_ctx, 0 ); + _mesa_make_current( &ctx->gl_ctx, ctx->gl_buffer ); ctx->buffer = buffer; ctx->width = width; @@ -400,10 +454,9 @@ OSMesaMakeCurrent( OSMesaContext ctx, void *buffer, GLenum type, - OSMesaContext GLAPIENTRY OSMesaGetCurrentContext( void ) { - GLcontext *ctx = gl_get_current_context(); + GLcontext *ctx = _mesa_get_current_context(); if (ctx) return (OSMesaContext) ctx; else @@ -419,7 +472,7 @@ void GLAPIENTRY OSMesaPixelStore( GLint pname, GLint value ) switch (pname) { case OSMESA_ROW_LENGTH: if (value<0) { - gl_error( &ctx->gl_ctx, GL_INVALID_VALUE, + _mesa_error( &ctx->gl_ctx, GL_INVALID_VALUE, "OSMesaPixelStore(value)" ); return; } @@ -430,7 +483,7 @@ void GLAPIENTRY OSMesaPixelStore( GLint pname, GLint value ) ctx->yup = value ? GL_TRUE : GL_FALSE; break; default: - gl_error( &ctx->gl_ctx, GL_INVALID_ENUM, "OSMesaPixelStore(pname)" ); + _mesa_error( &ctx->gl_ctx, GL_INVALID_ENUM, "OSMesaPixelStore(pname)" ); return; } @@ -453,7 +506,7 @@ void GLAPIENTRY OSMesaGetIntegerv( GLint pname, GLint *value ) *value = ctx->format; return; case OSMESA_TYPE: - *value = GL_UNSIGNED_BYTE; + *value = CHAN_TYPE; return; case OSMESA_ROW_LENGTH: *value = ctx->rowlength; @@ -462,22 +515,7 @@ void GLAPIENTRY OSMesaGetIntegerv( GLint pname, GLint *value ) *value = ctx->yup; return; default: - gl_error(&ctx->gl_ctx, GL_INVALID_ENUM, "OSMesaGetIntergerv(pname)"); - return; - } -} - -void GLAPIENTRY OSMesaGetBooleanv( GLint pname, GLboolean *value ) -{ - OSMesaContext ctx = OSMesaGetCurrentContext(); - - switch (pname) { - case OSMESA_OCCLUSION_TEST_RESULT_HP: - *value = ctx->bVisible; - ctx->bVisible = GL_FALSE; - return; - default: - gl_error(&ctx->gl_ctx, GL_INVALID_ENUM, "OSMesaGetBooleanv(pname)" ); + _mesa_error(&ctx->gl_ctx, GL_INVALID_ENUM, "OSMesaGetIntergerv(pname)"); return; } } @@ -490,10 +528,11 @@ void GLAPIENTRY OSMesaGetBooleanv( GLint pname, GLboolean *value ) * buffer - pointer to depth buffer values * Return: GL_TRUE or GL_FALSE to indicate success or failure. */ -GLboolean GLAPIENTRY OSMesaGetDepthBuffer( OSMesaContext c, GLint *width, GLint *height, - GLint *bytesPerValue, void **buffer ) +GLboolean GLAPIENTRY +OSMesaGetDepthBuffer( OSMesaContext c, GLint *width, GLint *height, + GLint *bytesPerValue, void **buffer ) { - if ((!c->gl_buffer) || (!c->gl_buffer->Depth)) { + if ((!c->gl_buffer) || (!c->gl_buffer->DepthBuffer)) { *width = 0; *height = 0; *bytesPerValue = 0; @@ -503,14 +542,42 @@ GLboolean GLAPIENTRY OSMesaGetDepthBuffer( OSMesaContext c, GLint *width, GLint else { *width = c->gl_buffer->Width; *height = c->gl_buffer->Height; - *bytesPerValue = sizeof(GLdepth); - *buffer = c->gl_buffer->Depth; + if (c->gl_visual->depthBits <= 16) + *bytesPerValue = sizeof(GLushort); + else + *bytesPerValue = sizeof(GLuint); + *buffer = c->gl_buffer->DepthBuffer; return GL_TRUE; } } - - +/* + * Return the color buffer associated with an OSMesa context. + * Input: c - the OSMesa context + * Output: width, height - size of buffer in pixels + * format - the pixel format (OSMESA_FORMAT) + * buffer - pointer to color buffer values + * Return: GL_TRUE or GL_FALSE to indicate success or failure. + */ +GLboolean GLAPIENTRY +OSMesaGetColorBuffer( OSMesaContext c, GLint *width, + GLint *height, GLint *format, void **buffer ) +{ + if (!c->buffer) { + *width = 0; + *height = 0; + *format = 0; + *buffer = 0; + return GL_FALSE; + } + else { + *width = c->width; + *height = c->height; + *format = c->format; + *buffer = c->buffer; + return GL_TRUE; + } +} /**********************************************************************/ /*** Device Driver Functions ***/ @@ -520,26 +587,40 @@ GLboolean GLAPIENTRY OSMesaGetDepthBuffer( OSMesaContext c, GLint *width, GLint /* * Useful macros: */ -#define PACK_RGBA(R,G,B,A) ( ((R) << osmesa->rshift) \ - | ((G) << osmesa->gshift) \ - | ((B) << osmesa->bshift) \ - | ((A) << osmesa->ashift) ) -#define PACK_RGBA2(R,G,B,A) ( ((R) << rshift) \ - | ((G) << gshift) \ - | ((B) << bshift) \ - | ((A) << ashift) ) +#define PACK_RGBA(DST, R, G, B, A) \ +do { \ + (DST)[osmesa->rInd] = R; \ + (DST)[osmesa->gInd] = G; \ + (DST)[osmesa->bInd] = B; \ + (DST)[osmesa->aInd] = A; \ +} while (0) + +#define PACK_RGB(DST, R, G, B) \ +do { \ + (DST)[0] = R; \ + (DST)[1] = G; \ + (DST)[2] = B; \ +} while (0) + +#define PACK_BGR(DST, R, G, B) \ +do { \ + (DST)[0] = B; \ + (DST)[1] = G; \ + (DST)[2] = R; \ +} while (0) -#define UNPACK_RED(P) (((P) >> osmesa->rshift) & 0xff) -#define UNPACK_GREEN(P) (((P) >> osmesa->gshift) & 0xff) -#define UNPACK_BLUE(P) (((P) >> osmesa->bshift) & 0xff) -#define UNPACK_ALPHA(P) (((P) >> osmesa->ashift) & 0xff) -#define PIXELADDR1(X,Y) ((GLubyte *) osmesa->rowaddr[Y] + (X)) -#define PIXELADDR3(X,Y) ((GLubyte *) osmesa->rowaddr[Y] + ((X)*3)) -#define PIXELADDR4(X,Y) ((GLuint *) osmesa->rowaddr[Y] + (X)) +#define UNPACK_RED(P) ( (P)[osmesa->rInd] ) +#define UNPACK_GREEN(P) ( (P)[osmesa->gInd] ) +#define UNPACK_BLUE(P) ( (P)[osmesa->bInd] ) +#define UNPACK_ALPHA(P) ( (P)[osmesa->aInd] ) +#define PIXELADDR1(X,Y) (osmesa->rowaddr[Y] + (X)) +#define PIXELADDR3(X,Y) (osmesa->rowaddr[Y] + 3 * (X)) +#define PIXELADDR4(X,Y) (osmesa->rowaddr[Y] + 4 * (X)) + static GLboolean set_draw_buffer( GLcontext *ctx, GLenum mode ) @@ -562,135 +643,170 @@ static void set_read_buffer( GLcontext *ctx, GLframebuffer *buffer, GLenum mode } -static void clear_index( GLcontext *ctx, GLuint index ) +static void clear( GLcontext *ctx, GLbitfield mask, GLboolean all, + GLint x, GLint y, GLint width, GLint height ) { - OSMesaContext osmesa = (OSMesaContext) ctx; - osmesa->clearpixel = index; -} - - - -static void clear_color( GLcontext *ctx, - GLubyte r, GLubyte g, GLubyte b, GLubyte a ) -{ - OSMesaContext osmesa = (OSMesaContext) ctx; - osmesa->clearpixel = PACK_RGBA( r, g, b, a ); -} - - - -static GLbitfield clear( GLcontext *ctx, GLbitfield mask, GLboolean all, - GLint x, GLint y, GLint width, GLint height ) -{ - OSMesaContext osmesa = (OSMesaContext) ctx; + OSMesaContext osmesa = OSMESA_CONTEXT(ctx); const GLuint *colorMask = (GLuint *) &ctx->Color.ColorMask; - /* we can't handle color or index masking */ - if (*colorMask != 0xffffffff || ctx->Color.IndexMask != 0xffffffff) - return mask; - /* sanity check - we only have a front-left buffer */ ASSERT((mask & (DD_FRONT_RIGHT_BIT | DD_BACK_LEFT_BIT | DD_BACK_RIGHT_BIT)) == 0); + if (*colorMask == 0xffffffff && ctx->Color.IndexMask == 0xffffffff) { + if (mask & DD_FRONT_LEFT_BIT) { + if (osmesa->format == OSMESA_COLOR_INDEX) { + if (all) { + /* Clear whole CI buffer */ +#if CHAN_TYPE == GL_UNSIGNED_BYTE + MEMSET(osmesa->buffer, ctx->Color.ClearIndex, + osmesa->rowlength * osmesa->height); +#else + const GLint n = osmesa->rowlength * osmesa->height; + GLchan *buffer = (GLchan *) osmesa->buffer; + GLint i; + for (i = 0; i < n; i ++) { + buffer[i] = ctx->Color.ClearIndex; + } +#endif + } + else { + /* Clear part of CI buffer */ + const GLchan clearIndex = (GLchan) ctx->Color.ClearIndex; + GLint i, j; + for (i = 0; i < height; i++) { + GLchan *ptr1 = PIXELADDR1(x, (y + i)); + for (j = 0; j < width; j++) { + *ptr1++ = clearIndex; + } + } + } + } + else if (osmesa->format == OSMESA_RGB) { + const GLchan r = ctx->Color.ClearColor[0]; + const GLchan g = ctx->Color.ClearColor[1]; + const GLchan b = ctx->Color.ClearColor[2]; + if (all) { + /* Clear whole RGB buffer */ + GLuint n = osmesa->rowlength * osmesa->height; + GLchan *ptr3 = (GLchan *) osmesa->buffer; + GLuint i; + for (i = 0; i < n; i++) { + PACK_RGB(ptr3, r, g, b); + ptr3 += 3; + } + } + else { + /* Clear part of RGB buffer */ + GLint i, j; + for (i = 0; i < height; i++) { + GLchan *ptr3 = PIXELADDR3(x, (y + i)); + for (j = 0; j < width; j++) { + PACK_RGB(ptr3, r, g, b); + ptr3 += 3; + } + } + } + } + else if (osmesa->format == OSMESA_BGR) { + const GLchan r = ctx->Color.ClearColor[0]; + const GLchan g = ctx->Color.ClearColor[1]; + const GLchan b = ctx->Color.ClearColor[2]; + if (all) { + /* Clear whole RGB buffer */ + const GLint n = osmesa->rowlength * osmesa->height; + GLchan *ptr3 = (GLchan *) osmesa->buffer; + GLint i; + for (i = 0; i < n; i++) { + PACK_BGR(ptr3, r, g, b); + ptr3 += 3; + } + } + else { + /* Clear part of RGB buffer */ + GLint i, j; + for (i = 0; i < height; i++) { + GLchan *ptr3 = PIXELADDR3(x, (y + i)); + for (j = 0; j < width; j++) { + PACK_BGR(ptr3, r, g, b); + ptr3 += 3; + } + } + } + } + else { +#if CHAN_TYPE == GL_UNSIGNED_BYTE + /* 4-byte pixel value */ + GLuint clearPixel; + GLchan *clr = (GLchan *) &clearPixel; + clr[osmesa->rInd] = ctx->Color.ClearColor[0]; + clr[osmesa->gInd] = ctx->Color.ClearColor[1]; + clr[osmesa->bInd] = ctx->Color.ClearColor[2]; + clr[osmesa->aInd] = ctx->Color.ClearColor[3]; + if (all) { + /* Clear whole RGBA buffer */ + const GLuint n = osmesa->rowlength * osmesa->height; + GLuint *ptr4 = (GLuint *) osmesa->buffer; + GLuint i; + if (clearPixel) { + for (i = 0; i < n; i++) { + *ptr4++ = clearPixel; + } + } + else { + BZERO(ptr4, n * sizeof(GLuint)); + } + } + else { + /* Clear part of RGBA buffer */ + GLint i, j; + for (i = 0; i < height; i++) { + GLuint *ptr4 = (GLuint *) PIXELADDR4(x, (y + i)); + for (j = 0; j < width; j++) { + *ptr4++ = clearPixel; + } + } + } +#else + const GLchan r = ctx->Color.ClearColor[0]; + const GLchan g = ctx->Color.ClearColor[1]; + const GLchan b = ctx->Color.ClearColor[2]; + const GLchan a = ctx->Color.ClearColor[3]; + if (all) { + /* Clear whole RGBA buffer */ + const GLuint n = osmesa->rowlength * osmesa->height; + GLchan *p = (GLchan *) osmesa->buffer; + GLuint i; + for (i = 0; i < n; i++) { + PACK_RGBA(p, r, g, b, a); + p += 4; + } + } + else { + /* Clear part of RGBA buffer */ + GLint i, j; + for (i = 0; i < height; i++) { + GLchan *p = PIXELADDR4(x, (y + i)); + for (j = 0; j < width; j++) { + PACK_RGBA(p, r, g, b, a); + p += 4; + } + } + } - if (mask & DD_FRONT_LEFT_BIT) { - if (osmesa->format==OSMESA_COLOR_INDEX) { - if (all) { - /* Clear whole CI buffer */ - MEMSET(osmesa->buffer, osmesa->clearpixel, - osmesa->rowlength * osmesa->height); - } - else { - /* Clear part of CI buffer */ - GLint i, j; - for (i=0;iclearpixel; - } - } - } - } - else if ((osmesa->format==OSMESA_RGB)||(osmesa->format==OSMESA_BGR)) { - GLubyte rval = UNPACK_RED(osmesa->clearpixel); - GLubyte gval = UNPACK_GREEN(osmesa->clearpixel); - GLubyte bval = UNPACK_BLUE(osmesa->clearpixel); - GLint rind = osmesa->rind; - GLint gind = osmesa->gind; - GLint bind = osmesa->bind; - if (all) { - GLuint i, n; - GLubyte *ptr3 = (GLubyte *) osmesa->buffer; - /* Clear whole RGB buffer */ - n = osmesa->rowlength * osmesa->height; - for (i=0;irowlength * osmesa->height; - ptr4 = (GLuint *) osmesa->buffer; - for (i=0;iclearpixel; - } - } - else { - /* Clear part of RGBA buffer */ - GLint i, j; - for (i=0;iclearpixel; - } - } - } +#endif + } + mask &= ~DD_FRONT_LEFT_BIT; } } - /* have Mesa clear all other buffers */ - return mask & (~DD_FRONT_LEFT_BIT); -} - - - -static void set_index( GLcontext *ctx, GLuint index ) -{ - OSMesaContext osmesa = (OSMesaContext) ctx; - osmesa->pixel = index; -} - - - -static void set_color( GLcontext *ctx, - GLubyte r, GLubyte g, GLubyte b, GLubyte a ) -{ - OSMesaContext osmesa = (OSMesaContext) ctx; - osmesa->pixel = PACK_RGBA( r, g, b, a ); + + if (mask) + _swrast_Clear( ctx, mask, all, x, y, width, height ); } static void buffer_size( GLcontext *ctx, GLuint *width, GLuint *height ) { - OSMesaContext osmesa = (OSMesaContext) ctx; + OSMesaContext osmesa = OSMESA_CONTEXT(ctx); *width = osmesa->width; *height = osmesa->height; } @@ -701,46 +817,42 @@ static void buffer_size( GLcontext *ctx, GLuint *width, GLuint *height ) /**********************************************************************/ /* Write RGBA pixels to an RGBA (or permuted) buffer. */ -static void write_rgba_span( const GLcontext *ctx, - GLuint n, GLint x, GLint y, - CONST GLubyte rgba[][4], const GLubyte mask[] ) +static void +write_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y, + CONST GLchan rgba[][4], const GLubyte mask[] ) { - OSMesaContext osmesa = (OSMesaContext) ctx; - GLuint *ptr4 = PIXELADDR4( x, y ); + const OSMesaContext osmesa = OSMESA_CONTEXT(ctx); + GLchan *p = PIXELADDR4(x, y); GLuint i; - GLint rshift = osmesa->rshift; - GLint gshift = osmesa->gshift; - GLint bshift = osmesa->bshift; - GLint ashift = osmesa->ashift; - osmesa->bVisible = GL_TRUE; /* if here, the occlusion test is misused */ if (mask) { - for (i=0;ibVisible = GL_TRUE; /* if here, the occlusion test is misused */ + ASSERT(CHAN_TYPE == GL_UNSIGNED_BYTE); if (mask) { - for (i=0;irshift; - GLint gshift = osmesa->gshift; - GLint bshift = osmesa->bshift; - GLint ashift = osmesa->ashift; - osmesa->bVisible = GL_TRUE; /* if here, the occlusion test is misused */ if (mask) { - for (i=0;ibVisible = GL_TRUE; /* if here, the occlusion test is misused */ - for (i=0;ipixel; + PACK_RGBA(p, color[RCOMP], color[GCOMP], color[BCOMP], color[ACOMP]); } } } -static void write_rgba_pixels( const GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - CONST GLubyte rgba[][4], const GLubyte mask[] ) +static void +write_rgba_pixels( const GLcontext *ctx, GLuint n, + const GLint x[], const GLint y[], + CONST GLchan rgba[][4], const GLubyte mask[] ) { - OSMesaContext osmesa = (OSMesaContext) ctx; + const OSMesaContext osmesa = OSMESA_CONTEXT(ctx); GLuint i; - GLint rshift = osmesa->rshift; - GLint gshift = osmesa->gshift; - GLint bshift = osmesa->bshift; - GLint ashift = osmesa->ashift; - osmesa->bVisible = GL_TRUE; /* if here, the occlusion test is misused */ - for (i=0;ibVisible = GL_TRUE; /* if here, the occlusion test is misused */ - for (i=0;ipixel; + GLchan *p = PIXELADDR4(x[i], y[i]); + PACK_RGBA(p, color[RCOMP], color[GCOMP], color[BCOMP], color[ACOMP]); } } } -static void read_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y, - GLubyte rgba[][4] ) +static void +read_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y, + GLchan rgba[][4] ) { - OSMesaContext osmesa = (OSMesaContext) ctx; + const OSMesaContext osmesa = OSMESA_CONTEXT(ctx); GLuint i; - GLuint *ptr4 = PIXELADDR4(x,y); - for (i=0;irind; - GLint gind = osmesa->gind; - GLint bind = osmesa->bind; - osmesa->bVisible = GL_TRUE; /* if here, the occlusion test is misused */ if (mask) { - for (i=0;irind; - GLint gind = osmesa->gind; - GLint bind = osmesa->bind; - osmesa->bVisible = GL_TRUE; /* if here, the occlusion test is misused */ if (mask) { - for (i=0;ipixel); - GLubyte gval = UNPACK_GREEN(osmesa->pixel); - GLubyte bval = UNPACK_BLUE(osmesa->pixel); - GLint rind = osmesa->rind; - GLint gind = osmesa->gind; - GLint bind = osmesa->bind; +static void +write_monocolor_span_BGR( const GLcontext *ctx, GLuint n, GLint x, GLint y, + const GLchan color[4], const GLubyte mask[] ) +{ + const OSMesaContext osmesa = OSMESA_CONTEXT(ctx); + GLchan *p = PIXELADDR3(x, y); + GLuint i; + for (i = 0; i < n; i++, p += 3) { + if (mask[i]) { + PACK_BGR(p, color[RCOMP], color[GCOMP], color[BCOMP]); + } + } +} +static void +write_rgba_pixels_RGB( const GLcontext *ctx, GLuint n, + const GLint x[], const GLint y[], + CONST GLchan rgba[][4], const GLubyte mask[] ) +{ + const OSMesaContext osmesa = (const OSMesaContext) ctx; + GLuint i; + for (i = 0; i < n; i++) { + if (mask[i]) { + GLchan *p = PIXELADDR3(x[i], y[i]); + PACK_RGB(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]); + } + } +} - GLubyte *ptr3 = PIXELADDR3( x, y); +static void +write_rgba_pixels_BGR( const GLcontext *ctx, GLuint n, + const GLint x[], const GLint y[], + CONST GLchan rgba[][4], const GLubyte mask[] ) +{ + const OSMesaContext osmesa = (const OSMesaContext) ctx; GLuint i; - osmesa->bVisible = GL_TRUE; /* if here, the occlusion test is misused */ - for (i=0;irind; - GLint gind = osmesa->gind; - GLint bind = osmesa->bind; - osmesa->bVisible = GL_TRUE; /* if here, the occlusion test is misused */ - for (i=0;irind; - GLint gind = osmesa->gind; - GLint bind = osmesa->bind; - GLubyte rval = UNPACK_RED(osmesa->pixel); - GLubyte gval = UNPACK_GREEN(osmesa->pixel); - GLubyte bval = UNPACK_BLUE(osmesa->pixel); - osmesa->bVisible = GL_TRUE; /* if here, the occlusion test is misused */ - for (i=0;irind; - GLint gind = osmesa->gind; - GLint bind = osmesa->bind; - GLubyte *ptr3 = PIXELADDR3( x, y); - for (i=0;irind; - GLint gind = osmesa->gind; - GLint bind = osmesa->bind; - for (i=0;ibVisible = GL_TRUE; /* if here, the occlusion test is misused */ if (mask) { for (i=0;ibVisible = GL_TRUE; /* if here, the occlusion test is misused */ if (mask) { for (i=0;ibVisible = GL_TRUE; /* if here, the occlusion test is misused */ for (i=0;ipixel; + *ptr1 = (GLchan) colorIndex; } } } -static void write_index_pixels( const GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - const GLuint index[], const GLubyte mask[] ) +static void +write_index_pixels( const GLcontext *ctx, + GLuint n, const GLint x[], const GLint y[], + const GLuint index[], const GLubyte mask[] ) { - OSMesaContext osmesa = (OSMesaContext) ctx; + const OSMesaContext osmesa = OSMESA_CONTEXT(ctx); GLuint i; - osmesa->bVisible = GL_TRUE; /* if here, the occlusion test is misused */ for (i=0;ibVisible = GL_TRUE; /* if here, the occlusion test is misused */ for (i=0;ipixel; + GLchan *ptr1 = PIXELADDR1(x[i], y[i]); + *ptr1 = (GLchan) colorIndex; } } } -static void read_index_span( const GLcontext *ctx, - GLuint n, GLint x, GLint y, GLuint index[] ) +static void +read_index_span( const GLcontext *ctx, + GLuint n, GLint x, GLint y, GLuint index[] ) { - OSMesaContext osmesa = (OSMesaContext) ctx; + const OSMesaContext osmesa = OSMESA_CONTEXT(ctx); GLuint i; - GLubyte *ptr1 = PIXELADDR1(x,y); + const GLchan *ptr1 = (const GLchan *) PIXELADDR1(x, y); for (i=0;iVB->ColorPtr->data[pvert]; - unsigned long pixel = PACK_RGBA( color[0], color[1], color[2], color[3] ); - osmesa->bVisible = GL_TRUE; /* if here, the occlusion test is misused */ + const OSMesaContext osmesa = OSMESA_CONTEXT(ctx); + const GLchan *color = vert0->color; #define INTERP_XY 1 #define CLIP_HACK 1 -#define PLOT(X,Y) { GLuint *ptr4 = PIXELADDR4(X,Y); *ptr4 = pixel; } +#define PLOT(X, Y) \ +do { \ + GLchan *p = PIXELADDR4(X, Y); \ + PACK_RGBA(p, color[0], color[1], color[2], color[3]); \ +} while (0) #ifdef WIN32 -#include "..\linetemp.h" +#include "..\swrast\s_linetemp.h" #else -#include "linetemp.h" +#include "swrast/s_linetemp.h" #endif } @@ -1210,144 +1356,149 @@ static void flat_rgba_line( GLcontext *ctx, /* * Draw a flat-shaded, Z-less, RGB line into an osmesa buffer. */ -static void flat_rgba_z_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) +static void +flat_rgba_z_line(GLcontext *ctx, const SWvertex *vert0, const SWvertex *vert1) { - OSMesaContext osmesa = (OSMesaContext) ctx; - GLubyte *color = ctx->VB->ColorPtr->data[pvert]; - unsigned long pixel = PACK_RGBA( color[0], color[1], color[2], color[3] ); - osmesa->bVisible = GL_TRUE; /* if here, the occlusion test is misused */ + const OSMesaContext osmesa = OSMESA_CONTEXT(ctx); + const GLchan *color = vert0->color; #define INTERP_XY 1 #define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE #define CLIP_HACK 1 -#define PLOT(X,Y) \ - if (Z < *zPtr) { \ - GLuint *ptr4 = PIXELADDR4(X,Y); \ - *ptr4 = pixel; \ - *zPtr = Z; \ - } +#define PLOT(X, Y) \ +do { \ + if (Z < *zPtr) { \ + GLchan *p = PIXELADDR4(X, Y); \ + PACK_RGBA(p, color[RCOMP], color[GCOMP], \ + color[BCOMP], color[ACOMP]); \ + *zPtr = Z; \ + } \ +} while (0) + #ifdef WIN32 -#include "..\linetemp.h" +#include "..\swrast\s_linetemp.h" #else -#include "linetemp.h" +#include "swrast/s_linetemp.h" #endif } /* * Draw a flat-shaded, alpha-blended, RGB line into an osmesa buffer. + * XXX update for GLchan */ -static void flat_blend_rgba_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) -{ - OSMesaContext osmesa = (OSMesaContext) ctx; - struct vertex_buffer *VB = ctx->VB; - GLint rshift = osmesa->rshift; - GLint gshift = osmesa->gshift; - GLint bshift = osmesa->bshift; - GLint avalue = VB->ColorPtr->data[pvert][3]; - GLint msavalue = 255 - avalue; - GLint rvalue = VB->ColorPtr->data[pvert][0]*avalue; - GLint gvalue = VB->ColorPtr->data[pvert][1]*avalue; - GLint bvalue = VB->ColorPtr->data[pvert][2]*avalue; - osmesa->bVisible = GL_TRUE; /* if here, the occlusion test is misused */ +static void +flat_blend_rgba_line( GLcontext *ctx, + const SWvertex *vert0, const SWvertex *vert1 ) +{ + const OSMesaContext osmesa = OSMESA_CONTEXT(ctx); + const GLint rshift = osmesa->rshift; + const GLint gshift = osmesa->gshift; + const GLint bshift = osmesa->bshift; + const GLint avalue = vert0->color[3]; + const GLint msavalue = 255 - avalue; + const GLint rvalue = vert0->color[0]*avalue; + const GLint gvalue = vert0->color[1]*avalue; + const GLint bvalue = vert0->color[2]*avalue; #define INTERP_XY 1 #define CLIP_HACK 1 #define PLOT(X,Y) \ - { GLuint *ptr4 = PIXELADDR4(X,Y); \ - GLuint pixel = 0; \ + { GLuint *ptr4 = (GLuint *) PIXELADDR4(X, Y); \ + GLuint pixel = 0; \ pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift);\ pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift);\ pixel |=((((((*ptr4) >> bshift) & 0xff)*msavalue+bvalue)>>8) << bshift);\ - *ptr4 = pixel; \ + *ptr4 = pixel; \ } #ifdef WIN32 -#include "..\linetemp.h" +#include "..\swrast\s_linetemp.h" #else -#include "linetemp.h" +#include "swrast/s_linetemp.h" #endif } + /* * Draw a flat-shaded, Z-less, alpha-blended, RGB line into an osmesa buffer. + * XXX update for GLchan */ -static void flat_blend_rgba_z_line( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) -{ - OSMesaContext osmesa = (OSMesaContext) ctx; - struct vertex_buffer *VB = ctx->VB; - GLint rshift = osmesa->rshift; - GLint gshift = osmesa->gshift; - GLint bshift = osmesa->bshift; - GLint avalue = VB->ColorPtr->data[pvert][3]; - GLint msavalue = 256 - avalue; - GLint rvalue = VB->ColorPtr->data[pvert][0]*avalue; - GLint gvalue = VB->ColorPtr->data[pvert][1]*avalue; - GLint bvalue = VB->ColorPtr->data[pvert][2]*avalue; - osmesa->bVisible = GL_TRUE; /* if here, the occlusion test is misused */ +static void +flat_blend_rgba_z_line( GLcontext *ctx, + const SWvertex *vert0, const SWvertex *vert1 ) +{ + const OSMesaContext osmesa = OSMESA_CONTEXT(ctx); + const GLint rshift = osmesa->rshift; + const GLint gshift = osmesa->gshift; + const GLint bshift = osmesa->bshift; + const GLint avalue = vert0->color[3]; + const GLint msavalue = 256 - avalue; + const GLint rvalue = vert0->color[0]*avalue; + const GLint gvalue = vert0->color[1]*avalue; + const GLint bvalue = vert0->color[2]*avalue; #define INTERP_XY 1 #define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE #define CLIP_HACK 1 -#define PLOT(X,Y) \ - if (Z < *zPtr) { \ - { GLuint *ptr4 = PIXELADDR4(X,Y); \ - GLuint pixel = 0; \ - pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift);\ - pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift);\ - pixel |=((((((*ptr4) >> bshift) & 0xff)*msavalue+bvalue)>>8) << bshift);\ - *ptr4 = pixel; \ - } \ +#define PLOT(X,Y) \ + if (Z < *zPtr) { \ + GLuint *ptr4 = (GLuint *) PIXELADDR4(X, Y); \ + GLuint pixel = 0; \ + pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift); \ + pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift); \ + pixel |=((((((*ptr4) >> bshift) & 0xff)*msavalue+bvalue)>>8) << bshift); \ + *ptr4 = pixel; \ } #ifdef WIN32 -#include "..\linetemp.h" +#include "..\swrast\s_linetemp.h" #else -#include "linetemp.h" +#include "swrast/s_linetemp.h" #endif } + /* * Draw a flat-shaded, Z-less, alpha-blended, RGB line into an osmesa buffer. + * XXX update for GLchan */ -static void flat_blend_rgba_z_line_write( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) -{ - OSMesaContext osmesa = (OSMesaContext) ctx; - struct vertex_buffer *VB = ctx->VB; - GLint rshift = osmesa->rshift; - GLint gshift = osmesa->gshift; - GLint bshift = osmesa->bshift; - GLint avalue = VB->ColorPtr->data[pvert][3]; - GLint msavalue = 256 - avalue; - GLint rvalue = VB->ColorPtr->data[pvert][0]*avalue; - GLint gvalue = VB->ColorPtr->data[pvert][1]*avalue; - GLint bvalue = VB->ColorPtr->data[pvert][2]*avalue; - osmesa->bVisible = GL_TRUE; /* if here, the occlusion test is misused */ +static void +flat_blend_rgba_z_line_write( GLcontext *ctx, + const SWvertex *vert0, const SWvertex *vert1 ) +{ + const OSMesaContext osmesa = OSMESA_CONTEXT(ctx); + const GLint rshift = osmesa->rshift; + const GLint gshift = osmesa->gshift; + const GLint bshift = osmesa->bshift; + const GLint avalue = vert0->color[3]; + const GLint msavalue = 256 - avalue; + const GLint rvalue = vert0->color[0]*avalue; + const GLint gvalue = vert0->color[1]*avalue; + const GLint bvalue = vert0->color[2]*avalue; #define INTERP_XY 1 #define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE #define CLIP_HACK 1 -#define PLOT(X,Y) \ - if (Z < *zPtr) { \ - { GLuint *ptr4 = PIXELADDR4(X,Y); \ - GLuint pixel = 0; \ - pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift);\ - pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift);\ - pixel |=((((((*ptr4) >> bshift) & 0xff)*msavalue+bvalue)>>8) << bshift);\ - *ptr4 = pixel; \ - } \ - *zPtr = Z; \ +#define PLOT(X,Y) \ + if (Z < *zPtr) { \ + GLuint *ptr4 = (GLuint *) PIXELADDR4(X, Y); \ + GLuint pixel = 0; \ + pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift); \ + pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift); \ + pixel |=((((((*ptr4) >> bshift) & 0xff)*msavalue+bvalue)>>8) << bshift); \ + *ptr4 = pixel; \ + *zPtr = Z; \ } #ifdef WIN32 -#include "..\linetemp.h" +#include "..\swrast\s_linetemp.h" #else -#include "linetemp.h" +#include "swrast/s_linetemp.h" #endif } @@ -1356,94 +1507,68 @@ static void flat_blend_rgba_z_line_write( GLcontext *ctx, * Analyze context state to see if we can provide a fast line drawing * function, like those in lines.c. Otherwise, return NULL. */ -static line_func choose_line_function( GLcontext *ctx ) +static swrast_line_func +osmesa_choose_line_function( GLcontext *ctx ) { - OSMesaContext osmesa = (OSMesaContext) ctx; + const OSMesaContext osmesa = OSMESA_CONTEXT(ctx); + const SWcontext *swrast = SWRAST_CONTEXT(ctx); + if (CHAN_BITS != 8) return NULL; + if (ctx->RenderMode != GL_RENDER) return NULL; if (ctx->Line.SmoothFlag) return NULL; - if (ctx->Texture.Enabled) return NULL; - if (ctx->Light.ShadeModel!=GL_FLAT) return NULL; - - if (ctx->Line.Width==1.0F - && ctx->Line.StippleFlag==GL_FALSE) { - - if (ctx->RasterMask==DEPTH_BIT - && ctx->Depth.Func==GL_LESS - && ctx->Depth.Mask==GL_TRUE) { - switch(osmesa->format) { - case OSMESA_RGBA: - case OSMESA_BGRA: - case OSMESA_ARGB: - return flat_rgba_z_line; - default: - return NULL; - } - } - - if (ctx->RasterMask==0) { - switch(osmesa->format) { - case OSMESA_RGBA: - case OSMESA_BGRA: - case OSMESA_ARGB: - return flat_rgba_line; - default: - return NULL; - } - } - - if (ctx->RasterMask==(DEPTH_BIT|BLEND_BIT) - && ctx->Depth.Func==GL_LESS - && ctx->Depth.Mask==GL_TRUE - && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA - && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA - && ctx->Color.BlendSrcA==GL_SRC_ALPHA - && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA - && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) { - switch(osmesa->format) { - case OSMESA_RGBA: - case OSMESA_BGRA: - case OSMESA_ARGB: - return flat_blend_rgba_z_line_write; - default: - return NULL; - } - } - - if (ctx->RasterMask==(DEPTH_BIT|BLEND_BIT) - && ctx->Depth.Func==GL_LESS - && ctx->Depth.Mask==GL_FALSE - && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA - && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA - && ctx->Color.BlendSrcA==GL_SRC_ALPHA - && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA - && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) { - switch(osmesa->format) { - case OSMESA_RGBA: - case OSMESA_BGRA: - case OSMESA_ARGB: - return flat_blend_rgba_z_line; - default: - return NULL; - } - } - - if (ctx->RasterMask==BLEND_BIT - && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA - && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA - && ctx->Color.BlendSrcA==GL_SRC_ALPHA - && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA - && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) { - switch(osmesa->format) { - case OSMESA_RGBA: - case OSMESA_BGRA: - case OSMESA_ARGB: - return flat_blend_rgba_line; - default: - return NULL; - } - } + if (ctx->Texture._ReallyEnabled) return NULL; + if (ctx->Light.ShadeModel != GL_FLAT) return NULL; + if (ctx->Line.Width != 1.0F) return NULL; + if (ctx->Line.StippleFlag) return NULL; + if (ctx->Line.SmoothFlag) return NULL; + if (osmesa->format != OSMESA_RGBA && + osmesa->format != OSMESA_BGRA && + osmesa->format != OSMESA_ARGB) return NULL; + if (swrast->_RasterMask==DEPTH_BIT + && ctx->Depth.Func==GL_LESS + && ctx->Depth.Mask==GL_TRUE + && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS) { + return flat_rgba_z_line; } + + if (swrast->_RasterMask == 0) { + return flat_rgba_line; + } + + if (swrast->_RasterMask==(DEPTH_BIT|BLEND_BIT) + && ctx->Depth.Func==GL_LESS + && ctx->Depth.Mask==GL_TRUE + && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS + && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA + && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA + && ctx->Color.BlendSrcA==GL_SRC_ALPHA + && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA + && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) { + return flat_blend_rgba_z_line_write; + } + + if (swrast->_RasterMask==(DEPTH_BIT|BLEND_BIT) + && ctx->Depth.Func==GL_LESS + && ctx->Depth.Mask==GL_FALSE + && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS + && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA + && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA + && ctx->Color.BlendSrcA==GL_SRC_ALPHA + && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA + && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) { + return flat_blend_rgba_z_line; + } + + if (swrast->_RasterMask==BLEND_BIT + && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA + && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA + && ctx->Color.BlendSrcA==GL_SRC_ALPHA + && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA + && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) { + return flat_blend_rgba_line; + } + return NULL; } @@ -1456,28 +1581,26 @@ static line_func choose_line_function( GLcontext *ctx ) /* * Smooth-shaded, z-less triangle, RGBA color. */ -static void smooth_rgba_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1, - GLuint v2, GLuint pv ) +static void smooth_rgba_z_triangle( GLcontext *ctx, + const SWvertex *v0, + const SWvertex *v1, + const SWvertex *v2 ) { - OSMesaContext osmesa = (OSMesaContext) ctx; - GLint rshift = osmesa->rshift; - GLint gshift = osmesa->gshift; - GLint bshift = osmesa->bshift; - GLint ashift = osmesa->ashift; - (void) pv; - osmesa->bVisible = GL_TRUE; /* if here, the occlusion test is misused */ + const OSMesaContext osmesa = OSMESA_CONTEXT(ctx); + #define INTERP_Z 1 +#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE #define INTERP_RGB 1 #define INTERP_ALPHA 1 #define INNER_LOOP( LEFT, RIGHT, Y ) \ { \ GLint i, len = RIGHT-LEFT; \ - GLuint *img = PIXELADDR4(LEFT,Y); \ - for (i=0;iColorPtr->data[pv][0]; \ - GLubyte g = VB->ColorPtr->data[pv][1]; \ - GLubyte b = VB->ColorPtr->data[pv][2]; \ - GLubyte a = VB->ColorPtr->data[pv][3]; \ - GLuint pixel = PACK_RGBA(r,g,b,a); - -#define INNER_LOOP( LEFT, RIGHT, Y ) \ -{ \ - GLint i, len = RIGHT-LEFT; \ - GLuint *img = PIXELADDR4(LEFT,Y); \ - for (i=0;icolor[0], v0->color[1], \ + v0->color[2], v0->color[3]); + +#define INNER_LOOP( LEFT, RIGHT, Y ) \ +{ \ + GLint i, len = RIGHT-LEFT; \ + GLuint *img = (GLuint *) PIXELADDR4(LEFT, Y); \ + for (i=0;iformat==OSMESA_RGB)||(osmesa->format==OSMESA_BGR)) return NULL; - - if (ctx->Polygon.SmoothFlag) return NULL; - if (ctx->Polygon.StippleFlag) return NULL; - if (ctx->Texture.Enabled) return NULL; - - if (ctx->RasterMask==DEPTH_BIT - && ctx->Depth.Func==GL_LESS - && ctx->Depth.Mask==GL_TRUE - && osmesa->format!=OSMESA_COLOR_INDEX) { - if (ctx->Light.ShadeModel==GL_SMOOTH) { +static swrast_tri_func +osmesa_choose_triangle_function( GLcontext *ctx ) +{ + const OSMesaContext osmesa = OSMESA_CONTEXT(ctx); + const SWcontext *swrast = SWRAST_CONTEXT(ctx); + + if (CHAN_BITS != 8) return (swrast_tri_func) NULL; + if (ctx->RenderMode != GL_RENDER) return (swrast_tri_func) NULL; + if (ctx->Polygon.SmoothFlag) return (swrast_tri_func) NULL; + if (ctx->Polygon.StippleFlag) return (swrast_tri_func) NULL; + if (ctx->Texture._ReallyEnabled) return (swrast_tri_func) NULL; + if (osmesa->format != OSMESA_RGBA && + osmesa->format != OSMESA_BGRA && + osmesa->format != OSMESA_ARGB) return (swrast_tri_func) NULL; + + if (swrast->_RasterMask == DEPTH_BIT && + ctx->Depth.Func == GL_LESS && + ctx->Depth.Mask == GL_TRUE && + ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS) { + if (ctx->Light.ShadeModel == GL_SMOOTH) { return smooth_rgba_z_triangle; } else { return flat_rgba_z_triangle; } } - return NULL; + return (swrast_tri_func) NULL; } -/**********************************************************************/ -/***** Occlusion rendering routines *****/ -/**********************************************************************/ -#define OCC_STD_MASK_TEST \ - OSMesaContext osmesa = (OSMesaContext) ctx->DriverCtx; \ - if (osmesa->bVisible) return; \ - if (mask) { \ - GLuint i; \ - for (i=0;ibVisible = GL_TRUE; \ - return; \ - } \ - } else { \ - osmesa->bVisible = GL_TRUE; \ - } \ - return; - -/***** Color Index *****/ -static void write_index32_span_occ( const GLcontext *ctx, - GLuint n, GLint x, GLint y, - const GLuint index[], const GLubyte mask[] ) -{ - OCC_STD_MASK_TEST -} -static void write_index8_span_occ( const GLcontext *ctx, - GLuint n, GLint x, GLint y, - const GLubyte index[], const GLubyte mask[] ) -{ - OCC_STD_MASK_TEST -} -static void write_monoindex_span_occ( const GLcontext *ctx, - GLuint n, GLint x, GLint y, - const GLubyte mask[] ) -{ - OCC_STD_MASK_TEST -} -static void write_index_pixels_occ( const GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - const GLuint index[], const GLubyte mask[] ) -{ - OCC_STD_MASK_TEST -} -static void write_monoindex_pixels_occ( const GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - const GLubyte mask[] ) -{ - OCC_STD_MASK_TEST -} -/***** RGB/RGBA *****/ -static void write_rgba_span_occ( const GLcontext *ctx, - GLuint n, GLint x, GLint y, - CONST GLubyte rgba[][4], const GLubyte mask[] ) -{ - OCC_STD_MASK_TEST -} -static void write_rgb_span_occ( const GLcontext *ctx, - GLuint n, GLint x, GLint y, - CONST GLubyte rgb[][3], - const GLubyte mask[] ) -{ - OCC_STD_MASK_TEST -} -static void write_rgba_pixels_occ( const GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - CONST GLubyte rgba[][4], const GLubyte mask[] ) -{ - OCC_STD_MASK_TEST -} -static void write_monocolor_span_occ( const GLcontext *ctx, - GLuint n, GLint x, GLint y, - const GLubyte mask[] ) -{ - OCC_STD_MASK_TEST -} -static void write_monocolor_pixels_occ( const GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - const GLubyte mask[] ) +/* Override for the swrast triangle-selection function. Try to use one + * of our internal triangle functions, otherwise fall back to the + * standard swrast functions. + */ +static void osmesa_choose_triangle( GLcontext *ctx ) { - OCC_STD_MASK_TEST + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + swrast->Triangle = osmesa_choose_triangle_function( ctx ); + if (!swrast->Triangle) + _swrast_choose_triangle( ctx ); } -/***** Line Drawing *****/ -static void line_occ( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) +static void osmesa_choose_line( GLcontext *ctx ) { - OSMesaContext osmesa = (OSMesaContext) ctx->DriverCtx; - osmesa->bVisible = GL_TRUE; + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + swrast->Line = osmesa_choose_line_function( ctx ); + if (!swrast->Line) + _swrast_choose_line( ctx ); } -static void line_z_occ( GLcontext *ctx, - GLuint vert0, GLuint vert1, GLuint pvert ) -{ - OSMesaContext osmesa = (OSMesaContext) ctx->DriverCtx; - if (osmesa->bVisible) return; -#define INTERP_XY 1 -#define INTERP_Z 1 -#define CLIP_HACK 1 -#define PLOT(X,Y) \ - if (Z < *zPtr) { \ - osmesa->bVisible = GL_TRUE; \ - return; \ - } +#define OSMESA_NEW_LINE (_NEW_LINE | \ + _NEW_TEXTURE | \ + _NEW_LIGHT | \ + _NEW_DEPTH | \ + _NEW_RENDERMODE | \ + _SWRAST_NEW_RASTERMASK) -#ifdef WIN32 -#include "..\linetemp.h" -#else -#include "linetemp.h" -#endif -} +#define OSMESA_NEW_TRIANGLE (_NEW_POLYGON | \ + _NEW_TEXTURE | \ + _NEW_LIGHT | \ + _NEW_DEPTH | \ + _NEW_RENDERMODE | \ + _SWRAST_NEW_RASTERMASK) -/***** Triangle Drawing *****/ -static void triangle_occ( GLcontext *ctx, GLuint v0, GLuint v1, - GLuint v2, GLuint pv ) -{ - OSMesaContext osmesa = (OSMesaContext) ctx->DriverCtx; - osmesa->bVisible = GL_TRUE; -} -static void triangle_z_occ( GLcontext *ctx, GLuint v0, GLuint v1, - GLuint v2, GLuint pv ) + +/* Extend the software rasterizer with our line and triangle + * functions. + */ +static void osmesa_register_swrast_functions( GLcontext *ctx ) { - OSMesaContext osmesa = (OSMesaContext) ctx->DriverCtx; - if (osmesa->bVisible) return; -#define INTERP_Z 1 -#define INNER_LOOP( LEFT, RIGHT, Y ) \ -{ \ - GLint i, len = RIGHT-LEFT; \ - for (i=0;ibVisible = GL_TRUE; \ - return; \ - } \ - ffz += fdzdx; \ - } \ -} -#ifdef WIN32 -#include "..\tritemp.h" -#else -#include "tritemp.h" -#endif + SWcontext *swrast = SWRAST_CONTEXT( ctx ); + + swrast->choose_line = osmesa_choose_line; + swrast->choose_triangle = osmesa_choose_triangle; + + swrast->invalidate_line |= OSMESA_NEW_LINE; + swrast->invalidate_triangle |= OSMESA_NEW_TRIANGLE; } + static const GLubyte *get_string( GLcontext *ctx, GLenum name ) { (void) ctx; @@ -1715,57 +1754,95 @@ static const GLubyte *get_string( GLcontext *ctx, GLenum name ) } -static void osmesa_update_state( GLcontext *ctx ) +static void osmesa_update_state( GLcontext *ctx, GLuint new_state ) { - OSMesaContext osmesa = (OSMesaContext) ctx; + OSMesaContext osmesa = OSMESA_CONTEXT(ctx); ASSERT((void *) osmesa == (void *) ctx->DriverCtx); + /* + * XXX these function pointers could be initialized just once during + * context creation since they don't depend on any state changes. + */ + ctx->Driver.GetString = get_string; ctx->Driver.UpdateState = osmesa_update_state; - ctx->Driver.SetDrawBuffer = set_draw_buffer; ctx->Driver.SetReadBuffer = set_read_buffer; - ctx->Driver.Color = set_color; - ctx->Driver.Index = set_index; - ctx->Driver.ClearIndex = clear_index; - ctx->Driver.ClearColor = clear_color; - ctx->Driver.Clear = clear; - + ctx->Driver.ResizeBuffersMESA = _swrast_alloc_buffers; ctx->Driver.GetBufferSize = buffer_size; - ctx->Driver.PointsFunc = NULL; - ctx->Driver.LineFunc = choose_line_function( ctx ); - ctx->Driver.TriangleFunc = choose_triangle_function( ctx ); + ctx->Driver.RenderStart = _swsetup_RenderStart; + ctx->Driver.RenderFinish = _swsetup_RenderFinish; + ctx->Driver.BuildProjectedVertices = _swsetup_BuildProjectedVertices; + ctx->Driver.RenderPrimitive = _swsetup_RenderPrimitive; + ctx->Driver.PointsFunc = _swsetup_Points; + ctx->Driver.LineFunc = _swsetup_Line; + ctx->Driver.TriangleFunc = _swsetup_Triangle; + ctx->Driver.QuadFunc = _swsetup_Quad; + ctx->Driver.ResetLineStipple = _swrast_ResetLineStipple; + ctx->Driver.RenderInterp = _swsetup_RenderInterp; + ctx->Driver.RenderCopyPV = _swsetup_RenderCopyPV; + ctx->Driver.RenderClippedLine = _swsetup_RenderClippedLine; + ctx->Driver.RenderClippedPolygon = _swsetup_RenderClippedPolygon; + + ctx->Driver.Accum = _swrast_Accum; + ctx->Driver.Bitmap = _swrast_Bitmap; + ctx->Driver.Clear = clear; + ctx->Driver.CopyPixels = _swrast_CopyPixels; + ctx->Driver.DrawPixels = _swrast_DrawPixels; + ctx->Driver.ReadPixels = _swrast_ReadPixels; + + ctx->Driver.TexImage1D = _mesa_store_teximage1d; + ctx->Driver.TexImage2D = _mesa_store_teximage2d; + ctx->Driver.TexImage3D = _mesa_store_teximage3d; + ctx->Driver.TexSubImage1D = _mesa_store_texsubimage1d; + ctx->Driver.TexSubImage2D = _mesa_store_texsubimage2d; + ctx->Driver.TexSubImage3D = _mesa_store_texsubimage3d; + ctx->Driver.CopyTexImage1D = _mesa_copy_teximage1d; + ctx->Driver.CopyTexImage2D = _mesa_copy_teximage2d; + ctx->Driver.CopyTexSubImage1D = _mesa_copy_texsubimage1d; + ctx->Driver.CopyTexSubImage2D = _mesa_copy_texsubimage2d; + ctx->Driver.CopyTexSubImage3D = _mesa_copy_texsubimage3d; + ctx->Driver.TestProxyTexImage = _mesa_test_proxy_teximage; /* RGB(A) span/pixel functions */ - if ((osmesa->format==OSMESA_RGB) || (osmesa->format==OSMESA_BGR)) { - /* 3 bytes / pixel in frame buffer */ - ctx->Driver.WriteRGBASpan = write_rgba_span3; - ctx->Driver.WriteRGBSpan = write_rgb_span3; - ctx->Driver.WriteRGBAPixels = write_rgba_pixels3; - ctx->Driver.WriteMonoRGBASpan = write_monocolor_span3; - ctx->Driver.WriteMonoRGBAPixels = write_monocolor_pixels3; + if (osmesa->format == OSMESA_RGB) { + ctx->Driver.WriteRGBASpan = write_rgba_span_RGB; + ctx->Driver.WriteRGBSpan = write_rgb_span_RGB; + ctx->Driver.WriteMonoRGBASpan = write_monocolor_span_RGB; + ctx->Driver.WriteRGBAPixels = write_rgba_pixels_RGB; + ctx->Driver.WriteMonoRGBAPixels = write_monocolor_pixels_RGB; + ctx->Driver.ReadRGBASpan = read_rgba_span3; + ctx->Driver.ReadRGBAPixels = read_rgba_pixels3; + } + else if (osmesa->format == OSMESA_BGR) { + ctx->Driver.WriteRGBASpan = write_rgba_span_BGR; + ctx->Driver.WriteRGBSpan = write_rgb_span_BGR; + ctx->Driver.WriteMonoRGBASpan = write_monocolor_span_BGR; + ctx->Driver.WriteRGBAPixels = write_rgba_pixels_BGR; + ctx->Driver.WriteMonoRGBAPixels = write_monocolor_pixels_BGR; ctx->Driver.ReadRGBASpan = read_rgba_span3; ctx->Driver.ReadRGBAPixels = read_rgba_pixels3; } else { /* 4 bytes / pixel in frame buffer */ - if (osmesa->format==OSMESA_RGBA - && RCOMP==0 && GCOMP==1 && BCOMP==2 && ACOMP==3) - ctx->Driver.WriteRGBASpan = write_rgba_span_rgba; - else - ctx->Driver.WriteRGBASpan = write_rgba_span; ctx->Driver.WriteRGBSpan = write_rgb_span; ctx->Driver.WriteRGBAPixels = write_rgba_pixels; ctx->Driver.WriteMonoRGBASpan = write_monocolor_span; ctx->Driver.WriteMonoRGBAPixels = write_monocolor_pixels; - if (osmesa->format==OSMESA_RGBA - && RCOMP==0 && GCOMP==1 && BCOMP==2 && ACOMP==3) + if (osmesa->format == OSMESA_RGBA && + CHAN_TYPE == GL_UNSIGNED_BYTE && + RCOMP==0 && GCOMP==1 && BCOMP==2 && ACOMP==3) { + /* special, fast case */ + ctx->Driver.WriteRGBASpan = write_rgba_span_rgba; ctx->Driver.ReadRGBASpan = read_rgba_span_rgba; - else + } + else { + ctx->Driver.WriteRGBASpan = write_rgba_span; ctx->Driver.ReadRGBASpan = read_rgba_span; + } ctx->Driver.ReadRGBAPixels = read_rgba_pixels; } @@ -1778,41 +1855,8 @@ static void osmesa_update_state( GLcontext *ctx ) ctx->Driver.ReadCI32Span = read_index_span; ctx->Driver.ReadCI32Pixels = read_index_pixels; - /* Occlusion test cases: - * If no buffers have been selected for writing, - * we swap in occlusion routines that: - * (1) check the current flag and return if set - * (2) set the flag if any pixel would be updated - * Note: all the other buffer writing routines will - * always set the visible flag so in cases of "improper" - * extension use will just cause unnecessary rasterization - * to occur. The image will be correct in any case. - */ - if ((ctx->Color.IndexMask == 0) && - (ctx->Color.ColorMask[0] == 0) && - (ctx->Color.ColorMask[1] == 0) && - (ctx->Color.ColorMask[2] == 0) && - (ctx->Color.ColorMask[3] == 0) && - (ctx->Stencil.Enabled == GL_FALSE)) { - - ctx->Driver.WriteCI32Span = write_index32_span_occ; - ctx->Driver.WriteCI8Span = write_index8_span_occ; - ctx->Driver.WriteMonoCISpan = write_monoindex_span_occ; - ctx->Driver.WriteCI32Pixels = write_index_pixels_occ; - ctx->Driver.WriteMonoCIPixels = write_monoindex_pixels_occ; - - ctx->Driver.WriteRGBASpan = write_rgba_span_occ; - ctx->Driver.WriteRGBSpan = write_rgb_span_occ; - ctx->Driver.WriteRGBAPixels = write_rgba_pixels_occ; - ctx->Driver.WriteMonoRGBASpan = write_monocolor_span_occ; - ctx->Driver.WriteMonoRGBAPixels = write_monocolor_pixels_occ; - - if (ctx->RasterMask & DEPTH_BIT) { - ctx->Driver.LineFunc = line_z_occ; - ctx->Driver.TriangleFunc = triangle_z_occ; - } else { - ctx->Driver.LineFunc = line_occ; - ctx->Driver.TriangleFunc = triangle_occ; - } - } + _swrast_InvalidateState( ctx, new_state ); + _swsetup_InvalidateState( ctx, new_state ); + _ac_InvalidateState( ctx, new_state ); + _tnl_InvalidateState( ctx, new_state ); }