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