X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Fcolortab.c;h=9fb0baf4a7c3e624148b189e268f503708f84195;hb=d0b5c77c68f45f9da5421248a064ece831923b0c;hp=31e595bdb84d75fee48f02741e6da8242f01f033;hpb=0c000ec90c8ca38bfcb94394001665d0be3112dd;p=mesa.git diff --git a/src/mesa/main/colortab.c b/src/mesa/main/colortab.c index 31e595bdb84..9fb0baf4a7c 100644 --- a/src/mesa/main/colortab.c +++ b/src/mesa/main/colortab.c @@ -1,21 +1,19 @@ -/* $Id: colortab.c,v 1.29 2000/11/21 23:26:13 brianp Exp $ */ - /* * Mesa 3-D graphics library - * Version: 3.5 - * - * Copyright (C) 1999-2000 Brian Paul All Rights Reserved. - * + * Version: 6.5.2 + * + * Copyright (C) 1999-2006 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 @@ -25,22 +23,16 @@ */ -#ifdef PC_HEADER -#include "all.h" -#else #include "glheader.h" +#include "bufferobj.h" #include "colortab.h" #include "context.h" #include "image.h" #include "macros.h" -#include "mem.h" -#include "mmath.h" -#include "swrast/s_span.h" /* XXX SWRAST hack */ -#endif - +#include "state.h" -/* +/** * Given an internalFormat token passed to glColorTable, * return the corresponding base format. * Return -1 if invalid token. @@ -99,54 +91,22 @@ base_colortab_format( GLenum format ) } -void -_mesa_init_colortable( struct gl_color_table *p ) -{ - p->FloatTable = GL_FALSE; - /* allocate a width=1 table by default */ - p->Table = CALLOC(4 * sizeof(GLchan)); - if (p->Table) { - GLchan *t = (GLchan *) p->Table; - t[0] = CHAN_MAX; - t[1] = CHAN_MAX; - t[2] = CHAN_MAX; - t[3] = CHAN_MAX; - } - p->Size = 1; - p->IntFormat = GL_RGBA; - p->Format = GL_RGBA; - p->RedSize = CHAN_BITS; - p->GreenSize = CHAN_BITS; - p->BlueSize = CHAN_BITS; - p->AlphaSize = CHAN_BITS; - p->IntensitySize = 0; - p->LuminanceSize = 0; -} - - - -void -_mesa_free_colortable_data( struct gl_color_table *p ) -{ - if (p->Table) { - FREE(p->Table); - p->Table = NULL; - } -} - -/* +/** * Examine table's format and set the component sizes accordingly. */ static void set_component_sizes( struct gl_color_table *table ) { - switch (table->Format) { + /* assuming the ubyte table */ + const GLubyte sz = 8; + + switch (table->_BaseFormat) { case GL_ALPHA: table->RedSize = 0; table->GreenSize = 0; table->BlueSize = 0; - table->AlphaSize = CHAN_BITS; + table->AlphaSize = sz; table->IntensitySize = 0; table->LuminanceSize = 0; break; @@ -156,48 +116,177 @@ set_component_sizes( struct gl_color_table *table ) table->BlueSize = 0; table->AlphaSize = 0; table->IntensitySize = 0; - table->LuminanceSize = CHAN_BITS; + table->LuminanceSize = sz; break; case GL_LUMINANCE_ALPHA: table->RedSize = 0; table->GreenSize = 0; table->BlueSize = 0; - table->AlphaSize = CHAN_BITS; + table->AlphaSize = sz; table->IntensitySize = 0; - table->LuminanceSize = CHAN_BITS; + table->LuminanceSize = sz; break; case GL_INTENSITY: table->RedSize = 0; table->GreenSize = 0; table->BlueSize = 0; table->AlphaSize = 0; - table->IntensitySize = CHAN_BITS; + table->IntensitySize = sz; table->LuminanceSize = 0; break; case GL_RGB: - table->RedSize = CHAN_BITS; - table->GreenSize = CHAN_BITS; - table->BlueSize = CHAN_BITS; + table->RedSize = sz; + table->GreenSize = sz; + table->BlueSize = sz; table->AlphaSize = 0; table->IntensitySize = 0; table->LuminanceSize = 0; break; case GL_RGBA: - table->RedSize = CHAN_BITS; - table->GreenSize = CHAN_BITS; - table->BlueSize = CHAN_BITS; - table->AlphaSize = CHAN_BITS; + table->RedSize = sz; + table->GreenSize = sz; + table->BlueSize = sz; + table->AlphaSize = sz; table->IntensitySize = 0; table->LuminanceSize = 0; break; default: - gl_problem(NULL, "unexpected format in set_component_sizes"); + _mesa_problem(NULL, "unexpected format in set_component_sizes"); } } -void +/** + * Update/replace all or part of a color table. Helper function + * used by _mesa_ColorTable() and _mesa_ColorSubTable(). + * The table->Table buffer should already be allocated. + * \param start first entry to update + * \param count number of entries to update + * \param format format of user-provided table data + * \param type datatype of user-provided table data + * \param data user-provided table data + * \param [rgba]Scale - RGBA scale factors + * \param [rgba]Bias - RGBA bias factors + */ +static void +store_colortable_entries(GLcontext *ctx, struct gl_color_table *table, + GLsizei start, GLsizei count, + GLenum format, GLenum type, const GLvoid *data, + GLfloat rScale, GLfloat rBias, + GLfloat gScale, GLfloat gBias, + GLfloat bScale, GLfloat bBias, + GLfloat aScale, GLfloat aBias) +{ + if (ctx->Unpack.BufferObj->Name) { + /* Get/unpack the color table data from a PBO */ + GLubyte *buf; + if (!_mesa_validate_pbo_access(1, &ctx->Unpack, count, 1, 1, + format, type, data)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glColor[Sub]Table(bad PBO access)"); + return; + } + buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, + GL_READ_ONLY_ARB, + ctx->Unpack.BufferObj); + if (!buf) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glColor[Sub]Table(PBO mapped)"); + return; + } + data = ADD_POINTERS(buf, data); + } + + + { + /* convert user-provided data to GLfloat values */ + GLfloat tempTab[MAX_COLOR_TABLE_SIZE * 4]; + GLfloat *tableF; + GLint i; + + _mesa_unpack_color_span_float(ctx, + count, /* number of pixels */ + table->_BaseFormat, /* dest format */ + tempTab, /* dest address */ + format, type, /* src format/type */ + data, /* src data */ + &ctx->Unpack, + IMAGE_CLAMP_BIT); /* transfer ops */ + + /* the destination */ + tableF = table->TableF; + + /* Apply scale & bias & clamp now */ + switch (table->_BaseFormat) { + case GL_INTENSITY: + for (i = 0; i < count; i++) { + GLuint j = start + i; + tableF[j] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F); + } + break; + case GL_LUMINANCE: + for (i = 0; i < count; i++) { + GLuint j = start + i; + tableF[j] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F); + } + break; + case GL_ALPHA: + for (i = 0; i < count; i++) { + GLuint j = start + i; + tableF[j] = CLAMP(tempTab[i] * aScale + aBias, 0.0F, 1.0F); + } + break; + case GL_LUMINANCE_ALPHA: + for (i = 0; i < count; i++) { + GLuint j = start + i; + tableF[j*2+0] = CLAMP(tempTab[i*2+0] * rScale + rBias, 0.0F, 1.0F); + tableF[j*2+1] = CLAMP(tempTab[i*2+1] * aScale + aBias, 0.0F, 1.0F); + } + break; + case GL_RGB: + for (i = 0; i < count; i++) { + GLuint j = start + i; + tableF[j*3+0] = CLAMP(tempTab[i*3+0] * rScale + rBias, 0.0F, 1.0F); + tableF[j*3+1] = CLAMP(tempTab[i*3+1] * gScale + gBias, 0.0F, 1.0F); + tableF[j*3+2] = CLAMP(tempTab[i*3+2] * bScale + bBias, 0.0F, 1.0F); + } + break; + case GL_RGBA: + for (i = 0; i < count; i++) { + GLuint j = start + i; + tableF[j*4+0] = CLAMP(tempTab[i*4+0] * rScale + rBias, 0.0F, 1.0F); + tableF[j*4+1] = CLAMP(tempTab[i*4+1] * gScale + gBias, 0.0F, 1.0F); + tableF[j*4+2] = CLAMP(tempTab[i*4+2] * bScale + bBias, 0.0F, 1.0F); + tableF[j*4+3] = CLAMP(tempTab[i*4+3] * aScale + aBias, 0.0F, 1.0F); + } + break; + default: + _mesa_problem(ctx, "Bad format in store_colortable_entries"); + return; + } + } + + /* update the ubyte table */ + { + const GLint comps = _mesa_components_in_format(table->_BaseFormat); + const GLfloat *tableF = table->TableF + start * comps; + GLubyte *tableUB = table->TableUB + start * comps; + GLint i; + for (i = 0; i < count * comps; i++) { + CLAMPED_FLOAT_TO_UBYTE(tableUB[i], tableF[i]); + } + } + + if (ctx->Unpack.BufferObj->Name) { + ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, + ctx->Unpack.BufferObj); + } +} + + + +void GLAPIENTRY _mesa_ColorTable( GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *data ) @@ -210,10 +299,8 @@ _mesa_ColorTable( GLenum target, GLenum internalFormat, GLint baseFormat; GLfloat rScale = 1.0, gScale = 1.0, bScale = 1.0, aScale = 1.0; GLfloat rBias = 0.0, gBias = 0.0, bBias = 0.0, aBias = 0.0; - GLboolean floatTable = GL_FALSE; GLint comps; - - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glColorTable"); + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* too complex */ switch (target) { case GL_TEXTURE_1D: @@ -228,6 +315,14 @@ _mesa_ColorTable( GLenum target, GLenum internalFormat, texObj = texUnit->Current3D; table = &texObj->Palette; break; + case GL_TEXTURE_CUBE_MAP_ARB: + if (!ctx->Extensions.ARB_texture_cube_map) { + _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)"); + return; + } + texObj = texUnit->CurrentCubeMap; + table = &texObj->Palette; + break; case GL_PROXY_TEXTURE_1D: texObj = ctx->Texture.Proxy1D; table = &texObj->Palette; @@ -243,12 +338,19 @@ _mesa_ColorTable( GLenum target, GLenum internalFormat, table = &texObj->Palette; proxy = GL_TRUE; break; + case GL_PROXY_TEXTURE_CUBE_MAP_ARB: + if (!ctx->Extensions.ARB_texture_cube_map) { + _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)"); + return; + } + texObj = ctx->Texture.ProxyCubeMap; + table = &texObj->Palette; + break; case GL_SHARED_TEXTURE_PALETTE_EXT: table = &ctx->Texture.Palette; break; case GL_COLOR_TABLE: table = &ctx->ColorTable; - floatTable = GL_TRUE; rScale = ctx->Pixel.ColorTableScale[0]; gScale = ctx->Pixel.ColorTableScale[1]; bScale = ctx->Pixel.ColorTableScale[2]; @@ -262,9 +364,31 @@ _mesa_ColorTable( GLenum target, GLenum internalFormat, table = &ctx->ProxyColorTable; proxy = GL_TRUE; break; + case GL_TEXTURE_COLOR_TABLE_SGI: + if (!ctx->Extensions.SGI_texture_color_table) { + _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)"); + return; + } + table = &(texUnit->ColorTable); + rScale = ctx->Pixel.TextureColorTableScale[0]; + gScale = ctx->Pixel.TextureColorTableScale[1]; + bScale = ctx->Pixel.TextureColorTableScale[2]; + aScale = ctx->Pixel.TextureColorTableScale[3]; + rBias = ctx->Pixel.TextureColorTableBias[0]; + gBias = ctx->Pixel.TextureColorTableBias[1]; + bBias = ctx->Pixel.TextureColorTableBias[2]; + aBias = ctx->Pixel.TextureColorTableBias[3]; + break; + case GL_PROXY_TEXTURE_COLOR_TABLE_SGI: + if (!ctx->Extensions.SGI_texture_color_table) { + _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)"); + return; + } + table = &(texUnit->ProxyColorTable); + proxy = GL_TRUE; + break; case GL_POST_CONVOLUTION_COLOR_TABLE: table = &ctx->PostConvolutionColorTable; - floatTable = GL_TRUE; rScale = ctx->Pixel.PCCTscale[0]; gScale = ctx->Pixel.PCCTscale[1]; bScale = ctx->Pixel.PCCTscale[2]; @@ -280,7 +404,6 @@ _mesa_ColorTable( GLenum target, GLenum internalFormat, break; case GL_POST_COLOR_MATRIX_COLOR_TABLE: table = &ctx->PostColorMatrixColorTable; - floatTable = GL_TRUE; rScale = ctx->Pixel.PCMCTscale[0]; gScale = ctx->Pixel.PCMCTscale[1]; bScale = ctx->Pixel.PCMCTscale[2]; @@ -295,153 +418,94 @@ _mesa_ColorTable( GLenum target, GLenum internalFormat, proxy = GL_TRUE; break; default: - gl_error(ctx, GL_INVALID_ENUM, "glColorTable(target)"); + _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)"); return; } assert(table); - if (!_mesa_is_legal_format_and_type(format, type) || + if (!_mesa_is_legal_format_and_type(ctx, format, type) || format == GL_INTENSITY) { - gl_error(ctx, GL_INVALID_ENUM, "glColorTable(format or type)"); + _mesa_error(ctx, GL_INVALID_OPERATION, "glColorTable(format or type)"); return; } baseFormat = base_colortab_format(internalFormat); - if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) { - gl_error(ctx, GL_INVALID_ENUM, "glColorTable(internalFormat)"); + if (baseFormat < 0) { + _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(internalFormat)"); return; } - if (width < 0 || _mesa_bitcount(width) != 1) { + if (width < 0 || (width != 0 && _mesa_bitcount(width) != 1)) { + /* error */ if (proxy) { table->Size = 0; - table->IntFormat = (GLenum) 0; - table->Format = (GLenum) 0; + table->InternalFormat = (GLenum) 0; + table->_BaseFormat = (GLenum) 0; } else { - gl_error(ctx, GL_INVALID_VALUE, "glColorTable(width)"); + _mesa_error(ctx, GL_INVALID_VALUE, "glColorTable(width=%d)", width); } return; } - if (width > ctx->Const.MaxColorTableSize) { + if (width > (GLsizei) ctx->Const.MaxColorTableSize) { if (proxy) { table->Size = 0; - table->IntFormat = (GLenum) 0; - table->Format = (GLenum) 0; + table->InternalFormat = (GLenum) 0; + table->_BaseFormat = (GLenum) 0; } else { - if (width > ctx->Const.MaxColorTableSize) - gl_error(ctx, GL_TABLE_TOO_LARGE, "glColorTable(width)"); - else - gl_error(ctx, GL_INVALID_VALUE, "glColorTable(width)"); + _mesa_error(ctx, GL_TABLE_TOO_LARGE, "glColorTable(width)"); } return; } table->Size = width; - table->IntFormat = internalFormat; - table->Format = (GLenum) baseFormat; - set_component_sizes(table); + table->InternalFormat = internalFormat; + table->_BaseFormat = (GLenum) baseFormat; - comps = _mesa_components_in_format(table->Format); + comps = _mesa_components_in_format(table->_BaseFormat); assert(comps > 0); /* error should have been caught sooner */ if (!proxy) { - /* free old table, if any */ - if (table->Table) { - FREE(table->Table); - } - if (floatTable) { - GLfloat tempTab[MAX_COLOR_TABLE_SIZE * 4]; - GLfloat *tableF; - GLuint i; - - _mesa_unpack_float_color_span(ctx, width, table->Format, - tempTab, /* dest */ - format, type, data, &ctx->Unpack, - 0, GL_FALSE); - - table->FloatTable = GL_TRUE; - table->Table = MALLOC(comps * width * sizeof(GLfloat)); - if (!table->Table) { - gl_error(ctx, GL_OUT_OF_MEMORY, "glColorTable"); - return; - } - - tableF = (GLfloat *) table->Table; - - switch (table->Format) { - case GL_INTENSITY: - for (i = 0; i < width; i++) { - tableF[i] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F); - } - break; - case GL_LUMINANCE: - for (i = 0; i < width; i++) { - tableF[i] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F); - } - break; - case GL_ALPHA: - for (i = 0; i < width; i++) { - tableF[i] = CLAMP(tempTab[i] * aScale + aBias, 0.0F, 1.0F); - } - break; - case GL_LUMINANCE_ALPHA: - for (i = 0; i < width; i++) { - tableF[i*2+0] = CLAMP(tempTab[i*2+0] * rScale + rBias, 0.0F, 1.0F); - tableF[i*2+1] = CLAMP(tempTab[i*2+1] * aScale + aBias, 0.0F, 1.0F); - } - break; - case GL_RGB: - for (i = 0; i < width; i++) { - tableF[i*3+0] = CLAMP(tempTab[i*3+0] * rScale + rBias, 0.0F, 1.0F); - tableF[i*3+1] = CLAMP(tempTab[i*3+1] * gScale + gBias, 0.0F, 1.0F); - tableF[i*3+2] = CLAMP(tempTab[i*3+2] * bScale + bBias, 0.0F, 1.0F); - } - break; - case GL_RGBA: - for (i = 0; i < width; i++) { - tableF[i*4+0] = CLAMP(tempTab[i*4+0] * rScale + rBias, 0.0F, 1.0F); - tableF[i*4+1] = CLAMP(tempTab[i*4+1] * gScale + gBias, 0.0F, 1.0F); - tableF[i*4+2] = CLAMP(tempTab[i*4+2] * bScale + bBias, 0.0F, 1.0F); - tableF[i*4+3] = CLAMP(tempTab[i*4+3] * aScale + aBias, 0.0F, 1.0F); - } - break; - default: - gl_problem(ctx, "Bad format in _mesa_ColorTable"); - return; - } + _mesa_free_colortable_data(table); + + if (width > 0) { + table->TableF = (GLfloat *) _mesa_malloc(comps * width * sizeof(GLfloat)); + table->TableUB = (GLubyte *) _mesa_malloc(comps * width * sizeof(GLubyte)); + + if (!table->TableF || !table->TableUB) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glColorTable"); + return; + } + + store_colortable_entries(ctx, table, + 0, width, /* start, count */ + format, type, data, + rScale, rBias, + gScale, gBias, + bScale, bBias, + aScale, aBias); } - else { - /* store GLchan table */ - table->FloatTable = GL_FALSE; - table->Table = MALLOC(comps * width * sizeof(GLchan)); - if (!table->Table) { - gl_error(ctx, GL_OUT_OF_MEMORY, "glColorTable"); - return; - } - _mesa_unpack_chan_color_span(ctx, width, table->Format, - table->Table, /* dest */ - format, type, data, - &ctx->Unpack, 0); - } /* floatTable */ } /* proxy */ + /* do this after the table's Type and Format are set */ + set_component_sizes(table); + if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) { /* texture object palette, texObj==NULL means the shared palette */ if (ctx->Driver.UpdateTexturePalette) { (*ctx->Driver.UpdateTexturePalette)( ctx, texObj ); } } - + ctx->NewState |= _NEW_PIXEL; } -void +void GLAPIENTRY _mesa_ColorSubTable( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data ) @@ -452,9 +516,7 @@ _mesa_ColorSubTable( GLenum target, GLsizei start, struct gl_color_table *table = NULL; GLfloat rScale = 1.0, gScale = 1.0, bScale = 1.0, aScale = 1.0; GLfloat rBias = 0.0, gBias = 0.0, bBias = 0.0, aBias = 0.0; - GLint comps; - - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glColorSubTable"); + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); switch (target) { case GL_TEXTURE_1D: @@ -469,6 +531,14 @@ _mesa_ColorSubTable( GLenum target, GLsizei start, texObj = texUnit->Current3D; table = &texObj->Palette; break; + case GL_TEXTURE_CUBE_MAP_ARB: + if (!ctx->Extensions.ARB_texture_cube_map) { + _mesa_error(ctx, GL_INVALID_ENUM, "glColorSubTable(target)"); + return; + } + texObj = texUnit->CurrentCubeMap; + table = &texObj->Palette; + break; case GL_SHARED_TEXTURE_PALETTE_EXT: table = &ctx->Texture.Palette; break; @@ -483,6 +553,21 @@ _mesa_ColorSubTable( GLenum target, GLsizei start, bBias = ctx->Pixel.ColorTableBias[2]; aBias = ctx->Pixel.ColorTableBias[3]; break; + case GL_TEXTURE_COLOR_TABLE_SGI: + if (!ctx->Extensions.SGI_texture_color_table) { + _mesa_error(ctx, GL_INVALID_ENUM, "glColorSubTable(target)"); + return; + } + table = &(texUnit->ColorTable); + rScale = ctx->Pixel.TextureColorTableScale[0]; + gScale = ctx->Pixel.TextureColorTableScale[1]; + bScale = ctx->Pixel.TextureColorTableScale[2]; + aScale = ctx->Pixel.TextureColorTableScale[3]; + rBias = ctx->Pixel.TextureColorTableBias[0]; + gBias = ctx->Pixel.TextureColorTableBias[1]; + bBias = ctx->Pixel.TextureColorTableBias[2]; + aBias = ctx->Pixel.TextureColorTableBias[3]; + break; case GL_POST_CONVOLUTION_COLOR_TABLE: table = &ctx->PostConvolutionColorTable; rScale = ctx->Pixel.PCCTscale[0]; @@ -506,103 +591,42 @@ _mesa_ColorSubTable( GLenum target, GLsizei start, aBias = ctx->Pixel.PCMCTbias[3]; break; default: - gl_error(ctx, GL_INVALID_ENUM, "glColorSubTable(target)"); + _mesa_error(ctx, GL_INVALID_ENUM, "glColorSubTable(target)"); return; } assert(table); - if (!_mesa_is_legal_format_and_type(format, type) || + if (!_mesa_is_legal_format_and_type(ctx, format, type) || format == GL_INTENSITY) { - gl_error(ctx, GL_INVALID_ENUM, "glColorSubTable(format or type)"); + _mesa_error(ctx, GL_INVALID_OPERATION, "glColorSubTable(format or type)"); return; } if (count < 1) { - gl_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)"); + _mesa_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)"); return; } - comps = _mesa_components_in_format(table->Format); - assert(comps > 0); /* error should have been caught sooner */ + /* error should have been caught sooner */ + assert(_mesa_components_in_format(table->_BaseFormat) > 0); - if (start + count > table->Size) { - gl_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)"); + if (start + count > (GLint) table->Size) { + _mesa_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)"); return; } - if (!table->Table) { - gl_error(ctx, GL_OUT_OF_MEMORY, "glColorSubTable"); + if (!table->TableF || !table->TableUB) { + /* a GL_OUT_OF_MEMORY error would have been recorded previously */ return; } - if (!table->FloatTable) { - GLchan *dest = (GLchan *) table->Table + start * comps * sizeof(GLchan); - _mesa_unpack_chan_color_span(ctx, count, table->Format, dest, - format, type, data, &ctx->Unpack, 0); - } - else { - GLfloat tempTab[MAX_COLOR_TABLE_SIZE * 4]; - GLfloat *tableF; - GLuint i; - - ASSERT(table->FloatTable); - - _mesa_unpack_float_color_span(ctx, count, table->Format, - tempTab, /* dest */ - format, type, data, &ctx->Unpack, - 0, GL_FALSE); - - tableF = (GLfloat *) table->Table; - - switch (table->Format) { - case GL_INTENSITY: - for (i = 0; i < count; i++) { - GLuint j = start + i; - tableF[j] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F); - } - break; - case GL_LUMINANCE: - for (i = 0; i < count; i++) { - GLuint j = start + i; - tableF[j] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F); - } - break; - case GL_ALPHA: - for (i = 0; i < count; i++) { - GLuint j = start + i; - tableF[j] = CLAMP(tempTab[i] * aScale + aBias, 0.0F, 1.0F); - } - break; - case GL_LUMINANCE_ALPHA: - for (i = 0; i < count; i++) { - GLuint j = start + i; - tableF[j*2+0] = CLAMP(tempTab[i*2+0] * rScale + rBias, 0.0F, 1.0F); - tableF[j*2+1] = CLAMP(tempTab[i*2+1] * aScale + aBias, 0.0F, 1.0F); - } - break; - case GL_RGB: - for (i = 0; i < count; i++) { - GLuint j = start + i; - tableF[j*3+0] = CLAMP(tempTab[i*3+0] * rScale + rBias, 0.0F, 1.0F); - tableF[j*3+1] = CLAMP(tempTab[i*3+1] * gScale + gBias, 0.0F, 1.0F); - tableF[j*3+2] = CLAMP(tempTab[i*3+2] * bScale + bBias, 0.0F, 1.0F); - } - break; - case GL_RGBA: - for (i = 0; i < count; i++) { - GLuint j = start + i; - tableF[j*4+0] = CLAMP(tempTab[i*4+0] * rScale + rBias, 0.0F, 1.0F); - tableF[j*4+1] = CLAMP(tempTab[i*4+1] * gScale + gBias, 0.0F, 1.0F); - tableF[j*4+2] = CLAMP(tempTab[i*4+2] * bScale + bBias, 0.0F, 1.0F); - tableF[j*4+3] = CLAMP(tempTab[i*4+3] * aScale + aBias, 0.0F, 1.0F); - } - break; - default: - gl_problem(ctx, "Bad format in _mesa_ColorSubTable"); - return; - } - } + store_colortable_entries(ctx, table, start, count, + format, type, data, + rScale, rBias, + gScale, gBias, + bScale, bBias, + aScale, aBias); if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) { /* per-texture object palette */ @@ -610,87 +634,49 @@ _mesa_ColorSubTable( GLenum target, GLsizei start, (*ctx->Driver.UpdateTexturePalette)( ctx, texObj ); } } - + ctx->NewState |= _NEW_PIXEL; } -/* XXX not tested */ -void +void GLAPIENTRY _mesa_CopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) { - GLchan data[MAX_WIDTH][4]; GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyColorTable"); + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* Select buffer to read from */ - (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer, - ctx->Pixel.DriverReadBuffer ); - - if (width > MAX_WIDTH) - width = MAX_WIDTH; - - /* read the data from framebuffer */ - RENDER_START(ctx); - gl_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y, data ); - RENDER_FINISH(ctx); - - /* Restore reading from draw buffer (the default) */ - (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, - ctx->Color.DriverDrawBuffer ); - - _mesa_ColorTable(target, internalformat, width, - GL_RGBA, GL_UNSIGNED_BYTE, data); + ctx->Driver.CopyColorTable( ctx, target, internalformat, x, y, width ); } -/* XXX not tested */ -void +void GLAPIENTRY _mesa_CopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) { - GLchan data[MAX_WIDTH][4]; GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyColorSubTable"); - - /* Select buffer to read from */ - (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer, - ctx->Pixel.DriverReadBuffer ); - - if (width > MAX_WIDTH) - width = MAX_WIDTH; + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); - /* read the data from framebuffer */ - RENDER_START(ctx); - gl_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y, data ); - RENDER_FINISH(ctx); - - /* Restore reading from draw buffer (the default) */ - (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, - ctx->Color.DriverDrawBuffer ); - - _mesa_ColorSubTable(target, start, width, GL_RGBA, GL_UNSIGNED_BYTE, data); + ctx->Driver.CopyColorSubTable( ctx, target, start, x, y, width ); } -void +void GLAPIENTRY _mesa_GetColorTable( GLenum target, GLenum format, GLenum type, GLvoid *data ) { GET_CURRENT_CONTEXT(ctx); struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; struct gl_color_table *table = NULL; - GLchan rgba[MAX_COLOR_TABLE_SIZE][4]; - GLint i; - - ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTable"); + GLfloat rgba[MAX_COLOR_TABLE_SIZE][4]; + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); if (ctx->NewState) { - gl_update_state(ctx); + _mesa_update_state(ctx); } switch (target) { @@ -703,12 +689,26 @@ _mesa_GetColorTable( GLenum target, GLenum format, case GL_TEXTURE_3D: table = &texUnit->Current3D->Palette; break; + case GL_TEXTURE_CUBE_MAP_ARB: + if (!ctx->Extensions.ARB_texture_cube_map) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTable(target)"); + return; + } + table = &texUnit->CurrentCubeMap->Palette; + break; case GL_SHARED_TEXTURE_PALETTE_EXT: table = &ctx->Texture.Palette; break; case GL_COLOR_TABLE: table = &ctx->ColorTable; break; + case GL_TEXTURE_COLOR_TABLE_SGI: + if (!ctx->Extensions.SGI_texture_color_table) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTable(target)"); + return; + } + table = &(texUnit->ColorTable); + break; case GL_POST_CONVOLUTION_COLOR_TABLE: table = &ctx->PostConvolutionColorTable; break; @@ -716,149 +716,113 @@ _mesa_GetColorTable( GLenum target, GLenum format, table = &ctx->PostColorMatrixColorTable; break; default: - gl_error(ctx, GL_INVALID_ENUM, "glGetColorTable(target)"); + _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTable(target)"); return; } - assert(table); + ASSERT(table); - switch (table->Format) { - case GL_ALPHA: - if (table->FloatTable) { - const GLfloat *tableF = (const GLfloat *) table->Table; - for (i = 0; i < table->Size; i++) { - rgba[i][RCOMP] = 0; - rgba[i][GCOMP] = 0; - rgba[i][BCOMP] = 0; - rgba[i][ACOMP] = (GLint) (tableF[i] * CHAN_MAXF); - } - } - else { - const GLchan *tableUB = (const GLchan *) table->Table; - for (i = 0; i < table->Size; i++) { - rgba[i][RCOMP] = 0; - rgba[i][GCOMP] = 0; - rgba[i][BCOMP] = 0; - rgba[i][ACOMP] = tableUB[i]; - } - } - break; - case GL_LUMINANCE: - if (table->FloatTable) { - const GLfloat *tableF = (const GLfloat *) table->Table; - for (i = 0; i < table->Size; i++) { - rgba[i][RCOMP] = (GLint) (tableF[i] * CHAN_MAXF); - rgba[i][GCOMP] = (GLint) (tableF[i] * CHAN_MAXF); - rgba[i][BCOMP] = (GLint) (tableF[i] * CHAN_MAXF); - rgba[i][ACOMP] = CHAN_MAX; - } - } - else { - const GLchan *tableUB = (const GLchan *) table->Table; - for (i = 0; i < table->Size; i++) { - rgba[i][RCOMP] = tableUB[i]; - rgba[i][GCOMP] = tableUB[i]; - rgba[i][BCOMP] = tableUB[i]; - rgba[i][ACOMP] = CHAN_MAX; - } - } - break; - case GL_LUMINANCE_ALPHA: - if (table->FloatTable) { - const GLfloat *tableF = (const GLfloat *) table->Table; - for (i = 0; i < table->Size; i++) { - rgba[i][RCOMP] = (GLint) (tableF[i*2+0] * CHAN_MAXF); - rgba[i][GCOMP] = (GLint) (tableF[i*2+0] * CHAN_MAXF); - rgba[i][BCOMP] = (GLint) (tableF[i*2+0] * CHAN_MAXF); - rgba[i][ACOMP] = (GLint) (tableF[i*2+1] * CHAN_MAXF); - } - } - else { - const GLchan *tableUB = (const GLchan *) table->Table; - for (i = 0; i < table->Size; i++) { - rgba[i][RCOMP] = tableUB[i*2+0]; - rgba[i][GCOMP] = tableUB[i*2+0]; - rgba[i][BCOMP] = tableUB[i*2+0]; - rgba[i][ACOMP] = tableUB[i*2+1]; - } - } - break; - case GL_INTENSITY: - if (table->FloatTable) { - const GLfloat *tableF = (const GLfloat *) table->Table; - for (i = 0; i < table->Size; i++) { - rgba[i][RCOMP] = (GLint) (tableF[i] * CHAN_MAXF); - rgba[i][GCOMP] = (GLint) (tableF[i] * CHAN_MAXF); - rgba[i][BCOMP] = (GLint) (tableF[i] * CHAN_MAXF); - rgba[i][ACOMP] = (GLint) (tableF[i] * CHAN_MAXF); - } - } - else { - const GLchan *tableUB = (const GLchan *) table->Table; - for (i = 0; i < table->Size; i++) { - rgba[i][RCOMP] = tableUB[i]; - rgba[i][GCOMP] = tableUB[i]; - rgba[i][BCOMP] = tableUB[i]; - rgba[i][ACOMP] = tableUB[i]; - } + switch (table->_BaseFormat) { + case GL_ALPHA: + { + GLuint i; + for (i = 0; i < table->Size; i++) { + rgba[i][RCOMP] = 0; + rgba[i][GCOMP] = 0; + rgba[i][BCOMP] = 0; + rgba[i][ACOMP] = table->TableF[i]; } - break; - case GL_RGB: - if (table->FloatTable) { - const GLfloat *tableF = (const GLfloat *) table->Table; - for (i = 0; i < table->Size; i++) { - rgba[i][RCOMP] = (GLint) (tableF[i*3+0] * CHAN_MAXF); - rgba[i][GCOMP] = (GLint) (tableF[i*3+1] * CHAN_MAXF); - rgba[i][BCOMP] = (GLint) (tableF[i*3+2] * CHAN_MAXF); - rgba[i][ACOMP] = CHAN_MAX; - } + } + break; + case GL_LUMINANCE: + { + GLuint i; + for (i = 0; i < table->Size; i++) { + rgba[i][RCOMP] = + rgba[i][GCOMP] = + rgba[i][BCOMP] = table->TableF[i]; + rgba[i][ACOMP] = 1.0F; } - else { - const GLchan *tableUB = (const GLchan *) table->Table; - for (i = 0; i < table->Size; i++) { - rgba[i][RCOMP] = tableUB[i*3+0]; - rgba[i][GCOMP] = tableUB[i*3+1]; - rgba[i][BCOMP] = tableUB[i*3+2]; - rgba[i][ACOMP] = CHAN_MAX; - } + } + break; + case GL_LUMINANCE_ALPHA: + { + GLuint i; + for (i = 0; i < table->Size; i++) { + rgba[i][RCOMP] = + rgba[i][GCOMP] = + rgba[i][BCOMP] = table->TableF[i*2+0]; + rgba[i][ACOMP] = table->TableF[i*2+1]; } - break; - case GL_RGBA: - if (table->FloatTable) { - const GLfloat *tableF = (const GLfloat *) table->Table; - for (i = 0; i < table->Size; i++) { - rgba[i][RCOMP] = (GLint) (tableF[i*4+0] * CHAN_MAXF + 0.5F); - rgba[i][GCOMP] = (GLint) (tableF[i*4+1] * CHAN_MAXF + 0.5F); - rgba[i][BCOMP] = (GLint) (tableF[i*4+2] * CHAN_MAXF + 0.5F); - rgba[i][ACOMP] = (GLint) (tableF[i*4+3] * CHAN_MAXF + 0.5F); - } + } + break; + case GL_INTENSITY: + { + GLuint i; + for (i = 0; i < table->Size; i++) { + rgba[i][RCOMP] = + rgba[i][GCOMP] = + rgba[i][BCOMP] = + rgba[i][ACOMP] = table->TableF[i]; } - else { - const GLchan *tableUB = (const GLchan *) table->Table; - for (i = 0; i < table->Size; i++) { - rgba[i][RCOMP] = tableUB[i*4+0]; - rgba[i][GCOMP] = tableUB[i*4+1]; - rgba[i][BCOMP] = tableUB[i*4+2]; - rgba[i][ACOMP] = tableUB[i*4+3]; - } + } + break; + case GL_RGB: + { + GLuint i; + for (i = 0; i < table->Size; i++) { + rgba[i][RCOMP] = table->TableF[i*3+0]; + rgba[i][GCOMP] = table->TableF[i*3+1]; + rgba[i][BCOMP] = table->TableF[i*3+2]; + rgba[i][ACOMP] = 1.0F; } - break; - default: - gl_problem(ctx, "bad table format in glGetColorTable"); + } + break; + case GL_RGBA: + _mesa_memcpy(rgba, table->TableF, 4 * table->Size * sizeof(GLfloat)); + break; + default: + _mesa_problem(ctx, "bad table format in glGetColorTable"); + return; + } + + if (ctx->Pack.BufferObj->Name) { + /* pack color table into PBO */ + GLubyte *buf; + if (!_mesa_validate_pbo_access(1, &ctx->Pack, table->Size, 1, 1, + format, type, data)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glGetColorTable(invalid PBO access)"); return; + } + buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, + GL_WRITE_ONLY_ARB, + ctx->Pack.BufferObj); + if (!buf) { + /* buffer is already mapped - that's an error */ + _mesa_error(ctx, GL_INVALID_OPERATION, + "glGetColorTable(PBO is mapped)"); + return; + } + data = ADD_POINTERS(buf, data); } - _mesa_pack_rgba_span(ctx, table->Size, (const GLchan (*)[]) rgba, - format, type, data, &ctx->Pack, GL_FALSE); + _mesa_pack_rgba_span_float(ctx, table->Size, rgba, + format, type, data, &ctx->Pack, 0x0); + + if (ctx->Pack.BufferObj->Name) { + ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, + ctx->Pack.BufferObj); + } } -void +void GLAPIENTRY _mesa_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params) { GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END(ctx, "glColorTableParameterfv"); + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); switch (target) { case GL_COLOR_TABLE_SGI: @@ -875,7 +839,29 @@ _mesa_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params) ctx->Pixel.ColorTableBias[3] = params[3]; } else { - gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)"); + _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)"); + return; + } + break; + case GL_TEXTURE_COLOR_TABLE_SGI: + if (!ctx->Extensions.SGI_texture_color_table) { + _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameter(target)"); + return; + } + if (pname == GL_COLOR_TABLE_SCALE_SGI) { + ctx->Pixel.TextureColorTableScale[0] = params[0]; + ctx->Pixel.TextureColorTableScale[1] = params[1]; + ctx->Pixel.TextureColorTableScale[2] = params[2]; + ctx->Pixel.TextureColorTableScale[3] = params[3]; + } + else if (pname == GL_COLOR_TABLE_BIAS_SGI) { + ctx->Pixel.TextureColorTableBias[0] = params[0]; + ctx->Pixel.TextureColorTableBias[1] = params[1]; + ctx->Pixel.TextureColorTableBias[2] = params[2]; + ctx->Pixel.TextureColorTableBias[3] = params[3]; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)"); return; } break; @@ -893,7 +879,7 @@ _mesa_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params) ctx->Pixel.PCCTbias[3] = params[3]; } else { - gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)"); + _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)"); return; } break; @@ -911,12 +897,12 @@ _mesa_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params) ctx->Pixel.PCMCTbias[3] = params[3]; } else { - gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)"); + _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)"); return; } break; default: - gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameter(target)"); + _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameter(target)"); return; } @@ -925,11 +911,12 @@ _mesa_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params) -void +void GLAPIENTRY _mesa_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params) { GLfloat fparams[4]; if (pname == GL_COLOR_TABLE_SGI || + pname == GL_TEXTURE_COLOR_TABLE_SGI || pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI || pname == GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI) { /* four values */ @@ -947,14 +934,13 @@ _mesa_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params) -void +void GLAPIENTRY _mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params ) { GET_CURRENT_CONTEXT(ctx); struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; struct gl_color_table *table = NULL; - - ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTableParameterfv"); + ASSERT_OUTSIDE_BEGIN_END(ctx); switch (target) { case GL_TEXTURE_1D: @@ -966,6 +952,14 @@ _mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params ) case GL_TEXTURE_3D: table = &texUnit->Current3D->Palette; break; + case GL_TEXTURE_CUBE_MAP_ARB: + if (!ctx->Extensions.ARB_texture_cube_map) { + _mesa_error(ctx, GL_INVALID_ENUM, + "glGetColorTableParameterfv(target)"); + return; + } + table = &texUnit->CurrentCubeMap->Palette; + break; case GL_PROXY_TEXTURE_1D: table = &ctx->Texture.Proxy1D->Palette; break; @@ -975,6 +969,14 @@ _mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params ) case GL_PROXY_TEXTURE_3D: table = &ctx->Texture.Proxy3D->Palette; break; + case GL_PROXY_TEXTURE_CUBE_MAP_ARB: + if (!ctx->Extensions.ARB_texture_cube_map) { + _mesa_error(ctx, GL_INVALID_ENUM, + "glGetColorTableParameterfv(target)"); + return; + } + table = &ctx->Texture.ProxyCubeMap->Palette; + break; case GL_SHARED_TEXTURE_PALETTE_EXT: table = &ctx->Texture.Palette; break; @@ -998,6 +1000,34 @@ _mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params ) case GL_PROXY_COLOR_TABLE: table = &ctx->ProxyColorTable; break; + case GL_TEXTURE_COLOR_TABLE_SGI: + if (!ctx->Extensions.SGI_texture_color_table) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameter(target)"); + return; + } + table = &(texUnit->ColorTable); + if (pname == GL_COLOR_TABLE_SCALE_SGI) { + params[0] = ctx->Pixel.TextureColorTableScale[0]; + params[1] = ctx->Pixel.TextureColorTableScale[1]; + params[2] = ctx->Pixel.TextureColorTableScale[2]; + params[3] = ctx->Pixel.TextureColorTableScale[3]; + return; + } + else if (pname == GL_COLOR_TABLE_BIAS_SGI) { + params[0] = ctx->Pixel.TextureColorTableBias[0]; + params[1] = ctx->Pixel.TextureColorTableBias[1]; + params[2] = ctx->Pixel.TextureColorTableBias[2]; + params[3] = ctx->Pixel.TextureColorTableBias[3]; + return; + } + break; + case GL_PROXY_TEXTURE_COLOR_TABLE_SGI: + if (!ctx->Extensions.SGI_texture_color_table) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameter(target)"); + return; + } + table = &(texUnit->ProxyColorTable); + break; case GL_POST_CONVOLUTION_COLOR_TABLE: table = &ctx->PostConvolutionColorTable; if (pname == GL_COLOR_TABLE_SCALE_SGI) { @@ -1039,7 +1069,7 @@ _mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params ) table = &ctx->ProxyPostColorMatrixColorTable; break; default: - gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(target)"); + _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(target)"); return; } @@ -1047,45 +1077,44 @@ _mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params ) switch (pname) { case GL_COLOR_TABLE_FORMAT: - *params = table->IntFormat; + *params = (GLfloat) table->InternalFormat; break; case GL_COLOR_TABLE_WIDTH: - *params = table->Size; + *params = (GLfloat) table->Size; break; case GL_COLOR_TABLE_RED_SIZE: - *params = table->RedSize; + *params = (GLfloat) table->RedSize; break; case GL_COLOR_TABLE_GREEN_SIZE: - *params = table->GreenSize; + *params = (GLfloat) table->GreenSize; break; case GL_COLOR_TABLE_BLUE_SIZE: - *params = table->BlueSize; + *params = (GLfloat) table->BlueSize; break; case GL_COLOR_TABLE_ALPHA_SIZE: - *params = table->AlphaSize; + *params = (GLfloat) table->AlphaSize; break; case GL_COLOR_TABLE_LUMINANCE_SIZE: - *params = table->LuminanceSize; + *params = (GLfloat) table->LuminanceSize; break; case GL_COLOR_TABLE_INTENSITY_SIZE: - *params = table->IntensitySize; + *params = (GLfloat) table->IntensitySize; break; default: - gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(pname)" ); + _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(pname)" ); return; } } -void +void GLAPIENTRY _mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params ) { GET_CURRENT_CONTEXT(ctx); struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; struct gl_color_table *table = NULL; - - ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTableParameteriv"); + ASSERT_OUTSIDE_BEGIN_END(ctx); switch (target) { case GL_TEXTURE_1D: @@ -1097,6 +1126,14 @@ _mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params ) case GL_TEXTURE_3D: table = &texUnit->Current3D->Palette; break; + case GL_TEXTURE_CUBE_MAP_ARB: + if (!ctx->Extensions.ARB_texture_cube_map) { + _mesa_error(ctx, GL_INVALID_ENUM, + "glGetColorTableParameteriv(target)"); + return; + } + table = &texUnit->CurrentCubeMap->Palette; + break; case GL_PROXY_TEXTURE_1D: table = &ctx->Texture.Proxy1D->Palette; break; @@ -1106,6 +1143,14 @@ _mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params ) case GL_PROXY_TEXTURE_3D: table = &ctx->Texture.Proxy3D->Palette; break; + case GL_PROXY_TEXTURE_CUBE_MAP_ARB: + if (!ctx->Extensions.ARB_texture_cube_map) { + _mesa_error(ctx, GL_INVALID_ENUM, + "glGetColorTableParameteriv(target)"); + return; + } + table = &ctx->Texture.ProxyCubeMap->Palette; + break; case GL_SHARED_TEXTURE_PALETTE_EXT: table = &ctx->Texture.Palette; break; @@ -1129,6 +1174,34 @@ _mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params ) case GL_PROXY_COLOR_TABLE: table = &ctx->ProxyColorTable; break; + case GL_TEXTURE_COLOR_TABLE_SGI: + if (!ctx->Extensions.SGI_texture_color_table) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameter(target)"); + return; + } + table = &(texUnit->ColorTable); + if (pname == GL_COLOR_TABLE_SCALE_SGI) { + params[0] = (GLint) ctx->Pixel.TextureColorTableScale[0]; + params[1] = (GLint) ctx->Pixel.TextureColorTableScale[1]; + params[2] = (GLint) ctx->Pixel.TextureColorTableScale[2]; + params[3] = (GLint) ctx->Pixel.TextureColorTableScale[3]; + return; + } + else if (pname == GL_COLOR_TABLE_BIAS_SGI) { + params[0] = (GLint) ctx->Pixel.TextureColorTableBias[0]; + params[1] = (GLint) ctx->Pixel.TextureColorTableBias[1]; + params[2] = (GLint) ctx->Pixel.TextureColorTableBias[2]; + params[3] = (GLint) ctx->Pixel.TextureColorTableBias[3]; + return; + } + break; + case GL_PROXY_TEXTURE_COLOR_TABLE_SGI: + if (!ctx->Extensions.SGI_texture_color_table) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameter(target)"); + return; + } + table = &(texUnit->ProxyColorTable); + break; case GL_POST_CONVOLUTION_COLOR_TABLE: table = &ctx->PostConvolutionColorTable; if (pname == GL_COLOR_TABLE_SCALE_SGI) { @@ -1170,7 +1243,7 @@ _mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params ) table = &ctx->ProxyPostColorMatrixColorTable; break; default: - gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(target)"); + _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(target)"); return; } @@ -1178,7 +1251,7 @@ _mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params ) switch (pname) { case GL_COLOR_TABLE_FORMAT: - *params = table->IntFormat; + *params = table->InternalFormat; break; case GL_COLOR_TABLE_WIDTH: *params = table->Size; @@ -1202,7 +1275,67 @@ _mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params ) *params = table->IntensitySize; break; default: - gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(pname)" ); + _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(pname)" ); return; } } + +/**********************************************************************/ +/***** Initialization *****/ +/**********************************************************************/ + + +void +_mesa_init_colortable( struct gl_color_table *p ) +{ + p->TableF = NULL; + p->TableUB = NULL; + p->Size = 0; + p->InternalFormat = GL_RGBA; +} + + + +void +_mesa_free_colortable_data( struct gl_color_table *p ) +{ + if (p->TableF) { + _mesa_free(p->TableF); + p->TableF = NULL; + } + if (p->TableUB) { + _mesa_free(p->TableUB); + p->TableUB = NULL; + } +} + + +/* + * Initialize all colortables for a context. + */ +void +_mesa_init_colortables( GLcontext * ctx ) +{ + /* Color tables */ + _mesa_init_colortable(&ctx->ColorTable); + _mesa_init_colortable(&ctx->ProxyColorTable); + _mesa_init_colortable(&ctx->PostConvolutionColorTable); + _mesa_init_colortable(&ctx->ProxyPostConvolutionColorTable); + _mesa_init_colortable(&ctx->PostColorMatrixColorTable); + _mesa_init_colortable(&ctx->ProxyPostColorMatrixColorTable); +} + + +/* + * Free all colortable data for a context + */ +void +_mesa_free_colortables_data( GLcontext *ctx ) +{ + _mesa_free_colortable_data(&ctx->ColorTable); + _mesa_free_colortable_data(&ctx->ProxyColorTable); + _mesa_free_colortable_data(&ctx->PostConvolutionColorTable); + _mesa_free_colortable_data(&ctx->ProxyPostConvolutionColorTable); + _mesa_free_colortable_data(&ctx->PostColorMatrixColorTable); + _mesa_free_colortable_data(&ctx->ProxyPostColorMatrixColorTable); +}