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