-/* $Id: pixel.c,v 1.1 1999/08/19 00:55:41 jtg Exp $ */
+/* $Id: pixel.c,v 1.5 1999/11/11 01:22:27 brianp Exp $ */
/*
* Mesa 3-D graphics library
- * Version: 3.1
+ * Version: 3.3
*
* Copyright (C) 1999 Brian Paul All Rights Reserved.
*
*/
-
-
-
/*
* glPixelStore, glPixelTransfer, glPixelMap, glPixelZoom, etc.
*/
#ifdef PC_HEADER
#include "all.h"
#else
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
+#include "glheader.h"
#include "context.h"
#include "macros.h"
+#include "mem.h"
#include "pixel.h"
#include "types.h"
-#ifdef XFree86Server
-#include "GL/xf86glx.h"
-#endif
#endif
-void gl_PixelZoom( GLcontext *ctx, GLfloat xfactor, GLfloat yfactor )
+void
+_mesa_PixelZoom( GLfloat xfactor, GLfloat yfactor )
{
+ GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelZoom");
ctx->Pixel.ZoomX = xfactor;
/**********************************************************************/
-void gl_PixelStorei( GLcontext *ctx, GLenum pname, GLint param )
+void
+_mesa_PixelStorei( GLenum pname, GLint param )
{
/* NOTE: this call can't be compiled into the display list */
-
+ GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelStore");
-
switch (pname) {
case GL_PACK_SWAP_BYTES:
ctx->Pack.SwapBytes = param ? GL_TRUE : GL_FALSE;
}
+void
+_mesa_PixelStoref( GLenum pname, GLfloat param )
+{
+ _mesa_PixelStorei( pname, (GLint) param );
+}
-void gl_PixelMapfv( GLcontext *ctx,
- GLenum map, GLint mapsize, const GLfloat *values )
+void
+_mesa_PixelMapfv( GLenum map, GLint mapsize, const GLfloat *values )
{
GLint i;
-
+ GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelMapfv");
+void
+_mesa_PixelMapuiv(GLenum map, GLint mapsize, const GLuint *values )
+{
+ GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
+ GLint i;
+ if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
+ for (i=0;i<mapsize;i++) {
+ fvalues[i] = (GLfloat) values[i];
+ }
+ }
+ else {
+ for (i=0;i<mapsize;i++) {
+ fvalues[i] = UINT_TO_FLOAT( values[i] );
+ }
+ }
+ _mesa_PixelMapfv(map, mapsize, fvalues);
+}
-void gl_GetPixelMapfv( GLcontext *ctx, GLenum map, GLfloat *values )
+
+void
+_mesa_PixelMapusv(GLenum map, GLint mapsize, const GLushort *values )
{
+ GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
+ GLint i;
+ if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
+ for (i=0;i<mapsize;i++) {
+ fvalues[i] = (GLfloat) values[i];
+ }
+ }
+ else {
+ for (i=0;i<mapsize;i++) {
+ fvalues[i] = USHORT_TO_FLOAT( values[i] );
+ }
+ }
+ _mesa_PixelMapfv(map, mapsize, fvalues);
+}
+
+
+
+void
+_mesa_GetPixelMapfv( GLenum map, GLfloat *values )
+{
+ GET_CURRENT_CONTEXT(ctx);
GLint i;
ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetPixelMapfv");
}
-void gl_GetPixelMapuiv( GLcontext *ctx, GLenum map, GLuint *values )
+void
+_mesa_GetPixelMapuiv( GLenum map, GLuint *values )
{
+ GET_CURRENT_CONTEXT(ctx);
GLint i;
ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetPixelMapfv");
}
-void gl_GetPixelMapusv( GLcontext *ctx, GLenum map, GLushort *values )
+void
+_mesa_GetPixelMapusv( GLenum map, GLushort *values )
{
+ GET_CURRENT_CONTEXT(ctx);
GLint i;
ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetPixelMapfv");
* Implements glPixelTransfer[fi] whether called immediately or from a
* display list.
*/
-void gl_PixelTransferf( GLcontext *ctx, GLenum pname, GLfloat param )
+void
+_mesa_PixelTransferf( GLenum pname, GLfloat param )
{
+ GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelTransfer");
}
+void
+_mesa_PixelTransferi( GLenum pname, GLint param )
+{
+ _mesa_PixelTransferf( pname, (GLfloat) param );
+}
+
+
/*
}
+/*
+ * Apply scale and bias factors to an array of RGBA pixels.
+ */
+void gl_scale_and_bias_rgba_float( const GLcontext *ctx, GLuint n, GLfloat rgba[][4] )
+{
+ if (ctx->Pixel.RedScale != 1.0 || ctx->Pixel.RedBias != 0.0) {
+ const GLfloat scale = ctx->Pixel.RedScale;
+ const GLfloat bias = ctx->Pixel.RedBias;
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ rgba[i][RCOMP] = rgba[i][RCOMP] * scale + bias;
+ }
+ }
+ if (ctx->Pixel.GreenScale != 1.0 || ctx->Pixel.GreenBias != 0.0) {
+ const GLfloat scale = ctx->Pixel.GreenScale;
+ const GLfloat bias = ctx->Pixel.GreenBias;
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ rgba[i][GCOMP] = rgba[i][GCOMP] * scale + bias;
+ }
+ }
+ if (ctx->Pixel.BlueScale != 1.0 || ctx->Pixel.BlueBias != 0.0) {
+ const GLfloat scale = ctx->Pixel.BlueScale;
+ const GLfloat bias = ctx->Pixel.BlueBias;
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ rgba[i][BCOMP] = rgba[i][BCOMP] * scale + bias;
+ }
+ }
+ if (ctx->Pixel.AlphaScale != 1.0 || ctx->Pixel.AlphaBias != 0.0) {
+ const GLfloat scale = ctx->Pixel.AlphaScale;
+ const GLfloat bias = ctx->Pixel.AlphaBias;
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ rgba[i][ACOMP] = rgba[i][ACOMP] * scale + bias;
+ }
+ }
+}
+
+
/*
* Apply pixel mapping to an array of RGBA pixels.
*/
}
+/*
+ * Apply pixel mapping to an array of floating point RGBA pixels.
+ */
+void gl_map_rgba_float( const GLcontext *ctx, GLuint n, GLfloat rgba[][4] )
+{
+ const GLfloat rscale = ctx->Pixel.MapRtoRsize - 1;
+ const GLfloat gscale = ctx->Pixel.MapGtoGsize - 1;
+ const GLfloat bscale = ctx->Pixel.MapBtoBsize - 1;
+ const GLfloat ascale = ctx->Pixel.MapAtoAsize - 1;
+ const GLfloat *rMap = ctx->Pixel.MapRtoR;
+ const GLfloat *gMap = ctx->Pixel.MapGtoG;
+ const GLfloat *bMap = ctx->Pixel.MapBtoB;
+ const GLfloat *aMap = ctx->Pixel.MapAtoA;
+ GLuint i;
+ for (i=0;i<n;i++) {
+ rgba[i][RCOMP] = rMap[(GLint) (rgba[i][RCOMP] * rscale + 0.5F)];
+ rgba[i][GCOMP] = gMap[(GLint) (rgba[i][GCOMP] * gscale + 0.5F)];
+ rgba[i][BCOMP] = bMap[(GLint) (rgba[i][BCOMP] * bscale + 0.5F)];
+ rgba[i][ACOMP] = aMap[(GLint) (rgba[i][ACOMP] * ascale + 0.5F)];
+ }
+}
+
+
/*
* Apply pixel mapping to an array of RGBA pixels.
*/
GLfloat red[], GLfloat green[],
GLfloat blue[], GLfloat alpha[] )
{
- GLfloat rscale = ctx->Pixel.MapRtoRsize-1;
- GLfloat gscale = ctx->Pixel.MapGtoGsize-1;
- GLfloat bscale = ctx->Pixel.MapBtoBsize-1;
- GLfloat ascale = ctx->Pixel.MapAtoAsize-1;
+ GLfloat rscale = ctx->Pixel.MapRtoRsize - 1;
+ GLfloat gscale = ctx->Pixel.MapGtoGsize - 1;
+ GLfloat bscale = ctx->Pixel.MapBtoBsize - 1;
+ GLfloat ascale = ctx->Pixel.MapAtoAsize - 1;
GLuint i;
for (i=0;i<n;i++) {
- red[i] = ctx->Pixel.MapRtoR[ (GLint) (red[i] * rscale) ];
- green[i] = ctx->Pixel.MapGtoG[ (GLint) (green[i] * gscale) ];
- blue[i] = ctx->Pixel.MapBtoB[ (GLint) (blue[i] * bscale) ];
- alpha[i] = ctx->Pixel.MapAtoA[ (GLint) (alpha[i] * ascale) ];
+ red[i] = ctx->Pixel.MapRtoR[ (GLint) (red[i] * rscale + 0.5F) ];
+ green[i] = ctx->Pixel.MapGtoG[ (GLint) (green[i] * gscale + 0.5F) ];
+ blue[i] = ctx->Pixel.MapBtoB[ (GLint) (blue[i] * bscale + 0.5F) ];
+ alpha[i] = ctx->Pixel.MapAtoA[ (GLint) (alpha[i] * ascale + 0.5F) ];
}
}
/*
- * Map color indexes to rgb values.
+ * Map color indexes to rgba values.
*/
void gl_map_ci_to_rgba( const GLcontext *ctx, GLuint n, const GLuint index[],
GLubyte rgba[][4] )
}
+/*
+ * Map color indexes to float rgba values.
+ */
+void gl_map_ci_to_rgba_float( const GLcontext *ctx, GLuint n, const GLuint index[],
+ GLfloat rgba[][4] )
+{
+ GLuint rmask = ctx->Pixel.MapItoRsize - 1;
+ GLuint gmask = ctx->Pixel.MapItoGsize - 1;
+ GLuint bmask = ctx->Pixel.MapItoBsize - 1;
+ GLuint amask = ctx->Pixel.MapItoAsize - 1;
+ const GLfloat *rMap = ctx->Pixel.MapItoR;
+ const GLfloat *gMap = ctx->Pixel.MapItoG;
+ const GLfloat *bMap = ctx->Pixel.MapItoB;
+ const GLfloat *aMap = ctx->Pixel.MapItoA;
+ GLuint i;
+ for (i=0;i<n;i++) {
+ rgba[i][RCOMP] = rMap[index[i] & rmask];
+ rgba[i][GCOMP] = gMap[index[i] & gmask];
+ rgba[i][BCOMP] = bMap[index[i] & bmask];
+ rgba[i][ACOMP] = aMap[index[i] & amask];
+ }
+}
+
+
/*
* Map 8-bit color indexes to rgb values.
*/
projects / mesa.git / blobdiff