src/mesa/main/colortab.c

   1 /* $Id: colortab.c,v 1.13 2000/04/12 00:27:37 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.3
   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 "mmath.h"
  37 #include "span.h"
  38 #include "teximage.h"
  39 #endif
  40
  41
  42
  43 /*
  44  * Examine table's format and set the component sizes accordingly.
  45  */
  46 static void
  47 set_component_sizes( struct gl_color_table *table )
  48 {
  49    switch (table->Format) {
  50       case GL_ALPHA:
  51          table->RedSize = 0;
  52          table->GreenSize = 0;
  53          table->BlueSize = 0;
  54          table->AlphaSize = 8;
  55          table->IntensitySize = 0;
  56          table->LuminanceSize = 0;
  57          break;
  58       case GL_LUMINANCE:
  59          table->RedSize = 0;
  60          table->GreenSize = 0;
  61          table->BlueSize = 0;
  62          table->AlphaSize = 0;
  63          table->IntensitySize = 0;
  64          table->LuminanceSize = 8;
  65          break;
  66       case GL_LUMINANCE_ALPHA:
  67          table->RedSize = 0;
  68          table->GreenSize = 0;
  69          table->BlueSize = 0;
  70          table->AlphaSize = 8;
  71          table->IntensitySize = 0;
  72          table->LuminanceSize = 8;
  73          break;
  74       case GL_INTENSITY:
  75          table->RedSize = 0;
  76          table->GreenSize = 0;
  77          table->BlueSize = 0;
  78          table->AlphaSize = 0;
  79          table->IntensitySize = 8;
  80          table->LuminanceSize = 0;
  81          break;
  82       case GL_RGB:
  83          table->RedSize = 8;
  84          table->GreenSize = 8;
  85          table->BlueSize = 8;
  86          table->AlphaSize = 0;
  87          table->IntensitySize = 0;
  88          table->LuminanceSize = 0;
  89          break;
  90       case GL_RGBA:
  91          table->RedSize = 8;
  92          table->GreenSize = 8;
  93          table->BlueSize = 8;
  94          table->AlphaSize = 8;
  95          table->IntensitySize = 0;
  96          table->LuminanceSize = 0;
  97          break;
  98       default:
  99          gl_problem(NULL, "unexpected format in set_component_sizes");
 100    }
 101 }
 102
 103
 104
 105 void
 106 _mesa_ColorTable( GLenum target, GLenum internalFormat,
 107                   GLsizei width, GLenum format, GLenum type,
 108                   const GLvoid *data )
 109 {
 110    GET_CURRENT_CONTEXT(ctx);
 111    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 112    struct gl_texture_object *texObj = NULL;
 113    struct gl_color_table *table = NULL;
 114    GLboolean proxy = GL_FALSE;
 115    GLint baseFormat;
 116    GLfloat rScale = 1.0, gScale = 1.0, bScale = 1.0, aScale = 1.0;
 117    GLfloat rBias  = 0.0, gBias  = 0.0, bBias  = 0.0, aBias  = 0.0;
 118
 119    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glColorTable");
 120
 121    switch (target) {
 122       case GL_TEXTURE_1D:
 123          texObj = texUnit->CurrentD[1];
 124          table = &texObj->Palette;
 125          break;
 126       case GL_TEXTURE_2D:
 127          texObj = texUnit->CurrentD[2];
 128          table = &texObj->Palette;
 129          break;
 130       case GL_TEXTURE_3D:
 131          texObj = texUnit->CurrentD[3];
 132          table = &texObj->Palette;
 133          break;
 134       case GL_PROXY_TEXTURE_1D:
 135          texObj = ctx->Texture.Proxy1D;
 136          table = &texObj->Palette;
 137          proxy = GL_TRUE;
 138          break;
 139       case GL_PROXY_TEXTURE_2D:
 140          texObj = ctx->Texture.Proxy2D;
 141          table = &texObj->Palette;
 142          proxy = GL_TRUE;
 143          break;
 144       case GL_PROXY_TEXTURE_3D:
 145          texObj = ctx->Texture.Proxy3D;
 146          table = &texObj->Palette;
 147          proxy = GL_TRUE;
 148          break;
 149       case GL_SHARED_TEXTURE_PALETTE_EXT:
 150          table = &ctx->Texture.Palette;
 151          break;
 152       case GL_COLOR_TABLE:
 153          table = &ctx->ColorTable;
 154          rScale = ctx->Pixel.ColorTableScale[0];
 155          gScale = ctx->Pixel.ColorTableScale[1];
 156          bScale = ctx->Pixel.ColorTableScale[2];
 157          aScale = ctx->Pixel.ColorTableScale[3];
 158          rBias = ctx->Pixel.ColorTableBias[0];
 159          gBias = ctx->Pixel.ColorTableBias[1];
 160          bBias = ctx->Pixel.ColorTableBias[2];
 161          aBias = ctx->Pixel.ColorTableBias[3];
 162          break;
 163       case GL_PROXY_COLOR_TABLE:
 164          table = &ctx->ProxyColorTable;
 165          proxy = GL_TRUE;
 166          break;
 167       case GL_POST_CONVOLUTION_COLOR_TABLE:
 168          table = &ctx->PostConvolutionColorTable;
 169          rScale = ctx->Pixel.PCCTscale[0];
 170          gScale = ctx->Pixel.PCCTscale[1];
 171          bScale = ctx->Pixel.PCCTscale[2];
 172          aScale = ctx->Pixel.PCCTscale[3];
 173          rBias = ctx->Pixel.PCCTbias[0];
 174          gBias = ctx->Pixel.PCCTbias[1];
 175          bBias = ctx->Pixel.PCCTbias[2];
 176          aBias = ctx->Pixel.PCCTbias[3];
 177          break;
 178       case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE:
 179          table = &ctx->ProxyPostConvolutionColorTable;
 180          proxy = GL_TRUE;
 181          break;
 182       case GL_POST_COLOR_MATRIX_COLOR_TABLE:
 183          table = &ctx->PostColorMatrixColorTable;
 184          rScale = ctx->Pixel.PCMCTscale[0];
 185          gScale = ctx->Pixel.PCMCTscale[1];
 186          bScale = ctx->Pixel.PCMCTscale[2];
 187          aScale = ctx->Pixel.PCMCTscale[3];
 188          rBias = ctx->Pixel.PCMCTbias[0];
 189          gBias = ctx->Pixel.PCMCTbias[1];
 190          bBias = ctx->Pixel.PCMCTbias[2];
 191          aBias = ctx->Pixel.PCMCTbias[3];
 192          break;
 193       case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE:
 194          table = &ctx->ProxyPostColorMatrixColorTable;
 195          proxy = GL_TRUE;
 196          break;
 197       default:
 198          gl_error(ctx, GL_INVALID_ENUM, "glColorTable(target)");
 199          return;
 200    }
 201
 202    assert(table);
 203
 204    if (!_mesa_is_legal_format_and_type(format, type)) {
 205       gl_error(ctx, GL_INVALID_ENUM, "glColorTable(format or type)");
 206       return;
 207    }
 208
 209    baseFormat = _mesa_base_tex_format(internalFormat);
 210    if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) {
 211       gl_error(ctx, GL_INVALID_ENUM, "glColorTable(internalFormat)");
 212       return;
 213    }
 214
 215    if (width < 1 || width > MAX_COLOR_TABLE_SIZE
 216        || _mesa_bitcount(width) != 1) {
 217       if (width > MAX_COLOR_TABLE_SIZE)
 218          gl_error(ctx, GL_TABLE_TOO_LARGE, "glColorTable(width)");
 219       else
 220          gl_error(ctx, GL_INVALID_VALUE, "glColorTable(width)");
 221       if (proxy) {
 222          table->Size = 0;
 223          table->IntFormat = (GLenum) 0;
 224          table->Format = (GLenum) 0;
 225       }
 226       return;
 227    }
 228
 229
 230    table->Size = width;
 231    table->IntFormat = internalFormat;
 232    table->Format = (GLenum) baseFormat;
 233    set_component_sizes(table);
 234
 235    if (!proxy) {
 236       _mesa_unpack_ubyte_color_span(ctx, width, table->Format,
 237                                     table->Table,  /* dest */
 238                                     format, type, data,
 239                                     &ctx->Unpack, GL_TRUE);
 240       if (rScale != 1.0 || gScale != 1.0 || bScale != 1.0 || aScale != 1.0 ||
 241           rBias != 0.0 || gBias != 0.0 || bBias != 0.0 || aBias != 0.0) {
 242          /* XXX apply scale and bias */
 243
 244       }
 245    }
 246
 247    if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) {
 248       /* texture object palette, texObj==NULL means the shared palette */
 249       if (ctx->Driver.UpdateTexturePalette) {
 250          (*ctx->Driver.UpdateTexturePalette)( ctx, texObj );
 251       }
 252    }
 253
 254 }
 255
 256
 257
 258 void
 259 _mesa_ColorSubTable( GLenum target, GLsizei start,
 260                      GLsizei count, GLenum format, GLenum type,
 261                      const GLvoid *data )
 262 {
 263    GET_CURRENT_CONTEXT(ctx);
 264    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 265    struct gl_texture_object *texObj = NULL;
 266    struct gl_color_table *table = NULL;
 267    GLint comps;
 268    GLubyte *dest;
 269
 270    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glColorSubTable");
 271
 272    switch (target) {
 273       case GL_TEXTURE_1D:
 274          texObj = texUnit->CurrentD[1];
 275          table = &texObj->Palette;
 276          break;
 277       case GL_TEXTURE_2D:
 278          texObj = texUnit->CurrentD[2];
 279          table = &texObj->Palette;
 280          break;
 281       case GL_TEXTURE_3D:
 282          texObj = texUnit->CurrentD[3];
 283          table = &texObj->Palette;
 284          break;
 285       case GL_SHARED_TEXTURE_PALETTE_EXT:
 286          table = &ctx->Texture.Palette;
 287          break;
 288       case GL_COLOR_TABLE:
 289          table = &ctx->ColorTable;
 290          break;
 291       case GL_POST_CONVOLUTION_COLOR_TABLE:
 292          table = &ctx->PostConvolutionColorTable;
 293          break;
 294       case GL_POST_COLOR_MATRIX_COLOR_TABLE:
 295          table = &ctx->PostColorMatrixColorTable;
 296          break;
 297       default:
 298          gl_error(ctx, GL_INVALID_ENUM, "glColorSubTable(target)");
 299          return;
 300    }
 301
 302    assert(table);
 303
 304    if (!_mesa_is_legal_format_and_type(format, type)) {
 305       gl_error(ctx, GL_INVALID_ENUM, "glColorSubTable(format or type)");
 306       return;
 307    }
 308
 309    if (count < 1) {
 310       gl_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)");
 311       return;
 312    }
 313
 314    comps = _mesa_components_in_format(table->Format);
 315    assert(comps > 0);  /* error should have been caught sooner */
 316
 317    if (start + count > table->Size) {
 318       gl_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)");
 319       return;
 320    }
 321
 322    dest = table->Table + start * comps * sizeof(GLubyte);
 323    _mesa_unpack_ubyte_color_span(ctx, count, table->Format, dest,
 324                                  format, type, data,
 325                                  &ctx->Unpack, GL_TRUE);
 326
 327    if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) {
 328       /* per-texture object palette */
 329       if (ctx->Driver.UpdateTexturePalette) {
 330          (*ctx->Driver.UpdateTexturePalette)( ctx, texObj );
 331       }
 332    }
 333 }
 334
 335
 336
 337 /* XXX not tested */
 338 void
 339 _mesa_CopyColorTable(GLenum target, GLenum internalformat,
 340                      GLint x, GLint y, GLsizei width)
 341 {
 342    GLubyte data[MAX_WIDTH][4];
 343    GET_CURRENT_CONTEXT(ctx);
 344    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyColorTable");
 345
 346    /* Select buffer to read from */
 347    (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
 348                                  ctx->Pixel.DriverReadBuffer );
 349
 350    if (width > MAX_WIDTH)
 351       width = MAX_WIDTH;
 352
 353    /* read the data from framebuffer */
 354    gl_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y, data );
 355
 356    /* Restore reading from draw buffer (the default) */
 357    (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
 358                                  ctx->Color.DriverDrawBuffer );
 359
 360    _mesa_ColorTable(target, internalformat, width,
 361                     GL_RGBA, GL_UNSIGNED_BYTE, data);
 362 }
 363
 364
 365
 366 /* XXX not tested */
 367 void
 368 _mesa_CopyColorSubTable(GLenum target, GLsizei start,
 369                         GLint x, GLint y, GLsizei width)
 370 {
 371    GLubyte data[MAX_WIDTH][4];
 372    GET_CURRENT_CONTEXT(ctx);
 373    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyColorSubTable");
 374
 375    /* Select buffer to read from */
 376    (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
 377                                  ctx->Pixel.DriverReadBuffer );
 378
 379    if (width > MAX_WIDTH)
 380       width = MAX_WIDTH;
 381
 382    /* read the data from framebuffer */
 383    gl_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y, data );
 384
 385    /* Restore reading from draw buffer (the default) */
 386    (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
 387                                  ctx->Color.DriverDrawBuffer );
 388
 389    _mesa_ColorSubTable(target, start, width, GL_RGBA, GL_UNSIGNED_BYTE, data);
 390 }
 391
 392
 393
 394 void
 395 _mesa_GetColorTable( GLenum target, GLenum format,
 396                      GLenum type, GLvoid *data )
 397 {
 398    GET_CURRENT_CONTEXT(ctx);
 399    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 400    struct gl_color_table *table = NULL;
 401    GLubyte rgba[MAX_COLOR_TABLE_SIZE][4];
 402    GLint i;
 403
 404    ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTable");
 405
 406    switch (target) {
 407       case GL_TEXTURE_1D:
 408          table = &texUnit->CurrentD[1]->Palette;
 409          break;
 410       case GL_TEXTURE_2D:
 411          table = &texUnit->CurrentD[2]->Palette;
 412          break;
 413       case GL_TEXTURE_3D:
 414          table = &texUnit->CurrentD[3]->Palette;
 415          break;
 416       case GL_SHARED_TEXTURE_PALETTE_EXT:
 417          table = &ctx->Texture.Palette;
 418          break;
 419       case GL_COLOR_TABLE:
 420          table = &ctx->ColorTable;
 421          break;
 422       case GL_POST_CONVOLUTION_COLOR_TABLE:
 423          table = &ctx->PostConvolutionColorTable;
 424          break;
 425       case GL_POST_COLOR_MATRIX_COLOR_TABLE:
 426          table = &ctx->PostColorMatrixColorTable;
 427          break;
 428       default:
 429          gl_error(ctx, GL_INVALID_ENUM, "glGetColorTable(target)");
 430          return;
 431    }
 432
 433    assert(table);
 434
 435    switch (table->Format) {
 436       case GL_ALPHA:
 437          for (i = 0; i < table->Size; i++) {
 438             rgba[i][RCOMP] = 0;
 439             rgba[i][GCOMP] = 0;
 440             rgba[i][BCOMP] = 0;
 441             rgba[i][ACOMP] = table->Table[i];
 442          }
 443          break;
 444       case GL_LUMINANCE:
 445          for (i = 0; i < table->Size; i++) {
 446             rgba[i][RCOMP] = table->Table[i];
 447             rgba[i][GCOMP] = table->Table[i];
 448             rgba[i][BCOMP] = table->Table[i];
 449             rgba[i][ACOMP] = 255;
 450          }
 451          break;
 452       case GL_LUMINANCE_ALPHA:
 453          for (i = 0; i < table->Size; i++) {
 454             rgba[i][RCOMP] = table->Table[i*2+0];
 455             rgba[i][GCOMP] = table->Table[i*2+0];
 456             rgba[i][BCOMP] = table->Table[i*2+0];
 457             rgba[i][ACOMP] = table->Table[i*2+1];
 458          }
 459          break;
 460       case GL_INTENSITY:
 461          for (i = 0; i < table->Size; i++) {
 462             rgba[i][RCOMP] = table->Table[i];
 463             rgba[i][GCOMP] = table->Table[i];
 464             rgba[i][BCOMP] = table->Table[i];
 465             rgba[i][ACOMP] = 255;
 466          }
 467          break;
 468       case GL_RGB:
 469          for (i = 0; i < table->Size; i++) {
 470             rgba[i][RCOMP] = table->Table[i*3+0];
 471             rgba[i][GCOMP] = table->Table[i*3+1];
 472             rgba[i][BCOMP] = table->Table[i*3+2];
 473             rgba[i][ACOMP] = 255;
 474          }
 475          break;
 476       case GL_RGBA:
 477          for (i = 0; i < table->Size; i++) {
 478             rgba[i][RCOMP] = table->Table[i*4+0];
 479             rgba[i][GCOMP] = table->Table[i*4+1];
 480             rgba[i][BCOMP] = table->Table[i*4+2];
 481             rgba[i][ACOMP] = table->Table[i*4+3];
 482          }
 483          break;
 484       default:
 485          gl_problem(ctx, "bad table format in glGetColorTable");
 486          return;
 487    }
 488
 489    _mesa_pack_rgba_span(ctx, table->Size, (const GLubyte (*)[]) rgba,
 490                         format, type, data, &ctx->Pack, GL_FALSE);
 491 }
 492
 493
 494
 495 void
 496 _mesa_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 497 {
 498    GET_CURRENT_CONTEXT(ctx);
 499    ASSERT_OUTSIDE_BEGIN_END(ctx, "glColorTableParameterfv");
 500
 501    switch (target) {
 502       case GL_COLOR_TABLE_SGI:
 503          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
 504             ctx->Pixel.ColorTableScale[0] = params[0];
 505             ctx->Pixel.ColorTableScale[1] = params[1];
 506             ctx->Pixel.ColorTableScale[2] = params[2];
 507             ctx->Pixel.ColorTableScale[3] = params[3];
 508          }
 509          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
 510             ctx->Pixel.ColorTableBias[0] = params[0];
 511             ctx->Pixel.ColorTableBias[1] = params[1];
 512             ctx->Pixel.ColorTableBias[2] = params[2];
 513             ctx->Pixel.ColorTableBias[3] = params[3];
 514          }
 515          else {
 516             gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)");
 517             return;
 518          }
 519          break;
 520       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
 521          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
 522             ctx->Pixel.PCCTscale[0] = params[0];
 523             ctx->Pixel.PCCTscale[1] = params[1];
 524             ctx->Pixel.PCCTscale[2] = params[2];
 525             ctx->Pixel.PCCTscale[3] = params[3];
 526          }
 527          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
 528             ctx->Pixel.PCCTbias[0] = params[0];
 529             ctx->Pixel.PCCTbias[1] = params[1];
 530             ctx->Pixel.PCCTbias[2] = params[2];
 531             ctx->Pixel.PCCTbias[3] = params[3];
 532          }
 533          else {
 534             gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)");
 535             return;
 536          }
 537          break;
 538       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
 539          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
 540             ctx->Pixel.PCMCTscale[0] = params[0];
 541             ctx->Pixel.PCMCTscale[1] = params[1];
 542             ctx->Pixel.PCMCTscale[2] = params[2];
 543             ctx->Pixel.PCMCTscale[3] = params[3];
 544          }
 545          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
 546             ctx->Pixel.PCMCTbias[0] = params[0];
 547             ctx->Pixel.PCMCTbias[1] = params[1];
 548             ctx->Pixel.PCMCTbias[2] = params[2];
 549             ctx->Pixel.PCMCTbias[3] = params[3];
 550          }
 551          else {
 552             gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)");
 553             return;
 554          }
 555          break;
 556       default:
 557          gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameter(target)");
 558          return;
 559    }
 560 }
 561
 562
 563
 564 void
 565 _mesa_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 566 {
 567    GLfloat fparams[4];
 568    if (pname == GL_COLOR_TABLE_SGI ||
 569        pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI ||
 570        pname == GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI) {
 571       /* four values */
 572       fparams[0] = (GLfloat) params[0];
 573       fparams[1] = (GLfloat) params[1];
 574       fparams[2] = (GLfloat) params[2];
 575       fparams[3] = (GLfloat) params[3];
 576    }
 577    else {
 578       /* one values */
 579       fparams[0] = (GLfloat) params[0];
 580    }
 581    _mesa_ColorTableParameterfv(target, pname, fparams);
 582 }
 583
 584
 585
 586 void
 587 _mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params )
 588 {
 589    GET_CURRENT_CONTEXT(ctx);
 590    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 591    struct gl_color_table *table = NULL;
 592
 593    ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTableParameterfv");
 594
 595    switch (target) {
 596       case GL_TEXTURE_1D:
 597          table = &texUnit->CurrentD[1]->Palette;
 598          break;
 599       case GL_TEXTURE_2D:
 600          table = &texUnit->CurrentD[2]->Palette;
 601          break;
 602       case GL_TEXTURE_3D:
 603          table = &texUnit->CurrentD[3]->Palette;
 604          break;
 605       case GL_PROXY_TEXTURE_1D:
 606          table = &ctx->Texture.Proxy1D->Palette;
 607          break;
 608       case GL_PROXY_TEXTURE_2D:
 609          table = &ctx->Texture.Proxy2D->Palette;
 610          break;
 611       case GL_PROXY_TEXTURE_3D:
 612          table = &ctx->Texture.Proxy3D->Palette;
 613          break;
 614       case GL_SHARED_TEXTURE_PALETTE_EXT:
 615          table = &ctx->Texture.Palette;
 616          break;
 617       case GL_COLOR_TABLE:
 618          table = &ctx->ColorTable;
 619          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
 620             params[0] = ctx->Pixel.ColorTableScale[0];
 621             params[1] = ctx->Pixel.ColorTableScale[1];
 622             params[2] = ctx->Pixel.ColorTableScale[2];
 623             params[3] = ctx->Pixel.ColorTableScale[3];
 624             return;
 625          }
 626          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
 627             params[0] = ctx->Pixel.ColorTableBias[0];
 628             params[1] = ctx->Pixel.ColorTableBias[1];
 629             params[2] = ctx->Pixel.ColorTableBias[2];
 630             params[3] = ctx->Pixel.ColorTableBias[3];
 631             return;
 632          }
 633          break;
 634       case GL_PROXY_COLOR_TABLE:
 635          table = &ctx->ProxyColorTable;
 636          break;
 637       case GL_POST_CONVOLUTION_COLOR_TABLE:
 638          table = &ctx->PostConvolutionColorTable;
 639          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
 640             params[0] = ctx->Pixel.PCCTscale[0];
 641             params[1] = ctx->Pixel.PCCTscale[1];
 642             params[2] = ctx->Pixel.PCCTscale[2];
 643             params[3] = ctx->Pixel.PCCTscale[3];
 644             return;
 645          }
 646          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
 647             params[0] = ctx->Pixel.PCCTbias[0];
 648             params[1] = ctx->Pixel.PCCTbias[1];
 649             params[2] = ctx->Pixel.PCCTbias[2];
 650             params[3] = ctx->Pixel.PCCTbias[3];
 651             return;
 652          }
 653          break;
 654       case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE:
 655          table = &ctx->ProxyPostConvolutionColorTable;
 656          break;
 657       case GL_POST_COLOR_MATRIX_COLOR_TABLE:
 658          table = &ctx->PostColorMatrixColorTable;
 659          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
 660             params[0] = ctx->Pixel.PCMCTscale[0];
 661             params[1] = ctx->Pixel.PCMCTscale[1];
 662             params[2] = ctx->Pixel.PCMCTscale[2];
 663             params[3] = ctx->Pixel.PCMCTscale[3];
 664             return;
 665          }
 666          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
 667             params[0] = ctx->Pixel.PCMCTbias[0];
 668             params[1] = ctx->Pixel.PCMCTbias[1];
 669             params[2] = ctx->Pixel.PCMCTbias[2];
 670             params[3] = ctx->Pixel.PCMCTbias[3];
 671             return;
 672          }
 673          break;
 674       case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE:
 675          table = &ctx->ProxyPostColorMatrixColorTable;
 676          break;
 677       default:
 678          gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(target)");
 679          return;
 680    }
 681
 682    assert(table);
 683
 684    switch (pname) {
 685       case GL_COLOR_TABLE_FORMAT:
 686          *params = table->IntFormat;
 687          break;
 688       case GL_COLOR_TABLE_WIDTH:
 689          *params = table->Size;
 690          break;
 691       case GL_COLOR_TABLE_RED_SIZE:
 692          *params = table->RedSize;
 693          break;
 694       case GL_COLOR_TABLE_GREEN_SIZE:
 695          *params = table->GreenSize;
 696          break;
 697       case GL_COLOR_TABLE_BLUE_SIZE:
 698          *params = table->BlueSize;
 699          break;
 700       case GL_COLOR_TABLE_ALPHA_SIZE:
 701          *params = table->AlphaSize;
 702          break;
 703       case GL_COLOR_TABLE_LUMINANCE_SIZE:
 704          *params = table->LuminanceSize;
 705          break;
 706       case GL_COLOR_TABLE_INTENSITY_SIZE:
 707          *params = table->IntensitySize;
 708          break;
 709       default:
 710          gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(pname)" );
 711          return;
 712    }
 713 }
 714
 715
 716
 717 void
 718 _mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params )
 719 {
 720    GET_CURRENT_CONTEXT(ctx);
 721    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 722    struct gl_color_table *table = NULL;
 723
 724    ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTableParameteriv");
 725
 726    switch (target) {
 727       case GL_TEXTURE_1D:
 728          table = &texUnit->CurrentD[1]->Palette;
 729          break;
 730       case GL_TEXTURE_2D:
 731          table = &texUnit->CurrentD[2]->Palette;
 732          break;
 733       case GL_TEXTURE_3D:
 734          table = &texUnit->CurrentD[3]->Palette;
 735          break;
 736       case GL_PROXY_TEXTURE_1D:
 737          table = &ctx->Texture.Proxy1D->Palette;
 738          break;
 739       case GL_PROXY_TEXTURE_2D:
 740          table = &ctx->Texture.Proxy2D->Palette;
 741          break;
 742       case GL_PROXY_TEXTURE_3D:
 743          table = &ctx->Texture.Proxy3D->Palette;
 744          break;
 745       case GL_SHARED_TEXTURE_PALETTE_EXT:
 746          table = &ctx->Texture.Palette;
 747          break;
 748       case GL_COLOR_TABLE:
 749          table = &ctx->ColorTable;
 750          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
 751             params[0] = (GLint) ctx->Pixel.ColorTableScale[0];
 752             params[1] = (GLint) ctx->Pixel.ColorTableScale[1];
 753             params[2] = (GLint) ctx->Pixel.ColorTableScale[2];
 754             params[3] = (GLint) ctx->Pixel.ColorTableScale[3];
 755             return;
 756          }
 757          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
 758             params[0] = (GLint) ctx->Pixel.ColorTableBias[0];
 759             params[1] = (GLint) ctx->Pixel.ColorTableBias[1];
 760             params[2] = (GLint) ctx->Pixel.ColorTableBias[2];
 761             params[3] = (GLint) ctx->Pixel.ColorTableBias[3];
 762             return;
 763          }
 764          break;
 765       case GL_PROXY_COLOR_TABLE:
 766          table = &ctx->ProxyColorTable;
 767          break;
 768       case GL_POST_CONVOLUTION_COLOR_TABLE:
 769          table = &ctx->PostConvolutionColorTable;
 770          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
 771             params[0] = (GLint) ctx->Pixel.PCCTscale[0];
 772             params[1] = (GLint) ctx->Pixel.PCCTscale[1];
 773             params[2] = (GLint) ctx->Pixel.PCCTscale[2];
 774             params[3] = (GLint) ctx->Pixel.PCCTscale[3];
 775             return;
 776          }
 777          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
 778             params[0] = (GLint) ctx->Pixel.PCCTbias[0];
 779             params[1] = (GLint) ctx->Pixel.PCCTbias[1];
 780             params[2] = (GLint) ctx->Pixel.PCCTbias[2];
 781             params[3] = (GLint) ctx->Pixel.PCCTbias[3];
 782             return;
 783          }
 784          break;
 785       case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE:
 786          table = &ctx->ProxyPostConvolutionColorTable;
 787          break;
 788       case GL_POST_COLOR_MATRIX_COLOR_TABLE:
 789          table = &ctx->PostColorMatrixColorTable;
 790          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
 791             params[0] = (GLint) ctx->Pixel.PCMCTscale[0];
 792             params[1] = (GLint) ctx->Pixel.PCMCTscale[1];
 793             params[2] = (GLint) ctx->Pixel.PCMCTscale[2];
 794             params[3] = (GLint) ctx->Pixel.PCMCTscale[3];
 795             return;
 796          }
 797          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
 798             params[0] = (GLint) ctx->Pixel.PCMCTbias[0];
 799             params[1] = (GLint) ctx->Pixel.PCMCTbias[1];
 800             params[2] = (GLint) ctx->Pixel.PCMCTbias[2];
 801             params[3] = (GLint) ctx->Pixel.PCMCTbias[3];
 802             return;
 803          }
 804          break;
 805       case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE:
 806          table = &ctx->ProxyPostColorMatrixColorTable;
 807          break;
 808       default:
 809          gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(target)");
 810          return;
 811    }
 812
 813    assert(table);
 814
 815    switch (pname) {
 816       case GL_COLOR_TABLE_FORMAT:
 817          *params = table->IntFormat;
 818          break;
 819       case GL_COLOR_TABLE_WIDTH:
 820          *params = table->Size;
 821          break;
 822       case GL_COLOR_TABLE_RED_SIZE:
 823          *params = table->RedSize;
 824          break;
 825       case GL_COLOR_TABLE_GREEN_SIZE:
 826          *params = table->GreenSize;
 827          break;
 828       case GL_COLOR_TABLE_BLUE_SIZE:
 829          *params = table->BlueSize;
 830          break;
 831       case GL_COLOR_TABLE_ALPHA_SIZE:
 832          *params = table->AlphaSize;
 833          break;
 834       case GL_COLOR_TABLE_LUMINANCE_SIZE:
 835          *params = table->LuminanceSize;
 836          break;
 837       case GL_COLOR_TABLE_INTENSITY_SIZE:
 838          *params = table->IntensitySize;
 839          break;
 840       default:
 841          gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(pname)" );
 842          return;
 843    }
 844 }