colortab.c revision 4e9676fb13f60ecdbc247b120031f18cd3febcb0
1/* $Id: colortab.c,v 1.44 2002/06/29 19:48:15 brianp Exp $ */ 2 3/* 4 * Mesa 3-D graphics library 5 * Version: 4.1 6 * 7 * Copyright (C) 1999-2002 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 "state.h" 39#include "swrast/s_span.h" /* XXX SWRAST hack */ 40#endif 41 42 43 44/* 45 * Given an internalFormat token passed to glColorTable, 46 * return the corresponding base format. 47 * Return -1 if invalid token. 48 */ 49static GLint 50base_colortab_format( GLenum format ) 51{ 52 switch (format) { 53 case GL_ALPHA: 54 case GL_ALPHA4: 55 case GL_ALPHA8: 56 case GL_ALPHA12: 57 case GL_ALPHA16: 58 return GL_ALPHA; 59 case GL_LUMINANCE: 60 case GL_LUMINANCE4: 61 case GL_LUMINANCE8: 62 case GL_LUMINANCE12: 63 case GL_LUMINANCE16: 64 return GL_LUMINANCE; 65 case GL_LUMINANCE_ALPHA: 66 case GL_LUMINANCE4_ALPHA4: 67 case GL_LUMINANCE6_ALPHA2: 68 case GL_LUMINANCE8_ALPHA8: 69 case GL_LUMINANCE12_ALPHA4: 70 case GL_LUMINANCE12_ALPHA12: 71 case GL_LUMINANCE16_ALPHA16: 72 return GL_LUMINANCE_ALPHA; 73 case GL_INTENSITY: 74 case GL_INTENSITY4: 75 case GL_INTENSITY8: 76 case GL_INTENSITY12: 77 case GL_INTENSITY16: 78 return GL_INTENSITY; 79 case GL_RGB: 80 case GL_R3_G3_B2: 81 case GL_RGB4: 82 case GL_RGB5: 83 case GL_RGB8: 84 case GL_RGB10: 85 case GL_RGB12: 86 case GL_RGB16: 87 return GL_RGB; 88 case GL_RGBA: 89 case GL_RGBA2: 90 case GL_RGBA4: 91 case GL_RGB5_A1: 92 case GL_RGBA8: 93 case GL_RGB10_A2: 94 case GL_RGBA12: 95 case GL_RGBA16: 96 return GL_RGBA; 97 default: 98 return -1; /* error */ 99 } 100} 101 102 103void 104_mesa_init_colortable( struct gl_color_table *p ) 105{ 106 p->FloatTable = GL_FALSE; 107 p->Table = NULL; 108 p->Size = 0; 109 p->IntFormat = GL_RGBA; 110} 111 112 113 114void 115_mesa_free_colortable_data( struct gl_color_table *p ) 116{ 117 if (p->Table) { 118 FREE(p->Table); 119 p->Table = NULL; 120 } 121} 122 123 124/* 125 * Examine table's format and set the component sizes accordingly. 126 */ 127static void 128set_component_sizes( struct gl_color_table *table ) 129{ 130 switch (table->Format) { 131 case GL_ALPHA: 132 table->RedSize = 0; 133 table->GreenSize = 0; 134 table->BlueSize = 0; 135 table->AlphaSize = CHAN_BITS; 136 table->IntensitySize = 0; 137 table->LuminanceSize = 0; 138 break; 139 case GL_LUMINANCE: 140 table->RedSize = 0; 141 table->GreenSize = 0; 142 table->BlueSize = 0; 143 table->AlphaSize = 0; 144 table->IntensitySize = 0; 145 table->LuminanceSize = CHAN_BITS; 146 break; 147 case GL_LUMINANCE_ALPHA: 148 table->RedSize = 0; 149 table->GreenSize = 0; 150 table->BlueSize = 0; 151 table->AlphaSize = CHAN_BITS; 152 table->IntensitySize = 0; 153 table->LuminanceSize = CHAN_BITS; 154 break; 155 case GL_INTENSITY: 156 table->RedSize = 0; 157 table->GreenSize = 0; 158 table->BlueSize = 0; 159 table->AlphaSize = 0; 160 table->IntensitySize = CHAN_BITS; 161 table->LuminanceSize = 0; 162 break; 163 case GL_RGB: 164 table->RedSize = CHAN_BITS; 165 table->GreenSize = CHAN_BITS; 166 table->BlueSize = CHAN_BITS; 167 table->AlphaSize = 0; 168 table->IntensitySize = 0; 169 table->LuminanceSize = 0; 170 break; 171 case GL_RGBA: 172 table->RedSize = CHAN_BITS; 173 table->GreenSize = CHAN_BITS; 174 table->BlueSize = CHAN_BITS; 175 table->AlphaSize = CHAN_BITS; 176 table->IntensitySize = 0; 177 table->LuminanceSize = 0; 178 break; 179 default: 180 _mesa_problem(NULL, "unexpected format in set_component_sizes"); 181 } 182} 183 184 185 186void 187_mesa_ColorTable( GLenum target, GLenum internalFormat, 188 GLsizei width, GLenum format, GLenum type, 189 const GLvoid *data ) 190{ 191 GET_CURRENT_CONTEXT(ctx); 192 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 193 struct gl_texture_object *texObj = NULL; 194 struct gl_color_table *table = NULL; 195 GLboolean proxy = GL_FALSE; 196 GLint baseFormat; 197 GLfloat rScale = 1.0, gScale = 1.0, bScale = 1.0, aScale = 1.0; 198 GLfloat rBias = 0.0, gBias = 0.0, bBias = 0.0, aBias = 0.0; 199 GLboolean floatTable = GL_FALSE; 200 GLint comps; 201 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* too complex */ 202 203 switch (target) { 204 case GL_TEXTURE_1D: 205 texObj = texUnit->Current1D; 206 table = &texObj->Palette; 207 break; 208 case GL_TEXTURE_2D: 209 texObj = texUnit->Current2D; 210 table = &texObj->Palette; 211 break; 212 case GL_TEXTURE_3D: 213 texObj = texUnit->Current3D; 214 table = &texObj->Palette; 215 break; 216 case GL_TEXTURE_CUBE_MAP_ARB: 217 if (!ctx->Extensions.ARB_texture_cube_map) { 218 _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)"); 219 return; 220 } 221 texObj = texUnit->CurrentCubeMap; 222 table = &texObj->Palette; 223 break; 224 case GL_PROXY_TEXTURE_1D: 225 texObj = ctx->Texture.Proxy1D; 226 table = &texObj->Palette; 227 proxy = GL_TRUE; 228 break; 229 case GL_PROXY_TEXTURE_2D: 230 texObj = ctx->Texture.Proxy2D; 231 table = &texObj->Palette; 232 proxy = GL_TRUE; 233 break; 234 case GL_PROXY_TEXTURE_3D: 235 texObj = ctx->Texture.Proxy3D; 236 table = &texObj->Palette; 237 proxy = GL_TRUE; 238 break; 239 case GL_PROXY_TEXTURE_CUBE_MAP_ARB: 240 if (!ctx->Extensions.ARB_texture_cube_map) { 241 _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)"); 242 return; 243 } 244 texObj = ctx->Texture.ProxyCubeMap; 245 table = &texObj->Palette; 246 break; 247 case GL_SHARED_TEXTURE_PALETTE_EXT: 248 table = &ctx->Texture.Palette; 249 break; 250 case GL_COLOR_TABLE: 251 table = &ctx->ColorTable; 252 floatTable = GL_TRUE; 253 rScale = ctx->Pixel.ColorTableScale[0]; 254 gScale = ctx->Pixel.ColorTableScale[1]; 255 bScale = ctx->Pixel.ColorTableScale[2]; 256 aScale = ctx->Pixel.ColorTableScale[3]; 257 rBias = ctx->Pixel.ColorTableBias[0]; 258 gBias = ctx->Pixel.ColorTableBias[1]; 259 bBias = ctx->Pixel.ColorTableBias[2]; 260 aBias = ctx->Pixel.ColorTableBias[3]; 261 break; 262 case GL_PROXY_COLOR_TABLE: 263 table = &ctx->ProxyColorTable; 264 proxy = GL_TRUE; 265 break; 266 case GL_POST_CONVOLUTION_COLOR_TABLE: 267 table = &ctx->PostConvolutionColorTable; 268 floatTable = GL_TRUE; 269 rScale = ctx->Pixel.PCCTscale[0]; 270 gScale = ctx->Pixel.PCCTscale[1]; 271 bScale = ctx->Pixel.PCCTscale[2]; 272 aScale = ctx->Pixel.PCCTscale[3]; 273 rBias = ctx->Pixel.PCCTbias[0]; 274 gBias = ctx->Pixel.PCCTbias[1]; 275 bBias = ctx->Pixel.PCCTbias[2]; 276 aBias = ctx->Pixel.PCCTbias[3]; 277 break; 278 case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE: 279 table = &ctx->ProxyPostConvolutionColorTable; 280 proxy = GL_TRUE; 281 break; 282 case GL_POST_COLOR_MATRIX_COLOR_TABLE: 283 table = &ctx->PostColorMatrixColorTable; 284 floatTable = GL_TRUE; 285 rScale = ctx->Pixel.PCMCTscale[0]; 286 gScale = ctx->Pixel.PCMCTscale[1]; 287 bScale = ctx->Pixel.PCMCTscale[2]; 288 aScale = ctx->Pixel.PCMCTscale[3]; 289 rBias = ctx->Pixel.PCMCTbias[0]; 290 gBias = ctx->Pixel.PCMCTbias[1]; 291 bBias = ctx->Pixel.PCMCTbias[2]; 292 aBias = ctx->Pixel.PCMCTbias[3]; 293 break; 294 case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE: 295 table = &ctx->ProxyPostColorMatrixColorTable; 296 proxy = GL_TRUE; 297 break; 298 default: 299 _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)"); 300 return; 301 } 302 303 assert(table); 304 305 if (!_mesa_is_legal_format_and_type(format, type) || 306 format == GL_INTENSITY) { 307 _mesa_error(ctx, GL_INVALID_OPERATION, "glColorTable(format or type)"); 308 return; 309 } 310 311 baseFormat = base_colortab_format(internalFormat); 312 if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) { 313 _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(internalFormat)"); 314 return; 315 } 316 317 if (width < 0 || (width != 0 && _mesa_bitcount(width) != 1)) { 318 /* error */ 319 if (proxy) { 320 table->Size = 0; 321 table->IntFormat = (GLenum) 0; 322 table->Format = (GLenum) 0; 323 } 324 else { 325 _mesa_error(ctx, GL_INVALID_VALUE, "glColorTable(width=%d)", width); 326 } 327 return; 328 } 329 330 if (width > (GLsizei) ctx->Const.MaxColorTableSize) { 331 if (proxy) { 332 table->Size = 0; 333 table->IntFormat = (GLenum) 0; 334 table->Format = (GLenum) 0; 335 } 336 else { 337 _mesa_error(ctx, GL_TABLE_TOO_LARGE, "glColorTable(width)"); 338 } 339 return; 340 } 341 342 table->Size = width; 343 table->IntFormat = internalFormat; 344 table->Format = (GLenum) baseFormat; 345 set_component_sizes(table); 346 347 comps = _mesa_components_in_format(table->Format); 348 assert(comps > 0); /* error should have been caught sooner */ 349 350 if (!proxy) { 351 /* free old table, if any */ 352 if (table->Table) { 353 FREE(table->Table); 354 table->Table = NULL; 355 } 356 if (width > 0) { 357 if (floatTable) { 358 GLfloat tempTab[MAX_COLOR_TABLE_SIZE * 4]; 359 GLfloat *tableF; 360 GLint i; 361 362 _mesa_unpack_float_color_span(ctx, width, table->Format, 363 tempTab, /* dest */ 364 format, type, data, &ctx->Unpack, 365 0, GL_FALSE); 366 367 table->FloatTable = GL_TRUE; 368 table->Table = MALLOC(comps * width * sizeof(GLfloat)); 369 if (!table->Table) { 370 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glColorTable"); 371 return; 372 } 373 374 tableF = (GLfloat *) table->Table; 375 376 switch (table->Format) { 377 case GL_INTENSITY: 378 for (i = 0; i < width; i++) { 379 tableF[i] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F); 380 } 381 break; 382 case GL_LUMINANCE: 383 for (i = 0; i < width; i++) { 384 tableF[i] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F); 385 } 386 break; 387 case GL_ALPHA: 388 for (i = 0; i < width; i++) { 389 tableF[i] = CLAMP(tempTab[i] * aScale + aBias, 0.0F, 1.0F); 390 } 391 break; 392 case GL_LUMINANCE_ALPHA: 393 for (i = 0; i < width; i++) { 394 tableF[i*2+0] = CLAMP(tempTab[i*2+0] * rScale + rBias, 0.0F, 1.0F); 395 tableF[i*2+1] = CLAMP(tempTab[i*2+1] * aScale + aBias, 0.0F, 1.0F); 396 } 397 break; 398 case GL_RGB: 399 for (i = 0; i < width; i++) { 400 tableF[i*3+0] = CLAMP(tempTab[i*3+0] * rScale + rBias, 0.0F, 1.0F); 401 tableF[i*3+1] = CLAMP(tempTab[i*3+1] * gScale + gBias, 0.0F, 1.0F); 402 tableF[i*3+2] = CLAMP(tempTab[i*3+2] * bScale + bBias, 0.0F, 1.0F); 403 } 404 break; 405 case GL_RGBA: 406 for (i = 0; i < width; i++) { 407 tableF[i*4+0] = CLAMP(tempTab[i*4+0] * rScale + rBias, 0.0F, 1.0F); 408 tableF[i*4+1] = CLAMP(tempTab[i*4+1] * gScale + gBias, 0.0F, 1.0F); 409 tableF[i*4+2] = CLAMP(tempTab[i*4+2] * bScale + bBias, 0.0F, 1.0F); 410 tableF[i*4+3] = CLAMP(tempTab[i*4+3] * aScale + aBias, 0.0F, 1.0F); 411 } 412 break; 413 default: 414 _mesa_problem(ctx, "Bad format in _mesa_ColorTable"); 415 return; 416 } 417 } 418 else { 419 /* store GLchan table */ 420 table->FloatTable = GL_FALSE; 421 table->Table = MALLOC(comps * width * sizeof(GLchan)); 422 if (!table->Table) { 423 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glColorTable"); 424 return; 425 } 426 _mesa_unpack_chan_color_span(ctx, width, table->Format, 427 (GLchan *) table->Table, /* dest */ 428 format, type, data, 429 &ctx->Unpack, 0); 430 } /* floatTable */ 431 } /* width > 0 */ 432 } /* proxy */ 433 434 if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) { 435 /* texture object palette, texObj==NULL means the shared palette */ 436 if (ctx->Driver.UpdateTexturePalette) { 437 (*ctx->Driver.UpdateTexturePalette)( ctx, texObj ); 438 } 439 } 440 441 ctx->NewState |= _NEW_PIXEL; 442} 443 444 445 446void 447_mesa_ColorSubTable( GLenum target, GLsizei start, 448 GLsizei count, GLenum format, GLenum type, 449 const GLvoid *data ) 450{ 451 GET_CURRENT_CONTEXT(ctx); 452 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 453 struct gl_texture_object *texObj = NULL; 454 struct gl_color_table *table = NULL; 455 GLfloat rScale = 1.0, gScale = 1.0, bScale = 1.0, aScale = 1.0; 456 GLfloat rBias = 0.0, gBias = 0.0, bBias = 0.0, aBias = 0.0; 457 GLint comps; 458 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 459 460 switch (target) { 461 case GL_TEXTURE_1D: 462 texObj = texUnit->Current1D; 463 table = &texObj->Palette; 464 break; 465 case GL_TEXTURE_2D: 466 texObj = texUnit->Current2D; 467 table = &texObj->Palette; 468 break; 469 case GL_TEXTURE_3D: 470 texObj = texUnit->Current3D; 471 table = &texObj->Palette; 472 break; 473 case GL_TEXTURE_CUBE_MAP_ARB: 474 if (!ctx->Extensions.ARB_texture_cube_map) { 475 _mesa_error(ctx, GL_INVALID_ENUM, "glColorSubTable(target)"); 476 return; 477 } 478 texObj = texUnit->CurrentCubeMap; 479 table = &texObj->Palette; 480 break; 481 case GL_SHARED_TEXTURE_PALETTE_EXT: 482 table = &ctx->Texture.Palette; 483 break; 484 case GL_COLOR_TABLE: 485 table = &ctx->ColorTable; 486 rScale = ctx->Pixel.ColorTableScale[0]; 487 gScale = ctx->Pixel.ColorTableScale[1]; 488 bScale = ctx->Pixel.ColorTableScale[2]; 489 aScale = ctx->Pixel.ColorTableScale[3]; 490 rBias = ctx->Pixel.ColorTableBias[0]; 491 gBias = ctx->Pixel.ColorTableBias[1]; 492 bBias = ctx->Pixel.ColorTableBias[2]; 493 aBias = ctx->Pixel.ColorTableBias[3]; 494 break; 495 case GL_POST_CONVOLUTION_COLOR_TABLE: 496 table = &ctx->PostConvolutionColorTable; 497 rScale = ctx->Pixel.PCCTscale[0]; 498 gScale = ctx->Pixel.PCCTscale[1]; 499 bScale = ctx->Pixel.PCCTscale[2]; 500 aScale = ctx->Pixel.PCCTscale[3]; 501 rBias = ctx->Pixel.PCCTbias[0]; 502 gBias = ctx->Pixel.PCCTbias[1]; 503 bBias = ctx->Pixel.PCCTbias[2]; 504 aBias = ctx->Pixel.PCCTbias[3]; 505 break; 506 case GL_POST_COLOR_MATRIX_COLOR_TABLE: 507 table = &ctx->PostColorMatrixColorTable; 508 rScale = ctx->Pixel.PCMCTscale[0]; 509 gScale = ctx->Pixel.PCMCTscale[1]; 510 bScale = ctx->Pixel.PCMCTscale[2]; 511 aScale = ctx->Pixel.PCMCTscale[3]; 512 rBias = ctx->Pixel.PCMCTbias[0]; 513 gBias = ctx->Pixel.PCMCTbias[1]; 514 bBias = ctx->Pixel.PCMCTbias[2]; 515 aBias = ctx->Pixel.PCMCTbias[3]; 516 break; 517 default: 518 _mesa_error(ctx, GL_INVALID_ENUM, "glColorSubTable(target)"); 519 return; 520 } 521 522 assert(table); 523 524 if (!_mesa_is_legal_format_and_type(format, type) || 525 format == GL_INTENSITY) { 526 _mesa_error(ctx, GL_INVALID_OPERATION, "glColorSubTable(format or type)"); 527 return; 528 } 529 530 if (count < 1) { 531 _mesa_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)"); 532 return; 533 } 534 535 comps = _mesa_components_in_format(table->Format); 536 assert(comps > 0); /* error should have been caught sooner */ 537 538 if (start + count > (GLint) table->Size) { 539 _mesa_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)"); 540 return; 541 } 542 543 if (!table->Table) { 544 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glColorSubTable"); 545 return; 546 } 547 548 if (!table->FloatTable) { 549 GLchan *dest = (GLchan *) table->Table + start * comps * sizeof(GLchan); 550 _mesa_unpack_chan_color_span(ctx, count, table->Format, dest, 551 format, type, data, &ctx->Unpack, 0); 552 } 553 else { 554 GLfloat tempTab[MAX_COLOR_TABLE_SIZE * 4]; 555 GLfloat *tableF; 556 GLint i; 557 558 ASSERT(table->FloatTable); 559 560 _mesa_unpack_float_color_span(ctx, count, table->Format, 561 tempTab, /* dest */ 562 format, type, data, &ctx->Unpack, 563 0, GL_FALSE); 564 565 tableF = (GLfloat *) table->Table; 566 567 switch (table->Format) { 568 case GL_INTENSITY: 569 for (i = 0; i < count; i++) { 570 GLuint j = start + i; 571 tableF[j] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F); 572 } 573 break; 574 case GL_LUMINANCE: 575 for (i = 0; i < count; i++) { 576 GLuint j = start + i; 577 tableF[j] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F); 578 } 579 break; 580 case GL_ALPHA: 581 for (i = 0; i < count; i++) { 582 GLuint j = start + i; 583 tableF[j] = CLAMP(tempTab[i] * aScale + aBias, 0.0F, 1.0F); 584 } 585 break; 586 case GL_LUMINANCE_ALPHA: 587 for (i = 0; i < count; i++) { 588 GLuint j = start + i; 589 tableF[j*2+0] = CLAMP(tempTab[i*2+0] * rScale + rBias, 0.0F, 1.0F); 590 tableF[j*2+1] = CLAMP(tempTab[i*2+1] * aScale + aBias, 0.0F, 1.0F); 591 } 592 break; 593 case GL_RGB: 594 for (i = 0; i < count; i++) { 595 GLuint j = start + i; 596 tableF[j*3+0] = CLAMP(tempTab[i*3+0] * rScale + rBias, 0.0F, 1.0F); 597 tableF[j*3+1] = CLAMP(tempTab[i*3+1] * gScale + gBias, 0.0F, 1.0F); 598 tableF[j*3+2] = CLAMP(tempTab[i*3+2] * bScale + bBias, 0.0F, 1.0F); 599 } 600 break; 601 case GL_RGBA: 602 for (i = 0; i < count; i++) { 603 GLuint j = start + i; 604 tableF[j*4+0] = CLAMP(tempTab[i*4+0] * rScale + rBias, 0.0F, 1.0F); 605 tableF[j*4+1] = CLAMP(tempTab[i*4+1] * gScale + gBias, 0.0F, 1.0F); 606 tableF[j*4+2] = CLAMP(tempTab[i*4+2] * bScale + bBias, 0.0F, 1.0F); 607 tableF[j*4+3] = CLAMP(tempTab[i*4+3] * aScale + aBias, 0.0F, 1.0F); 608 } 609 break; 610 default: 611 _mesa_problem(ctx, "Bad format in _mesa_ColorSubTable"); 612 return; 613 } 614 } 615 616 if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) { 617 /* per-texture object palette */ 618 if (ctx->Driver.UpdateTexturePalette) { 619 (*ctx->Driver.UpdateTexturePalette)( ctx, texObj ); 620 } 621 } 622 623 ctx->NewState |= _NEW_PIXEL; 624} 625 626 627 628/* XXX not tested */ 629void 630_mesa_CopyColorTable(GLenum target, GLenum internalformat, 631 GLint x, GLint y, GLsizei width) 632{ 633 GET_CURRENT_CONTEXT(ctx); 634 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 635 636 /* Select buffer to read from */ 637 ctx->Driver.CopyColorTable( ctx, target, internalformat, x, y, width ); 638} 639 640 641 642/* XXX not tested */ 643void 644_mesa_CopyColorSubTable(GLenum target, GLsizei start, 645 GLint x, GLint y, GLsizei width) 646{ 647 GET_CURRENT_CONTEXT(ctx); 648 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 649 650 ctx->Driver.CopyColorSubTable( ctx, target, start, x, y, width ); 651} 652 653 654 655void 656_mesa_GetColorTable( GLenum target, GLenum format, 657 GLenum type, GLvoid *data ) 658{ 659 GET_CURRENT_CONTEXT(ctx); 660 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 661 struct gl_color_table *table = NULL; 662 GLchan rgba[MAX_COLOR_TABLE_SIZE][4]; 663 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 664 665 if (ctx->NewState) { 666 _mesa_update_state(ctx); 667 } 668 669 switch (target) { 670 case GL_TEXTURE_1D: 671 table = &texUnit->Current1D->Palette; 672 break; 673 case GL_TEXTURE_2D: 674 table = &texUnit->Current2D->Palette; 675 break; 676 case GL_TEXTURE_3D: 677 table = &texUnit->Current3D->Palette; 678 break; 679 case GL_TEXTURE_CUBE_MAP_ARB: 680 if (!ctx->Extensions.ARB_texture_cube_map) { 681 _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTable(target)"); 682 return; 683 } 684 table = &texUnit->CurrentCubeMap->Palette; 685 break; 686 case GL_SHARED_TEXTURE_PALETTE_EXT: 687 table = &ctx->Texture.Palette; 688 break; 689 case GL_COLOR_TABLE: 690 table = &ctx->ColorTable; 691 break; 692 case GL_POST_CONVOLUTION_COLOR_TABLE: 693 table = &ctx->PostConvolutionColorTable; 694 break; 695 case GL_POST_COLOR_MATRIX_COLOR_TABLE: 696 table = &ctx->PostColorMatrixColorTable; 697 break; 698 default: 699 _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTable(target)"); 700 return; 701 } 702 703 assert(table); 704 705 switch (table->Format) { 706 case GL_ALPHA: 707 if (table->FloatTable) { 708 const GLfloat *tableF = (const GLfloat *) table->Table; 709 GLuint i; 710 for (i = 0; i < table->Size; i++) { 711 rgba[i][RCOMP] = 0; 712 rgba[i][GCOMP] = 0; 713 rgba[i][BCOMP] = 0; 714 rgba[i][ACOMP] = IROUND_POS(tableF[i] * CHAN_MAXF); 715 } 716 } 717 else { 718 const GLchan *tableUB = (const GLchan *) table->Table; 719 GLuint i; 720 for (i = 0; i < table->Size; i++) { 721 rgba[i][RCOMP] = 0; 722 rgba[i][GCOMP] = 0; 723 rgba[i][BCOMP] = 0; 724 rgba[i][ACOMP] = tableUB[i]; 725 } 726 } 727 break; 728 case GL_LUMINANCE: 729 if (table->FloatTable) { 730 const GLfloat *tableF = (const GLfloat *) table->Table; 731 GLuint i; 732 for (i = 0; i < table->Size; i++) { 733 rgba[i][RCOMP] = IROUND_POS(tableF[i] * CHAN_MAXF); 734 rgba[i][GCOMP] = IROUND_POS(tableF[i] * CHAN_MAXF); 735 rgba[i][BCOMP] = IROUND_POS(tableF[i] * CHAN_MAXF); 736 rgba[i][ACOMP] = CHAN_MAX; 737 } 738 } 739 else { 740 const GLchan *tableUB = (const GLchan *) table->Table; 741 GLuint i; 742 for (i = 0; i < table->Size; i++) { 743 rgba[i][RCOMP] = tableUB[i]; 744 rgba[i][GCOMP] = tableUB[i]; 745 rgba[i][BCOMP] = tableUB[i]; 746 rgba[i][ACOMP] = CHAN_MAX; 747 } 748 } 749 break; 750 case GL_LUMINANCE_ALPHA: 751 if (table->FloatTable) { 752 const GLfloat *tableF = (const GLfloat *) table->Table; 753 GLuint i; 754 for (i = 0; i < table->Size; i++) { 755 rgba[i][RCOMP] = IROUND_POS(tableF[i*2+0] * CHAN_MAXF); 756 rgba[i][GCOMP] = IROUND_POS(tableF[i*2+0] * CHAN_MAXF); 757 rgba[i][BCOMP] = IROUND_POS(tableF[i*2+0] * CHAN_MAXF); 758 rgba[i][ACOMP] = IROUND_POS(tableF[i*2+1] * CHAN_MAXF); 759 } 760 } 761 else { 762 const GLchan *tableUB = (const GLchan *) table->Table; 763 GLuint i; 764 for (i = 0; i < table->Size; i++) { 765 rgba[i][RCOMP] = tableUB[i*2+0]; 766 rgba[i][GCOMP] = tableUB[i*2+0]; 767 rgba[i][BCOMP] = tableUB[i*2+0]; 768 rgba[i][ACOMP] = tableUB[i*2+1]; 769 } 770 } 771 break; 772 case GL_INTENSITY: 773 if (table->FloatTable) { 774 const GLfloat *tableF = (const GLfloat *) table->Table; 775 GLuint i; 776 for (i = 0; i < table->Size; i++) { 777 rgba[i][RCOMP] = IROUND_POS(tableF[i] * CHAN_MAXF); 778 rgba[i][GCOMP] = IROUND_POS(tableF[i] * CHAN_MAXF); 779 rgba[i][BCOMP] = IROUND_POS(tableF[i] * CHAN_MAXF); 780 rgba[i][ACOMP] = IROUND_POS(tableF[i] * CHAN_MAXF); 781 } 782 } 783 else { 784 const GLchan *tableUB = (const GLchan *) table->Table; 785 GLuint i; 786 for (i = 0; i < table->Size; i++) { 787 rgba[i][RCOMP] = tableUB[i]; 788 rgba[i][GCOMP] = tableUB[i]; 789 rgba[i][BCOMP] = tableUB[i]; 790 rgba[i][ACOMP] = tableUB[i]; 791 } 792 } 793 break; 794 case GL_RGB: 795 if (table->FloatTable) { 796 const GLfloat *tableF = (const GLfloat *) table->Table; 797 GLuint i; 798 for (i = 0; i < table->Size; i++) { 799 rgba[i][RCOMP] = IROUND_POS(tableF[i*3+0] * CHAN_MAXF); 800 rgba[i][GCOMP] = IROUND_POS(tableF[i*3+1] * CHAN_MAXF); 801 rgba[i][BCOMP] = IROUND_POS(tableF[i*3+2] * CHAN_MAXF); 802 rgba[i][ACOMP] = CHAN_MAX; 803 } 804 } 805 else { 806 const GLchan *tableUB = (const GLchan *) table->Table; 807 GLuint i; 808 for (i = 0; i < table->Size; i++) { 809 rgba[i][RCOMP] = tableUB[i*3+0]; 810 rgba[i][GCOMP] = tableUB[i*3+1]; 811 rgba[i][BCOMP] = tableUB[i*3+2]; 812 rgba[i][ACOMP] = CHAN_MAX; 813 } 814 } 815 break; 816 case GL_RGBA: 817 if (table->FloatTable) { 818 const GLfloat *tableF = (const GLfloat *) table->Table; 819 GLuint i; 820 for (i = 0; i < table->Size; i++) { 821 rgba[i][RCOMP] = IROUND_POS(tableF[i*4+0] * CHAN_MAXF); 822 rgba[i][GCOMP] = IROUND_POS(tableF[i*4+1] * CHAN_MAXF); 823 rgba[i][BCOMP] = IROUND_POS(tableF[i*4+2] * CHAN_MAXF); 824 rgba[i][ACOMP] = IROUND_POS(tableF[i*4+3] * CHAN_MAXF); 825 } 826 } 827 else { 828 const GLchan *tableUB = (const GLchan *) table->Table; 829 GLuint i; 830 for (i = 0; i < table->Size; i++) { 831 rgba[i][RCOMP] = tableUB[i*4+0]; 832 rgba[i][GCOMP] = tableUB[i*4+1]; 833 rgba[i][BCOMP] = tableUB[i*4+2]; 834 rgba[i][ACOMP] = tableUB[i*4+3]; 835 } 836 } 837 break; 838 default: 839 _mesa_problem(ctx, "bad table format in glGetColorTable"); 840 return; 841 } 842 843 _mesa_pack_rgba_span(ctx, table->Size, (const GLchan (*)[4]) rgba, 844 format, type, data, &ctx->Pack, GL_FALSE); 845} 846 847 848 849void 850_mesa_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params) 851{ 852 GET_CURRENT_CONTEXT(ctx); 853 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 854 855 switch (target) { 856 case GL_COLOR_TABLE_SGI: 857 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 858 ctx->Pixel.ColorTableScale[0] = params[0]; 859 ctx->Pixel.ColorTableScale[1] = params[1]; 860 ctx->Pixel.ColorTableScale[2] = params[2]; 861 ctx->Pixel.ColorTableScale[3] = params[3]; 862 } 863 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 864 ctx->Pixel.ColorTableBias[0] = params[0]; 865 ctx->Pixel.ColorTableBias[1] = params[1]; 866 ctx->Pixel.ColorTableBias[2] = params[2]; 867 ctx->Pixel.ColorTableBias[3] = params[3]; 868 } 869 else { 870 _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)"); 871 return; 872 } 873 break; 874 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI: 875 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 876 ctx->Pixel.PCCTscale[0] = params[0]; 877 ctx->Pixel.PCCTscale[1] = params[1]; 878 ctx->Pixel.PCCTscale[2] = params[2]; 879 ctx->Pixel.PCCTscale[3] = params[3]; 880 } 881 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 882 ctx->Pixel.PCCTbias[0] = params[0]; 883 ctx->Pixel.PCCTbias[1] = params[1]; 884 ctx->Pixel.PCCTbias[2] = params[2]; 885 ctx->Pixel.PCCTbias[3] = params[3]; 886 } 887 else { 888 _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)"); 889 return; 890 } 891 break; 892 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI: 893 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 894 ctx->Pixel.PCMCTscale[0] = params[0]; 895 ctx->Pixel.PCMCTscale[1] = params[1]; 896 ctx->Pixel.PCMCTscale[2] = params[2]; 897 ctx->Pixel.PCMCTscale[3] = params[3]; 898 } 899 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 900 ctx->Pixel.PCMCTbias[0] = params[0]; 901 ctx->Pixel.PCMCTbias[1] = params[1]; 902 ctx->Pixel.PCMCTbias[2] = params[2]; 903 ctx->Pixel.PCMCTbias[3] = params[3]; 904 } 905 else { 906 _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)"); 907 return; 908 } 909 break; 910 default: 911 _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameter(target)"); 912 return; 913 } 914 915 ctx->NewState |= _NEW_PIXEL; 916} 917 918 919 920void 921_mesa_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params) 922{ 923 GLfloat fparams[4]; 924 if (pname == GL_COLOR_TABLE_SGI || 925 pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI || 926 pname == GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI) { 927 /* four values */ 928 fparams[0] = (GLfloat) params[0]; 929 fparams[1] = (GLfloat) params[1]; 930 fparams[2] = (GLfloat) params[2]; 931 fparams[3] = (GLfloat) params[3]; 932 } 933 else { 934 /* one values */ 935 fparams[0] = (GLfloat) params[0]; 936 } 937 _mesa_ColorTableParameterfv(target, pname, fparams); 938} 939 940 941 942void 943_mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params ) 944{ 945 GET_CURRENT_CONTEXT(ctx); 946 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 947 struct gl_color_table *table = NULL; 948 ASSERT_OUTSIDE_BEGIN_END(ctx); 949 950 switch (target) { 951 case GL_TEXTURE_1D: 952 table = &texUnit->Current1D->Palette; 953 break; 954 case GL_TEXTURE_2D: 955 table = &texUnit->Current2D->Palette; 956 break; 957 case GL_TEXTURE_3D: 958 table = &texUnit->Current3D->Palette; 959 break; 960 case GL_TEXTURE_CUBE_MAP_ARB: 961 if (!ctx->Extensions.ARB_texture_cube_map) { 962 _mesa_error(ctx, GL_INVALID_ENUM, 963 "glGetColorTableParameterfv(target)"); 964 return; 965 } 966 table = &texUnit->CurrentCubeMap->Palette; 967 break; 968 case GL_PROXY_TEXTURE_1D: 969 table = &ctx->Texture.Proxy1D->Palette; 970 break; 971 case GL_PROXY_TEXTURE_2D: 972 table = &ctx->Texture.Proxy2D->Palette; 973 break; 974 case GL_PROXY_TEXTURE_3D: 975 table = &ctx->Texture.Proxy3D->Palette; 976 break; 977 case GL_PROXY_TEXTURE_CUBE_MAP_ARB: 978 if (!ctx->Extensions.ARB_texture_cube_map) { 979 _mesa_error(ctx, GL_INVALID_ENUM, 980 "glGetColorTableParameterfv(target)"); 981 return; 982 } 983 table = &ctx->Texture.ProxyCubeMap->Palette; 984 break; 985 case GL_SHARED_TEXTURE_PALETTE_EXT: 986 table = &ctx->Texture.Palette; 987 break; 988 case GL_COLOR_TABLE: 989 table = &ctx->ColorTable; 990 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 991 params[0] = ctx->Pixel.ColorTableScale[0]; 992 params[1] = ctx->Pixel.ColorTableScale[1]; 993 params[2] = ctx->Pixel.ColorTableScale[2]; 994 params[3] = ctx->Pixel.ColorTableScale[3]; 995 return; 996 } 997 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 998 params[0] = ctx->Pixel.ColorTableBias[0]; 999 params[1] = ctx->Pixel.ColorTableBias[1]; 1000 params[2] = ctx->Pixel.ColorTableBias[2]; 1001 params[3] = ctx->Pixel.ColorTableBias[3]; 1002 return; 1003 } 1004 break; 1005 case GL_PROXY_COLOR_TABLE: 1006 table = &ctx->ProxyColorTable; 1007 break; 1008 case GL_POST_CONVOLUTION_COLOR_TABLE: 1009 table = &ctx->PostConvolutionColorTable; 1010 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 1011 params[0] = ctx->Pixel.PCCTscale[0]; 1012 params[1] = ctx->Pixel.PCCTscale[1]; 1013 params[2] = ctx->Pixel.PCCTscale[2]; 1014 params[3] = ctx->Pixel.PCCTscale[3]; 1015 return; 1016 } 1017 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 1018 params[0] = ctx->Pixel.PCCTbias[0]; 1019 params[1] = ctx->Pixel.PCCTbias[1]; 1020 params[2] = ctx->Pixel.PCCTbias[2]; 1021 params[3] = ctx->Pixel.PCCTbias[3]; 1022 return; 1023 } 1024 break; 1025 case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE: 1026 table = &ctx->ProxyPostConvolutionColorTable; 1027 break; 1028 case GL_POST_COLOR_MATRIX_COLOR_TABLE: 1029 table = &ctx->PostColorMatrixColorTable; 1030 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 1031 params[0] = ctx->Pixel.PCMCTscale[0]; 1032 params[1] = ctx->Pixel.PCMCTscale[1]; 1033 params[2] = ctx->Pixel.PCMCTscale[2]; 1034 params[3] = ctx->Pixel.PCMCTscale[3]; 1035 return; 1036 } 1037 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 1038 params[0] = ctx->Pixel.PCMCTbias[0]; 1039 params[1] = ctx->Pixel.PCMCTbias[1]; 1040 params[2] = ctx->Pixel.PCMCTbias[2]; 1041 params[3] = ctx->Pixel.PCMCTbias[3]; 1042 return; 1043 } 1044 break; 1045 case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE: 1046 table = &ctx->ProxyPostColorMatrixColorTable; 1047 break; 1048 default: 1049 _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(target)"); 1050 return; 1051 } 1052 1053 assert(table); 1054 1055 switch (pname) { 1056 case GL_COLOR_TABLE_FORMAT: 1057 *params = (GLfloat) table->IntFormat; 1058 break; 1059 case GL_COLOR_TABLE_WIDTH: 1060 *params = (GLfloat) table->Size; 1061 break; 1062 case GL_COLOR_TABLE_RED_SIZE: 1063 *params = table->RedSize; 1064 break; 1065 case GL_COLOR_TABLE_GREEN_SIZE: 1066 *params = table->GreenSize; 1067 break; 1068 case GL_COLOR_TABLE_BLUE_SIZE: 1069 *params = table->BlueSize; 1070 break; 1071 case GL_COLOR_TABLE_ALPHA_SIZE: 1072 *params = table->AlphaSize; 1073 break; 1074 case GL_COLOR_TABLE_LUMINANCE_SIZE: 1075 *params = table->LuminanceSize; 1076 break; 1077 case GL_COLOR_TABLE_INTENSITY_SIZE: 1078 *params = table->IntensitySize; 1079 break; 1080 default: 1081 _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(pname)" ); 1082 return; 1083 } 1084} 1085 1086 1087 1088void 1089_mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params ) 1090{ 1091 GET_CURRENT_CONTEXT(ctx); 1092 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 1093 struct gl_color_table *table = NULL; 1094 ASSERT_OUTSIDE_BEGIN_END(ctx); 1095 1096 switch (target) { 1097 case GL_TEXTURE_1D: 1098 table = &texUnit->Current1D->Palette; 1099 break; 1100 case GL_TEXTURE_2D: 1101 table = &texUnit->Current2D->Palette; 1102 break; 1103 case GL_TEXTURE_3D: 1104 table = &texUnit->Current3D->Palette; 1105 break; 1106 case GL_TEXTURE_CUBE_MAP_ARB: 1107 if (!ctx->Extensions.ARB_texture_cube_map) { 1108 _mesa_error(ctx, GL_INVALID_ENUM, 1109 "glGetColorTableParameteriv(target)"); 1110 return; 1111 } 1112 table = &texUnit->CurrentCubeMap->Palette; 1113 break; 1114 case GL_PROXY_TEXTURE_1D: 1115 table = &ctx->Texture.Proxy1D->Palette; 1116 break; 1117 case GL_PROXY_TEXTURE_2D: 1118 table = &ctx->Texture.Proxy2D->Palette; 1119 break; 1120 case GL_PROXY_TEXTURE_3D: 1121 table = &ctx->Texture.Proxy3D->Palette; 1122 break; 1123 case GL_PROXY_TEXTURE_CUBE_MAP_ARB: 1124 if (!ctx->Extensions.ARB_texture_cube_map) { 1125 _mesa_error(ctx, GL_INVALID_ENUM, 1126 "glGetColorTableParameteriv(target)"); 1127 return; 1128 } 1129 table = &ctx->Texture.ProxyCubeMap->Palette; 1130 break; 1131 case GL_SHARED_TEXTURE_PALETTE_EXT: 1132 table = &ctx->Texture.Palette; 1133 break; 1134 case GL_COLOR_TABLE: 1135 table = &ctx->ColorTable; 1136 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 1137 params[0] = (GLint) ctx->Pixel.ColorTableScale[0]; 1138 params[1] = (GLint) ctx->Pixel.ColorTableScale[1]; 1139 params[2] = (GLint) ctx->Pixel.ColorTableScale[2]; 1140 params[3] = (GLint) ctx->Pixel.ColorTableScale[3]; 1141 return; 1142 } 1143 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 1144 params[0] = (GLint) ctx->Pixel.ColorTableBias[0]; 1145 params[1] = (GLint) ctx->Pixel.ColorTableBias[1]; 1146 params[2] = (GLint) ctx->Pixel.ColorTableBias[2]; 1147 params[3] = (GLint) ctx->Pixel.ColorTableBias[3]; 1148 return; 1149 } 1150 break; 1151 case GL_PROXY_COLOR_TABLE: 1152 table = &ctx->ProxyColorTable; 1153 break; 1154 case GL_POST_CONVOLUTION_COLOR_TABLE: 1155 table = &ctx->PostConvolutionColorTable; 1156 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 1157 params[0] = (GLint) ctx->Pixel.PCCTscale[0]; 1158 params[1] = (GLint) ctx->Pixel.PCCTscale[1]; 1159 params[2] = (GLint) ctx->Pixel.PCCTscale[2]; 1160 params[3] = (GLint) ctx->Pixel.PCCTscale[3]; 1161 return; 1162 } 1163 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 1164 params[0] = (GLint) ctx->Pixel.PCCTbias[0]; 1165 params[1] = (GLint) ctx->Pixel.PCCTbias[1]; 1166 params[2] = (GLint) ctx->Pixel.PCCTbias[2]; 1167 params[3] = (GLint) ctx->Pixel.PCCTbias[3]; 1168 return; 1169 } 1170 break; 1171 case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE: 1172 table = &ctx->ProxyPostConvolutionColorTable; 1173 break; 1174 case GL_POST_COLOR_MATRIX_COLOR_TABLE: 1175 table = &ctx->PostColorMatrixColorTable; 1176 if (pname == GL_COLOR_TABLE_SCALE_SGI) { 1177 params[0] = (GLint) ctx->Pixel.PCMCTscale[0]; 1178 params[1] = (GLint) ctx->Pixel.PCMCTscale[1]; 1179 params[2] = (GLint) ctx->Pixel.PCMCTscale[2]; 1180 params[3] = (GLint) ctx->Pixel.PCMCTscale[3]; 1181 return; 1182 } 1183 else if (pname == GL_COLOR_TABLE_BIAS_SGI) { 1184 params[0] = (GLint) ctx->Pixel.PCMCTbias[0]; 1185 params[1] = (GLint) ctx->Pixel.PCMCTbias[1]; 1186 params[2] = (GLint) ctx->Pixel.PCMCTbias[2]; 1187 params[3] = (GLint) ctx->Pixel.PCMCTbias[3]; 1188 return; 1189 } 1190 break; 1191 case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE: 1192 table = &ctx->ProxyPostColorMatrixColorTable; 1193 break; 1194 default: 1195 _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(target)"); 1196 return; 1197 } 1198 1199 assert(table); 1200 1201 switch (pname) { 1202 case GL_COLOR_TABLE_FORMAT: 1203 *params = table->IntFormat; 1204 break; 1205 case GL_COLOR_TABLE_WIDTH: 1206 *params = table->Size; 1207 break; 1208 case GL_COLOR_TABLE_RED_SIZE: 1209 *params = table->RedSize; 1210 break; 1211 case GL_COLOR_TABLE_GREEN_SIZE: 1212 *params = table->GreenSize; 1213 break; 1214 case GL_COLOR_TABLE_BLUE_SIZE: 1215 *params = table->BlueSize; 1216 break; 1217 case GL_COLOR_TABLE_ALPHA_SIZE: 1218 *params = table->AlphaSize; 1219 break; 1220 case GL_COLOR_TABLE_LUMINANCE_SIZE: 1221 *params = table->LuminanceSize; 1222 break; 1223 case GL_COLOR_TABLE_INTENSITY_SIZE: 1224 *params = table->IntensitySize; 1225 break; 1226 default: 1227 _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(pname)" ); 1228 return; 1229 } 1230} 1231