X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fdrivers%2Fosmesa%2Fosmesa.c;h=c1549fdaeedbf5cfdd95e2d4777b9b3d3631d28e;hb=f431a3fb4dc1bf860203d79e54657e3a62bc50df;hp=7f79a1f272eadf8d21e40ae7d47287c46dc1b2fd;hpb=2bf5d9470d3232763cb49b5589209940d4d5398d;p=mesa.git diff --git a/src/mesa/drivers/osmesa/osmesa.c b/src/mesa/drivers/osmesa/osmesa.c index 7f79a1f272e..c1549fdaeed 100644 --- a/src/mesa/drivers/osmesa/osmesa.c +++ b/src/mesa/drivers/osmesa/osmesa.c @@ -1,21 +1,21 @@ -/* $Id: osmesa.c,v 1.20 2000/09/08 16:41:39 brianp Exp $ */ +/* $Id: osmesa.c,v 1.62 2001/07/13 20:07:37 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,36 @@ * * 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 "glheader.h" #include "GL/osmesa.h" #include "context.h" +#include "colormac.h" #include "depth.h" -#include "mem.h" -#include "matrix.h" -#include "types.h" -#include "vb.h" #include "extensions.h" -#endif +#include "macros.h" +#include "matrix.h" +#include "mem.h" +#include "mmath.h" +#include "mtypes.h" +#include "texformat.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 "swrast/s_trispan.h" +#include "tnl/tnl.h" +#include "tnl/t_context.h" +#include "tnl/t_pipeline.h" + /* @@ -64,14 +76,12 @@ 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 */ }; @@ -79,7 +89,12 @@ struct osmesa_context { /* 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)) @@ -117,16 +132,16 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits, { OSMesaContext osmesa; GLint rshift, gshift, bshift, ashift; - GLint rind, gind, bind; - GLint indexBits, redBits, greenBits, blueBits, alphaBits; + GLint rind, gind, bind, aind; + GLint indexBits = 0, redBits = 0, greenBits = 0, blueBits = 0, alphaBits =0; 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; @@ -134,10 +149,14 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits, } else if (format==OSMESA_RGBA) { indexBits = 0; - redBits = 8; - greenBits = 8; - blueBits = 8; - 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; @@ -154,10 +173,14 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits, } else if (format==OSMESA_BGRA) { indexBits = 0; - redBits = 8; - greenBits = 8; - blueBits = 8; - 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; @@ -174,10 +197,14 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits, } else if (format==OSMESA_ARGB) { indexBits = 0; - redBits = 8; - greenBits = 8; - blueBits = 8; - 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; @@ -194,36 +221,52 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits, } else if (format==OSMESA_RGB) { indexBits = 0; - redBits = 8; - greenBits = 8; - blueBits = 8; + 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 = 8; - greenBits = 8; - blueBits = 8; + 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; } + else if (format==OSMESA_RGB_565) { + indexBits = 0; + redBits = 5; + greenBits = 6; + blueBits = 5; + alphaBits = 0; + rshift = 11; + gshift = 5; + bshift = 0; + ashift = 0; + rind = 0; /* not used */ + gind = 0; + bind = 0; + rgbmode = GL_TRUE; + swalpha = GL_FALSE; + } else { return NULL; } @@ -261,19 +304,18 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits, FREE(osmesa); return NULL; } - gl_extensions_enable(&(osmesa->gl_ctx),"GL_HP_occlusion_test"); - gl_extensions_enable(&(osmesa->gl_ctx), "GL_ARB_texture_cube_map"); - gl_extensions_enable(&(osmesa->gl_ctx), "GL_EXT_texture_env_combine"); - osmesa->gl_buffer = gl_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 ); + _mesa_enable_sw_extensions(&(osmesa->gl_ctx)); + + osmesa->gl_buffer = _mesa_create_framebuffer( osmesa->gl_visual, + osmesa->gl_visual->depthBits > 0, + osmesa->gl_visual->stencilBits > 0, + osmesa->gl_visual->accumRedBits > 0, + swalpha ); 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; } @@ -281,8 +323,6 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits, 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; @@ -290,9 +330,25 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits, osmesa->gshift = gshift; osmesa->bshift = bshift; osmesa->ashift = ashift; - osmesa->rind = rind; - osmesa->gind = gind; - osmesa->bind = bind; + 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 ); + + _swsetup_Wakeup( ctx ); + osmesa_register_swrast_functions( ctx ); + } } return osmesa; } @@ -308,9 +364,14 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits, 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 ); + _swsetup_DestroyContext( &ctx->gl_ctx ); + _tnl_DestroyContext( &ctx->gl_ctx ); + _ac_DestroyContext( &ctx->gl_ctx ); + _swrast_DestroyContext( &ctx->gl_ctx ); + + _mesa_destroy_visual( ctx->gl_visual ); + _mesa_destroy_framebuffer( ctx->gl_buffer ); + _mesa_free_context_data( &ctx->gl_ctx ); FREE( ctx ); } } @@ -322,56 +383,39 @@ 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 if (ctx->format == OSMESA_RGB_565) { + /* 5/6/5 RGB pixel in 16 bits */ + bytesPerPixel = 2; + } + 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); } } } @@ -398,7 +442,7 @@ static void compute_row_addresses( OSMesaContext ctx ) * Input: ctx - the rendering context * buffer - the image buffer memory * type - data type for pixel components, only GL_UNSIGNED_BYTE - * supported now + * and GL_UNSIGNED_SHORT_5_6_5 supported now. * width, height - size of image buffer in pixels, at least 1 * Return: GL_TRUE if success, GL_FALSE if error because of invalid ctx, * invalid buffer address, type!=GL_UNSIGNED_BYTE, width<1, height<1, @@ -408,13 +452,22 @@ 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 || + 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 ); + if (ctx->format == OSMESA_RGB_565) { + if (type != GL_UNSIGNED_SHORT_5_6_5) + return GL_FALSE; + } + else if (type != CHAN_TYPE) { + return GL_FALSE; + } + + osmesa_update_state( &ctx->gl_ctx, 0 ); + _mesa_make_current( &ctx->gl_ctx, ctx->gl_buffer ); ctx->buffer = buffer; ctx->width = width; @@ -441,7 +494,7 @@ 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 @@ -457,7 +510,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; } @@ -468,7 +521,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; } @@ -491,7 +544,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; @@ -500,7 +553,7 @@ void GLAPIENTRY OSMesaGetIntegerv( GLint pname, GLint *value ) *value = ctx->yup; return; default: - gl_error(&ctx->gl_ctx, GL_INVALID_ENUM, "OSMesaGetIntergerv(pname)"); + _mesa_error(&ctx->gl_ctx, GL_INVALID_ENUM, "OSMesaGetIntergerv(pname)"); return; } } @@ -527,7 +580,10 @@ OSMesaGetDepthBuffer( OSMesaContext c, GLint *width, GLint *height, else { *width = c->gl_buffer->Width; *height = c->gl_buffer->Height; - *bytesPerValue = sizeof(GLdepth); + if (c->gl_visual->depthBits <= 16) + *bytesPerValue = sizeof(GLushort); + else + *bytesPerValue = sizeof(GLuint); *buffer = c->gl_buffer->DepthBuffer; return GL_TRUE; } @@ -569,25 +625,45 @@ OSMesaGetColorBuffer( OSMesaContext c, GLint *width, /* * 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 PACK_RGB_565(DST, R, G, B) \ +do { \ + (DST) = (((int) (R) << 8) & 0xf800) | (((int) (G) << 3) & 0x7e0) | ((int) (B) >> 3);\ +} while (0) -#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 PIXELADDR2(X,Y) (osmesa->rowaddr[Y] + 2 * (X)) +#define PIXELADDR3(X,Y) (osmesa->rowaddr[Y] + 3 * (X)) +#define PIXELADDR4(X,Y) (osmesa->rowaddr[Y] + 4 * (X)) @@ -611,140 +687,198 @@ static void set_read_buffer( GLcontext *ctx, GLframebuffer *buffer, GLenum mode } -static void clear_index( GLcontext *ctx, GLuint index ) -{ - 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 ) +static void 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 (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; - if (osmesa->clearpixel) { - for (i=0;iclearpixel; + 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 (osmesa->format == OSMESA_RGB_565) { + const GLchan r = ctx->Color.ClearColor[0]; + const GLchan g = ctx->Color.ClearColor[1]; + const GLchan b = ctx->Color.ClearColor[2]; + GLushort clearPixel; + PACK_RGB_565(clearPixel, r, g, b); + if (all) { + /* Clear whole RGB buffer */ + const GLint n = osmesa->rowlength * osmesa->height; + GLushort *ptr2 = (GLushort *) osmesa->buffer; + GLuint i; + for (i = 0; i < n; i++) { + *ptr2 = clearPixel; + ptr2++; } } else { - BZERO(ptr4, n * sizeof(GLuint)); - } - } - else { - /* Clear part of RGBA buffer */ - GLint i, j; - for (i=0;iclearpixel; + /* clear scissored region */ + GLint i, j; + for (i = 0; i < height; i++) { + GLushort *ptr2 = (GLushort *) PIXELADDR2(x, (y + i)); + for (j = 0; j < width; j++) { + *ptr2 = clearPixel; + ptr2++; + } } } } + 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; + } + } + } + +#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; } @@ -755,44 +889,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; if (mask) { - for (i=0;irshift; - GLint gshift = osmesa->gshift; - GLint bshift = osmesa->bshift; - GLint ashift = osmesa->ashift; if (mask) { - 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; - 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; if (mask) { - for (i=0;irind; - GLint gind = osmesa->gind; - GLint bind = osmesa->bind; 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; - GLubyte *ptr3 = PIXELADDR3( x, y); + const OSMesaContext osmesa = OSMESA_CONTEXT(ctx); + GLchan *p = PIXELADDR3(x, y); GLuint i; - for (i=0;irind; - GLint gind = osmesa->gind; - GLint bind = osmesa->bind; - 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); - for (i=0;irind; - GLint gind = osmesa->gind; - GLint bind = osmesa->bind; - const GLubyte *ptr3 = PIXELADDR3( x, y); - for (i=0;i> 8) & 0xFe; + rgba[i][GCOMP] = (*ptr2 >> 3) & 0xFc; + rgba[i][BCOMP] = (*ptr2 << 3) & 0xFe; rgba[i][ACOMP] = 0; } } -static void read_rgba_pixels3( const GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - GLubyte rgba[][4], const GLubyte mask[] ) +static void +read_rgba_pixels2( const GLcontext *ctx, + GLuint n, const GLint x[], const GLint y[], + GLchan rgba[][4], const GLubyte mask[] ) { - OSMesaContext osmesa = (OSMesaContext) ctx; + OSMesaContext osmesa = OSMESA_CONTEXT(ctx); GLuint i; - GLint rind = osmesa->rind; - GLint gind = osmesa->gind; - GLint bind = osmesa->bind; - for (i=0;i> 8) & 0xFE; + rgba[i][GCOMP] = (*ptr2 >> 3) & 0xFC; + rgba[i][BCOMP] = (*ptr2 << 3) & 0xFE; rgba[i][ACOMP] = 0; } } } + /**********************************************************************/ /***** Read/write spans/arrays of CI pixels *****/ /**********************************************************************/ /* Write 32-bit color index to buffer */ -static void write_index32_span( const GLcontext *ctx, - GLuint n, GLint x, GLint y, - const GLuint index[], const GLubyte mask[] ) +static void +write_index32_span( const GLcontext *ctx, GLuint n, GLint x, GLint y, + const GLuint index[], const GLubyte mask[] ) { - OSMesaContext osmesa = (OSMesaContext) ctx; - GLubyte *ptr1 = PIXELADDR1(x,y); + const OSMesaContext osmesa = OSMESA_CONTEXT(ctx); + GLchan *ptr1 = PIXELADDR1(x, y); GLuint i; if (mask) { 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; 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; - const 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] ); + 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 } @@ -1245,53 +1567,57 @@ 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] ); + 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 ) +static void +flat_blend_rgba_line( GLcontext *ctx, + const SWvertex *vert0, const SWvertex *vert1 ) { - 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; + 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 = CHAN_MAX - 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 *ptr4 = (GLuint *) PIXELADDR4(X, Y); \ GLuint pixel = 0; \ pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift);\ pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift);\ @@ -1300,29 +1626,30 @@ static void flat_blend_rgba_line( GLcontext *ctx, } #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 ) +static void +flat_blend_rgba_z_line( GLcontext *ctx, + const SWvertex *vert0, const SWvertex *vert1 ) { - 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; + 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 @@ -1330,7 +1657,7 @@ static void flat_blend_rgba_z_line( GLcontext *ctx, #define CLIP_HACK 1 #define PLOT(X,Y) \ if (Z < *zPtr) { \ - GLuint *ptr4 = PIXELADDR4(X,Y); \ + 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); \ @@ -1339,29 +1666,30 @@ static void flat_blend_rgba_z_line( GLcontext *ctx, } #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 ) +static void +flat_blend_rgba_z_line_write( GLcontext *ctx, + const SWvertex *vert0, const SWvertex *vert1 ) { - 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; + 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 @@ -1369,7 +1697,7 @@ static void flat_blend_rgba_z_line_write( GLcontext *ctx, #define CLIP_HACK 1 #define PLOT(X,Y) \ if (Z < *zPtr) { \ - GLuint *ptr4 = PIXELADDR4(X,Y); \ + 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); \ @@ -1379,9 +1707,9 @@ static void flat_blend_rgba_z_line_write( GLcontext *ctx, } #ifdef WIN32 -#include "..\linetemp.h" +#include "..\swrast\s_linetemp.h" #else -#include "linetemp.h" +#include "swrast/s_linetemp.h" #endif } @@ -1390,97 +1718,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 - && ctx->Visual->DepthBits == DEFAULT_SOFTWARE_DEPTH_BITS) { - 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->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) { - 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->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) { - 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; } @@ -1493,39 +1792,39 @@ 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; + 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 RENDER_SPAN( span ) \ + GLuint i; \ + GLuint *img = (GLuint *) PIXELADDR4(span.x, span.y); \ + for (i = 0; i < span.count; i++) { \ + const GLdepth z = FixedToDepth(span.z); \ + if (z < zRow[i]) { \ + img[i] = pixel; \ + zRow[i] = z; \ + } \ + span.z += span.zStep; \ + } + #ifdef WIN32 -#include "..\tritemp.h" +#include "..\swrast\s_tritemp.h" #else -#include "tritemp.h" +#include "swrast/s_tritemp.h" #endif } @@ -1573,32 +1871,89 @@ static void flat_rgba_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1, /* * Return pointer to an accelerated triangle function if possible. */ -static triangle_func choose_triangle_function( GLcontext *ctx ) +static swrast_tri_func +osmesa_choose_triangle_function( GLcontext *ctx ) { - OSMesaContext osmesa = (OSMesaContext) ctx; - - if ((osmesa->format==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 - && ctx->Visual->DepthBits == DEFAULT_SOFTWARE_DEPTH_BITS - && osmesa->format!=OSMESA_COLOR_INDEX) { - if (ctx->Light.ShadeModel==GL_SMOOTH) { + 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; +} + + + +/* 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 ) +{ + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + swrast->Triangle = osmesa_choose_triangle_function( ctx ); + if (!swrast->Triangle) + _swrast_choose_triangle( ctx ); +} + +static void osmesa_choose_line( GLcontext *ctx ) +{ + SWcontext *swrast = SWRAST_CONTEXT(ctx); + + swrast->Line = osmesa_choose_line_function( ctx ); + if (!swrast->Line) + _swrast_choose_line( ctx ); } +#define OSMESA_NEW_LINE (_NEW_LINE | \ + _NEW_TEXTURE | \ + _NEW_LIGHT | \ + _NEW_DEPTH | \ + _NEW_RENDERMODE | \ + _SWRAST_NEW_RASTERMASK) + +#define OSMESA_NEW_TRIANGLE (_NEW_POLYGON | \ + _NEW_TEXTURE | \ + _NEW_LIGHT | \ + _NEW_DEPTH | \ + _NEW_RENDERMODE | \ + _SWRAST_NEW_RASTERMASK) + + +/* Extend the software rasterizer with our line and triangle + * functions. + */ +static void osmesa_register_swrast_functions( GLcontext *ctx ) +{ + 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 ) { @@ -1612,66 +1967,115 @@ 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); + struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference( ctx ); + TNLcontext *tnl = TNL_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.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.ChooseTextureFormat = _mesa_choose_tex_format; + 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.TestProxyTexImage = _mesa_test_proxy_teximage; + + ctx->Driver.CopyTexImage1D = _swrast_copy_teximage1d; + ctx->Driver.CopyTexImage2D = _swrast_copy_teximage2d; + ctx->Driver.CopyTexSubImage1D = _swrast_copy_texsubimage1d; + ctx->Driver.CopyTexSubImage2D = _swrast_copy_texsubimage2d; + ctx->Driver.CopyTexSubImage3D = _swrast_copy_texsubimage3d; + ctx->Driver.CopyColorTable = _swrast_CopyColorTable; + ctx->Driver.CopyColorSubTable = _swrast_CopyColorSubTable; + ctx->Driver.CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D; + ctx->Driver.CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D; /* 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; - ctx->Driver.ReadRGBASpan = read_rgba_span3; - ctx->Driver.ReadRGBAPixels = read_rgba_pixels3; + if (osmesa->format == OSMESA_RGB) { + swdd->WriteRGBASpan = write_rgba_span_RGB; + swdd->WriteRGBSpan = write_rgb_span_RGB; + swdd->WriteMonoRGBASpan = write_monocolor_span_RGB; + swdd->WriteRGBAPixels = write_rgba_pixels_RGB; + swdd->WriteMonoRGBAPixels = write_monocolor_pixels_RGB; + swdd->ReadRGBASpan = read_rgba_span3; + swdd->ReadRGBAPixels = read_rgba_pixels3; + } + else if (osmesa->format == OSMESA_BGR) { + swdd->WriteRGBASpan = write_rgba_span_BGR; + swdd->WriteRGBSpan = write_rgb_span_BGR; + swdd->WriteMonoRGBASpan = write_monocolor_span_BGR; + swdd->WriteRGBAPixels = write_rgba_pixels_BGR; + swdd->WriteMonoRGBAPixels = write_monocolor_pixels_BGR; + swdd->ReadRGBASpan = read_rgba_span3; + swdd->ReadRGBAPixels = read_rgba_pixels3; + } + else if (osmesa->format == OSMESA_RGB_565) { + swdd->WriteRGBASpan = write_rgba_span2; + swdd->WriteRGBSpan = write_rgb_span2; + swdd->WriteMonoRGBASpan = write_monocolor_span2; + swdd->WriteRGBAPixels = write_rgba_pixels2; + swdd->WriteMonoRGBAPixels = write_monocolor_pixels2; + swdd->ReadRGBASpan = read_rgba_span2; + swdd->ReadRGBAPixels = read_rgba_pixels2; } 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) - ctx->Driver.ReadRGBASpan = read_rgba_span_rgba; - else - ctx->Driver.ReadRGBASpan = read_rgba_span; - ctx->Driver.ReadRGBAPixels = read_rgba_pixels; + /* 4 GLchan / pixel in frame buffer */ + swdd->WriteRGBSpan = write_rgb_span; + swdd->WriteRGBAPixels = write_rgba_pixels; + swdd->WriteMonoRGBASpan = write_monocolor_span; + swdd->WriteMonoRGBAPixels = write_monocolor_pixels; + if (osmesa->format == OSMESA_RGBA && + CHAN_TYPE == GL_UNSIGNED_BYTE && + RCOMP==0 && GCOMP==1 && BCOMP==2 && ACOMP==3) { + /* special, fast case */ + swdd->WriteRGBASpan = write_rgba_span_rgba; + swdd->ReadRGBASpan = read_rgba_span_rgba; + } + else { + swdd->WriteRGBASpan = write_rgba_span; + swdd->ReadRGBASpan = read_rgba_span; + } + swdd->ReadRGBAPixels = read_rgba_pixels; } /* CI span/pixel functions */ - ctx->Driver.WriteCI32Span = write_index32_span; - ctx->Driver.WriteCI8Span = write_index8_span; - ctx->Driver.WriteMonoCISpan = write_monoindex_span; - ctx->Driver.WriteCI32Pixels = write_index_pixels; - ctx->Driver.WriteMonoCIPixels = write_monoindex_pixels; - ctx->Driver.ReadCI32Span = read_index_span; - ctx->Driver.ReadCI32Pixels = read_index_pixels; + swdd->WriteCI32Span = write_index32_span; + swdd->WriteCI8Span = write_index8_span; + swdd->WriteMonoCISpan = write_monoindex_span; + swdd->WriteCI32Pixels = write_index_pixels; + swdd->WriteMonoCIPixels = write_monoindex_pixels; + swdd->ReadCI32Span = read_index_span; + swdd->ReadCI32Pixels = read_index_pixels; + + swdd->SetReadBuffer = set_read_buffer; + + tnl->Driver.RunPipeline = _tnl_run_pipeline; + + _swrast_InvalidateState( ctx, new_state ); + _swsetup_InvalidateState( ctx, new_state ); + _ac_InvalidateState( ctx, new_state ); + _tnl_InvalidateState( ctx, new_state ); }