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