2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 #include "bufferobj.h"
35 #include "main/dispatch.h"
38 #if FEATURE_colortable
42 * Given an internalFormat token passed to glColorTable,
43 * return the corresponding base format.
44 * Return -1 if invalid token.
47 base_colortab_format( GLenum format
)
62 case GL_LUMINANCE_ALPHA
:
63 case GL_LUMINANCE4_ALPHA4
:
64 case GL_LUMINANCE6_ALPHA2
:
65 case GL_LUMINANCE8_ALPHA8
:
66 case GL_LUMINANCE12_ALPHA4
:
67 case GL_LUMINANCE12_ALPHA12
:
68 case GL_LUMINANCE16_ALPHA16
:
69 return GL_LUMINANCE_ALPHA
;
95 return -1; /* error */
102 * Examine table's format and set the component sizes accordingly.
105 set_component_sizes( struct gl_color_table
*table
)
107 /* assuming the ubyte table */
108 const GLubyte sz
= 8;
110 switch (table
->_BaseFormat
) {
113 table
->GreenSize
= 0;
115 table
->AlphaSize
= sz
;
116 table
->IntensitySize
= 0;
117 table
->LuminanceSize
= 0;
121 table
->GreenSize
= 0;
123 table
->AlphaSize
= 0;
124 table
->IntensitySize
= 0;
125 table
->LuminanceSize
= sz
;
127 case GL_LUMINANCE_ALPHA
:
129 table
->GreenSize
= 0;
131 table
->AlphaSize
= sz
;
132 table
->IntensitySize
= 0;
133 table
->LuminanceSize
= sz
;
137 table
->GreenSize
= 0;
139 table
->AlphaSize
= 0;
140 table
->IntensitySize
= sz
;
141 table
->LuminanceSize
= 0;
145 table
->GreenSize
= sz
;
146 table
->BlueSize
= sz
;
147 table
->AlphaSize
= 0;
148 table
->IntensitySize
= 0;
149 table
->LuminanceSize
= 0;
153 table
->GreenSize
= sz
;
154 table
->BlueSize
= sz
;
155 table
->AlphaSize
= sz
;
156 table
->IntensitySize
= 0;
157 table
->LuminanceSize
= 0;
160 _mesa_problem(NULL
, "unexpected format in set_component_sizes");
167 * Update/replace all or part of a color table. Helper function
168 * used by _mesa_ColorTable() and _mesa_ColorSubTable().
169 * The table->Table buffer should already be allocated.
170 * \param start first entry to update
171 * \param count number of entries to update
172 * \param format format of user-provided table data
173 * \param type datatype of user-provided table data
174 * \param data user-provided table data
175 * \param [rgba]Scale - RGBA scale factors
176 * \param [rgba]Bias - RGBA bias factors
179 store_colortable_entries(GLcontext
*ctx
, struct gl_color_table
*table
,
180 GLsizei start
, GLsizei count
,
181 GLenum format
, GLenum type
, const GLvoid
*data
,
182 GLfloat rScale
, GLfloat rBias
,
183 GLfloat gScale
, GLfloat gBias
,
184 GLfloat bScale
, GLfloat bBias
,
185 GLfloat aScale
, GLfloat aBias
)
187 data
= _mesa_map_validate_pbo_source(ctx
,
188 1, &ctx
->Unpack
, count
, 1, 1,
190 "glColor[Sub]Table");
195 /* convert user-provided data to GLfloat values */
196 GLfloat tempTab
[MAX_COLOR_TABLE_SIZE
* 4];
200 _mesa_unpack_color_span_float(ctx
,
201 count
, /* number of pixels */
202 table
->_BaseFormat
, /* dest format */
203 tempTab
, /* dest address */
204 format
, type
, /* src format/type */
207 IMAGE_CLAMP_BIT
); /* transfer ops */
209 /* the destination */
210 tableF
= table
->TableF
;
212 /* Apply scale & bias & clamp now */
213 switch (table
->_BaseFormat
) {
215 for (i
= 0; i
< count
; i
++) {
216 GLuint j
= start
+ i
;
217 tableF
[j
] = CLAMP(tempTab
[i
] * rScale
+ rBias
, 0.0F
, 1.0F
);
221 for (i
= 0; i
< count
; i
++) {
222 GLuint j
= start
+ i
;
223 tableF
[j
] = CLAMP(tempTab
[i
] * rScale
+ rBias
, 0.0F
, 1.0F
);
227 for (i
= 0; i
< count
; i
++) {
228 GLuint j
= start
+ i
;
229 tableF
[j
] = CLAMP(tempTab
[i
] * aScale
+ aBias
, 0.0F
, 1.0F
);
232 case GL_LUMINANCE_ALPHA
:
233 for (i
= 0; i
< count
; i
++) {
234 GLuint j
= start
+ i
;
235 tableF
[j
*2+0] = CLAMP(tempTab
[i
*2+0] * rScale
+ rBias
, 0.0F
, 1.0F
);
236 tableF
[j
*2+1] = CLAMP(tempTab
[i
*2+1] * aScale
+ aBias
, 0.0F
, 1.0F
);
240 for (i
= 0; i
< count
; i
++) {
241 GLuint j
= start
+ i
;
242 tableF
[j
*3+0] = CLAMP(tempTab
[i
*3+0] * rScale
+ rBias
, 0.0F
, 1.0F
);
243 tableF
[j
*3+1] = CLAMP(tempTab
[i
*3+1] * gScale
+ gBias
, 0.0F
, 1.0F
);
244 tableF
[j
*3+2] = CLAMP(tempTab
[i
*3+2] * bScale
+ bBias
, 0.0F
, 1.0F
);
248 for (i
= 0; i
< count
; i
++) {
249 GLuint j
= start
+ i
;
250 tableF
[j
*4+0] = CLAMP(tempTab
[i
*4+0] * rScale
+ rBias
, 0.0F
, 1.0F
);
251 tableF
[j
*4+1] = CLAMP(tempTab
[i
*4+1] * gScale
+ gBias
, 0.0F
, 1.0F
);
252 tableF
[j
*4+2] = CLAMP(tempTab
[i
*4+2] * bScale
+ bBias
, 0.0F
, 1.0F
);
253 tableF
[j
*4+3] = CLAMP(tempTab
[i
*4+3] * aScale
+ aBias
, 0.0F
, 1.0F
);
257 _mesa_problem(ctx
, "Bad format in store_colortable_entries");
262 /* update the ubyte table */
264 const GLint comps
= _mesa_components_in_format(table
->_BaseFormat
);
265 const GLfloat
*tableF
= table
->TableF
+ start
* comps
;
266 GLubyte
*tableUB
= table
->TableUB
+ start
* comps
;
268 for (i
= 0; i
< count
* comps
; i
++) {
269 CLAMPED_FLOAT_TO_UBYTE(tableUB
[i
], tableF
[i
]);
273 _mesa_unmap_pbo_source(ctx
, &ctx
->Unpack
);
279 _mesa_ColorTable( GLenum target
, GLenum internalFormat
,
280 GLsizei width
, GLenum format
, GLenum type
,
283 static const GLfloat one
[4] = { 1.0, 1.0, 1.0, 1.0 };
284 static const GLfloat zero
[4] = { 0.0, 0.0, 0.0, 0.0 };
285 GET_CURRENT_CONTEXT(ctx
);
286 struct gl_texture_unit
*texUnit
= _mesa_get_current_tex_unit(ctx
);
287 struct gl_texture_object
*texObj
= NULL
;
288 struct gl_color_table
*table
= NULL
;
289 GLboolean proxy
= GL_FALSE
;
291 const GLfloat
*scale
= one
, *bias
= zero
;
294 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
); /* too complex */
297 case GL_SHARED_TEXTURE_PALETTE_EXT
:
298 table
= &ctx
->Texture
.Palette
;
301 table
= &ctx
->ColorTable
[COLORTABLE_PRECONVOLUTION
];
302 scale
= ctx
->Pixel
.ColorTableScale
[COLORTABLE_PRECONVOLUTION
];
303 bias
= ctx
->Pixel
.ColorTableBias
[COLORTABLE_PRECONVOLUTION
];
305 case GL_PROXY_COLOR_TABLE
:
306 table
= &ctx
->ProxyColorTable
[COLORTABLE_PRECONVOLUTION
];
309 case GL_TEXTURE_COLOR_TABLE_SGI
:
310 if (!ctx
->Extensions
.SGI_texture_color_table
) {
311 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTable(target)");
314 table
= &(texUnit
->ColorTable
);
315 scale
= ctx
->Pixel
.TextureColorTableScale
;
316 bias
= ctx
->Pixel
.TextureColorTableBias
;
318 case GL_PROXY_TEXTURE_COLOR_TABLE_SGI
:
319 if (!ctx
->Extensions
.SGI_texture_color_table
) {
320 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTable(target)");
323 table
= &(texUnit
->ProxyColorTable
);
326 case GL_POST_CONVOLUTION_COLOR_TABLE
:
327 table
= &ctx
->ColorTable
[COLORTABLE_POSTCONVOLUTION
];
328 scale
= ctx
->Pixel
.ColorTableScale
[COLORTABLE_POSTCONVOLUTION
];
329 bias
= ctx
->Pixel
.ColorTableBias
[COLORTABLE_POSTCONVOLUTION
];
331 case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE
:
332 table
= &ctx
->ProxyColorTable
[COLORTABLE_POSTCONVOLUTION
];
335 case GL_POST_COLOR_MATRIX_COLOR_TABLE
:
336 table
= &ctx
->ColorTable
[COLORTABLE_POSTCOLORMATRIX
];
337 scale
= ctx
->Pixel
.ColorTableScale
[COLORTABLE_POSTCOLORMATRIX
];
338 bias
= ctx
->Pixel
.ColorTableBias
[COLORTABLE_POSTCOLORMATRIX
];
340 case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE
:
341 table
= &ctx
->ProxyColorTable
[COLORTABLE_POSTCOLORMATRIX
];
345 /* try texture targets */
347 struct gl_texture_object
*texobj
348 = _mesa_select_tex_object(ctx
, texUnit
, target
);
350 table
= &texobj
->Palette
;
351 proxy
= _mesa_is_proxy_texture(target
);
354 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTable(target)");
362 if (!_mesa_is_legal_format_and_type(ctx
, format
, type
) ||
363 format
== GL_INTENSITY
) {
364 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glColorTable(format or type)");
368 baseFormat
= base_colortab_format(internalFormat
);
369 if (baseFormat
< 0) {
370 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTable(internalFormat)");
374 if (width
< 0 || (width
!= 0 && !_mesa_is_pow_two(width
))) {
378 table
->InternalFormat
= (GLenum
) 0;
379 table
->_BaseFormat
= (GLenum
) 0;
382 _mesa_error(ctx
, GL_INVALID_VALUE
, "glColorTable(width=%d)", width
);
387 if (width
> (GLsizei
) ctx
->Const
.MaxColorTableSize
) {
390 table
->InternalFormat
= (GLenum
) 0;
391 table
->_BaseFormat
= (GLenum
) 0;
394 _mesa_error(ctx
, GL_TABLE_TOO_LARGE
, "glColorTable(width)");
400 table
->InternalFormat
= internalFormat
;
401 table
->_BaseFormat
= (GLenum
) baseFormat
;
403 comps
= _mesa_components_in_format(table
->_BaseFormat
);
404 assert(comps
> 0); /* error should have been caught sooner */
407 _mesa_free_colortable_data(table
);
410 table
->TableF
= (GLfloat
*) malloc(comps
* width
* sizeof(GLfloat
));
411 table
->TableUB
= (GLubyte
*) malloc(comps
* width
* sizeof(GLubyte
));
413 if (!table
->TableF
|| !table
->TableUB
) {
414 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glColorTable");
418 store_colortable_entries(ctx
, table
,
419 0, width
, /* start, count */
428 /* do this after the table's Type and Format are set */
429 set_component_sizes(table
);
431 if (texObj
|| target
== GL_SHARED_TEXTURE_PALETTE_EXT
) {
432 /* texture object palette, texObj==NULL means the shared palette */
433 if (ctx
->Driver
.UpdateTexturePalette
) {
434 (*ctx
->Driver
.UpdateTexturePalette
)( ctx
, texObj
);
438 ctx
->NewState
|= _NEW_PIXEL
;
444 _mesa_ColorSubTable( GLenum target
, GLsizei start
,
445 GLsizei count
, GLenum format
, GLenum type
,
448 static const GLfloat one
[4] = { 1.0, 1.0, 1.0, 1.0 };
449 static const GLfloat zero
[4] = { 0.0, 0.0, 0.0, 0.0 };
450 GET_CURRENT_CONTEXT(ctx
);
451 struct gl_texture_unit
*texUnit
= _mesa_get_current_tex_unit(ctx
);
452 struct gl_texture_object
*texObj
= NULL
;
453 struct gl_color_table
*table
= NULL
;
454 const GLfloat
*scale
= one
, *bias
= zero
;
456 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
459 case GL_SHARED_TEXTURE_PALETTE_EXT
:
460 table
= &ctx
->Texture
.Palette
;
463 table
= &ctx
->ColorTable
[COLORTABLE_PRECONVOLUTION
];
464 scale
= ctx
->Pixel
.ColorTableScale
[COLORTABLE_PRECONVOLUTION
];
465 bias
= ctx
->Pixel
.ColorTableBias
[COLORTABLE_PRECONVOLUTION
];
467 case GL_TEXTURE_COLOR_TABLE_SGI
:
468 if (!ctx
->Extensions
.SGI_texture_color_table
) {
469 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorSubTable(target)");
472 table
= &(texUnit
->ColorTable
);
473 scale
= ctx
->Pixel
.TextureColorTableScale
;
474 bias
= ctx
->Pixel
.TextureColorTableBias
;
476 case GL_POST_CONVOLUTION_COLOR_TABLE
:
477 table
= &ctx
->ColorTable
[COLORTABLE_POSTCONVOLUTION
];
478 scale
= ctx
->Pixel
.ColorTableScale
[COLORTABLE_POSTCONVOLUTION
];
479 bias
= ctx
->Pixel
.ColorTableBias
[COLORTABLE_POSTCONVOLUTION
];
481 case GL_POST_COLOR_MATRIX_COLOR_TABLE
:
482 table
= &ctx
->ColorTable
[COLORTABLE_POSTCOLORMATRIX
];
483 scale
= ctx
->Pixel
.ColorTableScale
[COLORTABLE_POSTCOLORMATRIX
];
484 bias
= ctx
->Pixel
.ColorTableBias
[COLORTABLE_POSTCOLORMATRIX
];
487 /* try texture targets */
488 texObj
= _mesa_select_tex_object(ctx
, texUnit
, target
);
489 if (texObj
&& !_mesa_is_proxy_texture(target
)) {
490 table
= &texObj
->Palette
;
493 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorSubTable(target)");
500 if (!_mesa_is_legal_format_and_type(ctx
, format
, type
) ||
501 format
== GL_INTENSITY
) {
502 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glColorSubTable(format or type)");
507 _mesa_error(ctx
, GL_INVALID_VALUE
, "glColorSubTable(count)");
511 /* error should have been caught sooner */
512 assert(_mesa_components_in_format(table
->_BaseFormat
) > 0);
514 if (start
+ count
> (GLint
) table
->Size
) {
515 _mesa_error(ctx
, GL_INVALID_VALUE
, "glColorSubTable(count)");
519 if (!table
->TableF
|| !table
->TableUB
) {
520 /* a GL_OUT_OF_MEMORY error would have been recorded previously */
524 store_colortable_entries(ctx
, table
, start
, count
,
531 if (texObj
|| target
== GL_SHARED_TEXTURE_PALETTE_EXT
) {
532 /* per-texture object palette */
533 if (ctx
->Driver
.UpdateTexturePalette
) {
534 (*ctx
->Driver
.UpdateTexturePalette
)( ctx
, texObj
);
538 ctx
->NewState
|= _NEW_PIXEL
;
543 static void GLAPIENTRY
544 _mesa_CopyColorTable(GLenum target
, GLenum internalformat
,
545 GLint x
, GLint y
, GLsizei width
)
547 GET_CURRENT_CONTEXT(ctx
);
548 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
550 if (!ctx
->ReadBuffer
->_ColorReadBuffer
) {
551 return; /* no readbuffer - OK */
554 ctx
->Driver
.CopyColorTable( ctx
, target
, internalformat
, x
, y
, width
);
559 static void GLAPIENTRY
560 _mesa_CopyColorSubTable(GLenum target
, GLsizei start
,
561 GLint x
, GLint y
, GLsizei width
)
563 GET_CURRENT_CONTEXT(ctx
);
564 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
566 if (!ctx
->ReadBuffer
->_ColorReadBuffer
) {
567 return; /* no readbuffer - OK */
570 ctx
->Driver
.CopyColorSubTable( ctx
, target
, start
, x
, y
, width
);
575 static void GLAPIENTRY
576 _mesa_GetColorTable( GLenum target
, GLenum format
,
577 GLenum type
, GLvoid
*data
)
579 GET_CURRENT_CONTEXT(ctx
);
580 struct gl_texture_unit
*texUnit
= _mesa_get_current_tex_unit(ctx
);
581 struct gl_color_table
*table
= NULL
;
582 GLfloat rgba
[MAX_COLOR_TABLE_SIZE
][4];
583 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
586 _mesa_update_state(ctx
);
590 case GL_SHARED_TEXTURE_PALETTE_EXT
:
591 table
= &ctx
->Texture
.Palette
;
594 table
= &ctx
->ColorTable
[COLORTABLE_PRECONVOLUTION
];
596 case GL_TEXTURE_COLOR_TABLE_SGI
:
597 if (!ctx
->Extensions
.SGI_texture_color_table
) {
598 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTable(target)");
601 table
= &(texUnit
->ColorTable
);
603 case GL_POST_CONVOLUTION_COLOR_TABLE
:
604 table
= &ctx
->ColorTable
[COLORTABLE_POSTCONVOLUTION
];
606 case GL_POST_COLOR_MATRIX_COLOR_TABLE
:
607 table
= &ctx
->ColorTable
[COLORTABLE_POSTCOLORMATRIX
];
610 /* try texture targets */
612 struct gl_texture_object
*texobj
613 = _mesa_select_tex_object(ctx
, texUnit
, target
);
614 if (texobj
&& !_mesa_is_proxy_texture(target
)) {
615 table
= &texobj
->Palette
;
618 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTable(target)");
626 if (table
->Size
<= 0) {
630 switch (table
->_BaseFormat
) {
634 for (i
= 0; i
< table
->Size
; i
++) {
638 rgba
[i
][ACOMP
] = table
->TableF
[i
];
645 for (i
= 0; i
< table
->Size
; i
++) {
648 rgba
[i
][BCOMP
] = table
->TableF
[i
];
649 rgba
[i
][ACOMP
] = 1.0F
;
653 case GL_LUMINANCE_ALPHA
:
656 for (i
= 0; i
< table
->Size
; i
++) {
659 rgba
[i
][BCOMP
] = table
->TableF
[i
*2+0];
660 rgba
[i
][ACOMP
] = table
->TableF
[i
*2+1];
667 for (i
= 0; i
< table
->Size
; i
++) {
671 rgba
[i
][ACOMP
] = table
->TableF
[i
];
678 for (i
= 0; i
< table
->Size
; i
++) {
679 rgba
[i
][RCOMP
] = table
->TableF
[i
*3+0];
680 rgba
[i
][GCOMP
] = table
->TableF
[i
*3+1];
681 rgba
[i
][BCOMP
] = table
->TableF
[i
*3+2];
682 rgba
[i
][ACOMP
] = 1.0F
;
687 memcpy(rgba
, table
->TableF
, 4 * table
->Size
* sizeof(GLfloat
));
690 _mesa_problem(ctx
, "bad table format in glGetColorTable");
694 data
= _mesa_map_validate_pbo_dest(ctx
,
695 1, &ctx
->Pack
, table
->Size
, 1, 1,
701 _mesa_pack_rgba_span_float(ctx
, table
->Size
, rgba
,
702 format
, type
, data
, &ctx
->Pack
, 0x0);
704 _mesa_unmap_pbo_dest(ctx
, &ctx
->Pack
);
709 static void GLAPIENTRY
710 _mesa_ColorTableParameterfv(GLenum target
, GLenum pname
, const GLfloat
*params
)
712 GLfloat
*scale
, *bias
;
713 GET_CURRENT_CONTEXT(ctx
);
714 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
717 case GL_COLOR_TABLE_SGI
:
718 scale
= ctx
->Pixel
.ColorTableScale
[COLORTABLE_PRECONVOLUTION
];
719 bias
= ctx
->Pixel
.ColorTableBias
[COLORTABLE_PRECONVOLUTION
];
721 case GL_TEXTURE_COLOR_TABLE_SGI
:
722 scale
= ctx
->Pixel
.TextureColorTableScale
;
723 bias
= ctx
->Pixel
.TextureColorTableBias
;
725 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI
:
726 scale
= ctx
->Pixel
.ColorTableScale
[COLORTABLE_POSTCONVOLUTION
];
727 bias
= ctx
->Pixel
.ColorTableBias
[COLORTABLE_POSTCONVOLUTION
];
729 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI
:
730 scale
= ctx
->Pixel
.ColorTableScale
[COLORTABLE_POSTCOLORMATRIX
];
731 bias
= ctx
->Pixel
.ColorTableBias
[COLORTABLE_POSTCOLORMATRIX
];
734 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTableParameter(target)");
738 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
739 COPY_4V(scale
, params
);
741 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
742 COPY_4V(bias
, params
);
745 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTableParameterfv(pname)");
749 ctx
->NewState
|= _NEW_PIXEL
;
754 static void GLAPIENTRY
755 _mesa_ColorTableParameteriv(GLenum target
, GLenum pname
, const GLint
*params
)
758 if (pname
== GL_COLOR_TABLE_SGI
||
759 pname
== GL_TEXTURE_COLOR_TABLE_SGI
||
760 pname
== GL_POST_CONVOLUTION_COLOR_TABLE_SGI
||
761 pname
== GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI
) {
763 fparams
[0] = (GLfloat
) params
[0];
764 fparams
[1] = (GLfloat
) params
[1];
765 fparams
[2] = (GLfloat
) params
[2];
766 fparams
[3] = (GLfloat
) params
[3];
770 fparams
[0] = (GLfloat
) params
[0];
772 _mesa_ColorTableParameterfv(target
, pname
, fparams
);
777 static void GLAPIENTRY
778 _mesa_GetColorTableParameterfv( GLenum target
, GLenum pname
, GLfloat
*params
)
780 GET_CURRENT_CONTEXT(ctx
);
781 struct gl_texture_unit
*texUnit
= _mesa_get_current_tex_unit(ctx
);
782 struct gl_color_table
*table
= NULL
;
783 ASSERT_OUTSIDE_BEGIN_END(ctx
);
786 case GL_SHARED_TEXTURE_PALETTE_EXT
:
787 table
= &ctx
->Texture
.Palette
;
790 table
= &ctx
->ColorTable
[COLORTABLE_PRECONVOLUTION
];
791 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
792 COPY_4V(params
, ctx
->Pixel
.ColorTableScale
[COLORTABLE_PRECONVOLUTION
]);
795 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
796 COPY_4V(params
, ctx
->Pixel
.ColorTableBias
[COLORTABLE_PRECONVOLUTION
]);
800 case GL_PROXY_COLOR_TABLE
:
801 table
= &ctx
->ProxyColorTable
[COLORTABLE_PRECONVOLUTION
];
803 case GL_TEXTURE_COLOR_TABLE_SGI
:
804 if (!ctx
->Extensions
.SGI_texture_color_table
) {
805 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTableParameter(target)");
808 table
= &(texUnit
->ColorTable
);
809 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
810 COPY_4V(params
, ctx
->Pixel
.TextureColorTableScale
);
813 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
814 COPY_4V(params
, ctx
->Pixel
.TextureColorTableBias
);
818 case GL_PROXY_TEXTURE_COLOR_TABLE_SGI
:
819 if (!ctx
->Extensions
.SGI_texture_color_table
) {
820 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTableParameter(target)");
823 table
= &(texUnit
->ProxyColorTable
);
825 case GL_POST_CONVOLUTION_COLOR_TABLE
:
826 table
= &ctx
->ColorTable
[COLORTABLE_POSTCONVOLUTION
];
827 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
828 COPY_4V(params
, ctx
->Pixel
.ColorTableScale
[COLORTABLE_POSTCONVOLUTION
]);
831 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
832 COPY_4V(params
, ctx
->Pixel
.ColorTableBias
[COLORTABLE_POSTCONVOLUTION
]);
836 case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE
:
837 table
= &ctx
->ProxyColorTable
[COLORTABLE_POSTCONVOLUTION
];
839 case GL_POST_COLOR_MATRIX_COLOR_TABLE
:
840 table
= &ctx
->ColorTable
[COLORTABLE_POSTCOLORMATRIX
];
841 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
842 COPY_4V(params
, ctx
->Pixel
.ColorTableScale
[COLORTABLE_POSTCOLORMATRIX
]);
845 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
846 COPY_4V(params
, ctx
->Pixel
.ColorTableBias
[COLORTABLE_POSTCOLORMATRIX
]);
850 case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE
:
851 table
= &ctx
->ProxyColorTable
[COLORTABLE_POSTCOLORMATRIX
];
854 /* try texture targets */
856 struct gl_texture_object
*texobj
857 = _mesa_select_tex_object(ctx
, texUnit
, target
);
859 table
= &texobj
->Palette
;
862 _mesa_error(ctx
, GL_INVALID_ENUM
,
863 "glGetColorTableParameterfv(target)");
872 case GL_COLOR_TABLE_FORMAT
:
873 *params
= (GLfloat
) table
->InternalFormat
;
875 case GL_COLOR_TABLE_WIDTH
:
876 *params
= (GLfloat
) table
->Size
;
878 case GL_COLOR_TABLE_RED_SIZE
:
879 *params
= (GLfloat
) table
->RedSize
;
881 case GL_COLOR_TABLE_GREEN_SIZE
:
882 *params
= (GLfloat
) table
->GreenSize
;
884 case GL_COLOR_TABLE_BLUE_SIZE
:
885 *params
= (GLfloat
) table
->BlueSize
;
887 case GL_COLOR_TABLE_ALPHA_SIZE
:
888 *params
= (GLfloat
) table
->AlphaSize
;
890 case GL_COLOR_TABLE_LUMINANCE_SIZE
:
891 *params
= (GLfloat
) table
->LuminanceSize
;
893 case GL_COLOR_TABLE_INTENSITY_SIZE
:
894 *params
= (GLfloat
) table
->IntensitySize
;
897 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTableParameterfv(pname)" );
904 static void GLAPIENTRY
905 _mesa_GetColorTableParameteriv( GLenum target
, GLenum pname
, GLint
*params
)
907 GET_CURRENT_CONTEXT(ctx
);
908 struct gl_texture_unit
*texUnit
= _mesa_get_current_tex_unit(ctx
);
909 struct gl_color_table
*table
= NULL
;
910 ASSERT_OUTSIDE_BEGIN_END(ctx
);
913 case GL_SHARED_TEXTURE_PALETTE_EXT
:
914 table
= &ctx
->Texture
.Palette
;
917 table
= &ctx
->ColorTable
[COLORTABLE_PRECONVOLUTION
];
918 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
919 GLfloat
*scale
= ctx
->Pixel
.ColorTableScale
[COLORTABLE_PRECONVOLUTION
];
920 params
[0] = (GLint
) scale
[0];
921 params
[1] = (GLint
) scale
[1];
922 params
[2] = (GLint
) scale
[2];
923 params
[3] = (GLint
) scale
[3];
926 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
927 GLfloat
*bias
= ctx
->Pixel
.ColorTableBias
[COLORTABLE_PRECONVOLUTION
];
928 params
[0] = (GLint
) bias
[0];
929 params
[1] = (GLint
) bias
[1];
930 params
[2] = (GLint
) bias
[2];
931 params
[3] = (GLint
) bias
[3];
935 case GL_PROXY_COLOR_TABLE
:
936 table
= &ctx
->ProxyColorTable
[COLORTABLE_PRECONVOLUTION
];
938 case GL_TEXTURE_COLOR_TABLE_SGI
:
939 if (!ctx
->Extensions
.SGI_texture_color_table
) {
940 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTableParameter(target)");
943 table
= &(texUnit
->ColorTable
);
944 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
945 params
[0] = (GLint
) ctx
->Pixel
.TextureColorTableScale
[0];
946 params
[1] = (GLint
) ctx
->Pixel
.TextureColorTableScale
[1];
947 params
[2] = (GLint
) ctx
->Pixel
.TextureColorTableScale
[2];
948 params
[3] = (GLint
) ctx
->Pixel
.TextureColorTableScale
[3];
951 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
952 params
[0] = (GLint
) ctx
->Pixel
.TextureColorTableBias
[0];
953 params
[1] = (GLint
) ctx
->Pixel
.TextureColorTableBias
[1];
954 params
[2] = (GLint
) ctx
->Pixel
.TextureColorTableBias
[2];
955 params
[3] = (GLint
) ctx
->Pixel
.TextureColorTableBias
[3];
959 case GL_PROXY_TEXTURE_COLOR_TABLE_SGI
:
960 if (!ctx
->Extensions
.SGI_texture_color_table
) {
961 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTableParameter(target)");
964 table
= &(texUnit
->ProxyColorTable
);
966 case GL_POST_CONVOLUTION_COLOR_TABLE
:
967 table
= &ctx
->ColorTable
[COLORTABLE_POSTCONVOLUTION
];
968 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
969 GLfloat
*scale
= ctx
->Pixel
.ColorTableScale
[COLORTABLE_POSTCONVOLUTION
];
970 params
[0] = (GLint
) scale
[0];
971 params
[1] = (GLint
) scale
[1];
972 params
[2] = (GLint
) scale
[2];
973 params
[3] = (GLint
) scale
[3];
976 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
977 GLfloat
*bias
= ctx
->Pixel
.ColorTableBias
[COLORTABLE_POSTCONVOLUTION
];
978 params
[0] = (GLint
) bias
[0];
979 params
[1] = (GLint
) bias
[1];
980 params
[2] = (GLint
) bias
[2];
981 params
[3] = (GLint
) bias
[3];
985 case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE
:
986 table
= &ctx
->ProxyColorTable
[COLORTABLE_POSTCONVOLUTION
];
988 case GL_POST_COLOR_MATRIX_COLOR_TABLE
:
989 table
= &ctx
->ColorTable
[COLORTABLE_POSTCOLORMATRIX
];
990 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
991 GLfloat
*scale
= ctx
->Pixel
.ColorTableScale
[COLORTABLE_POSTCOLORMATRIX
];
992 params
[0] = (GLint
) scale
[0];
993 params
[0] = (GLint
) scale
[1];
994 params
[0] = (GLint
) scale
[2];
995 params
[0] = (GLint
) scale
[3];
998 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
999 GLfloat
*bias
= ctx
->Pixel
.ColorTableScale
[COLORTABLE_POSTCOLORMATRIX
];
1000 params
[0] = (GLint
) bias
[0];
1001 params
[1] = (GLint
) bias
[1];
1002 params
[2] = (GLint
) bias
[2];
1003 params
[3] = (GLint
) bias
[3];
1007 case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE
:
1008 table
= &ctx
->ProxyColorTable
[COLORTABLE_POSTCOLORMATRIX
];
1011 /* Try texture targets */
1013 struct gl_texture_object
*texobj
1014 = _mesa_select_tex_object(ctx
, texUnit
, target
);
1016 table
= &texobj
->Palette
;
1019 _mesa_error(ctx
, GL_INVALID_ENUM
,
1020 "glGetColorTableParameteriv(target)");
1029 case GL_COLOR_TABLE_FORMAT
:
1030 *params
= table
->InternalFormat
;
1032 case GL_COLOR_TABLE_WIDTH
:
1033 *params
= table
->Size
;
1035 case GL_COLOR_TABLE_RED_SIZE
:
1036 *params
= table
->RedSize
;
1038 case GL_COLOR_TABLE_GREEN_SIZE
:
1039 *params
= table
->GreenSize
;
1041 case GL_COLOR_TABLE_BLUE_SIZE
:
1042 *params
= table
->BlueSize
;
1044 case GL_COLOR_TABLE_ALPHA_SIZE
:
1045 *params
= table
->AlphaSize
;
1047 case GL_COLOR_TABLE_LUMINANCE_SIZE
:
1048 *params
= table
->LuminanceSize
;
1050 case GL_COLOR_TABLE_INTENSITY_SIZE
:
1051 *params
= table
->IntensitySize
;
1054 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTableParameteriv(pname)" );
1061 _mesa_init_colortable_dispatch(struct _glapi_table
*disp
)
1063 SET_ColorSubTable(disp
, _mesa_ColorSubTable
);
1064 SET_ColorTable(disp
, _mesa_ColorTable
);
1065 SET_ColorTableParameterfv(disp
, _mesa_ColorTableParameterfv
);
1066 SET_ColorTableParameteriv(disp
, _mesa_ColorTableParameteriv
);
1067 SET_CopyColorSubTable(disp
, _mesa_CopyColorSubTable
);
1068 SET_CopyColorTable(disp
, _mesa_CopyColorTable
);
1069 SET_GetColorTable(disp
, _mesa_GetColorTable
);
1070 SET_GetColorTableParameterfv(disp
, _mesa_GetColorTableParameterfv
);
1071 SET_GetColorTableParameteriv(disp
, _mesa_GetColorTableParameteriv
);
1075 #endif /* FEATURE_colortable */
1078 /**********************************************************************/
1079 /***** Initialization *****/
1080 /**********************************************************************/
1084 _mesa_init_colortable( struct gl_color_table
*p
)
1089 p
->InternalFormat
= GL_RGBA
;
1095 _mesa_free_colortable_data( struct gl_color_table
*p
)
1109 * Initialize all colortables for a context.
1112 _mesa_init_colortables( GLcontext
* ctx
)
1115 for (i
= 0; i
< COLORTABLE_MAX
; i
++) {
1116 _mesa_init_colortable(&ctx
->ColorTable
[i
]);
1117 _mesa_init_colortable(&ctx
->ProxyColorTable
[i
]);
1123 * Free all colortable data for a context
1126 _mesa_free_colortables_data( GLcontext
*ctx
)
1129 for (i
= 0; i
< COLORTABLE_MAX
; i
++) {
1130 _mesa_free_colortable_data(&ctx
->ColorTable
[i
]);
1131 _mesa_free_colortable_data(&ctx
->ProxyColorTable
[i
]);