colortab.c revision baf3e77ee2ea0a8721715d540d88066771f2dd67
1/* $Id: colortab.c,v 1.28 2000/11/21 23:01:23 brianp Exp $ */ 2 3/* 4 * Mesa 3-D graphics library 5 * Version: 3.5 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 "swrast/s_span.h" /* XXX SWRAST hack */ 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 */ 48static GLint 49base_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 102void 103_mesa_init_colortable( struct gl_color_table *p ) 104{ 105 p->FloatTable = GL_FALSE; 106 /* allocate a width=1 table by default */ 107 p->Table = CALLOC(4 * sizeof(GLchan)); 108 if (p->Table) { 109 GLchan *t = (GLchan *) p->Table; 110 t[0] = CHAN_MAX; 111 t[1] = CHAN_MAX; 112 t[2] = CHAN_MAX; 113 t[3] = CHAN_MAX; 114 } 115 p->Size = 1; 116 p->IntFormat = GL_RGBA; 117 p->Format = GL_RGBA; 118 p->RedSize = CHAN_BITS; 119 p->GreenSize = CHAN_BITS; 120 p->BlueSize = CHAN_BITS; 121 p->AlphaSize = CHAN_BITS; 122 p->IntensitySize = 0; 123 p->LuminanceSize = 0; 124} 125 126 127 128void 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 */ 141static void 142set_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 = CHAN_BITS; 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 = CHAN_BITS; 160 break; 161 case GL_LUMINANCE_ALPHA: 162 table->RedSize = 0; 163 table->GreenSize = 0; 164 table->BlueSize = 0; 165 table->AlphaSize = CHAN_BITS; 166 table->IntensitySize = 0; 167 table->LuminanceSize = CHAN_BITS; 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 = CHAN_BITS; 175 table->LuminanceSize = 0; 176 break; 177 case GL_RGB: 178 table->RedSize = CHAN_BITS; 179 table->GreenSize = CHAN_BITS; 180 table->BlueSize = CHAN_BITS; 181 table->AlphaSize = 0; 182 table->IntensitySize = 0; 183 table->LuminanceSize = 0; 184 break; 185 case GL_RGBA: 186 table->RedSize = CHAN_BITS; 187 table->GreenSize = CHAN_BITS; 188 table->BlueSize = CHAN_BITS; 189 table->AlphaSize = CHAN_BITS; 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 200void 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->Current1D; 221 table = &texObj->Palette; 222 break; 223 case GL_TEXTURE_2D: 224 texObj = texUnit->Current2D; 225 table = &texObj->Palette; 226 break; 227 case GL_TEXTURE_3D: 228 texObj = texUnit->Current3D; 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 < 0 || _mesa_bitcount(width) != 1) { 317 if (proxy) { 318 table->Size = 0; 319 table->IntFormat = (GLenum) 0; 320 table->Format = (GLenum) 0; 321 } 322 else { 323 gl_error(ctx, GL_INVALID_VALUE, "glColorTable(width)"); 324 } 325 return; 326 } 327 328 if (width > ctx->Const.MaxColorTableSize) { 329 if (proxy) { 330 table->Size = 0; 331 table->IntFormat = (GLenum) 0; 332 table->Format = (GLenum) 0; 333 } 334 else { 335 if (width > ctx->Const.MaxColorTableSize) 336 gl_error(ctx, GL_TABLE_TOO_LARGE, "glColorTable(width)"); 337 else 338 gl_error(ctx, GL_INVALID_VALUE, "glColorTable(width)"); 339 } 340 return; 341 } 342 343 table->Size = width; 344 table->IntFormat = internalFormat; 345 table->Format = (GLenum) baseFormat; 346 set_component_sizes(table); 347 348 comps = _mesa_components_in_format(table->Format); 349 assert(comps > 0); /* error should have been caught sooner */ 350 351 if (!proxy) { 352 /* free old table, if any */ 353 if (table->Table) { 354 FREE(table->Table); 355 } 356 if (floatTable) { 357 GLfloat tempTab[MAX_COLOR_TABLE_SIZE * 4]; 358 GLfloat *tableF; 359 GLuint i; 360 361 _mesa_unpack_float_color_span(ctx, width, table->Format, 362 tempTab, /* dest */ 363 format, type, data, &ctx->Unpack, 364 0, GL_FALSE); 365 366 table->FloatTable = GL_TRUE; 367 table->Table = MALLOC(comps * width * sizeof(GLfloat)); 368 if (!table->Table) { 369 gl_error(ctx, GL_OUT_OF_MEMORY, "glColorTable"); 370 return; 371 } 372 373 tableF = (GLfloat *) table->Table; 374 375 switch (table->Format) { 376 case GL_INTENSITY: 377 for (i = 0; i < width; i++) { 378 tableF[i] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F); 379 } 380 break; 381 case GL_LUMINANCE: 382 for (i = 0; i < width; i++) { 383 tableF[i] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F); 384 } 385 break; 386 case GL_ALPHA: 387 for (i = 0; i < width; i++) { 388 tableF[i] = CLAMP(tempTab[i] * aScale + aBias, 0.0F, 1.0F); 389 } 390 break; 391 case GL_LUMINANCE_ALPHA: 392 for (i = 0; i < width; i++) { 393 tableF[i*2+0] = CLAMP(tempTab[i*2+0] * rScale + rBias, 0.0F, 1.0F); 394 tableF[i*2+1] = CLAMP(tempTab[i*2+1] * aScale + aBias, 0.0F, 1.0F); 395 } 396 break; 397 case GL_RGB: 398 for (i = 0; i < width; i++) { 399 tableF[i*3+0] = CLAMP(tempTab[i*3+0] * rScale + rBias, 0.0F, 1.0F); 400 tableF[i*3+1] = CLAMP(tempTab[i*3+1] * gScale + gBias, 0.0F, 1.0F); 401 tableF[i*3+2] = CLAMP(tempTab[i*3+2] * bScale + bBias, 0.0F, 1.0F); 402 } 403 break; 404 case GL_RGBA: 405 for (i = 0; i < width; i++) { 406 tableF[i*4+0] = CLAMP(tempTab[i*4+0] * rScale + rBias, 0.0F, 1.0F); 407 tableF[i*4+1] = CLAMP(tempTab[i*4+1] * gScale + gBias, 0.0F, 1.0F); 408 tableF[i*4+2] = CLAMP(tempTab[i*4+2] * bScale + bBias, 0.0F, 1.0F); 409 tableF[i*4+3] = CLAMP(tempTab[i*4+3] * aScale + aBias, 0.0F, 1.0F); 410 } 411 break; 412 default: 413 gl_problem(ctx, "Bad format in _mesa_ColorTable"); 414 return; 415 } 416 } 417 else { 418 /* store GLchan table */ 419 table->FloatTable = GL_FALSE; 420 table->Table = MALLOC(comps * width * sizeof(GLchan)); 421 if (!table->Table) { 422 gl_error(ctx, GL_OUT_OF_MEMORY, "glColorTable"); 423 return; 424 } 425 _mesa_unpack_chan_color_span(ctx, width, table->Format, 426 table->Table, /* dest */ 427 format, type, data, 428 &ctx->Unpack, 0); 429 } /* floatTable */ 430 } /* proxy */ 431 432 if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) { 433 /* texture object palette, texObj==NULL means the shared palette */ 434 if (ctx->Driver.UpdateTexturePalette) { 435 (*ctx->Driver.UpdateTexturePalette)( ctx, texObj ); 436 } 437 } 438 439 ctx->NewState |= _NEW_PIXEL; 440} 441 442 443 444void 445_mesa_ColorSubTable( GLenum target, GLsizei start, 446 GLsizei count, GLenum format, GLenum type, 447 const GLvoid *data ) 448{ 449 GET_CURRENT_CONTEXT(ctx); 450 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 451 struct gl_texture_object *texObj = NULL; 452 struct gl_color_table *table = NULL; 453 GLfloat rScale = 1.0, gScale = 1.0, bScale = 1.0, aScale = 1.0; 454 GLfloat rBias = 0.0, gBias = 0.0, bBias = 0.0, aBias = 0.0; 455 GLint comps; 456 457 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glColorSubTable"); 458 459 switch (target) { 460 case GL_TEXTURE_1D: 461 texObj = texUnit->Current1D; 462 table = &texObj->Palette; 463 break; 464 case GL_TEXTURE_2D: 465 texObj = texUnit->Current2D; 466 table = &texObj->Palette; 467 break; 468 case GL_TEXTURE_3D: 469 texObj = texUnit->Current3D; 470 table = &texObj->Palette; 471 break; 472 case GL_SHARED_TEXTURE_PALETTE_EXT: 473 table = &ctx->Texture.Palette; 474 break; 475 case GL_COLOR_TABLE: 476 table = &ctx->ColorTable; 477 rScale = ctx->Pixel.ColorTableScale[0]; 478 gScale = ctx->Pixel.ColorTableScale[1]; 479 bScale = ctx->Pixel.ColorTableScale[2]; 480 aScale = ctx->Pixel.ColorTableScale[3]; 481 rBias = ctx->Pixel.ColorTableBias[0]; 482 gBias = ctx->Pixel.ColorTableBias[1]; 483 bBias = ctx->Pixel.ColorTableBias[2]; 484 aBias = ctx->Pixel.ColorTableBias[3]; 485 break; 486 case GL_POST_CONVOLUTION_COLOR_TABLE: 487 table = &ctx->PostConvolutionColorTable; 488 rScale = ctx->Pixel.PCCTscale[0]; 489 gScale = ctx->Pixel.PCCTscale[1]; 490 bScale = ctx->Pixel.PCCTscale[2]; 491 aScale = ctx->Pixel.PCCTscale[3]; 492 rBias = ctx->Pixel.PCCTbias[0]; 493 gBias = ctx->Pixel.PCCTbias[1]; 494 bBias = ctx->Pixel.PCCTbias[2]; 495 aBias = ctx->Pixel.PCCTbias[3]; 496 break; 497 case GL_POST_COLOR_MATRIX_COLOR_TABLE: 498 table = &ctx->PostColorMatrixColorTable; 499 rScale = ctx->Pixel.PCMCTscale[0]; 500 gScale = ctx->Pixel.PCMCTscale[1]; 501 bScale = ctx->Pixel.PCMCTscale[2]; 502 aScale = ctx->Pixel.PCMCTscale[3]; 503 rBias = ctx->Pixel.PCMCTbias[0]; 504 gBias = ctx->Pixel.PCMCTbias[1]; 505 bBias = ctx->Pixel.PCMCTbias[2]; 506 aBias = ctx->Pixel.PCMCTbias[3]; 507 break; 508 default: 509 gl_error(ctx, GL_INVALID_ENUM, "glColorSubTable(target)"); 510 return; 511 } 512 513 assert(table); 514 515 if (!_mesa_is_legal_format_and_type(format, type) || 516 format == GL_INTENSITY) { 517 gl_error(ctx, GL_INVALID_ENUM, "glColorSubTable(format or type)"); 518 return; 519 } 520 521 if (count < 1) { 522 gl_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)"); 523 return; 524 } 525 526 comps = _mesa_components_in_format(table->Format); 527 assert(comps > 0); /* error should have been caught sooner */ 528 529 if (start + count > table->Size) { 530 gl_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)"); 531 return; 532 } 533 534 if (!table->Table) { 535 gl_error(ctx, GL_OUT_OF_MEMORY, "glColorSubTable"); 536 return; 537 } 538 539 if (!table->FloatTable) { 540 GLchan *dest = (GLchan *) table->Table + start * comps * sizeof(GLchan); 541 _mesa_unpack_chan_color_span(ctx, count, table->Format, dest, 542 format, type, data, &ctx->Unpack, 0); 543 } 544 else { 545 GLfloat tempTab[MAX_COLOR_TABLE_SIZE * 4]; 546 GLfloat *tableF; 547 GLuint i; 548 549 ASSERT(table->FloatTable); 550 551 _mesa_unpack_float_color_span(ctx, count, table->Format, 552 tempTab, /* dest */ 553 format, type, data, &ctx->Unpack, 554 0, GL_FALSE); 555 556 tableF = (GLfloat *) table->Table; 557 558 switch (table->Format) { 559 case GL_INTENSITY: 560 for (i = 0; i < count; i++) { 561 GLuint j = start + i; 562 tableF[j] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F); 563 } 564 break; 565 case GL_LUMINANCE: 566 for (i = 0; i < count; i++) { 567 GLuint j = start + i; 568 tableF[j] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F); 569 } 570 break; 571 case GL_ALPHA: 572 for (i = 0; i < count; i++) { 573 GLuint j = start + i; 574 tableF[j] = CLAMP(tempTab[i] * aScale + aBias, 0.0F, 1.0F); 575 } 576 break; 577 case GL_LUMINANCE_ALPHA: 578 for (i = 0; i < count; i++) { 579 GLuint j = start + i; 580 tableF[j*2+0] = CLAMP(tempTab[i*2+0] * rScale + rBias, 0.0F, 1.0F); 581 tableF[j*2+1] = CLAMP(tempTab[i*2+1] * aScale + aBias, 0.0F, 1.0F); 582 } 583 break; 584 case GL_RGB: 585 for (i = 0; i < count; i++) { 586 GLuint j = start + i; 587 tableF[j*3+0] = CLAMP(tempTab[i*3+0] * rScale + rBias, 0.0F, 1.0F); 588 tableF[j*3+1] = CLAMP(tempTab[i*3+1] * gScale + gBias, 0.0F, 1.0F); 589 tableF[j*3+2] = CLAMP(tempTab[i*3+2] * bScale + bBias, 0.0F, 1.0F); 590 } 591 break; 592 case GL_RGBA: 593 for (i = 0; i < count; i++) { 594 GLuint j = start + i; 595 tableF[j*4+0] = CLAMP(tempTab[i*4+0] * rScale + rBias, 0.0F, 1.0F); 596 tableF[j*4+1] = CLAMP(tempTab[i*4+1] * gScale + gBias, 0.0F, 1.0F); 597 tableF[j*4+2] = CLAMP(tempTab[i*4+2] * bScale + bBias, 0.0F, 1.0F); 598 tableF[j*4+3] = CLAMP(tempTab[i*4+3] * aScale + aBias, 0.0F, 1.0F); 599 } 600 break; 601 default: 602 gl_problem(ctx, "Bad format in _mesa_ColorSubTable"); 603 return; 604 } 605 } 606 607 if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) { 608 /* per-texture object palette */ 609 if (ctx->Driver.UpdateTexturePalette) { 610 (*ctx->Driver.UpdateTexturePalette)( ctx, texObj ); 611 } 612 } 613 614 ctx->NewState |= _NEW_PIXEL; 615} 616 617 618 619/* XXX not tested */ 620void 621_mesa_CopyColorTable(GLenum target, GLenum internalformat, 622 GLint x, GLint y, GLsizei width) 623{ 624 GLchan data[MAX_WIDTH][4]; 625 GET_CURRENT_CONTEXT(ctx); 626 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyColorTable"); 627 628 /* Select buffer to read from */ 629 (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer, 630 ctx->Pixel.DriverReadBuffer ); 631 632 if (width > MAX_WIDTH) 633 width = MAX_WIDTH; 634 635 /* read the data from framebuffer */ 636 RENDER_START(ctx); 637 gl_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y, data ); 638 RENDER_FINISH(ctx); 639 640 /* Restore reading from draw buffer (the default) */ 641 (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, 642 ctx->Color.DriverDrawBuffer ); 643 644 _mesa_ColorTable(target, internalformat, width, 645 GL_RGBA, GL_UNSIGNED_BYTE, data); 646} 647 648 649 650/* XXX not tested */ 651void 652_mesa_CopyColorSubTable(GLenum target, GLsizei start, 653 GLint x, GLint y, GLsizei width) 654{ 655 GLchan data[MAX_WIDTH][4]; 656 GET_CURRENT_CONTEXT(ctx); 657 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyColorSubTable"); 658 659 /* Select buffer to read from */ 660 (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer, 661 ctx->Pixel.DriverReadBuffer ); 662 663 if (width > MAX_WIDTH) 664 width = MAX_WIDTH; 665 666 /* read the data from framebuffer */ 667 RENDER_START(ctx); 668 gl_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y, data ); 669 RENDER_FINISH(ctx); 670 671 /* Restore reading from draw buffer (the default) */ 672 (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, 673 ctx->Color.DriverDrawBuffer ); 674 675 _mesa_ColorSubTable(target, start, width, GL_RGBA, GL_UNSIGNED_BYTE, data); 676} 677 678 679 680void 681_mesa_GetColorTable( GLenum target, GLenum format, 682 GLenum type, GLvoid *data ) 683{ 684 GET_CURRENT_CONTEXT(ctx); 685 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 686 struct gl_color_table *table = NULL; 687 GLchan rgba[MAX_COLOR_TABLE_SIZE][4]; 688 GLint i; 689 690 ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTable"); 691 692 switch (target) { 693 case GL_TEXTURE_1D: 694 table = &texUnit->Current1D->Palette; 695 break; 696 case GL_TEXTURE_2D: 697 table = &texUnit->Current2D->Palette; 698 break; 699 case GL_TEXTURE_3D: 700 table = &texUnit->Current3D->Palette; 701 break; 702 case GL_SHARED_TEXTURE_PALETTE_EXT: 703 table = &ctx->Texture.Palette; 704 break; 705 case GL_COLOR_TABLE: 706 table = &ctx->ColorTable; 707 break; 708 case GL_POST_CONVOLUTION_COLOR_TABLE: 709 table = &ctx->PostConvolutionColorTable; 710 break; 711 case GL_POST_COLOR_MATRIX_COLOR_TABLE: 712 table = &ctx->PostColorMatrixColorTable; 713 break; 714 default: 715 gl_error(ctx, GL_INVALID_ENUM, "glGetColorTable(target)"); 716 return; 717 } 718 719 assert(table); 720 721 switch (table->Format) { 722 case GL_ALPHA: 723 if (table->FloatTable) { 724 const GLfloat *tableF = (const GLfloat *) table->Table; 725 for (i = 0; i < table->Size; i++) { 726 rgba[i][RCOMP] = 0; 727 rgba[i][GCOMP] = 0; 728 rgba[i][BCOMP] = 0; 729 rgba[i][ACOMP] = (GLint) (tableF[i] * CHAN_MAXF); 730 } 731 } 732 else { 733 const GLchan *tableUB = (const GLchan *) table->Table; 734 for (i = 0; i < table->Size; i++) { 735 rgba[i][RCOMP] = 0; 736 rgba[i][GCOMP] = 0; 737 rgba[i][BCOMP] = 0; 738 rgba[i][ACOMP] = tableUB[i]; 739 } 740 } 741 break; 742 case GL_LUMINANCE: 743 if (table->FloatTable) { 744 const GLfloat *tableF = (const GLfloat *) table->Table; 745 for (i = 0; i < table->Size; i++) { 746 rgba[i][RCOMP] = (GLint) (tableF[i] * CHAN_MAXF); 747 rgba[i][GCOMP] = (GLint) (tableF[i] * CHAN_MAXF); 748 rgba[i][BCOMP] = (GLint) (tableF[i] * CHAN_MAXF); 749 rgba[i][ACOMP] = CHAN_MAX; 750 } 751 } 752 else { 753 const GLchan *tableUB = (const GLchan *) table->Table; 754 for (i = 0; i < table->Size; i++) { 755 rgba[i][RCOMP] = tableUB[i]; 756 rgba[i][GCOMP] = tableUB[i]; 757 rgba[i][BCOMP] = tableUB[i]; 758 rgba[i][ACOMP] = CHAN_MAX; 759 } 760 } 761 break; 762 case GL_LUMINANCE_ALPHA: 763 if (table->FloatTable) { 764 const GLfloat *tableF = (const GLfloat *) table->Table; 765 for (i = 0; i < table->Size; i++) { 766 rgba[i][RCOMP] = (GLint) (tableF[i*2+0] * CHAN_MAXF); 767 rgba[i][GCOMP] = (GLint) (tableF[i*2+0] * CHAN_MAXF); 768 rgba[i][BCOMP] = (GLint) (tableF[i*2+0] * CHAN_MAXF); 769 rgba[i][ACOMP] = (GLint) (tableF[i*2+1] * CHAN_MAXF); 770 } 771 } 772 else { 773 const GLchan *tableUB = (const GLchan *) table->Table; 774 for (i = 0; i < table->Size; i++) { 775 rgba[i][RCOMP] = tableUB[i*2+0]; 776 rgba[i][GCOMP] = tableUB[i*2+0]; 777 rgba[i][BCOMP] = tableUB[i*2+0]; 778 rgba[i][ACOMP] = tableUB[i*2+1]; 779 } 780 } 781 break; 782 case GL_INTENSITY: 783 if (table->FloatTable) { 784 const GLfloat *tableF = (const GLfloat *) table->Table; 785 for (i = 0; i < table->Size; i++) { 786 rgba[i][RCOMP] = (GLint) (tableF[i] * CHAN_MAXF); 787 rgba[i][GCOMP] = (GLint) (tableF[i] * CHAN_MAXF); 788 rgba[i][BCOMP] = (GLint) (tableF[i] * CHAN_MAXF); 789 rgba[i][ACOMP] = (GLint) (tableF[i] * CHAN_MAXF); 790 } 791 } 792 else { 793 const GLchan *tableUB = (const GLchan *) table->Table; 794 for (i = 0; i < table->Size; i++) { 795 rgba[i][RCOMP] = tableUB[i]; 796 rgba[i][GCOMP] = tableUB[i]; 797 rgba[i][BCOMP] = tableUB[i]; 798 rgba[i][ACOMP] = tableUB[i]; 799 } 800 } 801 break; 802 case GL_RGB: 803 if (table->FloatTable) { 804 const GLfloat *tableF = (const GLfloat *) table->Table; 805 for (i = 0; i < table->Size; i++) { 806 rgba[i][RCOMP] = (GLint) (tableF[i*3+0] * CHAN_MAXF); 807 rgba[i][GCOMP] = (GLint) (tableF[i*3+1] * CHAN_MAXF); 808 rgba[i][BCOMP] = (GLint) (tableF[i*3+2] * CHAN_MAXF); 809 rgba[i][ACOMP] = CHAN_MAX; 810 } 811 } 812 else { 813 const GLchan *tableUB = (const GLchan *) table->Table; 814 for (i = 0; i < table->Size; i++) { 815 rgba[i][RCOMP] = tableUB[i*3+0]; 816 rgba[i][GCOMP] = tableUB[i*3+1]; 817 rgba[i][BCOMP] = tableUB[i*3+2]; 818 rgba[i][ACOMP] = CHAN_MAX; 819 } 820 } 821 break; 822 case GL_RGBA: 823 if (table->FloatTable) { 824 const GLfloat *tableF = (const GLfloat *) table->Table; 825 for (i = 0; i < table->Size; i++) { 826 rgba[i][RCOMP] = (GLint) (tableF[i*4+0] * CHAN_MAXF + 0.5F); 827 rgba[i][GCOMP] = (GLint) (tableF[i*4+1] * CHAN_MAXF + 0.5F); 828 rgba[i][BCOMP] = (GLint) (tableF[i*4+2] * CHAN_MAXF + 0.5F); 829 rgba[i][ACOMP] = (GLint) (tableF[i*4+3] * CHAN_MAXF + 0.5F); 830 } 831 } 832 else { 833 const GLchan *tableUB = (const GLchan *) table->Table; 834 for (i = 0; i < table->Size; i++) { 835 rgba[i][RCOMP] = tableUB[i*4+0]; 836 rgba[i][GCOMP] = tableUB[i*4+1]; 837 rgba[i][BCOMP] = tableUB[i*4+2]; 838 rgba[i][ACOMP] = tableUB[i*4+3]; 839 } 840 } 841 break; 842 default: 843 gl_problem(ctx, "bad table format in glGetColorTable"); 844 return; 845 } 846 847 _mesa_pack_rgba_span(ctx, table->Size, (const GLchan (*)[]) rgba, 848 format, type, data, &ctx->Pack, GL_FALSE); 849} 850 851 852 853void 854_mesa_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params) 855{ 856 GET_CURRENT_CONTEXT(ctx); 857 ASSERT_OUTSIDE_BEGIN_END(ctx, "glColorTableParameterfv"); 858 859 switch (target) { 860 case GL_COLOR_TABLE_SGI: 861 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 862 ctx->Pixel.ColorTableScale[0] = params[0]; 863 ctx->Pixel.ColorTableScale[1] = params[1]; 864 ctx->Pixel.ColorTableScale[2] = params[2]; 865 ctx->Pixel.ColorTableScale[3] = params[3]; 866 } 867 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 868 ctx->Pixel.ColorTableBias[0] = params[0]; 869 ctx->Pixel.ColorTableBias[1] = params[1]; 870 ctx->Pixel.ColorTableBias[2] = params[2]; 871 ctx->Pixel.ColorTableBias[3] = params[3]; 872 } 873 else { 874 gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)"); 875 return; 876 } 877 break; 878 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI: 879 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 880 ctx->Pixel.PCCTscale[0] = params[0]; 881 ctx->Pixel.PCCTscale[1] = params[1]; 882 ctx->Pixel.PCCTscale[2] = params[2]; 883 ctx->Pixel.PCCTscale[3] = params[3]; 884 } 885 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 886 ctx->Pixel.PCCTbias[0] = params[0]; 887 ctx->Pixel.PCCTbias[1] = params[1]; 888 ctx->Pixel.PCCTbias[2] = params[2]; 889 ctx->Pixel.PCCTbias[3] = params[3]; 890 } 891 else { 892 gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)"); 893 return; 894 } 895 break; 896 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI: 897 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 898 ctx->Pixel.PCMCTscale[0] = params[0]; 899 ctx->Pixel.PCMCTscale[1] = params[1]; 900 ctx->Pixel.PCMCTscale[2] = params[2]; 901 ctx->Pixel.PCMCTscale[3] = params[3]; 902 } 903 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 904 ctx->Pixel.PCMCTbias[0] = params[0]; 905 ctx->Pixel.PCMCTbias[1] = params[1]; 906 ctx->Pixel.PCMCTbias[2] = params[2]; 907 ctx->Pixel.PCMCTbias[3] = params[3]; 908 } 909 else { 910 gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)"); 911 return; 912 } 913 break; 914 default: 915 gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameter(target)"); 916 return; 917 } 918 919 ctx->NewState |= _NEW_PIXEL; 920} 921 922 923 924void 925_mesa_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params) 926{ 927 GLfloat fparams[4]; 928 if (pname == GL_COLOR_TABLE_SGI || 929 pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI || 930 pname == GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI) { 931 /* four values */ 932 fparams[0] = (GLfloat) params[0]; 933 fparams[1] = (GLfloat) params[1]; 934 fparams[2] = (GLfloat) params[2]; 935 fparams[3] = (GLfloat) params[3]; 936 } 937 else { 938 /* one values */ 939 fparams[0] = (GLfloat) params[0]; 940 } 941 _mesa_ColorTableParameterfv(target, pname, fparams); 942} 943 944 945 946void 947_mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params ) 948{ 949 GET_CURRENT_CONTEXT(ctx); 950 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 951 struct gl_color_table *table = NULL; 952 953 ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTableParameterfv"); 954 955 switch (target) { 956 case GL_TEXTURE_1D: 957 table = &texUnit->Current1D->Palette; 958 break; 959 case GL_TEXTURE_2D: 960 table = &texUnit->Current2D->Palette; 961 break; 962 case GL_TEXTURE_3D: 963 table = &texUnit->Current3D->Palette; 964 break; 965 case GL_PROXY_TEXTURE_1D: 966 table = &ctx->Texture.Proxy1D->Palette; 967 break; 968 case GL_PROXY_TEXTURE_2D: 969 table = &ctx->Texture.Proxy2D->Palette; 970 break; 971 case GL_PROXY_TEXTURE_3D: 972 table = &ctx->Texture.Proxy3D->Palette; 973 break; 974 case GL_SHARED_TEXTURE_PALETTE_EXT: 975 table = &ctx->Texture.Palette; 976 break; 977 case GL_COLOR_TABLE: 978 table = &ctx->ColorTable; 979 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 980 params[0] = ctx->Pixel.ColorTableScale[0]; 981 params[1] = ctx->Pixel.ColorTableScale[1]; 982 params[2] = ctx->Pixel.ColorTableScale[2]; 983 params[3] = ctx->Pixel.ColorTableScale[3]; 984 return; 985 } 986 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 987 params[0] = ctx->Pixel.ColorTableBias[0]; 988 params[1] = ctx->Pixel.ColorTableBias[1]; 989 params[2] = ctx->Pixel.ColorTableBias[2]; 990 params[3] = ctx->Pixel.ColorTableBias[3]; 991 return; 992 } 993 break; 994 case GL_PROXY_COLOR_TABLE: 995 table = &ctx->ProxyColorTable; 996 break; 997 case GL_POST_CONVOLUTION_COLOR_TABLE: 998 table = &ctx->PostConvolutionColorTable; 999 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 1000 params[0] = ctx->Pixel.PCCTscale[0]; 1001 params[1] = ctx->Pixel.PCCTscale[1]; 1002 params[2] = ctx->Pixel.PCCTscale[2]; 1003 params[3] = ctx->Pixel.PCCTscale[3]; 1004 return; 1005 } 1006 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 1007 params[0] = ctx->Pixel.PCCTbias[0]; 1008 params[1] = ctx->Pixel.PCCTbias[1]; 1009 params[2] = ctx->Pixel.PCCTbias[2]; 1010 params[3] = ctx->Pixel.PCCTbias[3]; 1011 return; 1012 } 1013 break; 1014 case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE: 1015 table = &ctx->ProxyPostConvolutionColorTable; 1016 break; 1017 case GL_POST_COLOR_MATRIX_COLOR_TABLE: 1018 table = &ctx->PostColorMatrixColorTable; 1019 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 1020 params[0] = ctx->Pixel.PCMCTscale[0]; 1021 params[1] = ctx->Pixel.PCMCTscale[1]; 1022 params[2] = ctx->Pixel.PCMCTscale[2]; 1023 params[3] = ctx->Pixel.PCMCTscale[3]; 1024 return; 1025 } 1026 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 1027 params[0] = ctx->Pixel.PCMCTbias[0]; 1028 params[1] = ctx->Pixel.PCMCTbias[1]; 1029 params[2] = ctx->Pixel.PCMCTbias[2]; 1030 params[3] = ctx->Pixel.PCMCTbias[3]; 1031 return; 1032 } 1033 break; 1034 case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE: 1035 table = &ctx->ProxyPostColorMatrixColorTable; 1036 break; 1037 default: 1038 gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(target)"); 1039 return; 1040 } 1041 1042 assert(table); 1043 1044 switch (pname) { 1045 case GL_COLOR_TABLE_FORMAT: 1046 *params = table->IntFormat; 1047 break; 1048 case GL_COLOR_TABLE_WIDTH: 1049 *params = table->Size; 1050 break; 1051 case GL_COLOR_TABLE_RED_SIZE: 1052 *params = table->RedSize; 1053 break; 1054 case GL_COLOR_TABLE_GREEN_SIZE: 1055 *params = table->GreenSize; 1056 break; 1057 case GL_COLOR_TABLE_BLUE_SIZE: 1058 *params = table->BlueSize; 1059 break; 1060 case GL_COLOR_TABLE_ALPHA_SIZE: 1061 *params = table->AlphaSize; 1062 break; 1063 case GL_COLOR_TABLE_LUMINANCE_SIZE: 1064 *params = table->LuminanceSize; 1065 break; 1066 case GL_COLOR_TABLE_INTENSITY_SIZE: 1067 *params = table->IntensitySize; 1068 break; 1069 default: 1070 gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(pname)" ); 1071 return; 1072 } 1073} 1074 1075 1076 1077void 1078_mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params ) 1079{ 1080 GET_CURRENT_CONTEXT(ctx); 1081 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 1082 struct gl_color_table *table = NULL; 1083 1084 ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTableParameteriv"); 1085 1086 switch (target) { 1087 case GL_TEXTURE_1D: 1088 table = &texUnit->Current1D->Palette; 1089 break; 1090 case GL_TEXTURE_2D: 1091 table = &texUnit->Current2D->Palette; 1092 break; 1093 case GL_TEXTURE_3D: 1094 table = &texUnit->Current3D->Palette; 1095 break; 1096 case GL_PROXY_TEXTURE_1D: 1097 table = &ctx->Texture.Proxy1D->Palette; 1098 break; 1099 case GL_PROXY_TEXTURE_2D: 1100 table = &ctx->Texture.Proxy2D->Palette; 1101 break; 1102 case GL_PROXY_TEXTURE_3D: 1103 table = &ctx->Texture.Proxy3D->Palette; 1104 break; 1105 case GL_SHARED_TEXTURE_PALETTE_EXT: 1106 table = &ctx->Texture.Palette; 1107 break; 1108 case GL_COLOR_TABLE: 1109 table = &ctx->ColorTable; 1110 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 1111 params[0] = (GLint) ctx->Pixel.ColorTableScale[0]; 1112 params[1] = (GLint) ctx->Pixel.ColorTableScale[1]; 1113 params[2] = (GLint) ctx->Pixel.ColorTableScale[2]; 1114 params[3] = (GLint) ctx->Pixel.ColorTableScale[3]; 1115 return; 1116 } 1117 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 1118 params[0] = (GLint) ctx->Pixel.ColorTableBias[0]; 1119 params[1] = (GLint) ctx->Pixel.ColorTableBias[1]; 1120 params[2] = (GLint) ctx->Pixel.ColorTableBias[2]; 1121 params[3] = (GLint) ctx->Pixel.ColorTableBias[3]; 1122 return; 1123 } 1124 break; 1125 case GL_PROXY_COLOR_TABLE: 1126 table = &ctx->ProxyColorTable; 1127 break; 1128 case GL_POST_CONVOLUTION_COLOR_TABLE: 1129 table = &ctx->PostConvolutionColorTable; 1130 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 1131 params[0] = (GLint) ctx->Pixel.PCCTscale[0]; 1132 params[1] = (GLint) ctx->Pixel.PCCTscale[1]; 1133 params[2] = (GLint) ctx->Pixel.PCCTscale[2]; 1134 params[3] = (GLint) ctx->Pixel.PCCTscale[3]; 1135 return; 1136 } 1137 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 1138 params[0] = (GLint) ctx->Pixel.PCCTbias[0]; 1139 params[1] = (GLint) ctx->Pixel.PCCTbias[1]; 1140 params[2] = (GLint) ctx->Pixel.PCCTbias[2]; 1141 params[3] = (GLint) ctx->Pixel.PCCTbias[3]; 1142 return; 1143 } 1144 break; 1145 case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE: 1146 table = &ctx->ProxyPostConvolutionColorTable; 1147 break; 1148 case GL_POST_COLOR_MATRIX_COLOR_TABLE: 1149 table = &ctx->PostColorMatrixColorTable; 1150 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 1151 params[0] = (GLint) ctx->Pixel.PCMCTscale[0]; 1152 params[1] = (GLint) ctx->Pixel.PCMCTscale[1]; 1153 params[2] = (GLint) ctx->Pixel.PCMCTscale[2]; 1154 params[3] = (GLint) ctx->Pixel.PCMCTscale[3]; 1155 return; 1156 } 1157 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 1158 params[0] = (GLint) ctx->Pixel.PCMCTbias[0]; 1159 params[1] = (GLint) ctx->Pixel.PCMCTbias[1]; 1160 params[2] = (GLint) ctx->Pixel.PCMCTbias[2]; 1161 params[3] = (GLint) ctx->Pixel.PCMCTbias[3]; 1162 return; 1163 } 1164 break; 1165 case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE: 1166 table = &ctx->ProxyPostColorMatrixColorTable; 1167 break; 1168 default: 1169 gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(target)"); 1170 return; 1171 } 1172 1173 assert(table); 1174 1175 switch (pname) { 1176 case GL_COLOR_TABLE_FORMAT: 1177 *params = table->IntFormat; 1178 break; 1179 case GL_COLOR_TABLE_WIDTH: 1180 *params = table->Size; 1181 break; 1182 case GL_COLOR_TABLE_RED_SIZE: 1183 *params = table->RedSize; 1184 break; 1185 case GL_COLOR_TABLE_GREEN_SIZE: 1186 *params = table->GreenSize; 1187 break; 1188 case GL_COLOR_TABLE_BLUE_SIZE: 1189 *params = table->BlueSize; 1190 break; 1191 case GL_COLOR_TABLE_ALPHA_SIZE: 1192 *params = table->AlphaSize; 1193 break; 1194 case GL_COLOR_TABLE_LUMINANCE_SIZE: 1195 *params = table->LuminanceSize; 1196 break; 1197 case GL_COLOR_TABLE_INTENSITY_SIZE: 1198 *params = table->IntensitySize; 1199 break; 1200 default: 1201 gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(pname)" ); 1202 return; 1203 } 1204} 1205