-# $Id: Makefile.X11,v 1.39 2001/01/08 21:55:59 keithw Exp $
+# $Id: Makefile.X11,v 1.40 2001/01/24 00:04:58 brianp Exp $
# Mesa 3-D graphics library
# Version: 3.5
X86/common_x86.c \
X86/3dnow.c \
X86/katmai.c \
+ swrast/s_aaline.c \
+ swrast/s_aatriangle.c \
+ swrast/s_accum.c \
+ swrast/s_alpha.c \
+ swrast/s_alphabuf.c \
+ swrast/s_bitmap.c \
+ swrast/s_blend.c \
+ swrast/s_buffers.c \
+ swrast/s_copypix.c \
+ swrast/s_context.c \
+ swrast/s_depth.c \
+ swrast/s_drawpix.c \
+ swrast/s_feedback.c \
+ swrast/s_fog.c \
+ swrast/s_histogram.c \
+ swrast/s_lines.c \
+ swrast/s_logic.c \
+ swrast/s_masking.c \
+ swrast/s_pb.c \
+ swrast/s_pixeltex.c \
+ swrast/s_points.c \
+ swrast/s_quads.c \
+ swrast/s_readpix.c \
+ swrast/s_scissor.c \
+ swrast/s_span.c \
+ swrast/s_stencil.c \
+ swrast/s_texture.c \
+ swrast/s_triangle.c \
+ swrast/s_zoom.c \
swrast_setup/ss_context.c \
swrast_setup/ss_triangle.c \
swrast_setup/ss_vb.c \
tnl/t_vb_render.c \
tnl/t_vb_texgen.c \
tnl/t_vb_texmat.c \
- tnl/t_vb_vertex.c \
- swrast/s_aaline.c \
- swrast/s_aatriangle.c \
- swrast/s_accum.c \
- swrast/s_alpha.c \
- swrast/s_alphabuf.c \
- swrast/s_bitmap.c \
- swrast/s_blend.c \
- swrast/s_buffers.c \
- swrast/s_copypix.c \
- swrast/s_context.c \
- swrast/s_depth.c \
- swrast/s_drawpix.c \
- swrast/s_feedback.c \
- swrast/s_fog.c \
- swrast/s_histogram.c \
- swrast/s_lines.c \
- swrast/s_logic.c \
- swrast/s_masking.c \
- swrast/s_pb.c \
- swrast/s_pixeltex.c \
- swrast/s_points.c \
- swrast/s_quads.c \
- swrast/s_readpix.c \
- swrast/s_scissor.c \
- swrast/s_span.c \
- swrast/s_stencil.c \
- swrast/s_texture.c \
- swrast/s_triangle.c \
- swrast/s_zoom.c
+ tnl/t_vb_vertex.c
DRIVER_SOURCES = \
ADDITIONAL_OBJ =
OBJECTS = $(ASM_SOURCES:.S=.o) \
- $(DRIVER_SOURCES:.c=.o) \
$(CORE_SOURCES:.c=.o) \
+ $(DRIVER_SOURCES:.c=.o) \
$(ADDITIONAL_OBJ)
-/* $Id: ac_import.c,v 1.3 2001/01/16 15:25:11 brianp Exp $ */
+/* $Id: ac_import.c,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
#include "mmath.h"
#include "mtypes.h"
+#include "math/m_translate.h"
#include "array_cache/ac_context.h"
#include "math/m_translate.h"
/* Limited choices at this stage:
*/
- ASSERT(type == GL_UNSIGNED_BYTE);
- ASSERT(stride == 4*sizeof(GLubyte) || stride == 0);
+ /* XXX GLchan: is this right for GLchan? */
+ ASSERT(type == CHAN_TYPE);
+ ASSERT(stride == 4 * sizeof(GLchan) || stride == 0);
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
_math_trans_4ub( to->Ptr,
- from->Ptr,
- from->StrideB,
- from->Type,
- from->Size,
- ac->start,
- ac->count);
+ from->Ptr,
+ from->StrideB,
+ from->Type,
+ from->Size,
+ ac->start,
+ ac->count);
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+ _math_trans_4us( to->Ptr,
+ from->Ptr,
+ from->StrideB,
+ from->Type,
+ from->Size,
+ ac->start,
+ ac->count);
+#elif CHAN_TYPE == GL_FLOAT
+ _math_trans_4f( to->Ptr,
+ from->Ptr,
+ from->StrideB,
+ from->Type,
+ from->Size,
+ ac->start,
+ ac->count);
+#endif
to->Size = from->Size;
- to->StrideB = 4 * sizeof(GLubyte);
- to->Type = GL_UNSIGNED_BYTE;
+ to->StrideB = 4 * sizeof(GLchan);
+ to->Type = CHAN_TYPE;
ac->Current.Color = to;
ac->Writeable.Color = GL_TRUE;
}
/* Limited choices at this stage:
*/
- ASSERT(type == GL_UNSIGNED_BYTE);
- ASSERT(stride == 4*sizeof(GLubyte) || stride == 0);
+ ASSERT(type == CHAN_TYPE);
+ ASSERT(stride == 4 * sizeof(GLchan) || stride == 0);
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
_math_trans_4ub( to->Ptr,
- from->Ptr,
- from->StrideB,
- from->Type,
- from->Size,
- ac->start,
- ac->count);
-
- to->StrideB = 4 * sizeof(GLubyte);
- to->Type = GL_UNSIGNED_BYTE;
+ from->Ptr,
+ from->StrideB,
+ from->Type,
+ from->Size,
+ ac->start,
+ ac->count);
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+ _math_trans_4us( to->Ptr,
+ from->Ptr,
+ from->StrideB,
+ from->Type,
+ from->Size,
+ ac->start,
+ ac->count);
+#elif CHAN_TYPE == GL_FLOAT
+ _math_trans_4f( to->Ptr,
+ from->Ptr,
+ from->StrideB,
+ from->Type,
+ from->Size,
+ ac->start,
+ ac->count);
+#endif
+
+ to->StrideB = 4 * sizeof(GLchan);
+ to->Type = CHAN_TYPE;
ac->Current.SecondaryColor = to;
ac->Writeable.SecondaryColor = GL_TRUE;
}
GGICTX->color = col;
}
-static void gl_ggiSetClearColor(GLcontext *ctx, GLubyte red, GLubyte green,
- GLubyte blue, GLubyte alpha)
+static void gl_ggiSetClearColor(GLcontext *ctx, const GLchan color[4])
{
ggi_color rgb;
ggi_pixel col;
GGIMESADPRINT_CORE("gl_ggiSetClearColor() called\n");
- rgb.r = (uint16)red << SHIFT;
- rgb.g = (uint16)green << SHIFT;
- rgb.b = (uint16)blue << SHIFT;
+ rgb.r = (uint16)color[0] << SHIFT;
+ rgb.g = (uint16)color[1] << SHIFT;
+ rgb.b = (uint16)color[2] << SHIFT;
col = ggiMapColor(VIS, &rgb);
ggiSetGCForeground(VIS, col);
GGICTX->clearcolor = col;
/* Implements glClearColor() */
-static void fxDDClearColor(GLcontext *ctx, GLubyte red, GLubyte green,
- GLubyte blue, GLubyte alpha )
+static void fxDDClearColor(GLcontext *ctx, const GLchan color[4])
{
fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx;
GLubyte col[4];
-
-
- ASSIGN_4V( col, red, green, blue, 255 );
-
if (MESA_VERBOSE&VERBOSE_DRIVER) {
- fprintf(stderr,"fxmesa: fxDDClearColor(%d,%d,%d,%d)\n",red,green,blue,alpha);
+ fprintf(stderr,"fxmesa: fxDDClearColor(%d,%d,%d,%d)\n",
+ color[0], color[1], color[2], color[3]);
}
- fxMesa->clearC=FXCOLOR4( col );
- fxMesa->clearA=alpha;
+ ASSIGN_4V( col, color[0], color[1], color[2], 255 );
+ fxMesa->clearC = FXCOLOR4( col );
+ fxMesa->clearA = color[3];
}
-/* $Id: osmesa.c,v 1.40 2001/01/23 23:39:36 brianp Exp $ */
+/* $Id: osmesa.c,v 1.41 2001/01/24 00:04:58 brianp Exp $ */
/*
* Mesa 3-D graphics library
- * Version: 3.3
+ * Version: 3.5
*
- * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
+ * 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"),
#include "glheader.h"
#include "GL/osmesa.h"
#include "context.h"
+#include "colormac.h"
#include "depth.h"
#include "macros.h"
#include "mem.h"
GLenum format; /* either GL_RGBA or GL_COLOR_INDEX */
void *buffer; /* the image buffer */
GLint width, height; /* size of image buffer */
- 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 */
};
{
OSMesaContext osmesa;
GLint rshift, gshift, bshift, ashift;
- GLint rind, gind, bind;
+ 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;
greenBits = 8;
blueBits = 8;
alphaBits = 8;
+ rind = 0;
+ gind = 1;
+ bind = 2;
+ aind = 3;
if (little_endian) {
rshift = 0;
gshift = 8;
greenBits = 8;
blueBits = 8;
alphaBits = 8;
+ rind = 2;
+ gind = 1;
+ bind = 0;
+ aind = 3;
if (little_endian) {
ashift = 0;
rshift = 8;
greenBits = 8;
blueBits = 8;
alphaBits = 8;
+ rind = 1;
+ gind = 2;
+ bind = 3;
+ aind = 0;
if (little_endian) {
bshift = 0;
gshift = 8;
gshift = 8;
rshift = 16;
ashift = 24;
- bind = 2;
- gind = 1;
rind = 0;
+ gind = 1;
+ bind = 2;
rgbmode = GL_TRUE;
swalpha = GL_TRUE;
}
gshift = 8;
rshift = 16;
ashift = 24;
- bind = 0;
- gind = 1;
rind = 2;
+ gind = 1;
+ bind = 0;
rgbmode = GL_TRUE;
swalpha = GL_TRUE;
}
osmesa->buffer = NULL;
osmesa->width = 0;
osmesa->height = 0;
- osmesa->clearpixel = 0;
osmesa->userRowLength = 0;
osmesa->rowlength = 0;
osmesa->yup = GL_TRUE;
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.
*/
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;i<MAX_HEIGHT;i++) {
- ctx->rowaddr[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;i<MAX_HEIGHT;i++) {
- ctx->rowaddr[i] = origin + (i * (ctx->rowlength*3));
- }
- } else {
- /* 4-byte RGBA mode */
- GLuint *origin = (GLuint *) ctx->buffer;
- for (i=0;i<MAX_HEIGHT;i++) {
- ctx->rowaddr[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;i<MAX_HEIGHT;i++) {
- ctx->rowaddr[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;i<MAX_HEIGHT;i++) {
- ctx->rowaddr[i] = origin + ((ctx->height-i-1) * (ctx->rowlength*3));
- }
- } else {
- /* 4-byte RGBA mode */
- GLuint *origin = (GLuint *) ctx->buffer;
- for (i=0;i<MAX_HEIGHT;i++) {
- ctx->rowaddr[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);
}
}
}
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;
}
/*
* 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 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_BGR(DST, R, G, B) \
+do { \
+ (DST)[0] = B; \
+ (DST)[1] = G; \
+ (DST)[2] = R; \
+} 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) ( ((GLchan *) &(P))[osmesa->rInd] )
+#define UNPACK_GREEN(P) ( ((GLchan *) &(P))[osmesa->gInd] )
+#define UNPACK_BLUE(P) ( ((GLchan *) &(P))[osmesa->bInd] )
+#define UNPACK_ALPHA(P) ( ((GLchan *) &(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 void clear_index( GLcontext *ctx, GLuint index )
-{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- osmesa->clearpixel = index;
-}
-
-
-
-static void clear_color( GLcontext *ctx,
- GLchan r, GLchan g, GLchan b, GLchan a )
-{
- OSMesaContext osmesa = OSMESA_CONTEXT(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 )
{
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 (osmesa->format == OSMESA_COLOR_INDEX) {
if (all) {
/* Clear whole CI buffer */
- MEMSET(osmesa->buffer, osmesa->clearpixel,
+#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++) {
- GLubyte *ptr1 = PIXELADDR1( x, (y+i) );
- for (j=0;j<width;j++) {
- *ptr1++ = osmesa->clearpixel;
+ 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)||(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;
+ 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) {
- GLuint i, n;
- GLubyte *ptr3 = (GLubyte *) osmesa->buffer;
/* Clear whole RGB buffer */
- n = osmesa->rowlength * osmesa->height;
- for (i=0;i<n;i++) {
- ptr3[rind] = rval;
- ptr3[gind] = gval;
- ptr3[bind] = bval;
+ 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++) {
- GLubyte *ptr3 = PIXELADDR3( x, (y+i) );
- for (j=0;j<width;j++) {
- ptr3[rind] = rval;
- ptr3[gind] = gval;
- ptr3[bind] = bval;
+ 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 */
- GLuint i, n, *ptr4;
- n = osmesa->rowlength * osmesa->height;
- ptr4 = (GLuint *) osmesa->buffer;
- if (osmesa->clearpixel) {
- for (i=0;i<n;i++) {
- *ptr4++ = osmesa->clearpixel;
+ 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 {
else {
/* Clear part of RGBA buffer */
GLint i, j;
- for (i=0;i<height;i++) {
- GLuint *ptr4 = PIXELADDR4( x, (y+i) );
- for (j=0;j<width;j++) {
- *ptr4++ = osmesa->clearpixel;
+ 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
}
}
/* have Mesa clear all other buffers */
/**********************************************************************/
/* Write RGBA pixels to an RGBA (or permuted) buffer. */
-static void write_rgba_span( const GLcontext *ctx,
- GLuint n, GLint x, GLint y,
- CONST GLchan 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 = OSMESA_CONTEXT(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;i<n;i++,ptr4++) {
+ for (i = 0; i < n; i++, p += 4) {
if (mask[i]) {
- *ptr4 = PACK_RGBA2( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+ PACK_RGBA(p, rgba[i][RCOMP], rgba[i][GCOMP],
+ rgba[i][BCOMP], rgba[i][ACOMP]);
}
}
}
else {
- for (i=0;i<n;i++,ptr4++) {
- *ptr4 = PACK_RGBA2( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+ for (i = 0; i < n; i++, p += 4) {
+ PACK_RGBA(p, rgba[i][RCOMP], rgba[i][GCOMP],
+ rgba[i][BCOMP], rgba[i][ACOMP]);
}
}
}
/* Write RGBA pixels to an RGBA buffer. This is the fastest span-writer. */
-static void write_rgba_span_rgba( const GLcontext *ctx,
- GLuint n, GLint x, GLint y,
- CONST GLchan rgba[][4],
- const GLubyte mask[] )
+static void
+write_rgba_span_rgba( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+ CONST GLchan rgba[][4], const GLubyte mask[] )
{
OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- GLuint *ptr4 = PIXELADDR4( x, y );
+ GLuint *ptr4 = (GLuint *) PIXELADDR4(x, y);
const GLuint *rgba4 = (const GLuint *) rgba;
GLuint i;
+ ASSERT(CHAN_TYPE == GL_UNSIGNED_BYTE);
if (mask) {
- for (i=0;i<n;i++) {
+ for (i = 0; i < n; i++) {
if (mask[i]) {
ptr4[i] = rgba4[i];
}
/* Write RGB pixels to an RGBA (or permuted) buffer. */
-static void write_rgb_span( const GLcontext *ctx,
- GLuint n, GLint x, GLint y,
- CONST GLchan rgb[][3], const GLubyte mask[] )
+static void
+write_rgb_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+ CONST GLchan rgb[][3], const GLubyte mask[] )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(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;i<n;i++,ptr4++) {
+ for (i = 0; i < n; i++, p+=4) {
if (mask[i]) {
- *ptr4 = PACK_RGBA2( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255 );
+ PACK_RGBA(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255);
}
}
}
else {
- for (i=0;i<n;i++,ptr4++) {
- *ptr4 = PACK_RGBA2( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255);
+ for (i = 0; i < n; i++, p+=4) {
+ PACK_RGBA(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255);
}
}
}
-static void write_monocolor_span( const GLcontext *ctx,
- GLuint n, GLint x, GLint y,
- const GLchan color[4], const GLubyte mask[] )
+static void
+write_monocolor_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLchan color[4], const GLubyte mask[] )
{
const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- const GLuint pixel = PACK_RGBA(color[RCOMP], color[GCOMP],
- color[BCOMP], color[ACOMP]);
- GLuint *ptr4 = PIXELADDR4(x,y);
+ GLchan *p = PIXELADDR4(x, y);
GLuint i;
- for (i=0;i<n;i++,ptr4++) {
+ for (i = 0; i < n; i++, p += 4) {
if (mask[i]) {
- *ptr4 = pixel;
+ 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 GLchan 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 = OSMESA_CONTEXT(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;i<n;i++) {
+ for (i = 0; i < n; i++) {
if (mask[i]) {
- GLuint *ptr4 = PIXELADDR4(x[i],y[i]);
- *ptr4 = PACK_RGBA2( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+ GLchan *p = PIXELADDR4(x[i], y[i]);
+ PACK_RGBA(p, rgba[i][RCOMP], rgba[i][GCOMP],
+ rgba[i][BCOMP], rgba[i][ACOMP]);
}
}
}
-static void write_monocolor_pixels( const GLcontext *ctx,
- GLuint n, const GLint x[], const GLint y[],
- const GLchan color[4],
- const GLubyte mask[] )
+static void
+write_monocolor_pixels( const GLcontext *ctx, GLuint n,
+ const GLint x[], const GLint y[],
+ const GLchan color[4], const GLubyte mask[] )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- const GLuint pixel = PACK_RGBA(color[RCOMP], color[GCOMP],
- color[BCOMP], color[ACOMP]);
+ const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
GLuint i;
- for (i=0;i<n;i++) {
+ for (i = 0; i < n; i++) {
if (mask[i]) {
- GLuint *ptr4 = PIXELADDR4(x[i],y[i]);
- *ptr4 = pixel;
+ 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,
- GLchan rgba[][4] )
+static void
+read_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+ GLchan rgba[][4] )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+ const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
GLuint i;
- GLuint *ptr4 = PIXELADDR4(x,y);
- for (i=0;i<n;i++) {
- GLuint pixel = *ptr4++;
- rgba[i][RCOMP] = UNPACK_RED(pixel);
- rgba[i][GCOMP] = UNPACK_GREEN(pixel);
- rgba[i][BCOMP] = UNPACK_BLUE(pixel);
- rgba[i][ACOMP] = UNPACK_ALPHA(pixel);
+ GLchan *p = PIXELADDR4(x, y);
+ for (i = 0; i < n; i++, p += 4) {
+ rgba[i][RCOMP] = UNPACK_RED(p);
+ rgba[i][GCOMP] = UNPACK_GREEN(p);
+ rgba[i][BCOMP] = UNPACK_BLUE(p);
+ rgba[i][ACOMP] = UNPACK_ALPHA(p);
}
}
/* Read RGBA pixels from an RGBA buffer */
-static void read_rgba_span_rgba( const GLcontext *ctx,
- GLuint n, GLint x, GLint y,
- GLchan rgba[][4] )
+static void
+read_rgba_span_rgba( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+ GLchan rgba[][4] )
{
OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- GLuint *ptr4 = PIXELADDR4(x,y);
+ GLuint *ptr4 = (GLuint *) PIXELADDR4(x, y);
MEMCPY( rgba, ptr4, n * 4 * sizeof(GLchan) );
}
-static void read_rgba_pixels( const GLcontext *ctx,
- GLuint n, const GLint x[], const GLint y[],
- GLchan rgba[][4], const GLubyte mask[] )
+static void
+read_rgba_pixels( const GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLchan rgba[][4], const GLubyte mask[] )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+ const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
GLuint i;
- for (i=0;i<n;i++) {
+ for (i = 0; i < n; i++) {
if (mask[i]) {
- GLuint *ptr4 = PIXELADDR4(x[i],y[i]);
- GLuint pixel = *ptr4;
- rgba[i][RCOMP] = UNPACK_RED(pixel);
- rgba[i][GCOMP] = UNPACK_GREEN(pixel);
- rgba[i][BCOMP] = UNPACK_BLUE(pixel);
- rgba[i][ACOMP] = UNPACK_ALPHA(pixel);
+ const GLchan *p = PIXELADDR4(x[i], y[i]);
+ rgba[i][RCOMP] = UNPACK_RED(p);
+ rgba[i][GCOMP] = UNPACK_GREEN(p);
+ rgba[i][BCOMP] = UNPACK_BLUE(p);
+ rgba[i][ACOMP] = UNPACK_ALPHA(p);
}
}
}
/***** 3 byte RGB pixel support funcs *****/
/**********************************************************************/
-/* Write RGBA pixels to an RGB or BGR buffer. */
-static void write_rgba_span3( const GLcontext *ctx,
- GLuint n, GLint x, GLint y,
- CONST GLchan rgba[][4], const GLubyte mask[] )
+/* Write RGBA pixels to an RGB buffer. */
+static void
+write_rgba_span_RGB( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+ CONST GLchan rgba[][4], const GLubyte mask[] )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- GLubyte *ptr3 = PIXELADDR3( x, y);
+ const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+ GLchan *p = PIXELADDR3(x, y);
GLuint i;
- GLint rind = osmesa->rind;
- GLint gind = osmesa->gind;
- GLint bind = osmesa->bind;
if (mask) {
- for (i=0;i<n;i++,ptr3+=3) {
+ for (i = 0; i < n; i++, p += 3) {
if (mask[i]) {
- ptr3[rind] = rgba[i][RCOMP];
- ptr3[gind] = rgba[i][GCOMP];
- ptr3[bind] = rgba[i][BCOMP];
+ PACK_RGB(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
}
}
}
else {
- for (i=0;i<n;i++,ptr3+=3) {
- ptr3[rind] = rgba[i][RCOMP];
- ptr3[gind] = rgba[i][GCOMP];
- ptr3[bind] = rgba[i][BCOMP];
+ for (i = 0; i < n; i++, p += 3) {
+ PACK_RGB(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
}
}
}
-/* Write RGB pixels to an RGB or BGR buffer. */
-static void write_rgb_span3( const GLcontext *ctx,
- GLuint n, GLint x, GLint y,
- CONST GLchan rgb[][3], const GLubyte mask[] )
+/* Write RGBA pixels to an BGR buffer. */
+static void
+write_rgba_span_BGR( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+ CONST GLchan rgba[][4], const GLubyte mask[] )
{
const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- const GLint rind = osmesa->rind;
- const GLint gind = osmesa->gind;
- const GLint bind = osmesa->bind;
- GLubyte *ptr3 = PIXELADDR3( x, y);
+ GLchan *p = PIXELADDR3(x, y);
GLuint i;
if (mask) {
- for (i=0;i<n;i++,ptr3+=3) {
+ for (i = 0; i < n; i++, p += 3) {
if (mask[i]) {
- ptr3[rind] = rgb[i][RCOMP];
- ptr3[gind] = rgb[i][GCOMP];
- ptr3[bind] = rgb[i][BCOMP];
+ PACK_BGR(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
}
}
}
else {
- for (i=0;i<n;i++,ptr3+=3) {
- ptr3[rind] = rgb[i][RCOMP];
- ptr3[gind] = rgb[i][GCOMP];
- ptr3[bind] = rgb[i][BCOMP];
+ for (i = 0; i < n; i++, p += 3) {
+ PACK_BGR(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
}
}
}
+/* Write RGB pixels to an RGB buffer. */
+static void
+write_rgb_span_RGB( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+ CONST GLchan rgb[][3], const GLubyte mask[] )
+{
+ const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+ GLchan *p = PIXELADDR3(x, y);
+ GLuint i;
+ if (mask) {
+ for (i = 0; i < n; i++, p += 3) {
+ if (mask[i]) {
+ PACK_RGB(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+ }
+ }
+ }
+ else {
+ for (i = 0; i < n; i++, p += 3) {
+ PACK_RGB(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+ }
+ }
+}
-static void write_monocolor_span3( const GLcontext *ctx,
- GLuint n, GLint x, GLint y,
- const GLchan color[4], const GLubyte mask[] )
+/* Write RGB pixels to an BGR buffer. */
+static void
+write_rgb_span_BGR( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+ CONST GLchan rgb[][3], const GLubyte mask[] )
{
const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- const GLubyte rval = color[RCOMP];
- const GLubyte gval = color[GCOMP];
- const GLubyte bval = color[BCOMP];
- const GLint rind = osmesa->rind;
- const GLint gind = osmesa->gind;
- const GLint bind = osmesa->bind;
- GLubyte *ptr3 = PIXELADDR3( x, y);
+ GLchan *p = PIXELADDR3(x, y);
GLuint i;
- for (i=0;i<n;i++,ptr3+=3) {
+ if (mask) {
+ for (i = 0; i < n; i++, p += 3) {
+ if (mask[i]) {
+ PACK_BGR(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+ }
+ }
+ }
+ else {
+ for (i = 0; i < n; i++, p += 3) {
+ PACK_BGR(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+ }
+ }
+}
+
+
+static void
+write_monocolor_span_RGB( 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_RGB(p, color[RCOMP], color[GCOMP], color[BCOMP]);
+ }
+ }
+}
+
+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]) {
- ptr3[rind] = rval;
- ptr3[gind] = gval;
- ptr3[bind] = bval;
+ PACK_BGR(p, color[RCOMP], color[GCOMP], color[BCOMP]);
}
}
}
-static void write_rgba_pixels3( const GLcontext *ctx,
- GLuint n, const GLint x[], const GLint y[],
- CONST GLchan rgba[][4], const GLubyte mask[] )
+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;
- GLint rind = osmesa->rind;
- GLint gind = osmesa->gind;
- GLint bind = osmesa->bind;
- for (i=0;i<n;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]);
+ }
+ }
+}
+
+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;
+ for (i = 0; i < n; i++) {
if (mask[i]) {
- GLubyte *ptr3 = PIXELADDR3(x[i],y[i]);
- ptr3[rind] = rgba[i][RCOMP];
- ptr3[gind] = rgba[i][GCOMP];
- ptr3[bind] = rgba[i][BCOMP];
+ GLchan *p = PIXELADDR3(x[i], y[i]);
+ PACK_BGR(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
}
}
}
-static void write_monocolor_pixels3( const GLcontext *ctx,
- GLuint n, const GLint x[],
- const GLint y[],
- const GLchan color[4],
- const GLubyte mask[] )
+static void
+write_monocolor_pixels_RGB( const GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ const GLchan color[4], const GLubyte mask[] )
{
const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- const GLint rind = osmesa->rind;
- const GLint gind = osmesa->gind;
- const GLint bind = osmesa->bind;
- const GLubyte rval = color[RCOMP];
- const GLubyte gval = color[GCOMP];
- const GLubyte bval = color[BCOMP];
GLuint i;
- for (i=0;i<n;i++) {
+ for (i = 0; i < n; i++) {
if (mask[i]) {
- GLubyte *ptr3 = PIXELADDR3(x[i],y[i]);
- ptr3[rind] = rval;
- ptr3[gind] = gval;
- ptr3[bind] = bval;
+ GLchan *p = PIXELADDR3(x[i], y[i]);
+ PACK_RGB(p, color[RCOMP], color[GCOMP], color[BCOMP]);
}
}
}
-static void read_rgba_span3( const GLcontext *ctx,
- GLuint n, GLint x, GLint y,
- GLchan rgba[][4] )
+static void
+write_monocolor_pixels_BGR( const GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ const GLchan color[4], const GLubyte mask[] )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+ const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ if (mask[i]) {
+ GLchan *p = PIXELADDR3(x[i], y[i]);
+ PACK_BGR(p, color[RCOMP], color[GCOMP], color[BCOMP]);
+ }
+ }
+}
+
+static void
+read_rgba_span3( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+ GLchan rgba[][4] )
+{
+ const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
GLuint i;
- GLint rind = osmesa->rind;
- GLint gind = osmesa->gind;
- GLint bind = osmesa->bind;
- const GLubyte *ptr3 = PIXELADDR3( x, y);
- for (i=0;i<n;i++,ptr3+=3) {
- rgba[i][RCOMP] = ptr3[rind];
- rgba[i][GCOMP] = ptr3[gind];
- rgba[i][BCOMP] = ptr3[bind];
- rgba[i][ACOMP] = 0;
+ const GLchan *p = PIXELADDR3(x, y);
+ for (i = 0; i < n; i++, p += 3) {
+ rgba[i][RCOMP] = UNPACK_RED(p);
+ rgba[i][GCOMP] = UNPACK_GREEN(p);
+ rgba[i][BCOMP] = UNPACK_BLUE(p);
+ rgba[i][ACOMP] = 255;
}
}
-static void read_rgba_pixels3( const GLcontext *ctx,
- GLuint n, const GLint x[], const GLint y[],
- GLchan rgba[][4], const GLubyte mask[] )
+static void
+read_rgba_pixels3( const GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLchan rgba[][4], const GLubyte mask[] )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+ const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
GLuint i;
- GLint rind = osmesa->rind;
- GLint gind = osmesa->gind;
- GLint bind = osmesa->bind;
- for (i=0;i<n;i++) {
+ for (i = 0; i < n; i++) {
if (mask[i]) {
- const GLubyte *ptr3 = PIXELADDR3(x[i],y[i]);
- rgba[i][RCOMP] = ptr3[rind];
- rgba[i][GCOMP] = ptr3[gind];
- rgba[i][BCOMP] = ptr3[bind];
- rgba[i][ACOMP] = 0;
+ const GLchan *p = PIXELADDR3(x[i], y[i]);
+ rgba[i][RCOMP] = UNPACK_RED(p);
+ rgba[i][GCOMP] = UNPACK_GREEN(p);
+ rgba[i][BCOMP] = UNPACK_BLUE(p);
+ rgba[i][ACOMP] = 255;
}
}
}
/**********************************************************************/
/* 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 = OSMESA_CONTEXT(ctx);
- GLubyte *ptr1 = PIXELADDR1(x,y);
+ const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+ GLchan *ptr1 = PIXELADDR1(x, y);
GLuint i;
if (mask) {
for (i=0;i<n;i++,ptr1++) {
if (mask[i]) {
- *ptr1 = (GLubyte) index[i];
+ *ptr1 = (GLchan) index[i];
}
}
}
else {
for (i=0;i<n;i++,ptr1++) {
- *ptr1 = (GLubyte) index[i];
+ *ptr1 = (GLchan) index[i];
}
}
}
/* Write 8-bit color index to buffer */
-static void write_index8_span( const GLcontext *ctx,
- GLuint n, GLint x, GLint y,
- const GLubyte index[], const GLubyte mask[] )
+static void
+write_index8_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+ const GLubyte index[], const GLubyte mask[] )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- GLubyte *ptr1 = PIXELADDR1(x,y);
+ const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+ GLchan *ptr1 = PIXELADDR1(x, y);
GLuint i;
if (mask) {
for (i=0;i<n;i++,ptr1++) {
if (mask[i]) {
- *ptr1 = (GLubyte) index[i];
+ *ptr1 = (GLchan) index[i];
}
}
}
else {
- MEMCPY( ptr1, index, n );
+ MEMCPY(ptr1, index, n * sizeof(GLchan));
}
}
-static void write_monoindex_span( const GLcontext *ctx,
- GLuint n, GLint x, GLint y,
- GLuint colorIndex, const GLubyte mask[] )
+static void
+write_monoindex_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+ GLuint colorIndex, const GLubyte mask[] )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- GLubyte *ptr1 = PIXELADDR1(x,y);
+ const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+ GLchan *ptr1 = PIXELADDR1(x, y);
GLuint i;
for (i=0;i<n;i++,ptr1++) {
if (mask[i]) {
- *ptr1 = (GLubyte) colorIndex;
+ *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 = OSMESA_CONTEXT(ctx);
+ const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
- GLubyte *ptr1 = PIXELADDR1(x[i],y[i]);
- *ptr1 = (GLubyte) index[i];
+ GLchan *ptr1 = PIXELADDR1(x[i], y[i]);
+ *ptr1 = (GLchan) index[i];
}
}
}
-static void write_monoindex_pixels( const GLcontext *ctx,
- GLuint n, const GLint x[], const GLint y[],
- GLuint colorIndex, const GLubyte mask[] )
+static void
+write_monoindex_pixels( const GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLuint colorIndex, const GLubyte mask[] )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+ const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
- GLubyte *ptr1 = PIXELADDR1(x[i],y[i]);
- *ptr1 = (GLubyte) colorIndex;
+ 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 = OSMESA_CONTEXT(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;i<n;i++,ptr1++) {
index[i] = (GLuint) *ptr1;
}
}
-static void read_index_pixels( const GLcontext *ctx,
- GLuint n, const GLint x[], const GLint y[],
- GLuint index[], const GLubyte mask[] )
+static void
+read_index_pixels( const GLcontext *ctx,
+ GLuint n, const GLint x[], const GLint y[],
+ GLuint index[], const GLubyte mask[] )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+ const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
GLuint i;
for (i=0;i<n;i++) {
if (mask[i] ) {
- const GLubyte *ptr1 = PIXELADDR1(x[i],y[i]);
+ const GLchan *ptr1 = PIXELADDR1(x[i], y[i]);
index[i] = (GLuint) *ptr1;
}
}
/*
* Draw a flat-shaded, RGB line into an osmesa buffer.
*/
-static void flat_rgba_line( GLcontext *ctx,
- const SWvertex *vert0, const SWvertex *vert1 )
+static void
+flat_rgba_line( GLcontext *ctx, const SWvertex *vert0, const SWvertex *vert1 )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- GLubyte *color = (GLubyte*) vert0->color;
- 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 "..\swrast\s_linetemp.h"
/*
* Draw a flat-shaded, Z-less, RGB line into an osmesa buffer.
*/
-static void flat_rgba_z_line( GLcontext *ctx,
- const SWvertex *vert0, const SWvertex *vert1 )
+static void
+flat_rgba_z_line(GLcontext *ctx, const SWvertex *vert0, const SWvertex *vert1)
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- GLubyte *color = (GLubyte*) vert0->color;
- 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 "..\swrast\s_linetemp.h"
/*
* Draw a flat-shaded, alpha-blended, RGB line into an osmesa buffer.
+ * XXX update for GLchan
*/
-static void flat_blend_rgba_line( GLcontext *ctx,
- const SWvertex *vert0, const SWvertex *vert1 )
+static void
+flat_blend_rgba_line( GLcontext *ctx,
+ const SWvertex *vert0, const SWvertex *vert1 )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- GLint rshift = osmesa->rshift;
- GLint gshift = osmesa->gshift;
- GLint bshift = osmesa->bshift;
- GLint avalue = vert0->color[3];
- GLint msavalue = 255 - avalue;
- GLint rvalue = vert0->color[0]*avalue;
- GLint gvalue = vert0->color[1]*avalue;
- GLint bvalue = vert0->color[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 = 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 *ptr4 = (GLuint *) PIXELADDR4(X, Y); \
GLuint pixel = 0; \
pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift);\
pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift);\
/*
* 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,
- const SWvertex *vert0, const SWvertex *vert1 )
+static void
+flat_blend_rgba_z_line( GLcontext *ctx,
+ const SWvertex *vert0, const SWvertex *vert1 )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- GLint rshift = osmesa->rshift;
- GLint gshift = osmesa->gshift;
- GLint bshift = osmesa->bshift;
- GLint avalue = vert0->color[3];
- GLint msavalue = 256 - avalue;
- GLint rvalue = vert0->color[0]*avalue;
- GLint gvalue = vert0->color[1]*avalue;
- GLint bvalue = vert0->color[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
#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); \
/*
* 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,
- const SWvertex *vert0, const SWvertex *vert1 )
+static void
+flat_blend_rgba_z_line_write( GLcontext *ctx,
+ const SWvertex *vert0, const SWvertex *vert1 )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- GLint rshift = osmesa->rshift;
- GLint gshift = osmesa->gshift;
- GLint bshift = osmesa->bshift;
- GLint avalue = vert0->color[3];
- GLint msavalue = 256 - avalue;
- GLint rvalue = vert0->color[0]*avalue;
- GLint gvalue = vert0->color[1]*avalue;
- GLint bvalue = vert0->color[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
#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); \
static swrast_line_func
osmesa_choose_line_function( GLcontext *ctx )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- SWcontext *swrast = SWRAST_CONTEXT(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._ReallyEnabled) return NULL;
- if (ctx->Light.ShadeModel!=GL_FLAT) return NULL;
-
- if (ctx->Line.Width==1.0F
- && ctx->Line.StippleFlag==GL_FALSE) {
-
- if (swrast->_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 (swrast->_RasterMask==0) {
- switch(osmesa->format) {
- case OSMESA_RGBA:
- case OSMESA_BGRA:
- case OSMESA_ARGB:
- return flat_rgba_line;
- default:
- return NULL;
- }
- }
-
- 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) {
- switch(osmesa->format) {
- case OSMESA_RGBA:
- case OSMESA_BGRA:
- case OSMESA_ARGB:
- return flat_blend_rgba_z_line_write;
- default:
- return NULL;
- }
- }
-
- 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) {
- switch(osmesa->format) {
- case OSMESA_RGBA:
- case OSMESA_BGRA:
- case OSMESA_ARGB:
- return flat_blend_rgba_z_line;
- default:
- return NULL;
- }
- }
-
- 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) {
- switch(osmesa->format) {
- case OSMESA_RGBA:
- case OSMESA_BGRA:
- case OSMESA_ARGB:
- return flat_blend_rgba_line;
- default:
- 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;
}
const SWvertex *v1,
const SWvertex *v2 )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- GLint rshift = osmesa->rshift;
- GLint gshift = osmesa->gshift;
- GLint bshift = osmesa->bshift;
- GLint ashift = osmesa->ashift;
+ const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
#define INTERP_Z 1
#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
#define INNER_LOOP( LEFT, RIGHT, Y ) \
{ \
GLint i, len = RIGHT-LEFT; \
- GLuint *img = PIXELADDR4(LEFT,Y); \
- (void) fffog; \
- for (i=0;i<len;i++,img++) { \
+ GLchan *img = PIXELADDR4(LEFT, Y); \
+ (void) fffog; \
+ for (i = 0; i < len; i++, img += 4) { \
GLdepth z = FixedToDepth(ffz); \
if (z < zRow[i]) { \
- *img = PACK_RGBA2( FixedToInt(ffr), FixedToInt(ffg), \
- FixedToInt(ffb), FixedToInt(ffa) ); \
+ PACK_RGBA(img, FixedToInt(ffr), FixedToInt(ffg), \
+ FixedToInt(ffb), FixedToInt(ffa)); \
zRow[i] = z; \
} \
ffr += fdrdx; ffg += fdgdx; ffb += fdbdx; ffa += fdadx;\
const SWvertex *v1,
const SWvertex *v2 )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+ const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
#define INTERP_Z 1
#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define SETUP_CODE \
- GLubyte r = v0->color[0]; \
- GLubyte g = v0->color[1]; \
- GLubyte b = v0->color[2]; \
- GLubyte a = v0->color[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); \
- (void) fffog; \
- for (i=0;i<len;i++,img++) { \
- GLdepth z = FixedToDepth(ffz); \
- if (z < zRow[i]) { \
- *img = pixel; \
- zRow[i] = z; \
- } \
- ffz += fdzdx; \
- } \
+#define SETUP_CODE \
+ GLuint pixel; \
+ PACK_RGBA((GLchan *) &pixel, v0->color[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); \
+ (void) fffog; \
+ for (i=0;i<len;i++) { \
+ GLdepth z = FixedToDepth(ffz); \
+ if (z < zRow[i]) { \
+ img[i] = pixel; \
+ zRow[i] = z; \
+ } \
+ ffz += fdzdx; \
+ } \
}
#ifdef WIN32
#include "..\swrast\s_tritemp.h"
static swrast_tri_func
osmesa_choose_triangle_function( GLcontext *ctx )
{
- OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
- SWcontext *swrast = SWRAST_CONTEXT(ctx);
-
- if ((osmesa->format==OSMESA_RGB)||(osmesa->format==OSMESA_BGR))
- 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 (swrast->_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 (swrast_tri_func)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.
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.ClearIndex = clear_index;
- ctx->Driver.ClearColor = clear_color;
ctx->Driver.Clear = clear;
ctx->Driver.GetBufferSize = buffer_size;
ctx->Driver.RenderFinish = _swsetup_RenderFinish;
/* 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;
}
-/* $Id: svgamesa15.c,v 1.7 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa15.c,v 1.8 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
return shortBuffer[offset];
}
-void __clear_color15( GLcontext *ctx,
- GLubyte red, GLubyte green,
- GLubyte blue, GLubyte alpha )
+void __clear_color15( GLcontext *ctx, const GLchan color[4] )
{
- SVGAMesa->clear_hicolor=(red>>3)<<10 | (green>>3)<<5 | (blue>>3);
+ SVGAMesa->clear_hicolor=(color[0]>>3)<<10 | (color[1]>>3)<<5 | (color[2]>>3);
/* SVGAMesa->clear_hicolor=(red)<<10 | (green)<<5 | (blue);*/
}
-/* $Id: svgamesa15.h,v 1.4 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa15.h,v 1.5 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
#ifndef SVGA_MESA_15_H
#define SVGA_MESA_15_H
-extern void __clear_color15( GLcontext *ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
+extern void __clear_color15( GLcontext *ctx, const GLchan color[4] );
extern GLbitfield __clear15( GLcontext *ctx, GLbitfield mask, GLboolean all, GLint x, GLint y, GLint width, GLint height );
extern void __write_rgba_span15( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte rgba[][4], const GLubyte mask[] );
extern void __write_mono_rgba_span15( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLchan color[4], const GLubyte mask[]);
-/* $Id: svgamesa16.c,v 1.7 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa16.c,v 1.8 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
return shortBuffer[offset];
}
-void __clear_color16( GLcontext *ctx,
- GLubyte red, GLubyte green,
- GLubyte blue, GLubyte alpha )
+void __clear_color16( GLcontext *ctx, const GLchan color[4] )
{
- SVGAMesa->clear_hicolor=(red>>3)<<11 | (green>>2)<<5 | (blue>>3);
+ SVGAMesa->clear_hicolor = (color[0] >> 3) << 11 |
+ (color[1] >> 2) << 5 |
+ (color[2] >> 3);
/* SVGAMesa->clear_hicolor=(red)<<11 | (green)<<5 | (blue); */
}
-/* $Id: svgamesa16.h,v 1.3 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa16.h,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
#ifndef SVGA_MESA_16_H
#define SVGA_MESA_16_H
-extern void __clear_color16( GLcontext *ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
+extern void __clear_color16( GLcontext *ctx, const GLchan color[4] );
extern GLbitfield __clear16( GLcontext *ctx, GLbitfield mask, GLboolean all, GLint x, GLint y, GLint width, GLint height );
extern void __write_rgba_span16( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte rgba[][4], const GLubyte mask[] );
extern void __write_mono_rgba_span16( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLchan color[4], const GLubyte mask[]);
-/* $Id: svgamesa24.c,v 1.8 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa24.c,v 1.9 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
return rgbBuffer[offset].r<<16 | rgbBuffer[offset].g<<8 | rgbBuffer[offset].b;
}
-void __clear_color24( GLcontext *ctx,
- GLubyte red, GLubyte green,
- GLubyte blue, GLubyte alpha )
+void __clear_color24( GLcontext *ctx, const GLchan color[4] )
{
- SVGAMesa->clear_red = red;
- SVGAMesa->clear_green = green;
- SVGAMesa->clear_blue = blue;
+ SVGAMesa->clear_red = color[0];
+ SVGAMesa->clear_green = color[1];
+ SVGAMesa->clear_blue = color[2];
/* SVGAMesa->clear_truecolor = red<<16 | green<<8 | blue; */
}
-/* $Id: svgamesa24.h,v 1.3 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa24.h,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
#ifndef SVGA_MESA_24_H
#define SVGA_MESA_24_H
-extern void __clear_color24( GLcontext *ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
+extern void __clear_color24( GLcontext *ctx, const GLchan color[4] );
extern GLbitfield __clear24( GLcontext *ctx, GLbitfield mask, GLboolean all, GLint x, GLint y, GLint width, GLint height );
extern void __write_rgba_span24( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte rgba[][4], const GLubyte mask[] );
extern void __write_mono_rgba_span24( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLchan color[4], const GLubyte mask[]);
-/* $Id: svgamesa32.c,v 1.8 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa32.c,v 1.9 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
return intBuffer[offset];
}
-void __clear_color32( GLcontext *ctx,
- GLubyte red, GLubyte green,
- GLubyte blue, GLubyte alpha )
+void __clear_color32( GLcontext *ctx, const GLchan color[4] )
{
- SVGAMesa->clear_truecolor = red<<16 | green<<8 | blue;
+ SVGAMesa->clear_truecolor = (color[0] << 16) | (color[1] << 8) | color[2];
}
GLbitfield __clear32( GLcontext *ctx, GLbitfield mask, GLboolean all,
-/* $Id: svgamesa32.h,v 1.3 2000/11/14 17:40:14 brianp Exp $ */
+/* $Id: svgamesa32.h,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
#ifndef SVGA_MESA_32_H
#define SVGA_MESA_32_H
-extern void __clear_color32( GLcontext *ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
+extern void __clear_color32( GLcontext *ctx, const GLchan color[4] );
extern GLbitfield __clear32( GLcontext *ctx, GLbitfield mask, GLboolean all, GLint x, GLint y, GLint width, GLint height );
extern void __write_rgba_span32( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte rgba[][4], const GLubyte mask[] );
extern void __write_mono_rgba_span32( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLchan color[4], const GLubyte mask[]);
-/* $Id: wmesa.c,v 1.12 2000/11/17 21:01:47 brianp Exp $ */
+/* $Id: wmesa.c,v 1.13 2001/01/24 00:04:59 brianp Exp $ */
/*
* Windows (Win32) device driver for Mesa 3.4
/*
* Set the color used to clear the color buffer.
*/
-static void clear_color( GLcontext* ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+static void clear_color( GLcontext* ctx, const GLchan color[4] )
{
STARTPROFILE
- Current->clearpixel=RGB(r, g, b );
+ Current->clearpixel = RGB(color[0], color[1], color[2]);
ENDPROFILE(clear_color)
}
/*\r
* Set the color used to clear the color buffer.\r
*/\r
-static void clear_color( GLcontext* ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a )\r
+static void clear_color( GLcontext* ctx, const GLchan color[4] )\r
{\r
STARTPROFILE\r
- Current->clearpixel=RGB(r, g, b );\r
+ Current->clearpixel = RGB(color[0], color[1], color[2]);\r
ENDPROFILE(clear_color)\r
}\r
\r
-/* $Id: xm_dd.c,v 1.10 2001/01/16 05:29:43 keithw Exp $ */
+/* $Id: xm_dd.c,v 1.11 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
static void
-clear_color( GLcontext *ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+clear_color( GLcontext *ctx, const GLchan color[4] )
{
const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
- xmesa->clearcolor[0] = r;
- xmesa->clearcolor[1] = g;
- xmesa->clearcolor[2] = b;
- xmesa->clearcolor[3] = a;
- xmesa->clearpixel = xmesa_color_to_pixel( xmesa, r, g, b, a,
+ xmesa->clearcolor[0] = color[0];
+ xmesa->clearcolor[1] = color[1];
+ xmesa->clearcolor[2] = color[2];
+ xmesa->clearcolor[3] = color[3];
+ xmesa->clearpixel = xmesa_color_to_pixel( xmesa, color[0], color[1],
+ color[2], color[3],
xmesa->xm_visual->undithered_pf );
_glthread_LOCK_MUTEX(_xmesa_lock);
XMesaSetForeground( xmesa->display, xmesa->xm_buffer->cleargc,
-/* $Id: xm_span.c,v 1.5 2001/01/08 04:06:20 keithw Exp $ */
+/* $Id: xm_span.c,v 1.6 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
static void
-clear_color_HPCR_ximage( GLcontext *ctx,
- GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+clear_color_HPCR_ximage( GLcontext *ctx, const GLchan color[4] )
{
int i;
const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
- xmesa->clearcolor[0] = r;
- xmesa->clearcolor[1] = g;
- xmesa->clearcolor[2] = b;
- xmesa->clearcolor[3] = a;
- if (r == 0 && g == 0 && b == 0) {
+ COPY_4V(xmesa->clearcolor, color);
+
+ if (color[0] == 0 && color[1] == 0 && color[2] == 0) {
/* black is black */
MEMSET( xmesa->xm_visual->hpcr_clear_ximage_pattern, 0x0 ,
sizeof(xmesa->xm_visual->hpcr_clear_ximage_pattern));
/* build clear pattern */
for (i=0; i<16; i++) {
xmesa->xm_visual->hpcr_clear_ximage_pattern[0][i] =
- DITHER_HPCR(i, 0, r, g, b);
+ DITHER_HPCR(i, 0, color[0], color[1], color[2]);
xmesa->xm_visual->hpcr_clear_ximage_pattern[1][i] =
- DITHER_HPCR(i, 1, r, g, b);
+ DITHER_HPCR(i, 1, color[0], color[1], color[2]);
}
}
}
static void
-clear_color_HPCR_pixmap( GLcontext *ctx,
- GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+clear_color_HPCR_pixmap( GLcontext *ctx, const GLchan color[4] )
{
int i;
const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
- xmesa->clearcolor[0] = r;
- xmesa->clearcolor[1] = g;
- xmesa->clearcolor[2] = b;
- xmesa->clearcolor[3] = a;
+ COPY_4V(xmesa->clearcolor, color);
- if (0x0==r && 0x0==g && 0x0==b) {
+ if (color[0] == 0 && color[1] == 0 && color[2] == 0) {
/* black is black */
for (i=0; i<16; i++) {
XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0, 0);
}
else {
for (i=0; i<16; i++) {
- XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0, DITHER_HPCR(i, 0, r, g, b));
- XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1, DITHER_HPCR(i, 1, r, g, b));
+ XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0,
+ DITHER_HPCR(i, 0, color[0], color[1], color[2]));
+ XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1,
+ DITHER_HPCR(i, 1, color[0], color[1], color[2]));
}
}
/* change tile pixmap content */
-# $Id: Makefile.X11,v 1.39 2001/01/08 21:55:59 keithw Exp $
+# $Id: Makefile.X11,v 1.40 2001/01/24 00:04:58 brianp Exp $
# Mesa 3-D graphics library
# Version: 3.5
X86/common_x86.c \
X86/3dnow.c \
X86/katmai.c \
+ swrast/s_aaline.c \
+ swrast/s_aatriangle.c \
+ swrast/s_accum.c \
+ swrast/s_alpha.c \
+ swrast/s_alphabuf.c \
+ swrast/s_bitmap.c \
+ swrast/s_blend.c \
+ swrast/s_buffers.c \
+ swrast/s_copypix.c \
+ swrast/s_context.c \
+ swrast/s_depth.c \
+ swrast/s_drawpix.c \
+ swrast/s_feedback.c \
+ swrast/s_fog.c \
+ swrast/s_histogram.c \
+ swrast/s_lines.c \
+ swrast/s_logic.c \
+ swrast/s_masking.c \
+ swrast/s_pb.c \
+ swrast/s_pixeltex.c \
+ swrast/s_points.c \
+ swrast/s_quads.c \
+ swrast/s_readpix.c \
+ swrast/s_scissor.c \
+ swrast/s_span.c \
+ swrast/s_stencil.c \
+ swrast/s_texture.c \
+ swrast/s_triangle.c \
+ swrast/s_zoom.c \
swrast_setup/ss_context.c \
swrast_setup/ss_triangle.c \
swrast_setup/ss_vb.c \
tnl/t_vb_render.c \
tnl/t_vb_texgen.c \
tnl/t_vb_texmat.c \
- tnl/t_vb_vertex.c \
- swrast/s_aaline.c \
- swrast/s_aatriangle.c \
- swrast/s_accum.c \
- swrast/s_alpha.c \
- swrast/s_alphabuf.c \
- swrast/s_bitmap.c \
- swrast/s_blend.c \
- swrast/s_buffers.c \
- swrast/s_copypix.c \
- swrast/s_context.c \
- swrast/s_depth.c \
- swrast/s_drawpix.c \
- swrast/s_feedback.c \
- swrast/s_fog.c \
- swrast/s_histogram.c \
- swrast/s_lines.c \
- swrast/s_logic.c \
- swrast/s_masking.c \
- swrast/s_pb.c \
- swrast/s_pixeltex.c \
- swrast/s_points.c \
- swrast/s_quads.c \
- swrast/s_readpix.c \
- swrast/s_scissor.c \
- swrast/s_span.c \
- swrast/s_stencil.c \
- swrast/s_texture.c \
- swrast/s_triangle.c \
- swrast/s_zoom.c
+ tnl/t_vb_vertex.c
DRIVER_SOURCES = \
ADDITIONAL_OBJ =
OBJECTS = $(ASM_SOURCES:.S=.o) \
- $(DRIVER_SOURCES:.c=.o) \
$(CORE_SOURCES:.c=.o) \
+ $(DRIVER_SOURCES:.c=.o) \
$(ADDITIONAL_OBJ)
+/* $Id: api_noop.c,v 1.4 2001/01/24 00:04:58 brianp Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * 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
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
#include "glheader.h"
#include "api_noop.h"
#include "api_validate.h"
void _mesa_noop_Color4ub( GLubyte a, GLubyte b, GLubyte c, GLubyte d )
{
GET_CURRENT_CONTEXT(ctx);
- GLubyte *color = ctx->Current.Color;
- color[0] = a;
- color[1] = b;
- color[2] = c;
- color[3] = d;
+ GLchan *color = ctx->Current.Color;
+ color[0] = UBYTE_TO_CHAN(a);
+ color[1] = UBYTE_TO_CHAN(b);
+ color[2] = UBYTE_TO_CHAN(c);
+ color[3] = UBYTE_TO_CHAN(d);
}
void _mesa_noop_Color4ubv( const GLubyte *v )
{
GET_CURRENT_CONTEXT(ctx);
- GLubyte *color = ctx->Current.Color;
+ GLchan *color = ctx->Current.Color;
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
COPY_4UBV( color, v );
+#else
+ color[0] = UBYTE_TO_CHAN(v[0]);
+ color[1] = UBYTE_TO_CHAN(v[1]);
+ color[2] = UBYTE_TO_CHAN(v[2]);
+ color[3] = UBYTE_TO_CHAN(v[3]);
+#endif
}
void _mesa_noop_Color4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
{
GET_CURRENT_CONTEXT(ctx);
- GLubyte *color = ctx->Current.Color;
- UNCLAMPED_FLOAT_TO_UBYTE(color[0], a);
- UNCLAMPED_FLOAT_TO_UBYTE(color[1], b);
- UNCLAMPED_FLOAT_TO_UBYTE(color[2], c);
- UNCLAMPED_FLOAT_TO_UBYTE(color[3], d);
+ GLchan *color = ctx->Current.Color;
+ UNCLAMPED_FLOAT_TO_CHAN(color[0], a);
+ UNCLAMPED_FLOAT_TO_CHAN(color[1], b);
+ UNCLAMPED_FLOAT_TO_CHAN(color[2], c);
+ UNCLAMPED_FLOAT_TO_CHAN(color[3], d);
}
void _mesa_noop_Color4fv( const GLfloat *v )
{
GET_CURRENT_CONTEXT(ctx);
- GLubyte *color = ctx->Current.Color;
+ GLchan *color = ctx->Current.Color;
UNCLAMPED_FLOAT_TO_CHAN(color[0], v[0]);
UNCLAMPED_FLOAT_TO_CHAN(color[1], v[1]);
UNCLAMPED_FLOAT_TO_CHAN(color[2], v[2]);
void _mesa_noop_Color3ub( GLubyte a, GLubyte b, GLubyte c )
{
GET_CURRENT_CONTEXT(ctx);
- GLubyte *color = ctx->Current.Color;
- color[0] = a;
- color[1] = b;
- color[2] = c;
- color[3] = 255;
+ GLchan *color = ctx->Current.Color;
+ color[0] = UBYTE_TO_CHAN(a);
+ color[1] = UBYTE_TO_CHAN(b);
+ color[2] = UBYTE_TO_CHAN(c);
+ color[3] = CHAN_MAX;
}
void _mesa_noop_Color3ubv( const GLubyte *v )
{
GET_CURRENT_CONTEXT(ctx);
- GLubyte *color = ctx->Current.Color;
- color[0] = v[0];
- color[1] = v[1];
- color[2] = v[2];
- color[3] = 255;
+ GLchan *color = ctx->Current.Color;
+ color[0] = UBYTE_TO_CHAN(v[0]);
+ color[1] = UBYTE_TO_CHAN(v[1]);
+ color[2] = UBYTE_TO_CHAN(v[2]);
+ color[3] = CHAN_MAX;
}
void _mesa_noop_Color3f( GLfloat a, GLfloat b, GLfloat c )
{
GET_CURRENT_CONTEXT(ctx);
- GLubyte *color = ctx->Current.Color;
- UNCLAMPED_FLOAT_TO_UBYTE(color[0], a);
- UNCLAMPED_FLOAT_TO_UBYTE(color[1], b);
- UNCLAMPED_FLOAT_TO_UBYTE(color[2], c);
- color[3] = 255;
+ GLchan *color = ctx->Current.Color;
+ UNCLAMPED_FLOAT_TO_CHAN(color[0], a);
+ UNCLAMPED_FLOAT_TO_CHAN(color[1], b);
+ UNCLAMPED_FLOAT_TO_CHAN(color[2], c);
+ color[3] = CHAN_MAX;
}
void _mesa_noop_Color3fv( const GLfloat *v )
{
GET_CURRENT_CONTEXT(ctx);
- GLubyte *color = ctx->Current.Color;
+ GLchan *color = ctx->Current.Color;
UNCLAMPED_FLOAT_TO_CHAN(color[0], v[0]);
UNCLAMPED_FLOAT_TO_CHAN(color[1], v[1]);
UNCLAMPED_FLOAT_TO_CHAN(color[2], v[2]);
- color[3] = 255;
+ color[3] = CHAN_MAX;
}
void _mesa_noop_MultiTexCoord1fARB( GLenum target, GLfloat a )
void _mesa_noop_SecondaryColor3ubEXT( GLubyte a, GLubyte b, GLubyte c )
{
GET_CURRENT_CONTEXT(ctx);
- GLubyte *color = ctx->Current.SecondaryColor;
- color[0] = a;
- color[1] = b;
- color[2] = c;
- color[3] = 255;
+ GLchan *color = ctx->Current.SecondaryColor;
+ color[0] = UBYTE_TO_CHAN(a);
+ color[1] = UBYTE_TO_CHAN(b);
+ color[2] = UBYTE_TO_CHAN(c);
+ color[3] = CHAN_MAX;
}
void _mesa_noop_SecondaryColor3ubvEXT( const GLubyte *v )
{
GET_CURRENT_CONTEXT(ctx);
- GLubyte *color = ctx->Current.SecondaryColor;
- color[0] = v[0];
- color[1] = v[1];
- color[2] = v[2];
- color[3] = 255;
+ GLchan *color = ctx->Current.SecondaryColor;
+ color[0] = UBYTE_TO_CHAN(v[0]);
+ color[1] = UBYTE_TO_CHAN(v[1]);
+ color[2] = UBYTE_TO_CHAN(v[2]);
+ color[3] = CHAN_MAX;
}
void _mesa_noop_SecondaryColor3fEXT( GLfloat a, GLfloat b, GLfloat c )
{
GET_CURRENT_CONTEXT(ctx);
- GLubyte *color = ctx->Current.SecondaryColor;
- UNCLAMPED_FLOAT_TO_UBYTE(color[0], a);
- UNCLAMPED_FLOAT_TO_UBYTE(color[1], b);
- UNCLAMPED_FLOAT_TO_UBYTE(color[2], c);
- color[3] = 255;
+ GLchan *color = ctx->Current.SecondaryColor;
+ UNCLAMPED_FLOAT_TO_CHAN(color[0], a);
+ UNCLAMPED_FLOAT_TO_CHAN(color[1], b);
+ UNCLAMPED_FLOAT_TO_CHAN(color[2], c);
+ color[3] = CHAN_MAX;
}
void _mesa_noop_SecondaryColor3fvEXT( const GLfloat *v )
{
GET_CURRENT_CONTEXT(ctx);
- GLubyte *color = ctx->Current.SecondaryColor;
+ GLchan *color = ctx->Current.SecondaryColor;
UNCLAMPED_FLOAT_TO_CHAN(color[0], v[0]);
UNCLAMPED_FLOAT_TO_CHAN(color[1], v[1]);
UNCLAMPED_FLOAT_TO_CHAN(color[2], v[2]);
- color[3] = 255;
+ color[3] = CHAN_MAX;
}
void _mesa_noop_TexCoord1f( GLfloat a )
-/* $Id: attrib.c,v 1.40 2001/01/23 23:39:36 brianp Exp $ */
+/* $Id: attrib.c,v 1.41 2001/01/24 00:04:58 brianp Exp $ */
/*
* Mesa 3-D graphics library
ctx->Driver.LogicOpcode( ctx, ctx->Color.LogicOp );
}
if (ctx->Visual.rgbMode) {
- GLchan r = (GLint) (ctx->Color.ClearColor[0] * CHAN_MAXF);
- GLchan g = (GLint) (ctx->Color.ClearColor[1] * CHAN_MAXF);
- GLchan b = (GLint) (ctx->Color.ClearColor[2] * CHAN_MAXF);
- GLchan a = (GLint) (ctx->Color.ClearColor[3] * CHAN_MAXF);
- (*ctx->Driver.ClearColor)( ctx, r, g, b, a );
+ (*ctx->Driver.ClearColor)(ctx, ctx->Color.ClearColor);
if ((ctx->Color.AlphaFunc != oldAlphaFunc ||
ctx->Color.AlphaRef != oldAlphaRef) &&
ctx->Driver.AlphaFunc)
-/* $Id: buffers.c,v 1.23 2001/01/23 23:39:36 brianp Exp $ */
+/* $Id: buffers.c,v 1.24 2001/01/24 00:04:58 brianp Exp $ */
/*
* Mesa 3-D graphics library
#include "glheader.h"
#include "accum.h"
#include "buffers.h"
+#include "colormac.h"
#include "context.h"
#include "depth.h"
#include "enums.h"
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
- if (ctx->Color.ClearIndex == (GLuint)c)
+ if (ctx->Color.ClearIndex == (GLuint) c)
return;
-
FLUSH_VERTICES(ctx, _NEW_COLOR);
ctx->Color.ClearIndex = (GLuint) c;
- if (!ctx->Visual.rgbMode) {
+ if (!ctx->Visual.rgbMode && ctx->Driver.ClearIndex) {
/* it's OK to call glClearIndex in RGBA mode but it should be a NOP */
(*ctx->Driver.ClearIndex)( ctx, ctx->Color.ClearIndex );
}
void
-_mesa_ClearColor( GLclampf red, GLclampf green,
- GLclampf blue, GLclampf alpha )
+_mesa_ClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
{
- GLfloat tmp[4];
+ GLchan tmp[4];
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
- tmp[0] = CLAMP( red, 0.0, 1.0 );
- tmp[1] = CLAMP( green, 0.0, 1.0 );
- tmp[2] = CLAMP( blue, 0.0, 1.0 );
- tmp[3] = CLAMP( alpha, 0.0, 1.0 );
+ UNCLAMPED_FLOAT_TO_CHAN(tmp[0], red);
+ UNCLAMPED_FLOAT_TO_CHAN(tmp[1], green);
+ UNCLAMPED_FLOAT_TO_CHAN(tmp[2], blue);
+ UNCLAMPED_FLOAT_TO_CHAN(tmp[3], alpha);
if (TEST_EQ_4V(tmp, ctx->Color.ClearColor))
return;
FLUSH_VERTICES(ctx, _NEW_COLOR);
- COPY_4FV( ctx->Color.ClearColor, tmp );
-
- if (ctx->Visual.rgbMode) {
- GLchan r = (GLint) (ctx->Color.ClearColor[0] * CHAN_MAXF);
- GLchan g = (GLint) (ctx->Color.ClearColor[1] * CHAN_MAXF);
- GLchan b = (GLint) (ctx->Color.ClearColor[2] * CHAN_MAXF);
- GLchan a = (GLint) (ctx->Color.ClearColor[3] * CHAN_MAXF);
- (*ctx->Driver.ClearColor)( ctx, r, g, b, a );
+ COPY_CHAN4(ctx->Color.ClearColor, tmp);
+
+ if (ctx->Visual.rgbMode && ctx->Driver.ClearColor) {
+ /* it's OK to call glClearColor in CI mode but it should be a NOP */
+ (*ctx->Driver.ClearColor)(ctx, ctx->Color.ClearColor);
}
}
-
-
-
void
_mesa_Clear( GLbitfield mask )
{
-/* $Id: context.c,v 1.117 2001/01/23 23:39:36 brianp Exp $ */
+/* $Id: context.c,v 1.118 2001/01/24 00:04:58 brianp Exp $ */
/*
* Mesa 3-D graphics library
ctx->Color.ColorMask[2] = 0xff;
ctx->Color.ColorMask[3] = 0xff;
ctx->Color.ClearIndex = 0;
- ASSIGN_4V( ctx->Color.ClearColor, 0.0, 0.0, 0.0, 0.0 );
+ ASSIGN_4V( ctx->Color.ClearColor, 0, 0, 0, 0 );
ctx->Color.DrawBuffer = GL_FRONT;
ctx->Color.AlphaEnabled = GL_FALSE;
ctx->Color.AlphaFunc = GL_ALWAYS;
-/* $Id: dd.h,v 1.47 2001/01/09 00:02:55 brianp Exp $ */
+/* $Id: dd.h,v 1.48 2001/01/24 00:04:58 brianp Exp $ */
/*
* Mesa 3-D graphics library
* LineFunc, or TriangleFunc).
*/
- void (*ClearIndex)( GLcontext *ctx, GLuint index );
- /*
- * Called whenever glClearIndex() is called. Set the index for clearing
- * the color buffer when in color index mode.
- */
-
- void (*ClearColor)( GLcontext *ctx, GLchan red, GLchan green,
- GLchan blue, GLchan alpha );
- /*
- * Called whenever glClearColor() is called. Set the color for clearing
- * the color buffer when in RGBA mode.
- */
-
GLbitfield (*Clear)( GLcontext *ctx, GLbitfield mask, GLboolean all,
GLint x, GLint y, GLint width, GLint height );
/* Clear the color/depth/stencil/accum buffer(s).
void (*BlendFuncSeparate)(GLcontext *ctx,
GLenum sfactorRGB, GLenum dfactorRGB,
GLenum sfactorA, GLenum dfactorA);
+ void (*ClearColor)(GLcontext *ctx, const GLchan color[4]);
void (*ClearDepth)(GLcontext *ctx, GLclampd d);
+ void (*ClearIndex)(GLcontext *ctx, GLuint index);
void (*ClearStencil)(GLcontext *ctx, GLint s);
void (*ColorMask)(GLcontext *ctx, GLboolean rmask, GLboolean gmask,
GLboolean bmask, GLboolean amask );
-/* $Id: get.c,v 1.50 2001/01/23 23:39:36 brianp Exp $ */
+/* $Id: get.c,v 1.51 2001/01/24 00:04:58 brianp Exp $ */
/*
* Mesa 3-D graphics library
*params = ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
break;
case GL_COLOR_CLEAR_VALUE:
- params[0] = FLOAT_TO_BOOL(ctx->Color.ClearColor[0]);
- params[1] = FLOAT_TO_BOOL(ctx->Color.ClearColor[1]);
- params[2] = FLOAT_TO_BOOL(ctx->Color.ClearColor[2]);
- params[3] = FLOAT_TO_BOOL(ctx->Color.ClearColor[3]);
+ params[0] = ctx->Color.ClearColor[0] ? GL_TRUE : GL_FALSE;
+ params[1] = ctx->Color.ClearColor[1] ? GL_TRUE : GL_FALSE;
+ params[2] = ctx->Color.ClearColor[2] ? GL_TRUE : GL_FALSE;
+ params[3] = ctx->Color.ClearColor[3] ? GL_TRUE : GL_FALSE;
break;
case GL_COLOR_MATERIAL:
*params = ctx->Light.ColorMaterialEnabled;
*params = (GLdouble) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
break;
case GL_COLOR_CLEAR_VALUE:
- params[0] = (GLdouble) ctx->Color.ClearColor[0];
- params[1] = (GLdouble) ctx->Color.ClearColor[1];
- params[2] = (GLdouble) ctx->Color.ClearColor[2];
- params[3] = (GLdouble) ctx->Color.ClearColor[3];
+ params[0] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[0]);
+ params[1] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[1]);
+ params[2] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[2]);
+ params[3] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[3]);
break;
case GL_COLOR_MATERIAL:
*params = (GLdouble) ctx->Light.ColorMaterialEnabled;
*params = (GLfloat) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
break;
case GL_COLOR_CLEAR_VALUE:
- params[0] = (GLfloat) ctx->Color.ClearColor[0];
- params[1] = (GLfloat) ctx->Color.ClearColor[1];
- params[2] = (GLfloat) ctx->Color.ClearColor[2];
- params[3] = (GLfloat) ctx->Color.ClearColor[3];
+ params[0] = CHAN_TO_FLOAT(ctx->Color.ClearColor[0]);
+ params[1] = CHAN_TO_FLOAT(ctx->Color.ClearColor[1]);
+ params[2] = CHAN_TO_FLOAT(ctx->Color.ClearColor[2]);
+ params[3] = CHAN_TO_FLOAT(ctx->Color.ClearColor[3]);
break;
case GL_COLOR_MATERIAL:
*params = (GLfloat) ctx->Light.ColorMaterialEnabled;
*params = (GLint) ctx->Transform.ClipEnabled[i];
break;
case GL_COLOR_CLEAR_VALUE:
- params[0] = FLOAT_TO_INT( ctx->Color.ClearColor[0] );
- params[1] = FLOAT_TO_INT( ctx->Color.ClearColor[1] );
- params[2] = FLOAT_TO_INT( ctx->Color.ClearColor[2] );
- params[3] = FLOAT_TO_INT( ctx->Color.ClearColor[3] );
+ params[0] = FLOAT_TO_INT( CHAN_TO_FLOAT(ctx->Color.ClearColor[0]) );
+ params[1] = FLOAT_TO_INT( CHAN_TO_FLOAT(ctx->Color.ClearColor[1]) );
+ params[2] = FLOAT_TO_INT( CHAN_TO_FLOAT(ctx->Color.ClearColor[2]) );
+ params[3] = FLOAT_TO_INT( CHAN_TO_FLOAT(ctx->Color.ClearColor[3]) );
break;
case GL_COLOR_MATERIAL:
*params = (GLint) ctx->Light.ColorMaterialEnabled;
-/* $Id: macros.h,v 1.17 2001/01/08 04:09:41 keithw Exp $ */
+/* $Id: macros.h,v 1.18 2001/01/24 00:04:58 brianp Exp $ */
/*
* Mesa 3-D graphics library
#define STRIDE_F(p, i) (p = (GLfloat *)((GLubyte *)p + i))
#define STRIDE_UI(p, i) (p = (GLuint *)((GLubyte *)p + i))
#define STRIDE_4UB(p, i) (p = (GLubyte (*)[4])((GLubyte *)p + i))
+#define STRIDE_4CHAN(p, i) (p = (GLchan (*)[4])((GLchan *)p + i))
#define STRIDE_T(p, t, i) (p = (t)((GLubyte *)p + i))
-/* $Id: mtypes.h,v 1.14 2001/01/23 23:39:36 brianp Exp $ */
+/* $Id: mtypes.h,v 1.15 2001/01/24 00:04:58 brianp Exp $ */
/*
* Mesa 3-D graphics library
struct gl_colorbuffer_attrib {
GLuint ClearIndex; /* Index to use for glClear */
- GLfloat ClearColor[4]; /* Color to use for glClear */
+ GLchan ClearColor[4]; /* Color to use for glClear */
GLuint IndexMask; /* Color index write mask */
GLubyte ColorMask[4]; /* Each flag is 0xff or 0x0 */
-/* $Id: texstate.c,v 1.27 2001/01/06 22:46:13 gareth Exp $ */
+/* $Id: texstate.c,v 1.28 2001/01/24 00:04:58 brianp Exp $ */
/*
* Mesa 3-D graphics library
}
break;
case GL_TEXTURE_BORDER_COLOR:
- texObj->BorderColor[0] = (GLchan) CLAMP((GLint)(params[0]*CHAN_MAXF), 0, CHAN_MAX);
- texObj->BorderColor[1] = (GLchan) CLAMP((GLint)(params[1]*CHAN_MAXF), 0, CHAN_MAX);
- texObj->BorderColor[2] = (GLchan) CLAMP((GLint)(params[2]*CHAN_MAXF), 0, CHAN_MAX);
- texObj->BorderColor[3] = (GLchan) CLAMP((GLint)(params[3]*CHAN_MAXF), 0, CHAN_MAX);
+ UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[0], params[0]);
+ UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[1], params[1]);
+ UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[2], params[2]);
+ UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[3], params[3]);
break;
case GL_TEXTURE_MIN_LOD:
texObj->MinLod = params[0];
-/* $Id: texutil.h,v 1.6 2000/11/22 07:32:17 joukj Exp $ */
+/* $Id: texutil.h,v 1.7 2001/01/24 00:04:58 brianp Exp $ */
/*
* Mesa 3-D graphics library
GLint srcWidth, GLint srcHeight,
const GLvoid *srcImage, GLint srcRowStride,
GLint dstWidth, GLint dstHeight,
- GLenum dstFormat, GLchan *dstImage);
+ GLenum dstFormat, GLubyte *dstImage);
extern void
-/* $Id: m_trans_tmp.h,v 1.2 2001/01/02 22:02:52 brianp Exp $ */
+/* $Id: m_trans_tmp.h,v 1.3 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
* Version: 3.5
*
- * Copyright (C) 1999 Brian Paul All Rights Reserved.
+ * 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"),
#ifdef DEST_4UB
static void DEST_4UB( GLubyte (*t)[4],
- CONST void *ptr,
- GLuint stride,
- ARGS)
+ CONST void *ptr,
+ GLuint stride,
+ ARGS)
{
const GLubyte *f = (GLubyte *) ptr + SRC_START * stride;
const GLubyte *first = f;
#endif
+#ifdef DEST_4US
+static void DEST_4US( GLushort (*t)[4],
+ CONST void *ptr,
+ GLuint stride,
+ ARGS)
+{
+ const GLushort *f = (GLushort *) ptr + SRC_START * stride;
+ const GLushort *first = f;
+ GLuint i;
+ (void) start;
+ (void) first;
+ for (i = DST_START ; i < n ; i++, NEXT_F) {
+ CHECK {
+ NEXT_F2;
+ if (SZ >= 1) TRX_US(t[i][0], f, 0);
+ if (SZ >= 2) TRX_US(t[i][1], f, 1);
+ if (SZ >= 3) TRX_US(t[i][2], f, 2);
+ if (SZ == 4) TRX_US(t[i][3], f, 3); else t[i][3] = 65535;
+ }
+ }
+}
+#endif
+
+
#ifdef DEST_1UB
static void DEST_1UB( GLubyte *t,
CONST void *ptr,
#ifdef DEST_4UB
TAB(_4ub)[SZ][SRC_IDX] = DEST_4UB;
#endif
+#ifdef DEST_4US
+ TAB(_4us)[SZ][SRC_IDX] = DEST_4US;
+#endif
#ifdef DEST_4F
TAB(_4f)[SZ][SRC_IDX] = DEST_4F;
#endif
#undef DEST_1UI
#undef DEST_1UB
#undef DEST_4UB
+#undef DEST_4US
#undef DEST_3F
#undef DEST_4F
#undef DEST_1F
-/* $Id: m_translate.c,v 1.3 2001/01/02 22:02:52 brianp Exp $ */
+/* $Id: m_translate.c,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
- * Version: 3.3
+ * Version: 3.5
*
- * Copyright (C) 1999 Brian Paul All Rights Reserved.
+ * 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"),
GLuint n );
typedef void (*trans_4ub_func)(GLubyte (*to)[4],
- CONST void *ptr,
- GLuint stride,
- GLuint start,
- GLuint n );
+ CONST void *ptr,
+ GLuint stride,
+ GLuint start,
+ GLuint n );
+
+typedef void (*trans_4us_func)(GLushort (*to)[4],
+ CONST void *ptr,
+ GLuint stride,
+ GLuint start,
+ GLuint n );
typedef void (*trans_4f_func)(GLfloat (*to)[4],
CONST void *ptr,
static trans_1ub_func _math_trans_1ub_tab[MAX_TYPES];
static trans_3f_func _math_trans_3f_tab[MAX_TYPES];
static trans_4ub_func _math_trans_4ub_tab[5][MAX_TYPES];
+static trans_4us_func _math_trans_4us_tab[5][MAX_TYPES];
static trans_4f_func _math_trans_4f_tab[5][MAX_TYPES];
/* GL_BYTE
*/
-#define BYTE_TO_UBYTE(b) (b < 0 ? 0 : (GLubyte) b)
-
#define SRC GLbyte
#define SRC_IDX TYPE_IDX(GL_BYTE)
#define TRX_3F(f,n) BYTE_TO_FLOAT( PTR_ELT(f,n) )
#define TRX_4F(f,n) (GLfloat)( PTR_ELT(f,n) )
#define TRX_UB(ub, f,n) ub = BYTE_TO_UBYTE( PTR_ELT(f,n) )
+#define TRX_US(ch, f,n) ch = BYTE_TO_USHORT( PTR_ELT(f,n) )
#define TRX_UI(f,n) (PTR_ELT(f,n) < 0 ? 0 : (GLuint) PTR_ELT(f,n))
#define INIT init_trans_4_GLbyte_raw
#define DEST_4F trans_4_GLbyte_4f_raw
#define DEST_4UB trans_4_GLbyte_4ub_raw
+#define DEST_4US trans_4_GLbyte_4us_raw
#include "m_trans_tmp.h"
#define SZ 3
#define INIT init_trans_3_GLbyte_raw
#define DEST_4F trans_3_GLbyte_4f_raw
#define DEST_4UB trans_3_GLbyte_4ub_raw
+#define DEST_4US trans_3_GLbyte_4us_raw
#define DEST_3F trans_3_GLbyte_3f_raw
#include "m_trans_tmp.h"
#undef TRX_3F
#undef TRX_4F
#undef TRX_UB
+#undef TRX_US
#undef TRX_UI
#undef SRC_IDX
+
/* GL_UNSIGNED_BYTE
*/
#define SRC GLubyte
#define TRX_3F(f,n) /* unused */
#define TRX_4F(f,n) /* unused */
#define TRX_UB(ub, f,n) ub = PTR_ELT(f,n)
+#define TRX_US(us, f,n) us = UBYTE_TO_USHORT(PTR_ELT(f,n))
#define TRX_UI(f,n) (GLuint)PTR_ELT(f,n)
/* 4ub->4ub handled in special case below.
#define SZ 3
#define INIT init_trans_3_GLubyte_raw
#define DEST_4UB trans_3_GLubyte_4ub_raw
+#define DEST_4US trans_3_GLubyte_4us_raw
#include "m_trans_tmp.h"
#undef TRX_3F
#undef TRX_4F
#undef TRX_UB
+#undef TRX_US
#undef TRX_UI
#define TRX_3F(f,n) SHORT_TO_FLOAT( PTR_ELT(f,n) )
#define TRX_4F(f,n) (GLfloat)( PTR_ELT(f,n) )
#define TRX_UB(ub, f,n) ub = SHORT_TO_UBYTE(PTR_ELT(f,n))
+#define TRX_US(us, f,n) us = SHORT_TO_USHORT(PTR_ELT(f,n))
#define TRX_UI(f,n) (PTR_ELT(f,n) < 0 ? 0 : (GLuint) PTR_ELT(f,n))
#define INIT init_trans_4_GLshort_raw
#define DEST_4F trans_4_GLshort_4f_raw
#define DEST_4UB trans_4_GLshort_4ub_raw
+#define DEST_4US trans_4_GLshort_4us_raw
#include "m_trans_tmp.h"
#define SZ 3
#define INIT init_trans_3_GLshort_raw
#define DEST_4F trans_3_GLshort_4f_raw
#define DEST_4UB trans_3_GLshort_4ub_raw
+#define DEST_4US trans_3_GLshort_4us_raw
#define DEST_3F trans_3_GLshort_3f_raw
#include "m_trans_tmp.h"
#undef TRX_3F
#undef TRX_4F
#undef TRX_UB
+#undef TRX_US
#undef TRX_UI
#define TRX_3F(f,n) USHORT_TO_FLOAT( PTR_ELT(f,n) )
#define TRX_4F(f,n) (GLfloat)( PTR_ELT(f,n) )
#define TRX_UB(ub,f,n) ub = (GLubyte) (PTR_ELT(f,n) >> 8)
+#define TRX_US(us,f,n) us = (GLushort) (PTR_ELT(f,n) >> 8)
#define TRX_UI(f,n) (GLuint) PTR_ELT(f,n)
#define INIT init_trans_4_GLushort_raw
#define DEST_4F trans_4_GLushort_4f_raw
#define DEST_4UB trans_4_GLushort_4ub_raw
+#define DEST_4US trans_4_GLushort_4us_raw
#include "m_trans_tmp.h"
#define SZ 3
#define INIT init_trans_3_GLushort_raw
#define DEST_4F trans_3_GLushort_4f_raw
#define DEST_4UB trans_3_GLushort_4ub_raw
+#define DEST_4US trans_3_GLushort_4us_raw
#define DEST_3F trans_3_GLushort_3f_raw
#include "m_trans_tmp.h"
#undef TRX_3F
#undef TRX_4F
#undef TRX_UB
+#undef TRX_US
#undef TRX_UI
#define TRX_3F(f,n) INT_TO_FLOAT( PTR_ELT(f,n) )
#define TRX_4F(f,n) (GLfloat)( PTR_ELT(f,n) )
#define TRX_UB(ub, f,n) ub = INT_TO_UBYTE(PTR_ELT(f,n))
+#define TRX_US(us, f,n) us = INT_TO_USHORT(PTR_ELT(f,n))
#define TRX_UI(f,n) (PTR_ELT(f,n) < 0 ? 0 : (GLuint) PTR_ELT(f,n))
#define INIT init_trans_4_GLint_raw
#define DEST_4F trans_4_GLint_4f_raw
#define DEST_4UB trans_4_GLint_4ub_raw
+#define DEST_4US trans_4_GLint_4us_raw
#include "m_trans_tmp.h"
#define SZ 3
#define INIT init_trans_3_GLint_raw
#define DEST_4F trans_3_GLint_4f_raw
#define DEST_4UB trans_3_GLint_4ub_raw
+#define DEST_4US trans_3_GLint_4us_raw
#define DEST_3F trans_3_GLint_3f_raw
#include "m_trans_tmp.h"
#undef TRX_3F
#undef TRX_4F
#undef TRX_UB
+#undef TRX_US
#undef TRX_UI
#define TRX_3F(f,n) INT_TO_FLOAT( PTR_ELT(f,n) )
#define TRX_4F(f,n) (GLfloat)( PTR_ELT(f,n) )
#define TRX_UB(ub, f,n) ub = (GLubyte) (PTR_ELT(f,n) >> 24)
+#define TRX_US(us, f,n) us = (GLshort) (PTR_ELT(f,n) >> 16)
#define TRX_UI(f,n) PTR_ELT(f,n)
#define INIT init_trans_4_GLuint_raw
#define DEST_4F trans_4_GLuint_4f_raw
#define DEST_4UB trans_4_GLuint_4ub_raw
+#define DEST_4US trans_4_GLuint_4us_raw
#include "m_trans_tmp.h"
#define SZ 3
#define INIT init_trans_3_GLuint_raw
#define DEST_4F trans_3_GLuint_4f_raw
#define DEST_4UB trans_3_GLuint_4ub_raw
+#define DEST_4US trans_3_GLuint_4us_raw
#define DEST_3F trans_3_GLuint_3f_raw
#include "m_trans_tmp.h"
#undef TRX_3F
#undef TRX_4F
#undef TRX_UB
+#undef TRX_US
#undef TRX_UI
#define SRC_IDX TYPE_IDX(GL_DOUBLE)
#define TRX_3F(f,n) PTR_ELT(f,n)
#define TRX_4F(f,n) PTR_ELT(f,n)
-#define TRX_UB(ub,f,n) UNCLAMPED_FLOAT_TO_CHAN(ub, PTR_ELT(f,n))
+#define TRX_UB(ub,f,n) UNCLAMPED_FLOAT_TO_UBYTE(ub, PTR_ELT(f,n))
+#define TRX_US(us,f,n) UNCLAMPED_FLOAT_TO_USHORT(us, PTR_ELT(f,n))
#define TRX_UI(f,n) (GLuint) (GLint) PTR_ELT(f,n)
#define TRX_1F(f,n) PTR_ELT(f,n)
#define INIT init_trans_4_GLdouble_raw
#define DEST_4F trans_4_GLdouble_4f_raw
#define DEST_4UB trans_4_GLdouble_4ub_raw
+#define DEST_4US trans_4_GLdouble_4us_raw
#include "m_trans_tmp.h"
#define SZ 3
#define INIT init_trans_3_GLdouble_raw
#define DEST_4F trans_3_GLdouble_4f_raw
#define DEST_4UB trans_3_GLdouble_4ub_raw
+#define DEST_4US trans_3_GLdouble_4us_raw
#define DEST_3F trans_3_GLdouble_3f_raw
#include "m_trans_tmp.h"
#define SZ 4
#define INIT init_trans_4_GLfloat_raw
#define DEST_4UB trans_4_GLfloat_4ub_raw
+#define DEST_4US trans_4_GLfloat_4us_raw
#define DEST_4F trans_4_GLfloat_4f_raw
#include "m_trans_tmp.h"
#define INIT init_trans_3_GLfloat_raw
#define DEST_4F trans_3_GLfloat_4f_raw
#define DEST_4UB trans_3_GLfloat_4ub_raw
+#define DEST_4US trans_3_GLfloat_4us_raw
#define DEST_3F trans_3_GLfloat_3f_raw
#include "m_trans_tmp.h"
#undef TRX_3F
#undef TRX_4F
#undef TRX_UB
+#undef TRX_US
#undef TRX_UI
-static void trans_4_GLubyte_4ub_raw (GLubyte (*t)[4],
- CONST void *Ptr,
- GLuint stride,
- ARGS )
+static void trans_4_GLubyte_4ub_raw(GLubyte (*t)[4],
+ CONST void *Ptr,
+ GLuint stride,
+ ARGS )
{
const GLubyte *f = (GLubyte *) Ptr + SRC_START * stride;
GLuint i;
MEMSET( TAB(_1ub), 0, sizeof(TAB(_1ub)) );
MEMSET( TAB(_3f), 0, sizeof(TAB(_3f)) );
MEMSET( TAB(_4ub), 0, sizeof(TAB(_4ub)) );
+ MEMSET( TAB(_4us), 0, sizeof(TAB(_4us)) );
MEMSET( TAB(_4f), 0, sizeof(TAB(_4f)) );
TAB(_4ub)[4][TYPE_IDX(GL_UNSIGNED_BYTE)] = trans_4_GLubyte_4ub_raw;
_math_trans_4ub_tab[size][TYPE_IDX(type)]( to, ptr, stride, start, n );
}
+void _math_trans_4us(GLushort (*to)[4],
+ CONST void *ptr,
+ GLuint stride,
+ GLenum type,
+ GLuint size,
+ GLuint start,
+ GLuint n )
+{
+ _math_trans_4us_tab[size][TYPE_IDX(type)]( to, ptr, stride, start, n );
+}
+
void _math_trans_4f(GLfloat (*to)[4],
CONST void *ptr,
GLuint stride,
-/* $Id: m_translate.h,v 1.3 2000/12/26 05:09:31 keithw Exp $ */
+/* $Id: m_translate.h,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
- * Version: 3.1
+ * Version: 3.5
*
- * Copyright (C) 1999 Brian Paul All Rights Reserved.
+ * 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"),
GLuint start,
GLuint n );
+extern void _math_trans_4us(GLushort (*to)[4],
+ CONST void *ptr,
+ GLuint stride,
+ GLenum type,
+ GLuint size,
+ GLuint start,
+ GLuint n );
+
extern void _math_trans_4f(GLfloat (*to)[4],
CONST void *ptr,
GLuint stride,
-/* $Id: m_vector.c,v 1.2 2000/12/26 05:09:31 keithw Exp $ */
+/* $Id: m_vector.c,v 1.3 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
* Version: 3.5
*
- * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
+ * 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"),
v->flags = flags ;
}
+void gl_vector4us_init( GLvector4us *v, GLuint flags, GLushort (*storage)[4] )
+{
+ v->stride = 4 * sizeof(GLushort);
+ v->data = storage;
+ v->start = (GLushort *) storage;
+ v->count = 0;
+ v->flags = flags ;
+}
+
void gl_vector1ub_init( GLvector1ub *v, GLuint flags, GLubyte *storage )
{
v->stride = 1 * sizeof(GLubyte);
v->flags = flags | VEC_MALLOC ;
}
+void gl_vector4us_alloc( GLvector4us *v, GLuint flags, GLuint count,
+ GLuint alignment )
+{
+ v->stride = 4 * sizeof(GLushort);
+ v->storage = ALIGN_MALLOC( count * 4 * sizeof(GLushort), alignment );
+ v->start = (GLushort *) v->storage;
+ v->data = (GLushort (*)[4]) v->storage;
+ v->count = 0;
+ v->flags = flags | VEC_MALLOC ;
+}
+
void gl_vector1ub_alloc( GLvector1ub *v, GLuint flags, GLuint count,
GLuint alignment )
{
}
}
+void gl_vector4us_free( GLvector4us *v )
+{
+ if (v->flags & VEC_MALLOC) {
+ ALIGN_FREE( v->storage );
+ v->data = NULL;
+ v->start = NULL;
+ v->storage = NULL;
+ v->flags &= ~VEC_MALLOC;
+ }
+}
+
void gl_vector1ub_free( GLvector1ub *v )
{
if (v->flags & VEC_MALLOC) {
-/* $Id: m_vector.h,v 1.2 2000/12/26 05:09:31 keithw Exp $ */
+/* $Id: m_vector.h,v 1.3 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
* Version: 3.5
*
- * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
+ * 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"),
+/* For 4 * GLushort rgba values.
+ */
+typedef struct {
+ GLushort (*data)[4];
+ GLushort *start;
+ GLuint count;
+ GLuint stride;
+ GLuint flags;
+ void *storage;
+} GLvector4us;
+
+extern void gl_vector4us_init( GLvector4us *v, GLuint flags,
+ GLushort (*storage)[4] );
+extern void gl_vector4us_alloc( GLvector4us *v, GLuint flags, GLuint count,
+ GLuint alignment );
+extern void gl_vector4us_free( GLvector4us * );
+
+
+
/* For 1ub values, eg edgeflag.
*/
-/* $Id: s_alphabuf.c,v 1.3 2001/01/23 23:39:37 brianp Exp $ */
+/* $Id: s_alphabuf.c,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
void
_mesa_clear_alpha_buffers( GLcontext *ctx )
{
- const GLchan aclear = (GLint) (ctx->Color.ClearColor[3] * CHAN_MAXF);
+ const GLchan aclear = ctx->Color.ClearColor[3];
GLuint bufferBit;
ASSERT(ctx->DrawBuffer->UseSoftwareAlphaBuffers);
-/* $Id: s_buffers.c,v 1.3 2001/01/23 23:39:37 brianp Exp $ */
+/* $Id: s_buffers.c,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
if (ctx->Visual.rgbMode) {
/* RGBA mode */
- const GLchan r = (GLint) (ctx->Color.ClearColor[0] * CHAN_MAXF);
- const GLchan g = (GLint) (ctx->Color.ClearColor[1] * CHAN_MAXF);
- const GLchan b = (GLint) (ctx->Color.ClearColor[2] * CHAN_MAXF);
- const GLchan a = (GLint) (ctx->Color.ClearColor[3] * CHAN_MAXF);
+ 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];
GLint i;
for (i = 0; i < height; i++) {
GLchan rgba[MAX_WIDTH][4];
GLint j;
- for (j=0; j<width; j++) {
+ for (j = 0; j < width; j++) {
rgba[j][RCOMP] = r;
rgba[j][GCOMP] = g;
rgba[j][BCOMP] = b;
if (ctx->Visual.rgbMode) {
/* RGBA mode */
- const GLchan r = (GLint) (ctx->Color.ClearColor[0] * CHAN_MAXF);
- const GLchan g = (GLint) (ctx->Color.ClearColor[1] * CHAN_MAXF);
- const GLchan b = (GLint) (ctx->Color.ClearColor[2] * CHAN_MAXF);
- const GLchan a = (GLint) (ctx->Color.ClearColor[3] * CHAN_MAXF);
+ 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];
GLchan span[MAX_WIDTH][4];
GLint i;
if (facing == 1) {
if (IND & SS_TWOSIDE_BIT) {
if (IND & SS_RGBA_BIT) {
- GLubyte (*vbcolor)[4] = VB->ColorPtr[1]->data;
- GLubyte (*vbspec)[4] = VB->SecondaryColorPtr[1]->data;
+ GLchan (*vbcolor)[4] = VB->ColorPtr[1]->data;
+ GLchan (*vbspec)[4] = VB->SecondaryColorPtr[1]->data;
SS_COLOR(v[0]->color, vbcolor[e0]);
SS_COLOR(v[1]->color, vbcolor[e1]);
SS_COLOR(v[2]->color, vbcolor[e2]);
if (IND & SS_TWOSIDE_BIT) {
if (facing == 1) {
if (IND & SS_RGBA_BIT) {
- GLubyte (*vbcolor)[4] = VB->ColorPtr[0]->data;
- GLubyte (*vbspec)[4] = VB->SecondaryColorPtr[0]->data;
+ GLchan (*vbcolor)[4] = VB->ColorPtr[0]->data;
+ GLchan (*vbspec)[4] = VB->SecondaryColorPtr[0]->data;
SS_COLOR(v[0]->color, vbcolor[e0]);
SS_COLOR(v[1]->color, vbcolor[e1]);
SS_COLOR(v[2]->color, vbcolor[e2]);
SWvertex *v;
GLfloat (*proj)[4]; /* projected clip coordinates */
GLfloat (*tc[MAX_TEXTURE_UNITS])[4];
- GLubyte (*color)[4];
- GLubyte (*spec)[4];
+ GLchan (*color)[4];
+ GLchan (*spec)[4];
GLuint *index;
GLfloat *fog;
GLfloat *pointSize;
-/* $Id: t_array_api.c,v 1.3 2001/01/14 06:14:21 keithw Exp $ */
+/* $Id: t_array_api.c,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
* Version: 3.5
*
- * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
+ * 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"),
*/
gl_vector4f_init( &tmp->Obj, 0, 0 );
gl_vector3f_init( &tmp->Normal, 0, 0 );
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
gl_vector4ub_init( &tmp->Color, 0, 0 );
gl_vector4ub_init( &tmp->SecondaryColor, 0, 0 );
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+ gl_vector4us_init( &tmp->Color, 0, 0 );
+ gl_vector4us_init( &tmp->SecondaryColor, 0, 0 );
+#elif CHAN_TYPE == GL_FLOAT
+ gl_vector4f_init( &tmp->Color, 0, 0 );
+ gl_vector4f_init( &tmp->SecondaryColor, 0, 0 );
+#endif
gl_vector1f_init( &tmp->FogCoord, 0, 0 );
gl_vector1ui_init( &tmp->Index, 0, 0 );
gl_vector1ub_init( &tmp->EdgeFlag, 0, 0 );
-/* $Id: t_array_import.c,v 1.6 2001/01/08 21:56:00 keithw Exp $ */
+/* $Id: t_array_import.c,v 1.7 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
&is_writeable);
inputs->Color.data = tmp->Ptr;
- inputs->Color.start = (GLubyte *)tmp->Ptr;
+ inputs->Color.start = (GLchan *)tmp->Ptr;
inputs->Color.stride = tmp->StrideB;
inputs->Color.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
- if (inputs->Color.stride != 4*sizeof(GLubyte))
+ if (inputs->Color.stride != 4*sizeof(GLchan))
inputs->Color.flags |= VEC_BAD_STRIDE;
if (!is_writeable)
inputs->Color.flags |= VEC_NOT_WRITEABLE;
&is_writeable);
inputs->SecondaryColor.data = tmp->Ptr;
- inputs->SecondaryColor.start = (GLubyte *)tmp->Ptr;
+ inputs->SecondaryColor.start = (GLchan *)tmp->Ptr;
inputs->SecondaryColor.stride = tmp->StrideB;
inputs->SecondaryColor.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
if (inputs->SecondaryColor.stride != 4*sizeof(GLubyte))
}
if (required & VERT_RGBA) {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
_math_trans_4ub( IM->Color + IM->Start,
ctx->Array.Color.Ptr,
ctx->Array.Color.StrideB,
ctx->Array.Color.Type,
ctx->Array.Color.Size,
start, n );
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+ _math_trans_4us( IM->Color + IM->Start,
+ ctx->Array.Color.Ptr,
+ ctx->Array.Color.StrideB,
+ ctx->Array.Color.Type,
+ ctx->Array.Color.Size,
+ start, n );
+#elif CHAN_TYPE == GL_FLOAT
+ _math_trans_4f( IM->Color + IM->Start,
+ ctx->Array.Color.Ptr,
+ ctx->Array.Color.StrideB,
+ ctx->Array.Color.Type,
+ ctx->Array.Color.Size,
+ start, n );
+#endif
}
if (required & VERT_SPEC_RGB) {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
_math_trans_4ub( IM->SecondaryColor + IM->Start,
ctx->Array.SecondaryColor.Ptr,
ctx->Array.SecondaryColor.StrideB,
ctx->Array.SecondaryColor.Type,
ctx->Array.SecondaryColor.Size,
start, n );
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+ _math_trans_4us( IM->SecondaryColor + IM->Start,
+ ctx->Array.SecondaryColor.Ptr,
+ ctx->Array.SecondaryColor.StrideB,
+ ctx->Array.SecondaryColor.Type,
+ ctx->Array.SecondaryColor.Size,
+ start, n );
+#elif CHAN_TYPE == GL_FLOAT
+ _math_trans_4f( IM->SecondaryColor + IM->Start,
+ ctx->Array.SecondaryColor.Ptr,
+ ctx->Array.SecondaryColor.StrideB,
+ ctx->Array.SecondaryColor.Type,
+ ctx->Array.SecondaryColor.Size,
+ start, n );
+#endif
}
if (required & VERT_FOG_COORD) {
-/* $Id: t_context.h,v 1.11 2001/01/14 06:14:21 keithw Exp $ */
+/* $Id: t_context.h,v 1.12 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
GLuint Elt[IMM_SIZE];
GLubyte EdgeFlag[IMM_SIZE];
GLuint Index[IMM_SIZE];
- GLubyte SecondaryColor[IMM_SIZE][4];
+ GLchan SecondaryColor[IMM_SIZE][4];
GLfloat FogCoord[IMM_SIZE];
};
{
GLvector4f Obj;
GLvector3f Normal;
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
GLvector4ub Color;
+ GLvector4ub SecondaryColor;
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+ GLvector4us Color;
+ GLvector4us SecondaryColor;
+#elif CHAN_TYPE == GL_FLOAT
+ GLvector4f Color;
+ GLvector4f SecondaryColor;
+#endif
GLvector1ui Index;
GLvector1ub EdgeFlag;
GLvector4f TexCoord[MAX_TEXTURE_UNITS];
GLvector1ui Elt;
- GLvector4ub SecondaryColor;
GLvector1f FogCoord;
};
GLboolean *EdgeFlag; /* VERT_EDGE */
GLvector4f *TexCoordPtr[MAX_TEXTURE_UNITS]; /* VERT_TEX_0..n */
GLvector1ui *IndexPtr[2]; /* VERT_INDEX */
+
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
GLvector4ub *ColorPtr[2]; /* VERT_RGBA */
- GLvector4ub *SecondaryColorPtr[2]; /* VERT_SPEC_RGB */
+ GLvector4ub *SecondaryColorPtr[2]; /* VERT_SPEC_RGB */
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+ GLvector4us *ColorPtr[2]; /* VERT_RGBA */
+ GLvector4us *SecondaryColorPtr[2]; /* VERT_SPEC_RGB */
+#elif CHAN_TYPE == GL_FLOAT
+ GLvector4f *ColorPtr[2]; /* VERT_RGBA */
+ GLvector4f *SecondaryColorPtr[2]; /* VERT_SPEC_RGB */
+#endif
GLvector1f *FogCoordPtr; /* VERT_FOG_COORD */
GLvector1f *PointSizePtr; /* VERT_POINT_SIZE */
GLmaterial (*Material)[2]; /* VERT_MATERIAL, optional */
static void
_tnl_Color3f( GLfloat red, GLfloat green, GLfloat blue )
{
-#if CHAN_BITS == 8
- GLubyte col[4];
+ GLchan col[4];
GET_IMMEDIATE;
- UNCLAMPED_FLOAT_TO_UBYTE(col[0], red);
- UNCLAMPED_FLOAT_TO_UBYTE(col[1], green);
- UNCLAMPED_FLOAT_TO_UBYTE(col[2], blue);
+ UNCLAMPED_FLOAT_TO_CHAN(col[0], red);
+ UNCLAMPED_FLOAT_TO_CHAN(col[1], green);
+ UNCLAMPED_FLOAT_TO_CHAN(col[2], blue);
col[3] = CHAN_MAX;
COLORV( IM, col );
-#else
- GET_IMMEDIATE;
- COLOR(IM,
- UNCLAMPED_FLOAT_TO_CHAN(red),
- UNCLAMPED_FLOAT_TO_CHAN(green),
- UNCLAMPED_FLOAT_TO_CHAN(blue),
- CHAN_MAX);
-#endif
}
static void
_tnl_Color4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
{
-#if CHAN_BITS == 8
- GLubyte col[4];
+ GLchan col[4];
GET_IMMEDIATE;
- UNCLAMPED_FLOAT_TO_UBYTE(col[0], red);
- UNCLAMPED_FLOAT_TO_UBYTE(col[1], green);
- UNCLAMPED_FLOAT_TO_UBYTE(col[2], blue);
- UNCLAMPED_FLOAT_TO_UBYTE(col[3], alpha);
+ UNCLAMPED_FLOAT_TO_CHAN(col[0], red);
+ UNCLAMPED_FLOAT_TO_CHAN(col[1], green);
+ UNCLAMPED_FLOAT_TO_CHAN(col[2], blue);
+ UNCLAMPED_FLOAT_TO_CHAN(col[3], alpha);
COLORV( IM, col );
-#else
- GET_IMMEDIATE;
- COLOR(IM,
- UNCLAMPED_FLOAT_TO_CHAN(red),
- UNCLAMPED_FLOAT_TO_CHAN(green),
- UNCLAMPED_FLOAT_TO_CHAN(blue),
- UNCLAMPED_FLOAT_TO_CHAN(alpha));
-#endif
}
static void
_tnl_Color4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
{
-#if CHAN_BITS == 8
- GET_IMMEDIATE;
- COLOR( IM, red, green, blue, alpha );
-#else
GET_IMMEDIATE;
COLOR(IM,
UBYTE_TO_CHAN(red),
UBYTE_TO_CHAN(green),
UBYTE_TO_CHAN(blue),
UBYTE_TO_CHAN(alpha));
-#endif
}
static void
_tnl_Color3fv( const GLfloat *v )
{
-#if CHAN_BITS == 8
- GLubyte col[4];
+ GLchan col[4];
GET_IMMEDIATE;
- UNCLAMPED_FLOAT_TO_UBYTE(col[0], v[0]);
- UNCLAMPED_FLOAT_TO_UBYTE(col[1], v[1]);
- UNCLAMPED_FLOAT_TO_UBYTE(col[2], v[2]);
+ UNCLAMPED_FLOAT_TO_CHAN(col[0], v[0]);
+ UNCLAMPED_FLOAT_TO_CHAN(col[1], v[1]);
+ UNCLAMPED_FLOAT_TO_CHAN(col[2], v[2]);
col[3] = CHAN_MAX;
COLORV( IM, col );
-#else
- GET_IMMEDIATE;
- COLOR(IM,
- UNCLAMPED_FLOAT_TO_CHAN(v[0]),
- UNCLAMPED_FLOAT_TO_CHAN(v[1]),
- UNCLAMPED_FLOAT_TO_CHAN(v[2]),
- CHAN_MAX);
-
-#endif
}
static void
_tnl_Color3ubv( const GLubyte *v )
{
-#if CHAN_BITS == 8
- GET_IMMEDIATE;
- COLOR( IM, v[0], v[1], v[2], CHAN_MAX );
-#else
GET_IMMEDIATE;
COLOR(IM,
UBYTE_TO_CHAN(v[0]),
UBYTE_TO_CHAN(v[1]),
UBYTE_TO_CHAN(v[2]),
- CHAN_MAX);
-#endif
+ CHAN_MAX );
}
static void
_tnl_Color4fv( const GLfloat *v )
{
-#if CHAN_BITS == 8
- GLubyte col[4];
+ GLchan col[4];
GET_IMMEDIATE;
- UNCLAMPED_FLOAT_TO_UBYTE(col[0], v[0]);
- UNCLAMPED_FLOAT_TO_UBYTE(col[1], v[1]);
- UNCLAMPED_FLOAT_TO_UBYTE(col[2], v[2]);
- UNCLAMPED_FLOAT_TO_UBYTE(col[3], v[3]);
+ UNCLAMPED_FLOAT_TO_CHAN(col[0], v[0]);
+ UNCLAMPED_FLOAT_TO_CHAN(col[1], v[1]);
+ UNCLAMPED_FLOAT_TO_CHAN(col[2], v[2]);
+ UNCLAMPED_FLOAT_TO_CHAN(col[3], v[3]);
COLORV( IM, col );
-#else
- GET_IMMEDIATE;
- COLOR(IM,
- UNCLAMPED_FLOAT_TO_CHAN(v[0]),
- UNCLAMPED_FLOAT_TO_CHAN(v[1]),
- UNCLAMPED_FLOAT_TO_CHAN(v[2]),
- UNCLAMPED_FLOAT_TO_CHAN(v[3]));
-#endif
}
static void
_tnl_Color4ubv( const GLubyte *v)
{
-#if CHAN_BITS == 8
- GET_IMMEDIATE;
- COLORV( IM, v );
-#else
GET_IMMEDIATE;
COLOR(IM,
UBYTE_TO_CHAN(v[0]),
UBYTE_TO_CHAN(v[1]),
UBYTE_TO_CHAN(v[2]),
UBYTE_TO_CHAN(v[3]));
-#endif
}
static void
_tnl_SecondaryColor3fEXT( GLfloat red, GLfloat green, GLfloat blue )
{
-#if CHAN_BITS == 8
- GLubyte col[3];
+ GLchan col[3];
GET_IMMEDIATE;
- UNCLAMPED_FLOAT_TO_UBYTE(col[0], red);
- UNCLAMPED_FLOAT_TO_UBYTE(col[1], green);
- UNCLAMPED_FLOAT_TO_UBYTE(col[2], blue);
+ UNCLAMPED_FLOAT_TO_CHAN(col[0], red);
+ UNCLAMPED_FLOAT_TO_CHAN(col[1], green);
+ UNCLAMPED_FLOAT_TO_CHAN(col[2], blue);
SECONDARY_COLORV( IM, col );
-#else
- GET_IMMEDIATE;
- SECONDARY_COLOR(IM,
- UNCLAMPED_FLOAT_TO_CHAN(red),
- UNCLAMPED_FLOAT_TO_CHAN(green),
- UNCLAMPED_FLOAT_TO_CHAN(blue));
-#endif
}
static void
_tnl_SecondaryColor3ubEXT( GLubyte red, GLubyte green, GLubyte blue )
{
-#if CHAN_BITS == 8
- GET_IMMEDIATE;
- SECONDARY_COLOR( IM, red, green, blue );
-#else
GET_IMMEDIATE;
SECONDARY_COLOR(IM,
UBYTE_TO_CHAN(red),
UBYTE_TO_CHAN(green),
UBYTE_TO_CHAN(blue));
-#endif
}
static void
_tnl_SecondaryColor3fvEXT( const GLfloat *v )
{
-#if CHAN_BITS == 8
- GLubyte col[3];
+ GLchan col[3];
GET_IMMEDIATE;
- UNCLAMPED_FLOAT_TO_UBYTE(col[0], v[0]);
- UNCLAMPED_FLOAT_TO_UBYTE(col[1], v[1]);
- UNCLAMPED_FLOAT_TO_UBYTE(col[2], v[2]);
+ UNCLAMPED_FLOAT_TO_CHAN(col[0], v[0]);
+ UNCLAMPED_FLOAT_TO_CHAN(col[1], v[1]);
+ UNCLAMPED_FLOAT_TO_CHAN(col[2], v[2]);
SECONDARY_COLORV( IM, col );
-#else
- GET_IMMEDIATE;
- SECONDARY_COLOR(IM,
- UNCLAMPED_FLOAT_TO_CHAN(v[0]),
- UNCLAMPED_FLOAT_TO_CHAN(v[1]),
- UNCLAMPED_FLOAT_TO_CHAN(v[2]));
-#endif
}
static void
_tnl_SecondaryColor3ubvEXT( const GLubyte *v )
{
-#if CHAN_BITS == 8
- GET_IMMEDIATE;
- SECONDARY_COLOR( IM, v[0], v[1], v[2] );
-#else
GET_IMMEDIATE;
SECONDARY_COLOR(IM,
UBYTE_TO_CHAN(v[0]),
UBYTE_TO_CHAN(v[1]),
UBYTE_TO_CHAN(v[2]));
-#endif
}
-/* $Id: t_imm_elt.c,v 1.2 2001/01/02 22:02:53 brianp Exp $ */
+/* $Id: t_imm_elt.c,v 1.3 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
GLuint n );
typedef void (*trans_elt_4ub_func)(GLubyte (*to)[4],
- CONST void *ptr,
- GLuint stride,
- GLuint *flags,
- GLuint *elts,
- GLuint match,
- GLuint start,
- GLuint n );
+ CONST void *ptr,
+ GLuint stride,
+ GLuint *flags,
+ GLuint *elts,
+ GLuint match,
+ GLuint start,
+ GLuint n );
+
+typedef void (*trans_elt_4us_func)(GLushort (*to)[4],
+ CONST void *ptr,
+ GLuint stride,
+ GLuint *flags,
+ GLuint *elts,
+ GLuint match,
+ GLuint start,
+ GLuint n );
typedef void (*trans_elt_4f_func)(GLfloat (*to)[4],
CONST void *ptr,
static trans_elt_1ub_func _tnl_trans_elt_1ub_tab[MAX_TYPES];
static trans_elt_3f_func _tnl_trans_elt_3f_tab[MAX_TYPES];
static trans_elt_4ub_func _tnl_trans_elt_4ub_tab[5][MAX_TYPES];
+static trans_elt_4us_func _tnl_trans_elt_4us_tab[5][MAX_TYPES];
static trans_elt_4f_func _tnl_trans_elt_4f_tab[5][MAX_TYPES];
#define TRX_3F(f,n) BYTE_TO_FLOAT( PTR_ELT(f,n) )
#define TRX_4F(f,n) (GLfloat)( PTR_ELT(f,n) )
#define TRX_UB(ub, f,n) ub = BYTE_TO_UBYTE( PTR_ELT(f,n) )
+#define TRX_US(us, f,n) us = BYTE_TO_USHORT( PTR_ELT(f,n) )
#define TRX_UI(f,n) (PTR_ELT(f,n) < 0 ? 0 : (GLuint) PTR_ELT(f,n))
#define INIT init_trans_3_GLbyte_elt
#define DEST_4F trans_3_GLbyte_4f_elt
#define DEST_4UB trans_3_GLbyte_4ub_elt
+#define DEST_4US trans_3_GLbyte_4us_elt
#define DEST_3F trans_3_GLbyte_3f_elt
#include "math/m_trans_tmp.h"
#undef TRX_3F
#undef TRX_4F
#undef TRX_UB
+#undef TRX_US
#undef TRX_UI
#undef SRC_IDX
#define TRX_3F(f,n) /* unused */
#define TRX_4F(f,n) /* unused */
#define TRX_UB(ub, f,n) ub = PTR_ELT(f,n)
+#define TRX_US(us, f,n) us = PTR_ELT(f,n)
#define TRX_UI(f,n) (GLuint)PTR_ELT(f,n)
/* 4ub->4ub handled in special case below.
#define SZ 3
#define INIT init_trans_3_GLubyte_elt
#define DEST_4UB trans_3_GLubyte_4ub_elt
+#define DEST_4US trans_3_GLubyte_4us_elt
#include "math/m_trans_tmp.h"
#undef TRX_3F
#undef TRX_4F
#undef TRX_UB
+#undef TRX_US
#undef TRX_UI
#define TRX_3F(f,n) SHORT_TO_FLOAT( PTR_ELT(f,n) )
#define TRX_4F(f,n) (GLfloat)( PTR_ELT(f,n) )
#define TRX_UB(ub, f,n) ub = SHORT_TO_UBYTE(PTR_ELT(f,n))
+#define TRX_US(us, f,n) us = SHORT_TO_USHORT(PTR_ELT(f,n))
#define TRX_UI(f,n) (PTR_ELT(f,n) < 0 ? 0 : (GLuint) PTR_ELT(f,n))
#define INIT init_trans_4_GLshort_elt
#define DEST_4F trans_4_GLshort_4f_elt
#define DEST_4UB trans_4_GLshort_4ub_elt
+#define DEST_4US trans_4_GLshort_4us_elt
#include "math/m_trans_tmp.h"
#define SZ 3
#define INIT init_trans_3_GLshort_elt
#define DEST_4F trans_3_GLshort_4f_elt
#define DEST_4UB trans_3_GLshort_4ub_elt
+#define DEST_4US trans_3_GLshort_4us_elt
#define DEST_3F trans_3_GLshort_3f_elt
#include "math/m_trans_tmp.h"
#undef TRX_3F
#undef TRX_4F
#undef TRX_UB
+#undef TRX_US
#undef TRX_UI
#define TRX_3F(f,n) USHORT_TO_FLOAT( PTR_ELT(f,n) )
#define TRX_4F(f,n) (GLfloat)( PTR_ELT(f,n) )
#define TRX_UB(ub,f,n) ub = (GLubyte) (PTR_ELT(f,n) >> 8)
+#define TRX_US(us,f,n) us = PTR_ELT(f,n)
#define TRX_UI(f,n) (GLuint) PTR_ELT(f,n)
#define INIT init_trans_4_GLushort_elt
#define DEST_4F trans_4_GLushort_4f_elt
#define DEST_4UB trans_4_GLushort_4ub_elt
+#define DEST_4US trans_4_GLushort_4us_elt
#include "math/m_trans_tmp.h"
#define SZ 3
#define INIT init_trans_3_GLushort_elt
#define DEST_4F trans_3_GLushort_4f_elt
#define DEST_4UB trans_3_GLushort_4ub_elt
+#define DEST_4US trans_3_GLushort_4us_elt
#define DEST_3F trans_3_GLushort_3f_elt
#include "math/m_trans_tmp.h"
#undef TRX_3F
#undef TRX_4F
#undef TRX_UB
+#undef TRX_US
#undef TRX_UI
#define TRX_3F(f,n) INT_TO_FLOAT( PTR_ELT(f,n) )
#define TRX_4F(f,n) (GLfloat)( PTR_ELT(f,n) )
#define TRX_UB(ub, f,n) ub = INT_TO_UBYTE(PTR_ELT(f,n))
+#define TRX_US(us, f,n) us = INT_TO_USHORT(PTR_ELT(f,n))
#define TRX_UI(f,n) (PTR_ELT(f,n) < 0 ? 0 : (GLuint) PTR_ELT(f,n))
#define INIT init_trans_4_GLint_elt
#define DEST_4F trans_4_GLint_4f_elt
#define DEST_4UB trans_4_GLint_4ub_elt
+#define DEST_4US trans_4_GLint_4us_elt
#include "math/m_trans_tmp.h"
#define SZ 3
#define INIT init_trans_3_GLint_elt
#define DEST_4F trans_3_GLint_4f_elt
#define DEST_4UB trans_3_GLint_4ub_elt
+#define DEST_4US trans_3_GLint_4us_elt
#define DEST_3F trans_3_GLint_3f_elt
#include "math/m_trans_tmp.h"
#undef TRX_3F
#undef TRX_4F
#undef TRX_UB
+#undef TRX_US
#undef TRX_UI
#define TRX_3F(f,n) UINT_TO_FLOAT( PTR_ELT(f,n) )
#define TRX_4F(f,n) (GLfloat)( PTR_ELT(f,n) )
#define TRX_UB(ub, f,n) ub = (GLubyte) (PTR_ELT(f,n) >> 24)
+#define TRX_US(us, f,n) us = (GLushort) (PTR_ELT(f,n) >> 16)
#define TRX_UI(f,n) PTR_ELT(f,n)
#define INIT init_trans_4_GLuint_elt
#define DEST_4F trans_4_GLuint_4f_elt
#define DEST_4UB trans_4_GLuint_4ub_elt
+#define DEST_4US trans_4_GLuint_4us_elt
#include "math/m_trans_tmp.h"
#define SZ 3
#define INIT init_trans_3_GLuint_elt
#define DEST_4F trans_3_GLuint_4f_elt
#define DEST_4UB trans_3_GLuint_4ub_elt
+#define DEST_4US trans_3_GLuint_4us_elt
#define DEST_3F trans_3_GLuint_3f_elt
#include "math/m_trans_tmp.h"
#undef TRX_3F
#undef TRX_4F
#undef TRX_UB
+#undef TRX_US
#undef TRX_UI
#define SRC_IDX TYPE_IDX(GL_DOUBLE)
#define TRX_3F(f,n) PTR_ELT(f,n)
#define TRX_4F(f,n) PTR_ELT(f,n)
-#define TRX_UB(ub,f,n) UNCLAMPED_FLOAT_TO_CHAN(ub, PTR_ELT(f,n))
+#define TRX_UB(ub,f,n) UNCLAMPED_FLOAT_TO_UBYTE(ub, PTR_ELT(f,n))
+#define TRX_US(us,f,n) UNCLAMPED_FLOAT_TO_USHORT(us, PTR_ELT(f,n))
#define TRX_UI(f,n) (GLuint) (GLint) PTR_ELT(f,n)
#define TRX_1F(f,n) PTR_ELT(f,n)
#define INIT init_trans_4_GLdouble_elt
#define DEST_4F trans_4_GLdouble_4f_elt
#define DEST_4UB trans_4_GLdouble_4ub_elt
+#define DEST_4US trans_4_GLdouble_4us_elt
#include "math/m_trans_tmp.h"
#define SZ 3
#define INIT init_trans_3_GLdouble_elt
#define DEST_4F trans_3_GLdouble_4f_elt
#define DEST_4UB trans_3_GLdouble_4ub_elt
+#define DEST_4US trans_3_GLdouble_4us_elt
#define DEST_3F trans_3_GLdouble_3f_elt
#include "math/m_trans_tmp.h"
#define SZ 4
#define INIT init_trans_4_GLfloat_elt
#define DEST_4UB trans_4_GLfloat_4ub_elt
+#define DEST_4US trans_4_GLfloat_4us_elt
#define DEST_4F trans_4_GLfloat_4f_elt
#include "math/m_trans_tmp.h"
#define INIT init_trans_3_GLfloat_elt
#define DEST_4F trans_3_GLfloat_4f_elt
#define DEST_4UB trans_3_GLfloat_4ub_elt
+#define DEST_4US trans_3_GLfloat_4us_elt
#define DEST_3F trans_3_GLfloat_3f_elt
#include "math/m_trans_tmp.h"
#undef TRX_3F
#undef TRX_4F
#undef TRX_UB
+#undef TRX_US
#undef TRX_UI
static void trans_4_GLubyte_4ub(GLubyte (*t)[4],
- CONST void *Ptr,
- GLuint stride,
- ARGS )
+ CONST void *Ptr,
+ GLuint stride,
+ ARGS )
{
const GLubyte *f = (GLubyte *) Ptr + SRC_START * stride;
const GLubyte *first = f;
MEMSET( TAB(_1ub), 0, sizeof(TAB(_1ub)) );
MEMSET( TAB(_3f), 0, sizeof(TAB(_3f)) );
MEMSET( TAB(_4ub), 0, sizeof(TAB(_4ub)) );
+ MEMSET( TAB(_4us), 0, sizeof(TAB(_4us)) );
MEMSET( TAB(_4f), 0, sizeof(TAB(_4f)) );
TAB(_4ub)[4][TYPE_IDX(GL_UNSIGNED_BYTE)] = trans_4_GLubyte_4ub;
GLuint n )
{
_tnl_trans_elt_1ub_tab[TYPE_IDX(from->Type)]( to,
- from->Ptr,
- from->StrideB,
- flags,
- elts,
- match,
- start,
- n );
+ from->Ptr,
+ from->StrideB,
+ flags,
+ elts,
+ match,
+ start,
+ n );
}
static void _tnl_trans_elt_4ub(GLubyte (*to)[4],
- const struct gl_client_array *from,
- GLuint *flags,
- GLuint *elts,
- GLuint match,
- GLuint start,
- GLuint n )
+ const struct gl_client_array *from,
+ GLuint *flags,
+ GLuint *elts,
+ GLuint match,
+ GLuint start,
+ GLuint n )
{
_tnl_trans_elt_4ub_tab[from->Size][TYPE_IDX(from->Type)]( to,
- from->Ptr,
- from->StrideB,
- flags,
- elts,
- match,
- start,
- n );
+ from->Ptr,
+ from->StrideB,
+ flags,
+ elts,
+ match,
+ start,
+ n );
+
+}
+
+static void _tnl_trans_elt_4us(GLushort (*to)[4],
+ const struct gl_client_array *from,
+ GLuint *flags,
+ GLuint *elts,
+ GLuint match,
+ GLuint start,
+ GLuint n )
+{
+ _tnl_trans_elt_4us_tab[from->Size][TYPE_IDX(from->Type)]( to,
+ from->Ptr,
+ from->StrideB,
+ flags,
+ elts,
+ match,
+ start,
+ n );
}
static void _tnl_trans_elt_4f(GLfloat (*to)[4],
- const struct gl_client_array *from,
- GLuint *flags,
- GLuint *elts,
- GLuint match,
- GLuint start,
- GLuint n )
+ const struct gl_client_array *from,
+ GLuint *flags,
+ GLuint *elts,
+ GLuint match,
+ GLuint start,
+ GLuint n )
{
_tnl_trans_elt_4f_tab[from->Size][TYPE_IDX(from->Type)]( to,
from->Ptr,
flags, elts, (VERT_ELT|VERT_EDGE),
start, count);
- if (translate & VERT_RGBA)
+ if (translate & VERT_RGBA) {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
_tnl_trans_elt_4ub( IM->Color,
- &ctx->Array.Color,
- flags, elts, (VERT_ELT|VERT_RGBA),
- start, count);
-
+ &ctx->Array.Color,
+ flags, elts, (VERT_ELT|VERT_RGBA),
+ start, count);
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+ _tnl_trans_elt_4us( IM->Color,
+ &ctx->Array.Color,
+ flags, elts, (VERT_ELT|VERT_RGBA),
+ start, count);
+#elif CHAN_TYPE == GL_FLOAT
+ _tnl_trans_elt_4f( IM->Color,
+ &ctx->Array.Color,
+ flags, elts, (VERT_ELT|VERT_RGBA),
+ start, count);
+#endif
+ }
- if (translate & VERT_SPEC_RGB)
+ if (translate & VERT_SPEC_RGB) {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
_tnl_trans_elt_4ub( IM->SecondaryColor,
- &ctx->Array.SecondaryColor,
- flags, elts, (VERT_ELT|VERT_SPEC_RGB),
- start, count);
+ &ctx->Array.SecondaryColor,
+ flags, elts, (VERT_ELT|VERT_SPEC_RGB),
+ start, count);
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+ _tnl_trans_elt_4us( IM->SecondaryColor,
+ &ctx->Array.SecondaryColor,
+ flags, elts, (VERT_ELT|VERT_SPEC_RGB),
+ start, count);
+#elif CHAN_TYPE == GL_FLOAT
+ _tnl_trans_elt_4f( IM->SecondaryColor,
+ &ctx->Array.SecondaryColor,
+ flags, elts, (VERT_ELT|VERT_SPEC_RGB),
+ start, count);
+#endif
+ }
if (translate & VERT_FOG_COORD)
_tnl_trans_elt_1f( IM->FogCoord,
-/* $Id: t_imm_eval.c,v 1.3 2001/01/03 15:59:30 brianp Exp $ */
+/* $Id: t_imm_eval.c,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
}
}
-static void eval1_color( GLvector4ub *dest,
+static void eval1_color(
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+ GLvector4ub *dest,
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+ GLvector4us *dest,
+#elif CHAN_TYPE == GL_FLOAT
+ GLvector4f *dest,
+#endif
GLfloat coord[][4],
const GLuint *flags,
struct gl_1d_map *map )
{
const GLfloat u1 = map->u1;
const GLfloat du = map->du;
- GLubyte (*to)[4] = dest->data;
+ GLchan (*to)[4] = dest->data;
GLuint i;
for (i = 0 ; !(flags[i] & VERT_END_VB) ; i++) {
-static void eval2_color( GLvector4ub *dest,
+static void eval2_color(
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+ GLvector4ub *dest,
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+ GLvector4us *dest,
+#elif CHAN_TYPE == GL_FLOAT
+ GLvector4f *dest,
+#endif
GLfloat coord[][4],
GLuint *flags,
struct gl_2d_map *map )
const GLfloat du = map->du;
const GLfloat v1 = map->v1;
const GLfloat dv = map->dv;
- GLubyte (*to)[4] = dest->data;
+ GLchan (*to)[4] = dest->data;
GLuint i;
for (i = 0 ; !(flags[i] & VERT_END_VB) ; i++) {
MEMCPY( to, from, (count) * sizeof(to[0]));
}
-static void copy_4ub( GLubyte to[][4], GLubyte from[][4], GLuint count )
+static void copy_4chan( GLchan to[][4], GLchan from[][4], GLuint count )
{
MEMCPY( to, from, (count) * sizeof(to[0]));
}
if (req & VERT_RGBA)
{
if (!all_eval)
- copy_4ub( store->Color, tmp->Color.data, count );
+ copy_4chan( store->Color, tmp->Color.data, count );
tmp->Color.data = store->Color;
- tmp->Color.start = (GLubyte *)store->Color;
+ tmp->Color.start = (GLchan *) store->Color;
if (ctx->Eval.Map1Color4 && any_eval1)
eval1_color( &tmp->Color, coord, flags, &ctx->EvalMap.Map1Color4 );
-/* $Id: t_imm_exec.c,v 1.8 2001/01/14 06:14:21 keithw Exp $ */
+/* $Id: t_imm_exec.c,v 1.9 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
* Version: 3.5
*
- * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
+ * 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"),
if (inputs & VERT_SPEC_RGB) {
tmp->SecondaryColor.data = IM->SecondaryColor + start;
- tmp->SecondaryColor.start = (GLubyte *)(IM->SecondaryColor + start);
+ tmp->SecondaryColor.start = (GLchan *)(IM->SecondaryColor + start);
tmp->SecondaryColor.count = count;
VB->SecondaryColorPtr[0] = &tmp->SecondaryColor;
}
if (inputs & VERT_RGBA) {
tmp->Color.data = IM->Color + start;
- tmp->Color.start = (GLubyte *)(IM->Color + start);
+ tmp->Color.start = (GLchan *)(IM->Color + start);
tmp->Color.count = count;
VB->ColorPtr[0] = &tmp->Color;
}
gl_vector4f_init( &tmp->Obj, 0, 0 );
gl_vector3f_init( &tmp->Normal, 0, 0 );
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
gl_vector4ub_init( &tmp->Color, 0, 0 );
gl_vector4ub_init( &tmp->SecondaryColor, 0, 0 );
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+ gl_vector4us_init( &tmp->Color, 0, 0 );
+ gl_vector4us_init( &tmp->SecondaryColor, 0, 0 );
+#elif CHAN_TYPE == GL_FLOAT
+ gl_vector4f_init( &tmp->Color, 0, 0 );
+ gl_vector4f_init( &tmp->SecondaryColor, 0, 0 );
+#endif
gl_vector1f_init( &tmp->FogCoord, 0, 0 );
gl_vector1ui_init( &tmp->Index, 0, 0 );
gl_vector1ub_init( &tmp->EdgeFlag, 0, 0 );
-/* $Id: t_imm_fixup.c,v 1.3 2001/01/08 21:56:00 keithw Exp $ */
+/* $Id: t_imm_fixup.c,v 1.4 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
#include "context.h"
#include "enums.h"
#include "dlist.h"
+#include "colormac.h"
#include "macros.h"
#include "mem.h"
#include "mmath.h"
static void
-fixup_4ub( GLubyte data[][4], GLuint flag[], GLuint start, GLuint match )
+fixup_4chan( GLchan data[][4], GLuint flag[], GLuint start, GLuint match )
{
GLuint i = start;
for (;;) {
if ((flag[++i] & match) == 0) {
- COPY_4UBV(data[i], data[i-1]);
+ COPY_CHAN4(data[i], data[i-1]);
if (flag[i] & VERT_END_VB) break;
}
}
static void
-fixup_first_4ub( GLubyte data[][4], GLuint flag[], GLuint match,
- GLuint start, GLubyte dflt[4] )
+fixup_first_4chan( GLchan data[][4], GLuint flag[], GLuint match,
+ GLuint start, GLchan dflt[4] )
{
GLuint i = start-1;
match |= VERT_END_VB;
while ((flag[++i]&match) == 0)
- COPY_4UBV(data[i], dflt);
+ COPY_CHAN4(data[i], dflt);
}
}
if (copy & VERT_RGBA) {
- COPY_4UBV( IM->Color[start], ctx->Current.Color);
+ COPY_CHAN4( IM->Color[start], ctx->Current.Color);
}
if (copy & VERT_SPEC_RGB)
- COPY_4UBV( IM->SecondaryColor[start], ctx->Current.SecondaryColor);
+ COPY_CHAN4( IM->SecondaryColor[start], ctx->Current.SecondaryColor);
if (copy & VERT_FOG_COORD)
IM->FogCoord[start] = ctx->Current.FogCoord;
if (fixup & VERT_RGBA) {
if (orflag & VERT_RGBA)
- fixup_4ub( IM->Color, IM->Flag, start, VERT_RGBA );
+ fixup_4chan( IM->Color, IM->Flag, start, VERT_RGBA );
else
- fixup_first_4ub( IM->Color, IM->Flag, VERT_END_VB, start, IM->Color[start] );
+ fixup_first_4chan( IM->Color, IM->Flag, VERT_END_VB, start, IM->Color[start] );
}
if (fixup & VERT_SPEC_RGB) {
if (orflag & VERT_SPEC_RGB)
- fixup_4ub( IM->SecondaryColor, IM->Flag, start, VERT_SPEC_RGB );
+ fixup_4chan( IM->SecondaryColor, IM->Flag, start, VERT_SPEC_RGB );
else
- fixup_first_4ub( IM->SecondaryColor, IM->Flag, VERT_END_VB, start,
- IM->SecondaryColor[start] );
+ fixup_first_4chan( IM->SecondaryColor, IM->Flag, VERT_END_VB, start,
+ IM->SecondaryColor[start] );
}
if (fixup & VERT_FOG_COORD) {
COPY_4FV( next->Obj[dst], prev->Obj[src] );
COPY_3FV( next->Normal[dst], prev->Normal[src] );
- COPY_4UBV( next->Color[dst], prev->Color[src] );
+ COPY_CHAN4( next->Color[dst], prev->Color[src] );
if (prev->OrFlag & VERT_TEX_ANY) {
GLuint i;
next->Elt[dst] = prev->Elt[src];
next->EdgeFlag[dst] = prev->EdgeFlag[src];
next->Index[dst] = prev->Index[src];
- COPY_4UBV( next->SecondaryColor[dst], prev->SecondaryColor[src] );
+ COPY_CHAN4( next->SecondaryColor[dst], prev->SecondaryColor[src] );
next->FogCoord[dst] = prev->FogCoord[src];
next->Flag[dst] = (prev->CopyOrFlag & VERT_FIXUP);
next->CopyOrFlag |= prev->Flag[src]; /* redundant for current_im */
ctx->Current.Index );
if (fixup & VERT_RGBA)
- fixup_first_4ub(IM->Color, IM->Flag, VERT_RGBA, start,
- ctx->Current.Color );
+ fixup_first_4chan(IM->Color, IM->Flag, VERT_RGBA, start,
+ ctx->Current.Color );
if (fixup & VERT_SPEC_RGB)
- fixup_first_4ub(IM->SecondaryColor, IM->Flag, VERT_SPEC_RGB, start,
- ctx->Current.SecondaryColor );
+ fixup_first_4chan(IM->SecondaryColor, IM->Flag, VERT_SPEC_RGB, start,
+ ctx->Current.SecondaryColor );
if (fixup & VERT_FOG_COORD)
fixup_first_1f(IM->FogCoord, IM->Flag, VERT_FOG_COORD, start,
fixup_1ui( store->Index, flags, 0, VERT_INDEX|fixup_fence );
if (fixup & VERT_RGBA)
- fixup_4ub( store->Color, flags, 0, VERT_RGBA|fixup_fence );
+ fixup_4chan( store->Color, flags, 0, VERT_RGBA|fixup_fence );
if (fixup & VERT_NORM)
fixup_3f( store->Normal, flags, 0, VERT_NORM|fixup_fence );
-/* $Id: t_vb_light.c,v 1.4 2001/01/23 23:39:37 brianp Exp $ */
+/* $Id: t_vb_light.c,v 1.5 2001/01/24 00:04:59 brianp Exp $ */
/*
* Mesa 3-D graphics library
GLvector4f *input );
struct light_stage_data {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
GLvector4ub LitColor[2];
- GLvector1ui LitIndex[2];
GLvector4ub LitSecondary[2];
-
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+ GLvector4us LitColor[2];
+ GLvector4us LitSecondary[2];
+#elif CHAN_TYPE == GL_FLOAT
+ GLvector4f LitColor[2];
+ GLvector4f LitSecondary[2];
+#endif
+ GLvector1ui LitIndex[2];
light_func *light_func_tab;
};
*/
init_lighting();
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
gl_vector4ub_alloc( &store->LitColor[0], 0, size, 32 );
gl_vector4ub_alloc( &store->LitColor[1], 0, size, 32 );
gl_vector4ub_alloc( &store->LitSecondary[0], 0, size, 32 );
gl_vector4ub_alloc( &store->LitSecondary[1], 0, size, 32 );
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+ gl_vector4us_alloc( &store->LitColor[0], 0, size, 32 );
+ gl_vector4us_alloc( &store->LitColor[1], 0, size, 32 );
+ gl_vector4us_alloc( &store->LitSecondary[0], 0, size, 32 );
+ gl_vector4us_alloc( &store->LitSecondary[1], 0, size, 32 );
+#elif CHAN_TYPE == GL_FLOAT
+ gl_vector4f_alloc( &store->LitColor[0], 0, size, 32 );
+ gl_vector4f_alloc( &store->LitColor[1], 0, size, 32 );
+ gl_vector4f_alloc( &store->LitSecondary[0], 0, size, 32 );
+ gl_vector4f_alloc( &store->LitSecondary[1], 0, size, 32 );
+#endif
gl_vector1ui_alloc( &store->LitIndex[0], 0, size, 32 );
gl_vector1ui_alloc( &store->LitIndex[1], 0, size, 32 );
struct light_stage_data *store = LIGHT_STAGE_DATA(stage);
if (store) {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
gl_vector4ub_free( &store->LitColor[0] );
gl_vector4ub_free( &store->LitColor[1] );
- gl_vector1ui_free( &store->LitIndex[0] );
- gl_vector1ui_free( &store->LitIndex[1] );
gl_vector4ub_free( &store->LitSecondary[0] );
gl_vector4ub_free( &store->LitSecondary[1] );
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+ gl_vector4us_free( &store->LitColor[0] );
+ gl_vector4us_free( &store->LitColor[1] );
+ gl_vector4us_free( &store->LitSecondary[0] );
+ gl_vector4us_free( &store->LitSecondary[1] );
+#elif CHAN_TYPE == GL_FLOAT
+ gl_vector4f_free( &store->LitColor[0] );
+ gl_vector4f_free( &store->LitColor[1] );
+ gl_vector4f_free( &store->LitSecondary[0] );
+ gl_vector4f_free( &store->LitSecondary[1] );
+#endif
+ gl_vector1ui_free( &store->LitIndex[0] );
+ gl_vector1ui_free( &store->LitIndex[1] );
FREE( store );
stage->private = 0;
}
-/* $Id: t_vb_lighttmp.h,v 1.3 2001/01/17 02:49:39 keithw Exp $ */
+/* $Id: t_vb_lighttmp.h,v 1.4 2001/01/24 00:05:00 brianp Exp $ */
/*
* Mesa 3-D graphics library
# define CHECK_MATERIAL(x) (flags[x] & VERT_MATERIAL)
# define CHECK_END_VB(x) (flags[x] & VERT_END_VB)
# if (IDX & LIGHT_COLORMATERIAL)
-# define CMSTRIDE STRIDE_4UB(CMcolor, (4 * sizeof(GLubyte)))
+# define CMSTRIDE STRIDE_4CHAN(CMcolor, (4 * sizeof(GLchan)))
# define CHECK_COLOR_MATERIAL(x) (flags[x] & VERT_RGBA)
# define CHECK_VALIDATE(x) (flags[x] & (VERT_RGBA|VERT_MATERIAL))
# define DO_ANOTHER_NORMAL(x) \
# define CHECK_MATERIAL(x) 0 /* no materials on array paths */
# define CHECK_END_VB(XX) (XX >= nr)
# if (IDX & LIGHT_COLORMATERIAL)
-# define CMSTRIDE STRIDE_4UB(CMcolor, CMstride)
+# define CMSTRIDE STRIDE_4CHAN(CMcolor, CMstride)
# define CHECK_COLOR_MATERIAL(x) (x < nr) /* always have colormaterial */
# define CHECK_VALIDATE(x) (x < nr)
# define DO_ANOTHER_NORMAL(x) 0 /* always stop to recalc colormat */
GLuint nstride = VB->NormalPtr->stride;
const GLfloat *normal = (GLfloat *)VB->NormalPtr->data;
- GLubyte (*CMcolor)[4];
+ GLchan (*CMcolor)[4];
GLuint CMstride;
GLchan (*Fcolor)[4] = (GLchan (*)[4]) store->LitColor[0].data;
struct light_stage_data *store = LIGHT_STAGE_DATA(stage);
GLuint nstride = VB->NormalPtr->stride;
const GLfloat *normal = (GLfloat *)VB->NormalPtr->data;
- GLubyte (*CMcolor)[4];
+ GLchan (*CMcolor)[4];
GLuint CMstride;
GLchan (*Fcolor)[4] = (GLchan (*)[4]) store->LitColor[0].data;
GLchan (*Bcolor)[4] = (GLchan (*)[4]) store->LitColor[1].data;
const GLchan *sumA = ctx->Light._BaseAlpha;
GLuint nstride = VB->NormalPtr->stride;
const GLfloat *normal = (GLfloat *)VB->NormalPtr->data;
- GLubyte (*CMcolor)[4];
+ GLchan (*CMcolor)[4];
GLuint CMstride;
GLchan (*Fcolor)[4] = (GLchan (*)[4]) store->LitColor[0].data;
GLchan (*Bcolor)[4] = (GLchan (*)[4]) store->LitColor[1].data;
const GLfloat *vertex = (GLfloat *) input->data;
GLuint nstride = VB->NormalPtr->stride;
const GLfloat *normal = (GLfloat *)VB->NormalPtr->data;
- GLubyte (*CMcolor)[4];
+ GLchan (*CMcolor)[4];
GLuint CMstride;
GLuint *flags = VB->Flag;
GLuint *indexResult[2];
projects / mesa.git / commitdiff