projects / mesa.git / blob
? search:


9ee3f0f2bb47bcb1d2e4228be8bafb0cfe37b23b
[mesa.git] / src / mesa / main / colortab.c
1 /* $Id: colortab.c,v 1.19 2000/06/27 15:47:59 brianp Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 3.3
6 *
7 * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27
28 #ifdef PC_HEADER
29 #include "all.h"
30 #else
31 #include "glheader.h"
32 #include "colortab.h"
33 #include "context.h"
34 #include "image.h"
35 #include "macros.h"
36 #include "mem.h"
37 #include "mmath.h"
38 #include "span.h"
39 #endif
40
41
42
43 /*
44 * Given an internalFormat token passed to glColorTable,
45 * return the corresponding base format.
46 * Return -1 if invalid token.
47 */
48 static GLint
49 base_colortab_format( GLenum format )
50 {
51 switch (format) {
52 case GL_ALPHA:
53 case GL_ALPHA4:
54 case GL_ALPHA8:
55 case GL_ALPHA12:
56 case GL_ALPHA16:
57 return GL_ALPHA;
58 case GL_LUMINANCE:
59 case GL_LUMINANCE4:
60 case GL_LUMINANCE8:
61 case GL_LUMINANCE12:
62 case GL_LUMINANCE16:
63 return GL_LUMINANCE;
64 case GL_LUMINANCE_ALPHA:
65 case GL_LUMINANCE4_ALPHA4:
66 case GL_LUMINANCE6_ALPHA2:
67 case GL_LUMINANCE8_ALPHA8:
68 case GL_LUMINANCE12_ALPHA4:
69 case GL_LUMINANCE12_ALPHA12:
70 case GL_LUMINANCE16_ALPHA16:
71 return GL_LUMINANCE_ALPHA;
72 case GL_INTENSITY:
73 case GL_INTENSITY4:
74 case GL_INTENSITY8:
75 case GL_INTENSITY12:
76 case GL_INTENSITY16:
77 return GL_INTENSITY;
78 case GL_RGB:
79 case GL_R3_G3_B2:
80 case GL_RGB4:
81 case GL_RGB5:
82 case GL_RGB8:
83 case GL_RGB10:
84 case GL_RGB12:
85 case GL_RGB16:
86 return GL_RGB;
87 case GL_RGBA:
88 case GL_RGBA2:
89 case GL_RGBA4:
90 case GL_RGB5_A1:
91 case GL_RGBA8:
92 case GL_RGB10_A2:
93 case GL_RGBA12:
94 case GL_RGBA16:
95 return GL_RGBA;
96 default:
97 return -1; /* error */
98 }
99 }
100
101
102 void
103 _mesa_init_colortable( struct gl_color_table *p )
104 {
105 p->TableType = GL_UNSIGNED_BYTE;
106 /* allocate a width=1 table by default */
107 p->Table = CALLOC(4 * sizeof(GLubyte));
108 if (p->Table) {
109 GLubyte *t = (GLubyte *) p->Table;
110 t[0] = 255;
111 t[1] = 255;
112 t[2] = 255;
113 t[3] = 255;
114 }
115 p->Size = 1;
116 p->IntFormat = GL_RGBA;
117 p->Format = GL_RGBA;
118 p->RedSize = 8;
119 p->GreenSize = 8;
120 p->BlueSize = 8;
121 p->AlphaSize = 8;
122 p->IntensitySize = 0;
123 p->LuminanceSize = 0;
124 }
125
126
127
128 void
129 _mesa_free_colortable_data( struct gl_color_table *p )
130 {
131 if (p->Table) {
132 FREE(p->Table);
133 p->Table = NULL;
134 }
135 }
136
137
138 /*
139 * Examine table's format and set the component sizes accordingly.
140 */
141 static void
142 set_component_sizes( struct gl_color_table *table )
143 {
144 switch (table->Format) {
145 case GL_ALPHA:
146 table->RedSize = 0;
147 table->GreenSize = 0;
148 table->BlueSize = 0;
149 table->AlphaSize = 8;
150 table->IntensitySize = 0;
151 table->LuminanceSize = 0;
152 break;
153 case GL_LUMINANCE:
154 table->RedSize = 0;
155 table->GreenSize = 0;
156 table->BlueSize = 0;
157 table->AlphaSize = 0;
158 table->IntensitySize = 0;
159 table->LuminanceSize = 8;
160 break;
161 case GL_LUMINANCE_ALPHA:
162 table->RedSize = 0;
163 table->GreenSize = 0;
164 table->BlueSize = 0;
165 table->AlphaSize = 8;
166 table->IntensitySize = 0;
167 table->LuminanceSize = 8;
168 break;
169 case GL_INTENSITY:
170 table->RedSize = 0;
171 table->GreenSize = 0;
172 table->BlueSize = 0;
173 table->AlphaSize = 0;
174 table->IntensitySize = 8;
175 table->LuminanceSize = 0;
176 break;
177 case GL_RGB:
178 table->RedSize = 8;
179 table->GreenSize = 8;
180 table->BlueSize = 8;
181 table->AlphaSize = 0;
182 table->IntensitySize = 0;
183 table->LuminanceSize = 0;
184 break;
185 case GL_RGBA:
186 table->RedSize = 8;
187 table->GreenSize = 8;
188 table->BlueSize = 8;
189 table->AlphaSize = 8;
190 table->IntensitySize = 0;
191 table->LuminanceSize = 0;
192 break;
193 default:
194 gl_problem(NULL, "unexpected format in set_component_sizes");
195 }
196 }
197
198
199
200 void
201 _mesa_ColorTable( GLenum target, GLenum internalFormat,
202 GLsizei width, GLenum format, GLenum type,
203 const GLvoid *data )
204 {
205 GET_CURRENT_CONTEXT(ctx);
206 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
207 struct gl_texture_object *texObj = NULL;
208 struct gl_color_table *table = NULL;
209 GLboolean proxy = GL_FALSE;
210 GLint baseFormat;
211 GLfloat rScale = 1.0, gScale = 1.0, bScale = 1.0, aScale = 1.0;
212 GLfloat rBias = 0.0, gBias = 0.0, bBias = 0.0, aBias = 0.0;
213 GLboolean floatTable = GL_FALSE;
214 GLint comps;
215
216 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glColorTable");
217
218 switch (target) {
219 case GL_TEXTURE_1D:
220 texObj = texUnit->CurrentD[1];
221 table = &texObj->Palette;
222 break;
223 case GL_TEXTURE_2D:
224 texObj = texUnit->CurrentD[2];
225 table = &texObj->Palette;
226 break;
227 case GL_TEXTURE_3D:
228 texObj = texUnit->CurrentD[3];
229 table = &texObj->Palette;
230 break;
231 case GL_PROXY_TEXTURE_1D:
232 texObj = ctx->Texture.Proxy1D;
233 table = &texObj->Palette;
234 proxy = GL_TRUE;
235 break;
236 case GL_PROXY_TEXTURE_2D:
237 texObj = ctx->Texture.Proxy2D;
238 table = &texObj->Palette;
239 proxy = GL_TRUE;
240 break;
241 case GL_PROXY_TEXTURE_3D:
242 texObj = ctx->Texture.Proxy3D;
243 table = &texObj->Palette;
244 proxy = GL_TRUE;
245 break;
246 case GL_SHARED_TEXTURE_PALETTE_EXT:
247 table = &ctx->Texture.Palette;
248 break;
249 case GL_COLOR_TABLE:
250 table = &ctx->ColorTable;
251 floatTable = GL_TRUE;
252 rScale = ctx->Pixel.ColorTableScale[0];
253 gScale = ctx->Pixel.ColorTableScale[1];
254 bScale = ctx->Pixel.ColorTableScale[2];
255 aScale = ctx->Pixel.ColorTableScale[3];
256 rBias = ctx->Pixel.ColorTableBias[0];
257 gBias = ctx->Pixel.ColorTableBias[1];
258 bBias = ctx->Pixel.ColorTableBias[2];
259 aBias = ctx->Pixel.ColorTableBias[3];
260 break;
261 case GL_PROXY_COLOR_TABLE:
262 table = &ctx->ProxyColorTable;
263 proxy = GL_TRUE;
264 break;
265 case GL_POST_CONVOLUTION_COLOR_TABLE:
266 table = &ctx->PostConvolutionColorTable;
267 floatTable = GL_TRUE;
268 rScale = ctx->Pixel.PCCTscale[0];
269 gScale = ctx->Pixel.PCCTscale[1];
270 bScale = ctx->Pixel.PCCTscale[2];
271 aScale = ctx->Pixel.PCCTscale[3];
272 rBias = ctx->Pixel.PCCTbias[0];
273 gBias = ctx->Pixel.PCCTbias[1];
274 bBias = ctx->Pixel.PCCTbias[2];
275 aBias = ctx->Pixel.PCCTbias[3];
276 break;
277 case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE:
278 table = &ctx->ProxyPostConvolutionColorTable;
279 proxy = GL_TRUE;
280 break;
281 case GL_POST_COLOR_MATRIX_COLOR_TABLE:
282 table = &ctx->PostColorMatrixColorTable;
283 floatTable = GL_TRUE;
284 rScale = ctx->Pixel.PCMCTscale[0];
285 gScale = ctx->Pixel.PCMCTscale[1];
286 bScale = ctx->Pixel.PCMCTscale[2];
287 aScale = ctx->Pixel.PCMCTscale[3];
288 rBias = ctx->Pixel.PCMCTbias[0];
289 gBias = ctx->Pixel.PCMCTbias[1];
290 bBias = ctx->Pixel.PCMCTbias[2];
291 aBias = ctx->Pixel.PCMCTbias[3];
292 break;
293 case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE:
294 table = &ctx->ProxyPostColorMatrixColorTable;
295 proxy = GL_TRUE;
296 break;
297 default:
298 gl_error(ctx, GL_INVALID_ENUM, "glColorTable(target)");
299 return;
300 }
301
302 assert(table);
303
304 if (!_mesa_is_legal_format_and_type(format, type) ||
305 format == GL_INTENSITY) {
306 gl_error(ctx, GL_INVALID_ENUM, "glColorTable(format or type)");
307 return;
308 }
309
310 baseFormat = base_colortab_format(internalFormat);
311 if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) {
312 gl_error(ctx, GL_INVALID_ENUM, "glColorTable(internalFormat)");
313 return;
314 }
315
316 if (width < 1 || width > ctx->Const.MaxColorTableSize
317 || _mesa_bitcount(width) != 1) {
318 if (width > ctx->Const.MaxColorTableSize)
319 gl_error(ctx, GL_TABLE_TOO_LARGE, "glColorTable(width)");
320 else
321 gl_error(ctx, GL_INVALID_VALUE, "glColorTable(width)");
322 if (proxy) {
323 table->Size = 0;
324 table->IntFormat = (GLenum) 0;
325 table->Format = (GLenum) 0;
326 }
327 return;
328 }
329
330 table->Size = width;
331 table->IntFormat = internalFormat;
332 table->Format = (GLenum) baseFormat;
333 set_component_sizes(table);
334
335 comps = _mesa_components_in_format(table->Format);
336 assert(comps > 0); /* error should have been caught sooner */
337
338 if (!proxy) {
339 /* free old table, if any */
340 if (table->Table) {
341 FREE(table->Table);
342 }
343 if (floatTable) {
344 GLubyte tableUB[MAX_COLOR_TABLE_SIZE * 4];
345 GLfloat *tableF;
346 GLuint i;
347
348 _mesa_unpack_ubyte_color_span(ctx, width, table->Format,
349 tableUB, /* dest */
350 format, type, data,
351 &ctx->Unpack, GL_TRUE);
352
353 table->TableType = GL_FLOAT;
354 table->Table = MALLOC(comps * width * sizeof(GLfloat));
355 if (!table->Table) {
356 gl_error(ctx, GL_OUT_OF_MEMORY, "glColorTable");
357 return;
358 }
359
360 /* Apply scale and bias and convert GLubyte values to GLfloats
361 * in [0, 1]. Store results in the tableF[].
362 */
363 rScale /= 255.0;
364 gScale /= 255.0;
365 bScale /= 255.0;
366 aScale /= 255.0;
367 tableF = (GLfloat *) table->Table;
368
369 switch (table->Format) {
370 case GL_INTENSITY:
371 for (i = 0; i < width; i++) {
372 tableF[i] = tableUB[i] * rScale + rBias;
373 }
374 break;
375 case GL_LUMINANCE:
376 for (i = 0; i < width; i++) {
377 tableF[i] = tableUB[i] * rScale + rBias;
378 }
379 break;
380 case GL_ALPHA:
381 for (i = 0; i < width; i++) {
382 tableF[i] = tableUB[i] * aScale + aBias;
383 }
384 break;
385 case GL_LUMINANCE_ALPHA:
386 for (i = 0; i < width; i++) {
387 tableF[i*2+0] = tableUB[i*2+0] * rScale + rBias;
388 tableF[i*2+1] = tableUB[i*2+1] * aScale + aBias;
389 }
390 break;
391 case GL_RGB:
392 for (i = 0; i < width; i++) {
393 tableF[i*3+0] = tableUB[i*3+0] * rScale + rBias;
394 tableF[i*3+1] = tableUB[i*3+1] * gScale + gBias;
395 tableF[i*3+2] = tableUB[i*3+2] * bScale + bBias;
396 }
397 break;
398 case GL_RGBA:
399 for (i = 0; i < width; i++) {
400 tableF[i*4+0] = tableUB[i*4+0] * rScale + rBias;
401 tableF[i*4+1] = tableUB[i*4+1] * gScale + gBias;
402 tableF[i*4+2] = tableUB[i*4+2] * bScale + bBias;
403 tableF[i*4+3] = tableUB[i*4+3] * aScale + aBias;
404 }
405 break;
406 default:
407 gl_problem(ctx, "Bad format in _mesa_ColorTable");
408 return;
409 }
410 }
411 else {
412 /* store GLubyte table */
413 table->TableType = GL_UNSIGNED_BYTE;
414 table->Table = MALLOC(comps * width * sizeof(GLubyte));
415 if (!table->Table) {
416 gl_error(ctx, GL_OUT_OF_MEMORY, "glColorTable");
417 return;
418 }
419 _mesa_unpack_ubyte_color_span(ctx, width, table->Format,
420 table->Table, /* dest */
421 format, type, data,
422 &ctx->Unpack, GL_TRUE);
423 } /* floatTable */
424 } /* proxy */
425
426 if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) {
427 /* texture object palette, texObj==NULL means the shared palette */
428 if (ctx->Driver.UpdateTexturePalette) {
429 (*ctx->Driver.UpdateTexturePalette)( ctx, texObj );
430 }
431 }
432 }
433
434
435
436 void
437 _mesa_ColorSubTable( GLenum target, GLsizei start,
438 GLsizei count, GLenum format, GLenum type,
439 const GLvoid *data )
440 {
441 GET_CURRENT_CONTEXT(ctx);
442 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
443 struct gl_texture_object *texObj = NULL;
444 struct gl_color_table *table = NULL;
445 GLint comps;
446
447 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glColorSubTable");
448
449 switch (target) {
450 case GL_TEXTURE_1D:
451 texObj = texUnit->CurrentD[1];
452 table = &texObj->Palette;
453 break;
454 case GL_TEXTURE_2D:
455 texObj = texUnit->CurrentD[2];
456 table = &texObj->Palette;
457 break;
458 case GL_TEXTURE_3D:
459 texObj = texUnit->CurrentD[3];
460 table = &texObj->Palette;
461 break;
462 case GL_SHARED_TEXTURE_PALETTE_EXT:
463 table = &ctx->Texture.Palette;
464 break;
465 case GL_COLOR_TABLE:
466 table = &ctx->ColorTable;
467 break;
468 case GL_POST_CONVOLUTION_COLOR_TABLE:
469 table = &ctx->PostConvolutionColorTable;
470 break;
471 case GL_POST_COLOR_MATRIX_COLOR_TABLE:
472 table = &ctx->PostColorMatrixColorTable;
473 break;
474 default:
475 gl_error(ctx, GL_INVALID_ENUM, "glColorSubTable(target)");
476 return;
477 }
478
479 assert(table);
480
481 if (!_mesa_is_legal_format_and_type(format, type) ||
482 format == GL_INTENSITY) {
483 gl_error(ctx, GL_INVALID_ENUM, "glColorSubTable(format or type)");
484 return;
485 }
486
487 if (count < 1) {
488 gl_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)");
489 return;
490 }
491
492 comps = _mesa_components_in_format(table->Format);
493 assert(comps > 0); /* error should have been caught sooner */
494
495 if (start + count > table->Size) {
496 gl_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)");
497 return;
498 }
499
500 if (!table->Table) {
501 gl_error(ctx, GL_OUT_OF_MEMORY, "glColorSubTable");
502 return;
503 }
504
505 if (table->TableType == GL_UNSIGNED_BYTE) {
506 GLubyte *dest = (GLubyte *) table->Table + start * comps * sizeof(GLubyte);
507 _mesa_unpack_ubyte_color_span(ctx, count, table->Format, dest,
508 format, type, data, &ctx->Unpack, GL_TRUE);
509 }
510 else {
511 GLfloat *dest = (GLfloat *) table->Table + start * comps * sizeof(GLfloat);
512 ASSERT(table->TableType == GL_FLOAT);
513 _mesa_unpack_float_color_span(ctx, count, table->Format, dest,
514 format, type, data, &ctx->Unpack,
515 GL_FALSE, GL_TRUE);
516 }
517
518 if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) {
519 /* per-texture object palette */
520 if (ctx->Driver.UpdateTexturePalette) {
521 (*ctx->Driver.UpdateTexturePalette)( ctx, texObj );
522 }
523 }
524 }
525
526
527
528 /* XXX not tested */
529 void
530 _mesa_CopyColorTable(GLenum target, GLenum internalformat,
531 GLint x, GLint y, GLsizei width)
532 {
533 GLubyte data[MAX_WIDTH][4];
534 GET_CURRENT_CONTEXT(ctx);
535 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyColorTable");
536
537 /* Select buffer to read from */
538 (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
539 ctx->Pixel.DriverReadBuffer );
540
541 if (width > MAX_WIDTH)
542 width = MAX_WIDTH;
543
544 /* read the data from framebuffer */
545 gl_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y, data );
546
547 /* Restore reading from draw buffer (the default) */
548 (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
549 ctx->Color.DriverDrawBuffer );
550
551 _mesa_ColorTable(target, internalformat, width,
552 GL_RGBA, GL_UNSIGNED_BYTE, data);
553 }
554
555
556
557 /* XXX not tested */
558 void
559 _mesa_CopyColorSubTable(GLenum target, GLsizei start,
560 GLint x, GLint y, GLsizei width)
561 {
562 GLubyte data[MAX_WIDTH][4];
563 GET_CURRENT_CONTEXT(ctx);
564 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyColorSubTable");
565
566 /* Select buffer to read from */
567 (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
568 ctx->Pixel.DriverReadBuffer );
569
570 if (width > MAX_WIDTH)
571 width = MAX_WIDTH;
572
573 /* read the data from framebuffer */
574 gl_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y, data );
575
576 /* Restore reading from draw buffer (the default) */
577 (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
578 ctx->Color.DriverDrawBuffer );
579
580 _mesa_ColorSubTable(target, start, width, GL_RGBA, GL_UNSIGNED_BYTE, data);
581 }
582
583
584
585 void
586 _mesa_GetColorTable( GLenum target, GLenum format,
587 GLenum type, GLvoid *data )
588 {
589 GET_CURRENT_CONTEXT(ctx);
590 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
591 struct gl_color_table *table = NULL;
592 GLubyte rgba[MAX_COLOR_TABLE_SIZE][4];
593 GLint i;
594
595 ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTable");
596
597 switch (target) {
598 case GL_TEXTURE_1D:
599 table = &texUnit->CurrentD[1]->Palette;
600 break;
601 case GL_TEXTURE_2D:
602 table = &texUnit->CurrentD[2]->Palette;
603 break;
604 case GL_TEXTURE_3D:
605 table = &texUnit->CurrentD[3]->Palette;
606 break;
607 case GL_SHARED_TEXTURE_PALETTE_EXT:
608 table = &ctx->Texture.Palette;
609 break;
610 case GL_COLOR_TABLE:
611 table = &ctx->ColorTable;
612 break;
613 case GL_POST_CONVOLUTION_COLOR_TABLE:
614 table = &ctx->PostConvolutionColorTable;
615 break;
616 case GL_POST_COLOR_MATRIX_COLOR_TABLE:
617 table = &ctx->PostColorMatrixColorTable;
618 break;
619 default:
620 gl_error(ctx, GL_INVALID_ENUM, "glGetColorTable(target)");
621 return;
622 }
623
624 assert(table);
625
626 switch (table->Format) {
627 case GL_ALPHA:
628 if (table->TableType == GL_FLOAT) {
629 const GLfloat *tableF = (const GLfloat *) table->Table;
630 for (i = 0; i < table->Size; i++) {
631 rgba[i][RCOMP] = 0;
632 rgba[i][GCOMP] = 0;
633 rgba[i][BCOMP] = 0;
634 rgba[i][ACOMP] = (GLint) (tableF[i] * 255.0F);
635 }
636 }
637 else {
638 const GLubyte *tableUB = (const GLubyte *) table->Table;
639 for (i = 0; i < table->Size; i++) {
640 rgba[i][RCOMP] = 0;
641 rgba[i][GCOMP] = 0;
642 rgba[i][BCOMP] = 0;
643 rgba[i][ACOMP] = tableUB[i];
644 }
645 }
646 break;
647 case GL_LUMINANCE:
648 if (table->TableType == GL_FLOAT) {
649 const GLfloat *tableF = (const GLfloat *) table->Table;
650 for (i = 0; i < table->Size; i++) {
651 rgba[i][RCOMP] = (GLint) (tableF[i] * 255.0F);
652 rgba[i][GCOMP] = (GLint) (tableF[i] * 255.0F);
653 rgba[i][BCOMP] = (GLint) (tableF[i] * 255.0F);
654 rgba[i][ACOMP] = 255;
655 }
656 }
657 else {
658 const GLubyte *tableUB = (const GLubyte *) table->Table;
659 for (i = 0; i < table->Size; i++) {
660 rgba[i][RCOMP] = tableUB[i];
661 rgba[i][GCOMP] = tableUB[i];
662 rgba[i][BCOMP] = tableUB[i];
663 rgba[i][ACOMP] = 255;
664 }
665 }
666 break;
667 case GL_LUMINANCE_ALPHA:
668 if (table->TableType == GL_FLOAT) {
669 const GLfloat *tableF = (const GLfloat *) table->Table;
670 for (i = 0; i < table->Size; i++) {
671 rgba[i][RCOMP] = (GLint) (tableF[i*2+0] * 255.0F);
672 rgba[i][GCOMP] = (GLint) (tableF[i*2+0] * 255.0F);
673 rgba[i][BCOMP] = (GLint) (tableF[i*2+0] * 255.0F);
674 rgba[i][ACOMP] = (GLint) (tableF[i*2+1] * 255.0F);
675 }
676 }
677 else {
678 const GLubyte *tableUB = (const GLubyte *) table->Table;
679 for (i = 0; i < table->Size; i++) {
680 rgba[i][RCOMP] = tableUB[i*2+0];
681 rgba[i][GCOMP] = tableUB[i*2+0];
682 rgba[i][BCOMP] = tableUB[i*2+0];
683 rgba[i][ACOMP] = tableUB[i*2+1];
684 }
685 }
686 break;
687 case GL_INTENSITY:
688 if (table->TableType == GL_FLOAT) {
689 const GLfloat *tableF = (const GLfloat *) table->Table;
690 for (i = 0; i < table->Size; i++) {
691 rgba[i][RCOMP] = (GLint) (tableF[i] * 255.0F);
692 rgba[i][GCOMP] = (GLint) (tableF[i] * 255.0F);
693 rgba[i][BCOMP] = (GLint) (tableF[i] * 255.0F);
694 rgba[i][ACOMP] = (GLint) (tableF[i] * 255.0F);
695 }
696 }
697 else {
698 const GLubyte *tableUB = (const GLubyte *) table->Table;
699 for (i = 0; i < table->Size; i++) {
700 rgba[i][RCOMP] = tableUB[i];
701 rgba[i][GCOMP] = tableUB[i];
702 rgba[i][BCOMP] = tableUB[i];
703 rgba[i][ACOMP] = tableUB[i];
704 }
705 }
706 break;
707 case GL_RGB:
708 if (table->TableType == GL_FLOAT) {
709 const GLfloat *tableF = (const GLfloat *) table->Table;
710 for (i = 0; i < table->Size; i++) {
711 rgba[i][RCOMP] = (GLint) (tableF[i*3+0] * 255.0F);
712 rgba[i][GCOMP] = (GLint) (tableF[i*3+1] * 255.0F);
713 rgba[i][BCOMP] = (GLint) (tableF[i*3+2] * 255.0F);
714 rgba[i][ACOMP] = 255;
715 }
716 }
717 else {
718 const GLubyte *tableUB = (const GLubyte *) table->Table;
719 for (i = 0; i < table->Size; i++) {
720 rgba[i][RCOMP] = tableUB[i*3+0];
721 rgba[i][GCOMP] = tableUB[i*3+1];
722 rgba[i][BCOMP] = tableUB[i*3+2];
723 rgba[i][ACOMP] = 255;
724 }
725 }
726 break;
727 case GL_RGBA:
728 if (table->TableType == GL_FLOAT) {
729 const GLfloat *tableF = (const GLfloat *) table->Table;
730 for (i = 0; i < table->Size; i++) {
731 rgba[i][RCOMP] = (GLint) (tableF[i*4+0] * 255.0F);
732 rgba[i][GCOMP] = (GLint) (tableF[i*4+1] * 255.0F);
733 rgba[i][BCOMP] = (GLint) (tableF[i*4+2] * 255.0F);
734 rgba[i][ACOMP] = (GLint) (tableF[i*4+3] * 255.0F);
735 }
736 }
737 else {
738 const GLubyte *tableUB = (const GLubyte *) table->Table;
739 for (i = 0; i < table->Size; i++) {
740 rgba[i][RCOMP] = tableUB[i*4+0];
741 rgba[i][GCOMP] = tableUB[i*4+1];
742 rgba[i][BCOMP] = tableUB[i*4+2];
743 rgba[i][ACOMP] = tableUB[i*4+3];
744 }
745 }
746 break;
747 default:
748 gl_problem(ctx, "bad table format in glGetColorTable");
749 return;
750 }
751
752 _mesa_pack_rgba_span(ctx, table->Size, (const GLubyte (*)[]) rgba,
753 format, type, data, &ctx->Pack, GL_FALSE);
754 }
755
756
757
758 void
759 _mesa_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
760 {
761 GET_CURRENT_CONTEXT(ctx);
762 ASSERT_OUTSIDE_BEGIN_END(ctx, "glColorTableParameterfv");
763
764 switch (target) {
765 case GL_COLOR_TABLE_SGI:
766 if (pname == GL_COLOR_TABLE_SCALE_SGI) {
767 ctx->Pixel.ColorTableScale[0] = params[0];
768 ctx->Pixel.ColorTableScale[1] = params[1];
769 ctx->Pixel.ColorTableScale[2] = params[2];
770 ctx->Pixel.ColorTableScale[3] = params[3];
771 }
772 else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
773 ctx->Pixel.ColorTableBias[0] = params[0];
774 ctx->Pixel.ColorTableBias[1] = params[1];
775 ctx->Pixel.ColorTableBias[2] = params[2];
776 ctx->Pixel.ColorTableBias[3] = params[3];
777 }
778 else {
779 gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)");
780 return;
781 }
782 break;
783 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
784 if (pname == GL_COLOR_TABLE_SCALE_SGI) {
785 ctx->Pixel.PCCTscale[0] = params[0];
786 ctx->Pixel.PCCTscale[1] = params[1];
787 ctx->Pixel.PCCTscale[2] = params[2];
788 ctx->Pixel.PCCTscale[3] = params[3];
789 }
790 else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
791 ctx->Pixel.PCCTbias[0] = params[0];
792 ctx->Pixel.PCCTbias[1] = params[1];
793 ctx->Pixel.PCCTbias[2] = params[2];
794 ctx->Pixel.PCCTbias[3] = params[3];
795 }
796 else {
797 gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)");
798 return;
799 }
800 break;
801 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
802 if (pname == GL_COLOR_TABLE_SCALE_SGI) {
803 ctx->Pixel.PCMCTscale[0] = params[0];
804 ctx->Pixel.PCMCTscale[1] = params[1];
805 ctx->Pixel.PCMCTscale[2] = params[2];
806 ctx->Pixel.PCMCTscale[3] = params[3];
807 }
808 else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
809 ctx->Pixel.PCMCTbias[0] = params[0];
810 ctx->Pixel.PCMCTbias[1] = params[1];
811 ctx->Pixel.PCMCTbias[2] = params[2];
812 ctx->Pixel.PCMCTbias[3] = params[3];
813 }
814 else {
815 gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)");
816 return;
817 }
818 break;
819 default:
820 gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameter(target)");
821 return;
822 }
823 }
824
825
826
827 void
828 _mesa_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
829 {
830 GLfloat fparams[4];
831 if (pname == GL_COLOR_TABLE_SGI ||
832 pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI ||
833 pname == GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI) {
834 /* four values */
835 fparams[0] = (GLfloat) params[0];
836 fparams[1] = (GLfloat) params[1];
837 fparams[2] = (GLfloat) params[2];
838 fparams[3] = (GLfloat) params[3];
839 }
840 else {
841 /* one values */
842 fparams[0] = (GLfloat) params[0];
843 }
844 _mesa_ColorTableParameterfv(target, pname, fparams);
845 }
846
847
848
849 void
850 _mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params )
851 {
852 GET_CURRENT_CONTEXT(ctx);
853 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
854 struct gl_color_table *table = NULL;
855
856 ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTableParameterfv");
857
858 switch (target) {
859 case GL_TEXTURE_1D:
860 table = &texUnit->CurrentD[1]->Palette;
861 break;
862 case GL_TEXTURE_2D:
863 table = &texUnit->CurrentD[2]->Palette;
864 break;
865 case GL_TEXTURE_3D:
866 table = &texUnit->CurrentD[3]->Palette;
867 break;
868 case GL_PROXY_TEXTURE_1D:
869 table = &ctx->Texture.Proxy1D->Palette;
870 break;
871 case GL_PROXY_TEXTURE_2D:
872 table = &ctx->Texture.Proxy2D->Palette;
873 break;
874 case GL_PROXY_TEXTURE_3D:
875 table = &ctx->Texture.Proxy3D->Palette;
876 break;
877 case GL_SHARED_TEXTURE_PALETTE_EXT:
878 table = &ctx->Texture.Palette;
879 break;
880 case GL_COLOR_TABLE:
881 table = &ctx->ColorTable;
882 if (pname == GL_COLOR_TABLE_SCALE_SGI) {
883 params[0] = ctx->Pixel.ColorTableScale[0];
884 params[1] = ctx->Pixel.ColorTableScale[1];
885 params[2] = ctx->Pixel.ColorTableScale[2];
886 params[3] = ctx->Pixel.ColorTableScale[3];
887 return;
888 }
889 else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
890 params[0] = ctx->Pixel.ColorTableBias[0];
891 params[1] = ctx->Pixel.ColorTableBias[1];
892 params[2] = ctx->Pixel.ColorTableBias[2];
893 params[3] = ctx->Pixel.ColorTableBias[3];
894 return;
895 }
896 break;
897 case GL_PROXY_COLOR_TABLE:
898 table = &ctx->ProxyColorTable;
899 break;
900 case GL_POST_CONVOLUTION_COLOR_TABLE:
901 table = &ctx->PostConvolutionColorTable;
902 if (pname == GL_COLOR_TABLE_SCALE_SGI) {
903 params[0] = ctx->Pixel.PCCTscale[0];
904 params[1] = ctx->Pixel.PCCTscale[1];
905 params[2] = ctx->Pixel.PCCTscale[2];
906 params[3] = ctx->Pixel.PCCTscale[3];
907 return;
908 }
909 else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
910 params[0] = ctx->Pixel.PCCTbias[0];
911 params[1] = ctx->Pixel.PCCTbias[1];
912 params[2] = ctx->Pixel.PCCTbias[2];
913 params[3] = ctx->Pixel.PCCTbias[3];
914 return;
915 }
916 break;
917 case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE:
918 table = &ctx->ProxyPostConvolutionColorTable;
919 break;
920 case GL_POST_COLOR_MATRIX_COLOR_TABLE:
921 table = &ctx->PostColorMatrixColorTable;
922 if (pname == GL_COLOR_TABLE_SCALE_SGI) {
923 params[0] = ctx->Pixel.PCMCTscale[0];
924 params[1] = ctx->Pixel.PCMCTscale[1];
925 params[2] = ctx->Pixel.PCMCTscale[2];
926 params[3] = ctx->Pixel.PCMCTscale[3];
927 return;
928 }
929 else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
930 params[0] = ctx->Pixel.PCMCTbias[0];
931 params[1] = ctx->Pixel.PCMCTbias[1];
932 params[2] = ctx->Pixel.PCMCTbias[2];
933 params[3] = ctx->Pixel.PCMCTbias[3];
934 return;
935 }
936 break;
937 case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE:
938 table = &ctx->ProxyPostColorMatrixColorTable;
939 break;
940 default:
941 gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(target)");
942 return;
943 }
944
945 assert(table);
946
947 switch (pname) {
948 case GL_COLOR_TABLE_FORMAT:
949 *params = table->IntFormat;
950 break;
951 case GL_COLOR_TABLE_WIDTH:
952 *params = table->Size;
953 break;
954 case GL_COLOR_TABLE_RED_SIZE:
955 *params = table->RedSize;
956 break;
957 case GL_COLOR_TABLE_GREEN_SIZE:
958 *params = table->GreenSize;
959 break;
960 case GL_COLOR_TABLE_BLUE_SIZE:
961 *params = table->BlueSize;
962 break;
963 case GL_COLOR_TABLE_ALPHA_SIZE:
964 *params = table->AlphaSize;
965 break;
966 case GL_COLOR_TABLE_LUMINANCE_SIZE:
967 *params = table->LuminanceSize;
968 break;
969 case GL_COLOR_TABLE_INTENSITY_SIZE:
970 *params = table->IntensitySize;
971 break;
972 default:
973 gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(pname)" );
974 return;
975 }
976 }
977
978
979
980 void
981 _mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params )
982 {
983 GET_CURRENT_CONTEXT(ctx);
984 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
985 struct gl_color_table *table = NULL;
986
987 ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTableParameteriv");
988
989 switch (target) {
990 case GL_TEXTURE_1D:
991 table = &texUnit->CurrentD[1]->Palette;
992 break;
993 case GL_TEXTURE_2D:
994 table = &texUnit->CurrentD[2]->Palette;
995 break;
996 case GL_TEXTURE_3D:
997 table = &texUnit->CurrentD[3]->Palette;
998 break;
999 case GL_PROXY_TEXTURE_1D:
1000 table = &ctx->Texture.Proxy1D->Palette;
1001 break;
1002 case GL_PROXY_TEXTURE_2D:
1003 table = &ctx->Texture.Proxy2D->Palette;
1004 break;
1005 case GL_PROXY_TEXTURE_3D:
1006 table = &ctx->Texture.Proxy3D->Palette;
1007 break;
1008 case GL_SHARED_TEXTURE_PALETTE_EXT:
1009 table = &ctx->Texture.Palette;
1010 break;
1011 case GL_COLOR_TABLE:
1012 table = &ctx->ColorTable;
1013 if (pname == GL_COLOR_TABLE_SCALE_SGI) {
1014 params[0] = (GLint) ctx->Pixel.ColorTableScale[0];
1015 params[1] = (GLint) ctx->Pixel.ColorTableScale[1];
1016 params[2] = (GLint) ctx->Pixel.ColorTableScale[2];
1017 params[3] = (GLint) ctx->Pixel.ColorTableScale[3];
1018 return;
1019 }
1020 else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
1021 params[0] = (GLint) ctx->Pixel.ColorTableBias[0];
1022 params[1] = (GLint) ctx->Pixel.ColorTableBias[1];
1023 params[2] = (GLint) ctx->Pixel.ColorTableBias[2];
1024 params[3] = (GLint) ctx->Pixel.ColorTableBias[3];
1025 return;
1026 }
1027 break;
1028 case GL_PROXY_COLOR_TABLE:
1029 table = &ctx->ProxyColorTable;
1030 break;
1031 case GL_POST_CONVOLUTION_COLOR_TABLE:
1032 table = &ctx->PostConvolutionColorTable;
1033 if (pname == GL_COLOR_TABLE_SCALE_SGI) {
1034 params[0] = (GLint) ctx->Pixel.PCCTscale[0];
1035 params[1] = (GLint) ctx->Pixel.PCCTscale[1];
1036 params[2] = (GLint) ctx->Pixel.PCCTscale[2];
1037 params[3] = (GLint) ctx->Pixel.PCCTscale[3];
1038 return;
1039 }
1040 else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
1041 params[0] = (GLint) ctx->Pixel.PCCTbias[0];
1042 params[1] = (GLint) ctx->Pixel.PCCTbias[1];
1043 params[2] = (GLint) ctx->Pixel.PCCTbias[2];
1044 params[3] = (GLint) ctx->Pixel.PCCTbias[3];
1045 return;
1046 }
1047 break;
1048 case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE:
1049 table = &ctx->ProxyPostConvolutionColorTable;
1050 break;
1051 case GL_POST_COLOR_MATRIX_COLOR_TABLE:
1052 table = &ctx->PostColorMatrixColorTable;
1053 if (pname == GL_COLOR_TABLE_SCALE_SGI) {
1054 params[0] = (GLint) ctx->Pixel.PCMCTscale[0];
1055 params[1] = (GLint) ctx->Pixel.PCMCTscale[1];
1056 params[2] = (GLint) ctx->Pixel.PCMCTscale[2];
1057 params[3] = (GLint) ctx->Pixel.PCMCTscale[3];
1058 return;
1059 }
1060 else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
1061 params[0] = (GLint) ctx->Pixel.PCMCTbias[0];
1062 params[1] = (GLint) ctx->Pixel.PCMCTbias[1];
1063 params[2] = (GLint) ctx->Pixel.PCMCTbias[2];
1064 params[3] = (GLint) ctx->Pixel.PCMCTbias[3];
1065 return;
1066 }
1067 break;
1068 case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE:
1069 table = &ctx->ProxyPostColorMatrixColorTable;
1070 break;
1071 default:
1072 gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(target)");
1073 return;
1074 }
1075
1076 assert(table);
1077
1078 switch (pname) {
1079 case GL_COLOR_TABLE_FORMAT:
1080 *params = table->IntFormat;
1081 break;
1082 case GL_COLOR_TABLE_WIDTH:
1083 *params = table->Size;
1084 break;
1085 case GL_COLOR_TABLE_RED_SIZE:
1086 *params = table->RedSize;
1087 break;
1088 case GL_COLOR_TABLE_GREEN_SIZE:
1089 *params = table->GreenSize;
1090 break;
1091 case GL_COLOR_TABLE_BLUE_SIZE:
1092 *params = table->BlueSize;
1093 break;
1094 case GL_COLOR_TABLE_ALPHA_SIZE:
1095 *params = table->AlphaSize;
1096 break;
1097 case GL_COLOR_TABLE_LUMINANCE_SIZE:
1098 *params = table->LuminanceSize;
1099 break;
1100 case GL_COLOR_TABLE_INTENSITY_SIZE:
1101 *params = table->IntensitySize;
1102 break;
1103 default:
1104 gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(pname)" );
1105 return;
1106 }
1107 }