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