2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2004 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"
36 * Given an internalFormat token passed to glColorTable,
37 * return the corresponding base format.
38 * Return -1 if invalid token.
41 base_colortab_format( GLenum format
)
56 case GL_LUMINANCE_ALPHA
:
57 case GL_LUMINANCE4_ALPHA4
:
58 case GL_LUMINANCE6_ALPHA2
:
59 case GL_LUMINANCE8_ALPHA8
:
60 case GL_LUMINANCE12_ALPHA4
:
61 case GL_LUMINANCE12_ALPHA12
:
62 case GL_LUMINANCE16_ALPHA16
:
63 return GL_LUMINANCE_ALPHA
;
89 return -1; /* error */
96 * Examine table's format and set the component sizes accordingly.
99 set_component_sizes( struct gl_color_table
*table
)
103 switch (table
->Type
) {
104 case GL_UNSIGNED_BYTE
:
105 sz
= sizeof(GLubyte
);
107 case GL_UNSIGNED_SHORT
:
108 sz
= sizeof(GLushort
);
111 sz
= sizeof(GLfloat
);
114 _mesa_problem(NULL
, "bad color table type in set_component_sizes 0x%x", table
->Type
);
118 switch (table
->Format
) {
121 table
->GreenSize
= 0;
123 table
->AlphaSize
= sz
;
124 table
->IntensitySize
= 0;
125 table
->LuminanceSize
= 0;
129 table
->GreenSize
= 0;
131 table
->AlphaSize
= 0;
132 table
->IntensitySize
= 0;
133 table
->LuminanceSize
= sz
;
135 case GL_LUMINANCE_ALPHA
:
137 table
->GreenSize
= 0;
139 table
->AlphaSize
= sz
;
140 table
->IntensitySize
= 0;
141 table
->LuminanceSize
= sz
;
145 table
->GreenSize
= 0;
147 table
->AlphaSize
= 0;
148 table
->IntensitySize
= sz
;
149 table
->LuminanceSize
= 0;
153 table
->GreenSize
= sz
;
154 table
->BlueSize
= sz
;
155 table
->AlphaSize
= 0;
156 table
->IntensitySize
= 0;
157 table
->LuminanceSize
= 0;
161 table
->GreenSize
= sz
;
162 table
->BlueSize
= sz
;
163 table
->AlphaSize
= sz
;
164 table
->IntensitySize
= 0;
165 table
->LuminanceSize
= 0;
168 _mesa_problem(NULL
, "unexpected format in set_component_sizes");
175 * Update/replace all or part of a color table. Helper function
176 * used by _mesa_ColorTable() and _mesa_ColorSubTable().
177 * The table->Table buffer should already be allocated.
178 * \param start first entry to update
179 * \param count number of entries to update
180 * \param format format of user-provided table data
181 * \param type datatype of user-provided table data
182 * \param data user-provided table data
183 * \param [rgba]Scale - RGBA scale factors
184 * \param [rgba]Bias - RGBA bias factors
187 store_colortable_entries(GLcontext
*ctx
, struct gl_color_table
*table
,
188 GLsizei start
, GLsizei count
,
189 GLenum format
, GLenum type
, const GLvoid
*data
,
190 GLfloat rScale
, GLfloat rBias
,
191 GLfloat gScale
, GLfloat gBias
,
192 GLfloat bScale
, GLfloat bBias
,
193 GLfloat aScale
, GLfloat aBias
)
195 if (ctx
->Unpack
.BufferObj
->Name
) {
196 /* Get/unpack the color table data from a PBO */
198 if (!_mesa_validate_pbo_access(1, &ctx
->Unpack
, count
, 1, 1,
199 format
, type
, data
)) {
200 _mesa_error(ctx
, GL_INVALID_OPERATION
,
201 "glColor[Sub]Table(bad PBO access)");
204 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
206 ctx
->Unpack
.BufferObj
);
208 _mesa_error(ctx
, GL_INVALID_OPERATION
,
209 "glColor[Sub]Table(PBO mapped)");
212 data
= ADD_POINTERS(buf
, data
);
216 if (table
->Type
== GL_FLOAT
) {
217 /* convert user-provided data to GLfloat values */
218 GLfloat tempTab
[MAX_COLOR_TABLE_SIZE
* 4];
222 _mesa_unpack_color_span_float(ctx
,
223 count
, /* number of pixels */
224 table
->Format
, /* dest format */
225 tempTab
, /* dest address */
226 format
, type
, /* src format/type */
229 IMAGE_CLAMP_BIT
); /* transfer ops */
231 /* the destination */
232 tableF
= (GLfloat
*) table
->Table
;
234 /* Apply scale & bias & clamp now */
235 switch (table
->Format
) {
237 for (i
= 0; i
< count
; i
++) {
238 GLuint j
= start
+ i
;
239 tableF
[j
] = CLAMP(tempTab
[i
] * rScale
+ rBias
, 0.0F
, 1.0F
);
243 for (i
= 0; i
< count
; i
++) {
244 GLuint j
= start
+ i
;
245 tableF
[j
] = CLAMP(tempTab
[i
] * rScale
+ rBias
, 0.0F
, 1.0F
);
249 for (i
= 0; i
< count
; i
++) {
250 GLuint j
= start
+ i
;
251 tableF
[j
] = CLAMP(tempTab
[i
] * aScale
+ aBias
, 0.0F
, 1.0F
);
254 case GL_LUMINANCE_ALPHA
:
255 for (i
= 0; i
< count
; i
++) {
256 GLuint j
= start
+ i
;
257 tableF
[j
*2+0] = CLAMP(tempTab
[i
*2+0] * rScale
+ rBias
, 0.0F
, 1.0F
);
258 tableF
[j
*2+1] = CLAMP(tempTab
[i
*2+1] * aScale
+ aBias
, 0.0F
, 1.0F
);
262 for (i
= 0; i
< count
; i
++) {
263 GLuint j
= start
+ i
;
264 tableF
[j
*3+0] = CLAMP(tempTab
[i
*3+0] * rScale
+ rBias
, 0.0F
, 1.0F
);
265 tableF
[j
*3+1] = CLAMP(tempTab
[i
*3+1] * gScale
+ gBias
, 0.0F
, 1.0F
);
266 tableF
[j
*3+2] = CLAMP(tempTab
[i
*3+2] * bScale
+ bBias
, 0.0F
, 1.0F
);
270 for (i
= 0; i
< count
; i
++) {
271 GLuint j
= start
+ i
;
272 tableF
[j
*4+0] = CLAMP(tempTab
[i
*4+0] * rScale
+ rBias
, 0.0F
, 1.0F
);
273 tableF
[j
*4+1] = CLAMP(tempTab
[i
*4+1] * gScale
+ gBias
, 0.0F
, 1.0F
);
274 tableF
[j
*4+2] = CLAMP(tempTab
[i
*4+2] * bScale
+ bBias
, 0.0F
, 1.0F
);
275 tableF
[j
*4+3] = CLAMP(tempTab
[i
*4+3] * aScale
+ aBias
, 0.0F
, 1.0F
);
279 _mesa_problem(ctx
, "Bad format in store_colortable_entries");
284 /* non-float (GLchan) */
285 const GLint comps
= _mesa_components_in_format(table
->Format
);
286 GLchan
*dest
= (GLchan
*) table
->Table
+ start
* comps
;
287 _mesa_unpack_color_span_chan(ctx
, count
, /* number of entries */
288 table
->Format
, /* dest format */
289 dest
, /* dest address */
290 format
, type
, data
, /* src data */
292 0); /* transfer ops */
295 if (ctx
->Unpack
.BufferObj
->Name
) {
296 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_UNPACK_BUFFER_EXT
,
297 ctx
->Unpack
.BufferObj
);
304 _mesa_ColorTable( GLenum target
, GLenum internalFormat
,
305 GLsizei width
, GLenum format
, GLenum type
,
308 GET_CURRENT_CONTEXT(ctx
);
309 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[ctx
->Texture
.CurrentUnit
];
310 struct gl_texture_object
*texObj
= NULL
;
311 struct gl_color_table
*table
= NULL
;
312 GLboolean proxy
= GL_FALSE
;
314 GLfloat rScale
= 1.0, gScale
= 1.0, bScale
= 1.0, aScale
= 1.0;
315 GLfloat rBias
= 0.0, gBias
= 0.0, bBias
= 0.0, aBias
= 0.0;
316 GLenum tableType
= CHAN_TYPE
;
318 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
); /* too complex */
322 texObj
= texUnit
->Current1D
;
323 table
= &texObj
->Palette
;
326 texObj
= texUnit
->Current2D
;
327 table
= &texObj
->Palette
;
330 texObj
= texUnit
->Current3D
;
331 table
= &texObj
->Palette
;
333 case GL_TEXTURE_CUBE_MAP_ARB
:
334 if (!ctx
->Extensions
.ARB_texture_cube_map
) {
335 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTable(target)");
338 texObj
= texUnit
->CurrentCubeMap
;
339 table
= &texObj
->Palette
;
341 case GL_PROXY_TEXTURE_1D
:
342 texObj
= ctx
->Texture
.Proxy1D
;
343 table
= &texObj
->Palette
;
346 case GL_PROXY_TEXTURE_2D
:
347 texObj
= ctx
->Texture
.Proxy2D
;
348 table
= &texObj
->Palette
;
351 case GL_PROXY_TEXTURE_3D
:
352 texObj
= ctx
->Texture
.Proxy3D
;
353 table
= &texObj
->Palette
;
356 case GL_PROXY_TEXTURE_CUBE_MAP_ARB
:
357 if (!ctx
->Extensions
.ARB_texture_cube_map
) {
358 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTable(target)");
361 texObj
= ctx
->Texture
.ProxyCubeMap
;
362 table
= &texObj
->Palette
;
364 case GL_SHARED_TEXTURE_PALETTE_EXT
:
365 table
= &ctx
->Texture
.Palette
;
368 table
= &ctx
->ColorTable
;
369 tableType
= GL_FLOAT
;
370 rScale
= ctx
->Pixel
.ColorTableScale
[0];
371 gScale
= ctx
->Pixel
.ColorTableScale
[1];
372 bScale
= ctx
->Pixel
.ColorTableScale
[2];
373 aScale
= ctx
->Pixel
.ColorTableScale
[3];
374 rBias
= ctx
->Pixel
.ColorTableBias
[0];
375 gBias
= ctx
->Pixel
.ColorTableBias
[1];
376 bBias
= ctx
->Pixel
.ColorTableBias
[2];
377 aBias
= ctx
->Pixel
.ColorTableBias
[3];
379 case GL_PROXY_COLOR_TABLE
:
380 table
= &ctx
->ProxyColorTable
;
383 case GL_TEXTURE_COLOR_TABLE_SGI
:
384 if (!ctx
->Extensions
.SGI_texture_color_table
) {
385 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTable(target)");
388 table
= &(texUnit
->ColorTable
);
389 tableType
= GL_FLOAT
;
390 rScale
= ctx
->Pixel
.TextureColorTableScale
[0];
391 gScale
= ctx
->Pixel
.TextureColorTableScale
[1];
392 bScale
= ctx
->Pixel
.TextureColorTableScale
[2];
393 aScale
= ctx
->Pixel
.TextureColorTableScale
[3];
394 rBias
= ctx
->Pixel
.TextureColorTableBias
[0];
395 gBias
= ctx
->Pixel
.TextureColorTableBias
[1];
396 bBias
= ctx
->Pixel
.TextureColorTableBias
[2];
397 aBias
= ctx
->Pixel
.TextureColorTableBias
[3];
399 case GL_PROXY_TEXTURE_COLOR_TABLE_SGI
:
400 if (!ctx
->Extensions
.SGI_texture_color_table
) {
401 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTable(target)");
404 table
= &(texUnit
->ProxyColorTable
);
407 case GL_POST_CONVOLUTION_COLOR_TABLE
:
408 table
= &ctx
->PostConvolutionColorTable
;
409 tableType
= GL_FLOAT
;
410 rScale
= ctx
->Pixel
.PCCTscale
[0];
411 gScale
= ctx
->Pixel
.PCCTscale
[1];
412 bScale
= ctx
->Pixel
.PCCTscale
[2];
413 aScale
= ctx
->Pixel
.PCCTscale
[3];
414 rBias
= ctx
->Pixel
.PCCTbias
[0];
415 gBias
= ctx
->Pixel
.PCCTbias
[1];
416 bBias
= ctx
->Pixel
.PCCTbias
[2];
417 aBias
= ctx
->Pixel
.PCCTbias
[3];
419 case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE
:
420 table
= &ctx
->ProxyPostConvolutionColorTable
;
423 case GL_POST_COLOR_MATRIX_COLOR_TABLE
:
424 table
= &ctx
->PostColorMatrixColorTable
;
425 tableType
= GL_FLOAT
;
426 rScale
= ctx
->Pixel
.PCMCTscale
[0];
427 gScale
= ctx
->Pixel
.PCMCTscale
[1];
428 bScale
= ctx
->Pixel
.PCMCTscale
[2];
429 aScale
= ctx
->Pixel
.PCMCTscale
[3];
430 rBias
= ctx
->Pixel
.PCMCTbias
[0];
431 gBias
= ctx
->Pixel
.PCMCTbias
[1];
432 bBias
= ctx
->Pixel
.PCMCTbias
[2];
433 aBias
= ctx
->Pixel
.PCMCTbias
[3];
435 case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE
:
436 table
= &ctx
->ProxyPostColorMatrixColorTable
;
440 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTable(target)");
446 if (!_mesa_is_legal_format_and_type(ctx
, format
, type
) ||
447 format
== GL_INTENSITY
) {
448 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glColorTable(format or type)");
452 baseFormat
= base_colortab_format(internalFormat
);
453 if (baseFormat
< 0 || baseFormat
== GL_COLOR_INDEX
) {
454 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTable(internalFormat)");
458 if (width
< 0 || (width
!= 0 && _mesa_bitcount(width
) != 1)) {
462 table
->IntFormat
= (GLenum
) 0;
463 table
->Format
= (GLenum
) 0;
466 _mesa_error(ctx
, GL_INVALID_VALUE
, "glColorTable(width=%d)", width
);
471 if (width
> (GLsizei
) ctx
->Const
.MaxColorTableSize
) {
474 table
->IntFormat
= (GLenum
) 0;
475 table
->Format
= (GLenum
) 0;
478 _mesa_error(ctx
, GL_TABLE_TOO_LARGE
, "glColorTable(width)");
484 table
->IntFormat
= internalFormat
;
485 table
->Format
= (GLenum
) baseFormat
;
487 comps
= _mesa_components_in_format(table
->Format
);
488 assert(comps
> 0); /* error should have been caught sooner */
491 /* free old table, if any */
498 if (tableType
== GL_FLOAT
) {
499 table
->Type
= GL_FLOAT
;
500 table
->Table
= MALLOC(comps
* width
* sizeof(GLfloat
));
503 table
->Type
= CHAN_TYPE
;
504 table
->Table
= MALLOC(comps
* width
* sizeof(GLchan
));
508 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glColorTable");
512 store_colortable_entries(ctx
, table
,
513 0, width
, /* start, count */
522 /* do this after the table's Type and Format are set */
523 set_component_sizes(table
);
525 if (texObj
|| target
== GL_SHARED_TEXTURE_PALETTE_EXT
) {
526 /* texture object palette, texObj==NULL means the shared palette */
527 if (ctx
->Driver
.UpdateTexturePalette
) {
528 (*ctx
->Driver
.UpdateTexturePalette
)( ctx
, texObj
);
532 ctx
->NewState
|= _NEW_PIXEL
;
538 _mesa_ColorSubTable( GLenum target
, GLsizei start
,
539 GLsizei count
, GLenum format
, GLenum type
,
542 GET_CURRENT_CONTEXT(ctx
);
543 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[ctx
->Texture
.CurrentUnit
];
544 struct gl_texture_object
*texObj
= NULL
;
545 struct gl_color_table
*table
= NULL
;
546 GLfloat rScale
= 1.0, gScale
= 1.0, bScale
= 1.0, aScale
= 1.0;
547 GLfloat rBias
= 0.0, gBias
= 0.0, bBias
= 0.0, aBias
= 0.0;
548 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
552 texObj
= texUnit
->Current1D
;
553 table
= &texObj
->Palette
;
556 texObj
= texUnit
->Current2D
;
557 table
= &texObj
->Palette
;
560 texObj
= texUnit
->Current3D
;
561 table
= &texObj
->Palette
;
563 case GL_TEXTURE_CUBE_MAP_ARB
:
564 if (!ctx
->Extensions
.ARB_texture_cube_map
) {
565 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorSubTable(target)");
568 texObj
= texUnit
->CurrentCubeMap
;
569 table
= &texObj
->Palette
;
571 case GL_SHARED_TEXTURE_PALETTE_EXT
:
572 table
= &ctx
->Texture
.Palette
;
575 table
= &ctx
->ColorTable
;
576 rScale
= ctx
->Pixel
.ColorTableScale
[0];
577 gScale
= ctx
->Pixel
.ColorTableScale
[1];
578 bScale
= ctx
->Pixel
.ColorTableScale
[2];
579 aScale
= ctx
->Pixel
.ColorTableScale
[3];
580 rBias
= ctx
->Pixel
.ColorTableBias
[0];
581 gBias
= ctx
->Pixel
.ColorTableBias
[1];
582 bBias
= ctx
->Pixel
.ColorTableBias
[2];
583 aBias
= ctx
->Pixel
.ColorTableBias
[3];
585 case GL_TEXTURE_COLOR_TABLE_SGI
:
586 if (!ctx
->Extensions
.SGI_texture_color_table
) {
587 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorSubTable(target)");
590 table
= &(texUnit
->ColorTable
);
591 rScale
= ctx
->Pixel
.TextureColorTableScale
[0];
592 gScale
= ctx
->Pixel
.TextureColorTableScale
[1];
593 bScale
= ctx
->Pixel
.TextureColorTableScale
[2];
594 aScale
= ctx
->Pixel
.TextureColorTableScale
[3];
595 rBias
= ctx
->Pixel
.TextureColorTableBias
[0];
596 gBias
= ctx
->Pixel
.TextureColorTableBias
[1];
597 bBias
= ctx
->Pixel
.TextureColorTableBias
[2];
598 aBias
= ctx
->Pixel
.TextureColorTableBias
[3];
600 case GL_POST_CONVOLUTION_COLOR_TABLE
:
601 table
= &ctx
->PostConvolutionColorTable
;
602 rScale
= ctx
->Pixel
.PCCTscale
[0];
603 gScale
= ctx
->Pixel
.PCCTscale
[1];
604 bScale
= ctx
->Pixel
.PCCTscale
[2];
605 aScale
= ctx
->Pixel
.PCCTscale
[3];
606 rBias
= ctx
->Pixel
.PCCTbias
[0];
607 gBias
= ctx
->Pixel
.PCCTbias
[1];
608 bBias
= ctx
->Pixel
.PCCTbias
[2];
609 aBias
= ctx
->Pixel
.PCCTbias
[3];
611 case GL_POST_COLOR_MATRIX_COLOR_TABLE
:
612 table
= &ctx
->PostColorMatrixColorTable
;
613 rScale
= ctx
->Pixel
.PCMCTscale
[0];
614 gScale
= ctx
->Pixel
.PCMCTscale
[1];
615 bScale
= ctx
->Pixel
.PCMCTscale
[2];
616 aScale
= ctx
->Pixel
.PCMCTscale
[3];
617 rBias
= ctx
->Pixel
.PCMCTbias
[0];
618 gBias
= ctx
->Pixel
.PCMCTbias
[1];
619 bBias
= ctx
->Pixel
.PCMCTbias
[2];
620 aBias
= ctx
->Pixel
.PCMCTbias
[3];
623 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorSubTable(target)");
629 if (!_mesa_is_legal_format_and_type(ctx
, format
, type
) ||
630 format
== GL_INTENSITY
) {
631 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glColorSubTable(format or type)");
636 _mesa_error(ctx
, GL_INVALID_VALUE
, "glColorSubTable(count)");
640 /* error should have been caught sooner */
641 assert(_mesa_components_in_format(table
->Format
) > 0);
643 if (start
+ count
> (GLint
) table
->Size
) {
644 _mesa_error(ctx
, GL_INVALID_VALUE
, "glColorSubTable(count)");
649 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glColorSubTable");
653 store_colortable_entries(ctx
, table
, start
, count
,
660 if (texObj
|| target
== GL_SHARED_TEXTURE_PALETTE_EXT
) {
661 /* per-texture object palette */
662 if (ctx
->Driver
.UpdateTexturePalette
) {
663 (*ctx
->Driver
.UpdateTexturePalette
)( ctx
, texObj
);
667 ctx
->NewState
|= _NEW_PIXEL
;
673 _mesa_CopyColorTable(GLenum target
, GLenum internalformat
,
674 GLint x
, GLint y
, GLsizei width
)
676 GET_CURRENT_CONTEXT(ctx
);
677 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
679 /* Select buffer to read from */
680 ctx
->Driver
.CopyColorTable( ctx
, target
, internalformat
, x
, y
, width
);
686 _mesa_CopyColorSubTable(GLenum target
, GLsizei start
,
687 GLint x
, GLint y
, GLsizei width
)
689 GET_CURRENT_CONTEXT(ctx
);
690 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
692 ctx
->Driver
.CopyColorSubTable( ctx
, target
, start
, x
, y
, width
);
698 _mesa_GetColorTable( GLenum target
, GLenum format
,
699 GLenum type
, GLvoid
*data
)
701 GET_CURRENT_CONTEXT(ctx
);
702 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[ctx
->Texture
.CurrentUnit
];
703 struct gl_color_table
*table
= NULL
;
704 GLchan rgba
[MAX_COLOR_TABLE_SIZE
][4];
705 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
708 _mesa_update_state(ctx
);
713 table
= &texUnit
->Current1D
->Palette
;
716 table
= &texUnit
->Current2D
->Palette
;
719 table
= &texUnit
->Current3D
->Palette
;
721 case GL_TEXTURE_CUBE_MAP_ARB
:
722 if (!ctx
->Extensions
.ARB_texture_cube_map
) {
723 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTable(target)");
726 table
= &texUnit
->CurrentCubeMap
->Palette
;
728 case GL_SHARED_TEXTURE_PALETTE_EXT
:
729 table
= &ctx
->Texture
.Palette
;
732 table
= &ctx
->ColorTable
;
734 case GL_TEXTURE_COLOR_TABLE_SGI
:
735 if (!ctx
->Extensions
.SGI_texture_color_table
) {
736 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTable(target)");
739 table
= &(texUnit
->ColorTable
);
741 case GL_POST_CONVOLUTION_COLOR_TABLE
:
742 table
= &ctx
->PostConvolutionColorTable
;
744 case GL_POST_COLOR_MATRIX_COLOR_TABLE
:
745 table
= &ctx
->PostColorMatrixColorTable
;
748 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTable(target)");
754 switch (table
->Format
) {
756 if (table
->Type
== GL_FLOAT
) {
757 const GLfloat
*tableF
= (const GLfloat
*) table
->Table
;
759 for (i
= 0; i
< table
->Size
; i
++) {
763 rgba
[i
][ACOMP
] = IROUND_POS(tableF
[i
] * CHAN_MAXF
);
767 const GLchan
*tableUB
= (const GLchan
*) table
->Table
;
769 for (i
= 0; i
< table
->Size
; i
++) {
773 rgba
[i
][ACOMP
] = tableUB
[i
];
778 if (table
->Type
== GL_FLOAT
) {
779 const GLfloat
*tableF
= (const GLfloat
*) table
->Table
;
781 for (i
= 0; i
< table
->Size
; i
++) {
782 rgba
[i
][RCOMP
] = IROUND_POS(tableF
[i
] * CHAN_MAXF
);
783 rgba
[i
][GCOMP
] = IROUND_POS(tableF
[i
] * CHAN_MAXF
);
784 rgba
[i
][BCOMP
] = IROUND_POS(tableF
[i
] * CHAN_MAXF
);
785 rgba
[i
][ACOMP
] = CHAN_MAX
;
789 const GLchan
*tableUB
= (const GLchan
*) table
->Table
;
791 for (i
= 0; i
< table
->Size
; i
++) {
792 rgba
[i
][RCOMP
] = tableUB
[i
];
793 rgba
[i
][GCOMP
] = tableUB
[i
];
794 rgba
[i
][BCOMP
] = tableUB
[i
];
795 rgba
[i
][ACOMP
] = CHAN_MAX
;
799 case GL_LUMINANCE_ALPHA
:
800 if (table
->Type
== GL_FLOAT
) {
801 const GLfloat
*tableF
= (const GLfloat
*) table
->Table
;
803 for (i
= 0; i
< table
->Size
; i
++) {
804 rgba
[i
][RCOMP
] = IROUND_POS(tableF
[i
*2+0] * CHAN_MAXF
);
805 rgba
[i
][GCOMP
] = IROUND_POS(tableF
[i
*2+0] * CHAN_MAXF
);
806 rgba
[i
][BCOMP
] = IROUND_POS(tableF
[i
*2+0] * CHAN_MAXF
);
807 rgba
[i
][ACOMP
] = IROUND_POS(tableF
[i
*2+1] * CHAN_MAXF
);
811 const GLchan
*tableUB
= (const GLchan
*) table
->Table
;
813 for (i
= 0; i
< table
->Size
; i
++) {
814 rgba
[i
][RCOMP
] = tableUB
[i
*2+0];
815 rgba
[i
][GCOMP
] = tableUB
[i
*2+0];
816 rgba
[i
][BCOMP
] = tableUB
[i
*2+0];
817 rgba
[i
][ACOMP
] = tableUB
[i
*2+1];
822 if (table
->Type
== GL_FLOAT
) {
823 const GLfloat
*tableF
= (const GLfloat
*) table
->Table
;
825 for (i
= 0; i
< table
->Size
; i
++) {
826 rgba
[i
][RCOMP
] = IROUND_POS(tableF
[i
] * CHAN_MAXF
);
827 rgba
[i
][GCOMP
] = IROUND_POS(tableF
[i
] * CHAN_MAXF
);
828 rgba
[i
][BCOMP
] = IROUND_POS(tableF
[i
] * CHAN_MAXF
);
829 rgba
[i
][ACOMP
] = IROUND_POS(tableF
[i
] * CHAN_MAXF
);
833 const GLchan
*tableUB
= (const GLchan
*) table
->Table
;
835 for (i
= 0; i
< table
->Size
; i
++) {
836 rgba
[i
][RCOMP
] = tableUB
[i
];
837 rgba
[i
][GCOMP
] = tableUB
[i
];
838 rgba
[i
][BCOMP
] = tableUB
[i
];
839 rgba
[i
][ACOMP
] = tableUB
[i
];
844 if (table
->Type
== GL_FLOAT
) {
845 const GLfloat
*tableF
= (const GLfloat
*) table
->Table
;
847 for (i
= 0; i
< table
->Size
; i
++) {
848 rgba
[i
][RCOMP
] = IROUND_POS(tableF
[i
*3+0] * CHAN_MAXF
);
849 rgba
[i
][GCOMP
] = IROUND_POS(tableF
[i
*3+1] * CHAN_MAXF
);
850 rgba
[i
][BCOMP
] = IROUND_POS(tableF
[i
*3+2] * CHAN_MAXF
);
851 rgba
[i
][ACOMP
] = CHAN_MAX
;
855 const GLchan
*tableUB
= (const GLchan
*) table
->Table
;
857 for (i
= 0; i
< table
->Size
; i
++) {
858 rgba
[i
][RCOMP
] = tableUB
[i
*3+0];
859 rgba
[i
][GCOMP
] = tableUB
[i
*3+1];
860 rgba
[i
][BCOMP
] = tableUB
[i
*3+2];
861 rgba
[i
][ACOMP
] = CHAN_MAX
;
866 if (table
->Type
== GL_FLOAT
) {
867 const GLfloat
*tableF
= (const GLfloat
*) table
->Table
;
869 for (i
= 0; i
< table
->Size
; i
++) {
870 rgba
[i
][RCOMP
] = IROUND_POS(tableF
[i
*4+0] * CHAN_MAXF
);
871 rgba
[i
][GCOMP
] = IROUND_POS(tableF
[i
*4+1] * CHAN_MAXF
);
872 rgba
[i
][BCOMP
] = IROUND_POS(tableF
[i
*4+2] * CHAN_MAXF
);
873 rgba
[i
][ACOMP
] = IROUND_POS(tableF
[i
*4+3] * CHAN_MAXF
);
877 const GLchan
*tableUB
= (const GLchan
*) table
->Table
;
879 for (i
= 0; i
< table
->Size
; i
++) {
880 rgba
[i
][RCOMP
] = tableUB
[i
*4+0];
881 rgba
[i
][GCOMP
] = tableUB
[i
*4+1];
882 rgba
[i
][BCOMP
] = tableUB
[i
*4+2];
883 rgba
[i
][ACOMP
] = tableUB
[i
*4+3];
888 _mesa_problem(ctx
, "bad table format in glGetColorTable");
892 if (ctx
->Pack
.BufferObj
->Name
) {
893 /* pack color table into PBO */
895 if (!_mesa_validate_pbo_access(1, &ctx
->Pack
, table
->Size
, 1, 1,
896 format
, type
, data
)) {
897 _mesa_error(ctx
, GL_INVALID_OPERATION
,
898 "glGetColorTable(invalid PBO access)");
901 buf
= (GLubyte
*) ctx
->Driver
.MapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
903 ctx
->Pack
.BufferObj
);
905 /* buffer is already mapped - that's an error */
906 _mesa_error(ctx
, GL_INVALID_OPERATION
,
907 "glGetColorTable(PBO is mapped)");
910 data
= ADD_POINTERS(buf
, data
);
913 _mesa_pack_rgba_span_chan(ctx
, table
->Size
, (const GLchan (*)[4]) rgba
,
914 format
, type
, data
, &ctx
->Pack
, GL_FALSE
);
916 if (ctx
->Pack
.BufferObj
->Name
) {
917 ctx
->Driver
.UnmapBuffer(ctx
, GL_PIXEL_PACK_BUFFER_EXT
,
918 ctx
->Pack
.BufferObj
);
925 _mesa_ColorTableParameterfv(GLenum target
, GLenum pname
, const GLfloat
*params
)
927 GET_CURRENT_CONTEXT(ctx
);
928 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx
);
931 case GL_COLOR_TABLE_SGI
:
932 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
933 ctx
->Pixel
.ColorTableScale
[0] = params
[0];
934 ctx
->Pixel
.ColorTableScale
[1] = params
[1];
935 ctx
->Pixel
.ColorTableScale
[2] = params
[2];
936 ctx
->Pixel
.ColorTableScale
[3] = params
[3];
938 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
939 ctx
->Pixel
.ColorTableBias
[0] = params
[0];
940 ctx
->Pixel
.ColorTableBias
[1] = params
[1];
941 ctx
->Pixel
.ColorTableBias
[2] = params
[2];
942 ctx
->Pixel
.ColorTableBias
[3] = params
[3];
945 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTableParameterfv(pname)");
949 case GL_TEXTURE_COLOR_TABLE_SGI
:
950 if (!ctx
->Extensions
.SGI_texture_color_table
) {
951 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTableParameter(target)");
954 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
955 ctx
->Pixel
.TextureColorTableScale
[0] = params
[0];
956 ctx
->Pixel
.TextureColorTableScale
[1] = params
[1];
957 ctx
->Pixel
.TextureColorTableScale
[2] = params
[2];
958 ctx
->Pixel
.TextureColorTableScale
[3] = params
[3];
960 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
961 ctx
->Pixel
.TextureColorTableBias
[0] = params
[0];
962 ctx
->Pixel
.TextureColorTableBias
[1] = params
[1];
963 ctx
->Pixel
.TextureColorTableBias
[2] = params
[2];
964 ctx
->Pixel
.TextureColorTableBias
[3] = params
[3];
967 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTableParameterfv(pname)");
971 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI
:
972 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
973 ctx
->Pixel
.PCCTscale
[0] = params
[0];
974 ctx
->Pixel
.PCCTscale
[1] = params
[1];
975 ctx
->Pixel
.PCCTscale
[2] = params
[2];
976 ctx
->Pixel
.PCCTscale
[3] = params
[3];
978 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
979 ctx
->Pixel
.PCCTbias
[0] = params
[0];
980 ctx
->Pixel
.PCCTbias
[1] = params
[1];
981 ctx
->Pixel
.PCCTbias
[2] = params
[2];
982 ctx
->Pixel
.PCCTbias
[3] = params
[3];
985 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTableParameterfv(pname)");
989 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI
:
990 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
991 ctx
->Pixel
.PCMCTscale
[0] = params
[0];
992 ctx
->Pixel
.PCMCTscale
[1] = params
[1];
993 ctx
->Pixel
.PCMCTscale
[2] = params
[2];
994 ctx
->Pixel
.PCMCTscale
[3] = params
[3];
996 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
997 ctx
->Pixel
.PCMCTbias
[0] = params
[0];
998 ctx
->Pixel
.PCMCTbias
[1] = params
[1];
999 ctx
->Pixel
.PCMCTbias
[2] = params
[2];
1000 ctx
->Pixel
.PCMCTbias
[3] = params
[3];
1003 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTableParameterfv(pname)");
1008 _mesa_error(ctx
, GL_INVALID_ENUM
, "glColorTableParameter(target)");
1012 ctx
->NewState
|= _NEW_PIXEL
;
1018 _mesa_ColorTableParameteriv(GLenum target
, GLenum pname
, const GLint
*params
)
1021 if (pname
== GL_COLOR_TABLE_SGI
||
1022 pname
== GL_TEXTURE_COLOR_TABLE_SGI
||
1023 pname
== GL_POST_CONVOLUTION_COLOR_TABLE_SGI
||
1024 pname
== GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI
) {
1026 fparams
[0] = (GLfloat
) params
[0];
1027 fparams
[1] = (GLfloat
) params
[1];
1028 fparams
[2] = (GLfloat
) params
[2];
1029 fparams
[3] = (GLfloat
) params
[3];
1033 fparams
[0] = (GLfloat
) params
[0];
1035 _mesa_ColorTableParameterfv(target
, pname
, fparams
);
1041 _mesa_GetColorTableParameterfv( GLenum target
, GLenum pname
, GLfloat
*params
)
1043 GET_CURRENT_CONTEXT(ctx
);
1044 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[ctx
->Texture
.CurrentUnit
];
1045 struct gl_color_table
*table
= NULL
;
1046 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1050 table
= &texUnit
->Current1D
->Palette
;
1053 table
= &texUnit
->Current2D
->Palette
;
1056 table
= &texUnit
->Current3D
->Palette
;
1058 case GL_TEXTURE_CUBE_MAP_ARB
:
1059 if (!ctx
->Extensions
.ARB_texture_cube_map
) {
1060 _mesa_error(ctx
, GL_INVALID_ENUM
,
1061 "glGetColorTableParameterfv(target)");
1064 table
= &texUnit
->CurrentCubeMap
->Palette
;
1066 case GL_PROXY_TEXTURE_1D
:
1067 table
= &ctx
->Texture
.Proxy1D
->Palette
;
1069 case GL_PROXY_TEXTURE_2D
:
1070 table
= &ctx
->Texture
.Proxy2D
->Palette
;
1072 case GL_PROXY_TEXTURE_3D
:
1073 table
= &ctx
->Texture
.Proxy3D
->Palette
;
1075 case GL_PROXY_TEXTURE_CUBE_MAP_ARB
:
1076 if (!ctx
->Extensions
.ARB_texture_cube_map
) {
1077 _mesa_error(ctx
, GL_INVALID_ENUM
,
1078 "glGetColorTableParameterfv(target)");
1081 table
= &ctx
->Texture
.ProxyCubeMap
->Palette
;
1083 case GL_SHARED_TEXTURE_PALETTE_EXT
:
1084 table
= &ctx
->Texture
.Palette
;
1086 case GL_COLOR_TABLE
:
1087 table
= &ctx
->ColorTable
;
1088 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
1089 params
[0] = ctx
->Pixel
.ColorTableScale
[0];
1090 params
[1] = ctx
->Pixel
.ColorTableScale
[1];
1091 params
[2] = ctx
->Pixel
.ColorTableScale
[2];
1092 params
[3] = ctx
->Pixel
.ColorTableScale
[3];
1095 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
1096 params
[0] = ctx
->Pixel
.ColorTableBias
[0];
1097 params
[1] = ctx
->Pixel
.ColorTableBias
[1];
1098 params
[2] = ctx
->Pixel
.ColorTableBias
[2];
1099 params
[3] = ctx
->Pixel
.ColorTableBias
[3];
1103 case GL_PROXY_COLOR_TABLE
:
1104 table
= &ctx
->ProxyColorTable
;
1106 case GL_TEXTURE_COLOR_TABLE_SGI
:
1107 if (!ctx
->Extensions
.SGI_texture_color_table
) {
1108 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTableParameter(target)");
1111 table
= &(texUnit
->ColorTable
);
1112 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
1113 params
[0] = ctx
->Pixel
.TextureColorTableScale
[0];
1114 params
[1] = ctx
->Pixel
.TextureColorTableScale
[1];
1115 params
[2] = ctx
->Pixel
.TextureColorTableScale
[2];
1116 params
[3] = ctx
->Pixel
.TextureColorTableScale
[3];
1119 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
1120 params
[0] = ctx
->Pixel
.TextureColorTableBias
[0];
1121 params
[1] = ctx
->Pixel
.TextureColorTableBias
[1];
1122 params
[2] = ctx
->Pixel
.TextureColorTableBias
[2];
1123 params
[3] = ctx
->Pixel
.TextureColorTableBias
[3];
1127 case GL_PROXY_TEXTURE_COLOR_TABLE_SGI
:
1128 if (!ctx
->Extensions
.SGI_texture_color_table
) {
1129 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTableParameter(target)");
1132 table
= &(texUnit
->ProxyColorTable
);
1134 case GL_POST_CONVOLUTION_COLOR_TABLE
:
1135 table
= &ctx
->PostConvolutionColorTable
;
1136 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
1137 params
[0] = ctx
->Pixel
.PCCTscale
[0];
1138 params
[1] = ctx
->Pixel
.PCCTscale
[1];
1139 params
[2] = ctx
->Pixel
.PCCTscale
[2];
1140 params
[3] = ctx
->Pixel
.PCCTscale
[3];
1143 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
1144 params
[0] = ctx
->Pixel
.PCCTbias
[0];
1145 params
[1] = ctx
->Pixel
.PCCTbias
[1];
1146 params
[2] = ctx
->Pixel
.PCCTbias
[2];
1147 params
[3] = ctx
->Pixel
.PCCTbias
[3];
1151 case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE
:
1152 table
= &ctx
->ProxyPostConvolutionColorTable
;
1154 case GL_POST_COLOR_MATRIX_COLOR_TABLE
:
1155 table
= &ctx
->PostColorMatrixColorTable
;
1156 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
1157 params
[0] = ctx
->Pixel
.PCMCTscale
[0];
1158 params
[1] = ctx
->Pixel
.PCMCTscale
[1];
1159 params
[2] = ctx
->Pixel
.PCMCTscale
[2];
1160 params
[3] = ctx
->Pixel
.PCMCTscale
[3];
1163 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
1164 params
[0] = ctx
->Pixel
.PCMCTbias
[0];
1165 params
[1] = ctx
->Pixel
.PCMCTbias
[1];
1166 params
[2] = ctx
->Pixel
.PCMCTbias
[2];
1167 params
[3] = ctx
->Pixel
.PCMCTbias
[3];
1171 case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE
:
1172 table
= &ctx
->ProxyPostColorMatrixColorTable
;
1175 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTableParameterfv(target)");
1182 case GL_COLOR_TABLE_FORMAT
:
1183 *params
= (GLfloat
) table
->IntFormat
;
1185 case GL_COLOR_TABLE_WIDTH
:
1186 *params
= (GLfloat
) table
->Size
;
1188 case GL_COLOR_TABLE_RED_SIZE
:
1189 *params
= (GLfloat
) table
->RedSize
;
1191 case GL_COLOR_TABLE_GREEN_SIZE
:
1192 *params
= (GLfloat
) table
->GreenSize
;
1194 case GL_COLOR_TABLE_BLUE_SIZE
:
1195 *params
= (GLfloat
) table
->BlueSize
;
1197 case GL_COLOR_TABLE_ALPHA_SIZE
:
1198 *params
= (GLfloat
) table
->AlphaSize
;
1200 case GL_COLOR_TABLE_LUMINANCE_SIZE
:
1201 *params
= (GLfloat
) table
->LuminanceSize
;
1203 case GL_COLOR_TABLE_INTENSITY_SIZE
:
1204 *params
= (GLfloat
) table
->IntensitySize
;
1207 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTableParameterfv(pname)" );
1215 _mesa_GetColorTableParameteriv( GLenum target
, GLenum pname
, GLint
*params
)
1217 GET_CURRENT_CONTEXT(ctx
);
1218 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[ctx
->Texture
.CurrentUnit
];
1219 struct gl_color_table
*table
= NULL
;
1220 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1224 table
= &texUnit
->Current1D
->Palette
;
1227 table
= &texUnit
->Current2D
->Palette
;
1230 table
= &texUnit
->Current3D
->Palette
;
1232 case GL_TEXTURE_CUBE_MAP_ARB
:
1233 if (!ctx
->Extensions
.ARB_texture_cube_map
) {
1234 _mesa_error(ctx
, GL_INVALID_ENUM
,
1235 "glGetColorTableParameteriv(target)");
1238 table
= &texUnit
->CurrentCubeMap
->Palette
;
1240 case GL_PROXY_TEXTURE_1D
:
1241 table
= &ctx
->Texture
.Proxy1D
->Palette
;
1243 case GL_PROXY_TEXTURE_2D
:
1244 table
= &ctx
->Texture
.Proxy2D
->Palette
;
1246 case GL_PROXY_TEXTURE_3D
:
1247 table
= &ctx
->Texture
.Proxy3D
->Palette
;
1249 case GL_PROXY_TEXTURE_CUBE_MAP_ARB
:
1250 if (!ctx
->Extensions
.ARB_texture_cube_map
) {
1251 _mesa_error(ctx
, GL_INVALID_ENUM
,
1252 "glGetColorTableParameteriv(target)");
1255 table
= &ctx
->Texture
.ProxyCubeMap
->Palette
;
1257 case GL_SHARED_TEXTURE_PALETTE_EXT
:
1258 table
= &ctx
->Texture
.Palette
;
1260 case GL_COLOR_TABLE
:
1261 table
= &ctx
->ColorTable
;
1262 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
1263 params
[0] = (GLint
) ctx
->Pixel
.ColorTableScale
[0];
1264 params
[1] = (GLint
) ctx
->Pixel
.ColorTableScale
[1];
1265 params
[2] = (GLint
) ctx
->Pixel
.ColorTableScale
[2];
1266 params
[3] = (GLint
) ctx
->Pixel
.ColorTableScale
[3];
1269 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
1270 params
[0] = (GLint
) ctx
->Pixel
.ColorTableBias
[0];
1271 params
[1] = (GLint
) ctx
->Pixel
.ColorTableBias
[1];
1272 params
[2] = (GLint
) ctx
->Pixel
.ColorTableBias
[2];
1273 params
[3] = (GLint
) ctx
->Pixel
.ColorTableBias
[3];
1277 case GL_PROXY_COLOR_TABLE
:
1278 table
= &ctx
->ProxyColorTable
;
1280 case GL_TEXTURE_COLOR_TABLE_SGI
:
1281 if (!ctx
->Extensions
.SGI_texture_color_table
) {
1282 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTableParameter(target)");
1285 table
= &(texUnit
->ColorTable
);
1286 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
1287 params
[0] = (GLint
) ctx
->Pixel
.TextureColorTableScale
[0];
1288 params
[1] = (GLint
) ctx
->Pixel
.TextureColorTableScale
[1];
1289 params
[2] = (GLint
) ctx
->Pixel
.TextureColorTableScale
[2];
1290 params
[3] = (GLint
) ctx
->Pixel
.TextureColorTableScale
[3];
1293 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
1294 params
[0] = (GLint
) ctx
->Pixel
.TextureColorTableBias
[0];
1295 params
[1] = (GLint
) ctx
->Pixel
.TextureColorTableBias
[1];
1296 params
[2] = (GLint
) ctx
->Pixel
.TextureColorTableBias
[2];
1297 params
[3] = (GLint
) ctx
->Pixel
.TextureColorTableBias
[3];
1301 case GL_PROXY_TEXTURE_COLOR_TABLE_SGI
:
1302 if (!ctx
->Extensions
.SGI_texture_color_table
) {
1303 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTableParameter(target)");
1306 table
= &(texUnit
->ProxyColorTable
);
1308 case GL_POST_CONVOLUTION_COLOR_TABLE
:
1309 table
= &ctx
->PostConvolutionColorTable
;
1310 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
1311 params
[0] = (GLint
) ctx
->Pixel
.PCCTscale
[0];
1312 params
[1] = (GLint
) ctx
->Pixel
.PCCTscale
[1];
1313 params
[2] = (GLint
) ctx
->Pixel
.PCCTscale
[2];
1314 params
[3] = (GLint
) ctx
->Pixel
.PCCTscale
[3];
1317 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
1318 params
[0] = (GLint
) ctx
->Pixel
.PCCTbias
[0];
1319 params
[1] = (GLint
) ctx
->Pixel
.PCCTbias
[1];
1320 params
[2] = (GLint
) ctx
->Pixel
.PCCTbias
[2];
1321 params
[3] = (GLint
) ctx
->Pixel
.PCCTbias
[3];
1325 case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE
:
1326 table
= &ctx
->ProxyPostConvolutionColorTable
;
1328 case GL_POST_COLOR_MATRIX_COLOR_TABLE
:
1329 table
= &ctx
->PostColorMatrixColorTable
;
1330 if (pname
== GL_COLOR_TABLE_SCALE_SGI
) {
1331 params
[0] = (GLint
) ctx
->Pixel
.PCMCTscale
[0];
1332 params
[1] = (GLint
) ctx
->Pixel
.PCMCTscale
[1];
1333 params
[2] = (GLint
) ctx
->Pixel
.PCMCTscale
[2];
1334 params
[3] = (GLint
) ctx
->Pixel
.PCMCTscale
[3];
1337 else if (pname
== GL_COLOR_TABLE_BIAS_SGI
) {
1338 params
[0] = (GLint
) ctx
->Pixel
.PCMCTbias
[0];
1339 params
[1] = (GLint
) ctx
->Pixel
.PCMCTbias
[1];
1340 params
[2] = (GLint
) ctx
->Pixel
.PCMCTbias
[2];
1341 params
[3] = (GLint
) ctx
->Pixel
.PCMCTbias
[3];
1345 case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE
:
1346 table
= &ctx
->ProxyPostColorMatrixColorTable
;
1349 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTableParameteriv(target)");
1356 case GL_COLOR_TABLE_FORMAT
:
1357 *params
= table
->IntFormat
;
1359 case GL_COLOR_TABLE_WIDTH
:
1360 *params
= table
->Size
;
1362 case GL_COLOR_TABLE_RED_SIZE
:
1363 *params
= table
->RedSize
;
1365 case GL_COLOR_TABLE_GREEN_SIZE
:
1366 *params
= table
->GreenSize
;
1368 case GL_COLOR_TABLE_BLUE_SIZE
:
1369 *params
= table
->BlueSize
;
1371 case GL_COLOR_TABLE_ALPHA_SIZE
:
1372 *params
= table
->AlphaSize
;
1374 case GL_COLOR_TABLE_LUMINANCE_SIZE
:
1375 *params
= table
->LuminanceSize
;
1377 case GL_COLOR_TABLE_INTENSITY_SIZE
:
1378 *params
= table
->IntensitySize
;
1381 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetColorTableParameteriv(pname)" );
1386 /**********************************************************************/
1387 /***** Initialization *****/
1388 /**********************************************************************/
1392 _mesa_init_colortable( struct gl_color_table
*p
)
1394 p
->Type
= CHAN_TYPE
;
1397 p
->IntFormat
= GL_RGBA
;
1403 _mesa_free_colortable_data( struct gl_color_table
*p
)
1413 * Initialize all colortables for a context.
1415 void _mesa_init_colortables( GLcontext
* ctx
)
1418 _mesa_init_colortable(&ctx
->ColorTable
);
1419 _mesa_init_colortable(&ctx
->ProxyColorTable
);
1420 _mesa_init_colortable(&ctx
->PostConvolutionColorTable
);
1421 _mesa_init_colortable(&ctx
->ProxyPostConvolutionColorTable
);
1422 _mesa_init_colortable(&ctx
->PostColorMatrixColorTable
);
1423 _mesa_init_colortable(&ctx
->ProxyPostColorMatrixColorTable
);
1428 * Free all colortable data for a context
1430 void _mesa_free_colortables_data( GLcontext
*ctx
)
1432 _mesa_free_colortable_data(&ctx
->ColorTable
);
1433 _mesa_free_colortable_data(&ctx
->ProxyColorTable
);
1434 _mesa_free_colortable_data(&ctx
->PostConvolutionColorTable
);
1435 _mesa_free_colortable_data(&ctx
->ProxyPostConvolutionColorTable
);
1436 _mesa_free_colortable_data(&ctx
->PostColorMatrixColorTable
);
1437 _mesa_free_colortable_data(&ctx
->ProxyPostColorMatrixColorTable
);