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