src/mesa/shader/prog_statevars.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.0
   4  *
   5  * Copyright (C) 1999-2007  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  * \file prog_statevars.c
  27  * Program state variable management.
  28  * \author Brian Paul
  29  */
  30
  31
  32 #include "glheader.h"
  33 #include "context.h"
  34 #include "hash.h"
  35 #include "imports.h"
  36 #include "macros.h"
  37 #include "mtypes.h"
  38 #include "prog_statevars.h"
  39 #include "prog_parameter.h"
  40 #include "nvvertparse.h"
  41
  42
  43 /**
  44  * Use the list of tokens in the state[] array to find global GL state
  45  * and return it in <value>.  Usually, four values are returned in <value>
  46  * but matrix queries may return as many as 16 values.
  47  * This function is used for ARB vertex/fragment programs.
  48  * The program parser will produce the state[] values.
  49  */
  50 static void
  51 _mesa_fetch_state(GLcontext *ctx, const gl_state_index state[],
  52                   GLfloat *value)
  53 {
  54    switch (state[0]) {
  55    case STATE_MATERIAL:
  56       {
  57          /* state[1] is either 0=front or 1=back side */
  58          const GLuint face = (GLuint) state[1];
  59          const struct gl_material *mat = &ctx->Light.Material;
  60          ASSERT(face == 0 || face == 1);
  61          /* we rely on tokens numbered so that _BACK_ == _FRONT_+ 1 */
  62          ASSERT(MAT_ATTRIB_FRONT_AMBIENT + 1 == MAT_ATTRIB_BACK_AMBIENT);
  63          /* XXX we could get rid of this switch entirely with a little
  64           * work in arbprogparse.c's parse_state_single_item().
  65           */
  66          /* state[2] is the material attribute */
  67          switch (state[2]) {
  68          case STATE_AMBIENT:
  69             COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_AMBIENT + face]);
  70             return;
  71          case STATE_DIFFUSE:
  72             COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_DIFFUSE + face]);
  73             return;
  74          case STATE_SPECULAR:
  75             COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_SPECULAR + face]);
  76             return;
  77          case STATE_EMISSION:
  78             COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_EMISSION + face]);
  79             return;
  80          case STATE_SHININESS:
  81             value[0] = mat->Attrib[MAT_ATTRIB_FRONT_SHININESS + face][0];
  82             value[1] = 0.0F;
  83             value[2] = 0.0F;
  84             value[3] = 1.0F;
  85             return;
  86          default:
  87             _mesa_problem(ctx, "Invalid material state in fetch_state");
  88             return;
  89          }
  90       }
  91    case STATE_LIGHT:
  92       {
  93          /* state[1] is the light number */
  94          const GLuint ln = (GLuint) state[1];
  95          /* state[2] is the light attribute */
  96          switch (state[2]) {
  97          case STATE_AMBIENT:
  98             COPY_4V(value, ctx->Light.Light[ln].Ambient);
  99             return;
 100          case STATE_DIFFUSE:
 101             COPY_4V(value, ctx->Light.Light[ln].Diffuse);
 102             return;
 103          case STATE_SPECULAR:
 104             COPY_4V(value, ctx->Light.Light[ln].Specular);
 105             return;
 106          case STATE_POSITION:
 107             COPY_4V(value, ctx->Light.Light[ln].EyePosition);
 108             return;
 109          case STATE_ATTENUATION:
 110             value[0] = ctx->Light.Light[ln].ConstantAttenuation;
 111             value[1] = ctx->Light.Light[ln].LinearAttenuation;
 112             value[2] = ctx->Light.Light[ln].QuadraticAttenuation;
 113             value[3] = ctx->Light.Light[ln].SpotExponent;
 114             return;
 115          case STATE_SPOT_DIRECTION:
 116             COPY_3V(value, ctx->Light.Light[ln].EyeDirection);
 117             value[3] = ctx->Light.Light[ln]._CosCutoff;
 118             return;
 119          case STATE_SPOT_CUTOFF:
 120             value[0] = ctx->Light.Light[ln].SpotCutoff;
 121             return;
 122          case STATE_HALF_VECTOR:
 123             {
 124                static const GLfloat eye_z[] = {0, 0, 1};
 125                GLfloat p[3];
 126                /* Compute infinite half angle vector:
 127                 *   halfVector = normalize(normalize(lightPos) + (0, 0, 1))
 128                 * light.EyePosition.w should be 0 for infinite lights.
 129                 */
 130                COPY_3V(p, ctx->Light.Light[ln].EyePosition);
 131                NORMALIZE_3FV(p);
 132                ADD_3V(value, p, eye_z);
 133                NORMALIZE_3FV(value);
 134                value[3] = 1.0;
 135             }
 136             return;
 137          case STATE_POSITION_NORMALIZED:
 138             COPY_4V(value, ctx->Light.Light[ln].EyePosition);
 139             NORMALIZE_3FV( value );
 140             return;
 141          default:
 142             _mesa_problem(ctx, "Invalid light state in fetch_state");
 143             return;
 144          }
 145       }
 146    case STATE_LIGHTMODEL_AMBIENT:
 147       COPY_4V(value, ctx->Light.Model.Ambient);
 148       return;
 149    case STATE_LIGHTMODEL_SCENECOLOR:
 150       if (state[1] == 0) {
 151          /* front */
 152          GLint i;
 153          for (i = 0; i < 3; i++) {
 154             value[i] = ctx->Light.Model.Ambient[i]
 155                * ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT][i]
 156                + ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_EMISSION][i];
 157          }
 158          value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE][3];
 159       }
 160       else {
 161          /* back */
 162          GLint i;
 163          for (i = 0; i < 3; i++) {
 164             value[i] = ctx->Light.Model.Ambient[i]
 165                * ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_AMBIENT][i]
 166                + ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_EMISSION][i];
 167          }
 168          value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_DIFFUSE][3];
 169       }
 170       return;
 171    case STATE_LIGHTPROD:
 172       {
 173          const GLuint ln = (GLuint) state[1];
 174          const GLuint face = (GLuint) state[2];
 175          GLint i;
 176          ASSERT(face == 0 || face == 1);
 177          switch (state[3]) {
 178             case STATE_AMBIENT:
 179                for (i = 0; i < 3; i++) {
 180                   value[i] = ctx->Light.Light[ln].Ambient[i] *
 181                      ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][i];
 182                }
 183                /* [3] = material alpha */
 184                value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][3];
 185                return;
 186             case STATE_DIFFUSE:
 187                for (i = 0; i < 3; i++) {
 188                   value[i] = ctx->Light.Light[ln].Diffuse[i] *
 189                      ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][i];
 190                }
 191                /* [3] = material alpha */
 192                value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][3];
 193                return;
 194             case STATE_SPECULAR:
 195                for (i = 0; i < 3; i++) {
 196                   value[i] = ctx->Light.Light[ln].Specular[i] *
 197                      ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][i];
 198                }
 199                /* [3] = material alpha */
 200                value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][3];
 201                return;
 202             default:
 203                _mesa_problem(ctx, "Invalid lightprod state in fetch_state");
 204                return;
 205          }
 206       }
 207    case STATE_TEXGEN:
 208       {
 209          /* state[1] is the texture unit */
 210          const GLuint unit = (GLuint) state[1];
 211          /* state[2] is the texgen attribute */
 212          switch (state[2]) {
 213          case STATE_TEXGEN_EYE_S:
 214             COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneS);
 215             return;
 216          case STATE_TEXGEN_EYE_T:
 217             COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneT);
 218             return;
 219          case STATE_TEXGEN_EYE_R:
 220             COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneR);
 221             return;
 222          case STATE_TEXGEN_EYE_Q:
 223             COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneQ);
 224             return;
 225          case STATE_TEXGEN_OBJECT_S:
 226             COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneS);
 227             return;
 228          case STATE_TEXGEN_OBJECT_T:
 229             COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneT);
 230             return;
 231          case STATE_TEXGEN_OBJECT_R:
 232             COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneR);
 233             return;
 234          case STATE_TEXGEN_OBJECT_Q:
 235             COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneQ);
 236             return;
 237          default:
 238             _mesa_problem(ctx, "Invalid texgen state in fetch_state");
 239             return;
 240          }
 241       }
 242    case STATE_TEXENV_COLOR:
 243       {
 244          /* state[1] is the texture unit */
 245          const GLuint unit = (GLuint) state[1];
 246          COPY_4V(value, ctx->Texture.Unit[unit].EnvColor);
 247       }
 248       return;
 249    case STATE_FOG_COLOR:
 250       COPY_4V(value, ctx->Fog.Color);
 251       return;
 252    case STATE_FOG_PARAMS:
 253       value[0] = ctx->Fog.Density;
 254       value[1] = ctx->Fog.Start;
 255       value[2] = ctx->Fog.End;
 256       value[3] = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
 257       return;
 258    case STATE_CLIPPLANE:
 259       {
 260          const GLuint plane = (GLuint) state[1];
 261          COPY_4V(value, ctx->Transform.EyeUserPlane[plane]);
 262       }
 263       return;
 264    case STATE_POINT_SIZE:
 265       value[0] = ctx->Point.Size;
 266       value[1] = ctx->Point.MinSize;
 267       value[2] = ctx->Point.MaxSize;
 268       value[3] = ctx->Point.Threshold;
 269       return;
 270    case STATE_POINT_ATTENUATION:
 271       value[0] = ctx->Point.Params[0];
 272       value[1] = ctx->Point.Params[1];
 273       value[2] = ctx->Point.Params[2];
 274       value[3] = 1.0F;
 275       return;
 276    case STATE_MODELVIEW_MATRIX:
 277    case STATE_PROJECTION_MATRIX:
 278    case STATE_MVP_MATRIX:
 279    case STATE_TEXTURE_MATRIX:
 280    case STATE_PROGRAM_MATRIX:
 281       {
 282          /* state[0] = modelview, projection, texture, etc. */
 283          /* state[1] = which texture matrix or program matrix */
 284          /* state[2] = first row to fetch */
 285          /* state[3] = last row to fetch */
 286          /* state[4] = transpose, inverse or invtrans */
 287          const GLmatrix *matrix;
 288          const gl_state_index mat = state[0];
 289          const GLuint index = (GLuint) state[1];
 290          const GLuint firstRow = (GLuint) state[2];
 291          const GLuint lastRow = (GLuint) state[3];
 292          const gl_state_index modifier = state[4];
 293          const GLfloat *m;
 294          GLuint row, i;
 295          ASSERT(firstRow >= 0);
 296          ASSERT(firstRow < 4);
 297          ASSERT(lastRow >= 0);
 298          ASSERT(lastRow < 4);
 299          if (mat == STATE_MODELVIEW_MATRIX) {
 300             matrix = ctx->ModelviewMatrixStack.Top;
 301          }
 302          else if (mat == STATE_PROJECTION_MATRIX) {
 303             matrix = ctx->ProjectionMatrixStack.Top;
 304          }
 305          else if (mat == STATE_MVP_MATRIX) {
 306             matrix = &ctx->_ModelProjectMatrix;
 307          }
 308          else if (mat == STATE_TEXTURE_MATRIX) {
 309             matrix = ctx->TextureMatrixStack[index].Top;
 310          }
 311          else if (mat == STATE_PROGRAM_MATRIX) {
 312             matrix = ctx->ProgramMatrixStack[index].Top;
 313          }
 314          else {
 315             _mesa_problem(ctx, "Bad matrix name in _mesa_fetch_state()");
 316             return;
 317          }
 318          if (modifier == STATE_MATRIX_INVERSE ||
 319              modifier == STATE_MATRIX_INVTRANS) {
 320             /* Be sure inverse is up to date:
 321              */
 322             _math_matrix_alloc_inv( (GLmatrix *) matrix );
 323             _math_matrix_analyse( (GLmatrix*) matrix );
 324             m = matrix->inv;
 325          }
 326          else {
 327             m = matrix->m;
 328          }
 329          if (modifier == STATE_MATRIX_TRANSPOSE ||
 330              modifier == STATE_MATRIX_INVTRANS) {
 331             for (i = 0, row = firstRow; row <= lastRow; row++) {
 332                value[i++] = m[row * 4 + 0];
 333                value[i++] = m[row * 4 + 1];
 334                value[i++] = m[row * 4 + 2];
 335                value[i++] = m[row * 4 + 3];
 336             }
 337          }
 338          else {
 339             for (i = 0, row = firstRow; row <= lastRow; row++) {
 340                value[i++] = m[row + 0];
 341                value[i++] = m[row + 4];
 342                value[i++] = m[row + 8];
 343                value[i++] = m[row + 12];
 344             }
 345          }
 346       }
 347       return;
 348    case STATE_DEPTH_RANGE:
 349       value[0] = ctx->Viewport.Near;                     /* near       */
 350       value[1] = ctx->Viewport.Far;                      /* far        */
 351       value[2] = ctx->Viewport.Far - ctx->Viewport.Near; /* far - near */
 352       value[3] = 0;
 353       return;
 354    case STATE_FRAGMENT_PROGRAM:
 355       {
 356          /* state[1] = {STATE_ENV, STATE_LOCAL} */
 357          /* state[2] = parameter index          */
 358          const int idx = (int) state[2];
 359          switch (state[1]) {
 360             case STATE_ENV:
 361                COPY_4V(value, ctx->FragmentProgram.Parameters[idx]);
 362                break;
 363             case STATE_LOCAL:
 364                COPY_4V(value, ctx->FragmentProgram.Current->Base.LocalParams[idx]);
 365                break;
 366             default:
 367                _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
 368                return;
 369          }
 370       }
 371       return;
 372
 373    case STATE_VERTEX_PROGRAM:
 374       {
 375          /* state[1] = {STATE_ENV, STATE_LOCAL} */
 376          /* state[2] = parameter index          */
 377          const int idx = (int) state[2];
 378          switch (state[1]) {
 379             case STATE_ENV:
 380                COPY_4V(value, ctx->VertexProgram.Parameters[idx]);
 381                break;
 382             case STATE_LOCAL:
 383                COPY_4V(value, ctx->VertexProgram.Current->Base.LocalParams[idx]);
 384                break;
 385             default:
 386                _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
 387                return;
 388          }
 389       }
 390       return;
 391
 392    case STATE_NORMAL_SCALE:
 393       ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
 394       return;
 395
 396    case STATE_INTERNAL:
 397       switch (state[1]) {
 398       case STATE_NORMAL_SCALE:
 399          ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
 400          return;
 401       case STATE_TEXRECT_SCALE:
 402          {
 403             const int unit = (int) state[2];
 404             const struct gl_texture_object *texObj
 405                = ctx->Texture.Unit[unit]._Current;
 406             if (texObj) {
 407                struct gl_texture_image *texImage = texObj->Image[0][0];
 408                ASSIGN_4V(value, 1.0 / texImage->Width,
 409                          1.0 / texImage->Height,
 410                          0.0, 1.0);
 411             }
 412          }
 413          return;
 414       case STATE_FOG_PARAMS_OPTIMIZED:
 415          /* for simpler per-vertex/pixel fog calcs. POW (for EXP/EXP2 fog)
 416           * might be more expensive than EX2 on some hw, plus it needs
 417           * another constant (e) anyway. Linear fog can now be done with a
 418           * single MAD.
 419           * linear: fogcoord * -1/(end-start) + end/(end-start)
 420           * exp: 2^-(density/ln(2) * fogcoord)
 421           * exp2: 2^-((density/(ln(2)^2) * fogcoord)^2)
 422           */
 423          value[0] = -1.0F / (ctx->Fog.End - ctx->Fog.Start);
 424          value[1] = ctx->Fog.End / (ctx->Fog.End - ctx->Fog.Start);
 425          value[2] = ctx->Fog.Density * ONE_DIV_LN2;
 426          value[3] = ctx->Fog.Density * ONE_DIV_SQRT_LN2;
 427          return;
 428       case STATE_SPOT_DIR_NORMALIZED: {
 429          /* here, state[2] is the light number */
 430          /* pre-normalize spot dir */
 431          const GLuint ln = (GLuint) state[2];
 432          COPY_3V(value, ctx->Light.Light[ln].EyeDirection);
 433          NORMALIZE_3FV(value);
 434          value[3] = ctx->Light.Light[ln]._CosCutoff;
 435          return;
 436       }
 437       default:
 438          /* unknown state indexes are silently ignored
 439           *  should be handled by the driver.
 440           */
 441          return;
 442       }
 443       return;
 444
 445    default:
 446       _mesa_problem(ctx, "Invalid state in _mesa_fetch_state");
 447       return;
 448    }
 449 }
 450
 451
 452 /**
 453  * Return a bitmask of the Mesa state flags (_NEW_* values) which would
 454  * indicate that the given context state may have changed.
 455  * The bitmask is used during validation to determine if we need to update
 456  * vertex/fragment program parameters (like "state.material.color") when
 457  * some GL state has changed.
 458  */
 459 GLbitfield
 460 _mesa_program_state_flags(const gl_state_index state[STATE_LENGTH])
 461 {
 462    switch (state[0]) {
 463    case STATE_MATERIAL:
 464    case STATE_LIGHT:
 465    case STATE_LIGHTMODEL_AMBIENT:
 466    case STATE_LIGHTMODEL_SCENECOLOR:
 467    case STATE_LIGHTPROD:
 468       return _NEW_LIGHT;
 469
 470    case STATE_TEXGEN:
 471    case STATE_TEXENV_COLOR:
 472       return _NEW_TEXTURE;
 473
 474    case STATE_FOG_COLOR:
 475    case STATE_FOG_PARAMS:
 476       return _NEW_FOG;
 477
 478    case STATE_CLIPPLANE:
 479       return _NEW_TRANSFORM;
 480
 481    case STATE_POINT_SIZE:
 482    case STATE_POINT_ATTENUATION:
 483       return _NEW_POINT;
 484
 485    case STATE_MODELVIEW_MATRIX:
 486       return _NEW_MODELVIEW;
 487    case STATE_PROJECTION_MATRIX:
 488       return _NEW_PROJECTION;
 489    case STATE_MVP_MATRIX:
 490       return _NEW_MODELVIEW | _NEW_PROJECTION;
 491    case STATE_TEXTURE_MATRIX:
 492       return _NEW_TEXTURE_MATRIX;
 493    case STATE_PROGRAM_MATRIX:
 494       return _NEW_TRACK_MATRIX;
 495
 496    case STATE_DEPTH_RANGE:
 497       return _NEW_VIEWPORT;
 498
 499    case STATE_FRAGMENT_PROGRAM:
 500    case STATE_VERTEX_PROGRAM:
 501       return _NEW_PROGRAM;
 502
 503    case STATE_NORMAL_SCALE:
 504       return _NEW_MODELVIEW;
 505
 506    case STATE_INTERNAL:
 507       switch (state[1]) {
 508       case STATE_TEXRECT_SCALE:
 509          return _NEW_TEXTURE;
 510       default:
 511          /* unknown state indexes are silently ignored and
 512          *  no flag set, since it is handled by the driver.
 513          */
 514          return 0;
 515       }
 516
 517    default:
 518       _mesa_problem(NULL, "unexpected state[0] in make_state_flags()");
 519       return 0;
 520    }
 521 }
 522
 523
 524 static void
 525 append(char *dst, const char *src)
 526 {
 527    while (*dst)
 528       dst++;
 529    while (*src)
 530      *dst++ = *src++;
 531    *dst = 0;
 532 }
 533
 534
 535 static void
 536 append_token(char *dst, gl_state_index k)
 537 {
 538    switch (k) {
 539    case STATE_MATERIAL:
 540       append(dst, "material");
 541       break;
 542    case STATE_LIGHT:
 543       append(dst, "light");
 544       break;
 545    case STATE_LIGHTMODEL_AMBIENT:
 546       append(dst, "lightmodel.ambient");
 547       break;
 548    case STATE_LIGHTMODEL_SCENECOLOR:
 549       break;
 550    case STATE_LIGHTPROD:
 551       append(dst, "lightprod");
 552       break;
 553    case STATE_TEXGEN:
 554       append(dst, "texgen");
 555       break;
 556    case STATE_FOG_COLOR:
 557       append(dst, "fog.color");
 558       break;
 559    case STATE_FOG_PARAMS:
 560       append(dst, "fog.params");
 561       break;
 562    case STATE_CLIPPLANE:
 563       append(dst, "clip");
 564       break;
 565    case STATE_POINT_SIZE:
 566       append(dst, "point.size");
 567       break;
 568    case STATE_POINT_ATTENUATION:
 569       append(dst, "point.attenuation");
 570       break;
 571    case STATE_MODELVIEW_MATRIX:
 572       append(dst, "matrix.modelview");
 573       break;
 574    case STATE_PROJECTION_MATRIX:
 575       append(dst, "matrix.projection");
 576       break;
 577    case STATE_MVP_MATRIX:
 578       append(dst, "matrix.mvp");
 579       break;
 580    case STATE_TEXTURE_MATRIX:
 581       append(dst, "matrix.texture");
 582       break;
 583    case STATE_PROGRAM_MATRIX:
 584       append(dst, "matrix.program");
 585       break;
 586    case STATE_MATRIX_INVERSE:
 587       append(dst, ".inverse");
 588       break;
 589    case STATE_MATRIX_TRANSPOSE:
 590       append(dst, ".transpose");
 591       break;
 592    case STATE_MATRIX_INVTRANS:
 593       append(dst, ".invtrans");
 594       break;
 595    case STATE_AMBIENT:
 596       append(dst, ".ambient");
 597       break;
 598    case STATE_DIFFUSE:
 599       append(dst, ".diffuse");
 600       break;
 601    case STATE_SPECULAR:
 602       append(dst, ".specular");
 603       break;
 604    case STATE_EMISSION:
 605       append(dst, ".emission");
 606       break;
 607    case STATE_SHININESS:
 608       append(dst, "lshininess");
 609       break;
 610    case STATE_HALF_VECTOR:
 611       append(dst, ".half");
 612       break;
 613    case STATE_POSITION:
 614       append(dst, ".position");
 615       break;
 616    case STATE_ATTENUATION:
 617       append(dst, ".attenuation");
 618       break;
 619    case STATE_SPOT_DIRECTION:
 620       append(dst, ".spot.direction");
 621       break;
 622    case STATE_SPOT_CUTOFF:
 623       append(dst, ".spot.cutoff");
 624       break;
 625    case STATE_TEXGEN_EYE_S:
 626       append(dst, "eye.s");
 627       break;
 628    case STATE_TEXGEN_EYE_T:
 629       append(dst, "eye.t");
 630       break;
 631    case STATE_TEXGEN_EYE_R:
 632       append(dst, "eye.r");
 633       break;
 634    case STATE_TEXGEN_EYE_Q:
 635       append(dst, "eye.q");
 636       break;
 637    case STATE_TEXGEN_OBJECT_S:
 638       append(dst, "object.s");
 639       break;
 640    case STATE_TEXGEN_OBJECT_T:
 641       append(dst, "object.t");
 642       break;
 643    case STATE_TEXGEN_OBJECT_R:
 644       append(dst, "object.r");
 645       break;
 646    case STATE_TEXGEN_OBJECT_Q:
 647       append(dst, "object.q");
 648       break;
 649    case STATE_TEXENV_COLOR:
 650       append(dst, "texenv");
 651       break;
 652    case STATE_DEPTH_RANGE:
 653       append(dst, "depth.range");
 654       break;
 655    case STATE_VERTEX_PROGRAM:
 656    case STATE_FRAGMENT_PROGRAM:
 657       break;
 658    case STATE_ENV:
 659       append(dst, "env");
 660       break;
 661    case STATE_LOCAL:
 662       append(dst, "local");
 663       break;
 664    case STATE_NORMAL_SCALE:
 665       append(dst, "normalScale");
 666       break;
 667    case STATE_INTERNAL:
 668    case STATE_POSITION_NORMALIZED:
 669       append(dst, "(internal)");
 670       break;
 671    default:
 672       ;
 673    }
 674 }
 675
 676 static void
 677 append_face(char *dst, GLint face)
 678 {
 679    if (face == 0)
 680       append(dst, "front.");
 681    else
 682       append(dst, "back.");
 683 }
 684
 685 static void
 686 append_index(char *dst, GLint index)
 687 {
 688    char s[20];
 689    _mesa_sprintf(s, "[%d]", index);
 690    append(dst, s);
 691 }
 692
 693 /**
 694  * Make a string from the given state vector.
 695  * For example, return "state.matrix.texture[2].inverse".
 696  * Use _mesa_free() to deallocate the string.
 697  */
 698 const char *
 699 _mesa_program_state_string(const gl_state_index state[STATE_LENGTH])
 700 {
 701    char str[1000] = "";
 702    char tmp[30];
 703
 704    append(str, "state.");
 705    append_token(str, (gl_state_index) state[0]);
 706
 707    switch (state[0]) {
 708    case STATE_MATERIAL:
 709       append_face(str, state[1]);
 710       append_token(str, (gl_state_index) state[2]);
 711       break;
 712    case STATE_LIGHT:
 713       append_index(str, state[1]); /* light number [i]. */
 714       append_token(str, (gl_state_index) state[2]); /* coefficients */
 715       break;
 716    case STATE_LIGHTMODEL_AMBIENT:
 717       append(str, "lightmodel.ambient");
 718       break;
 719    case STATE_LIGHTMODEL_SCENECOLOR:
 720       if (state[1] == 0) {
 721          append(str, "lightmodel.front.scenecolor");
 722       }
 723       else {
 724          append(str, "lightmodel.back.scenecolor");
 725       }
 726       break;
 727    case STATE_LIGHTPROD:
 728       append_index(str, state[1]); /* light number [i]. */
 729       append_face(str, state[2]);
 730       append_token(str, (gl_state_index) state[3]);
 731       break;
 732    case STATE_TEXGEN:
 733       append_index(str, state[1]); /* tex unit [i] */
 734       append_token(str, (gl_state_index) state[2]); /* plane coef */
 735       break;
 736    case STATE_TEXENV_COLOR:
 737       append_index(str, state[1]); /* tex unit [i] */
 738       append(str, "color");
 739       break;
 740    case STATE_CLIPPLANE:
 741       append_index(str, state[1]); /* plane [i] */
 742       append(str, ".plane");
 743       break;
 744    case STATE_MODELVIEW_MATRIX:
 745    case STATE_PROJECTION_MATRIX:
 746    case STATE_MVP_MATRIX:
 747    case STATE_TEXTURE_MATRIX:
 748    case STATE_PROGRAM_MATRIX:
 749       {
 750          /* state[0] = modelview, projection, texture, etc. */
 751          /* state[1] = which texture matrix or program matrix */
 752          /* state[2] = first row to fetch */
 753          /* state[3] = last row to fetch */
 754          /* state[4] = transpose, inverse or invtrans */
 755          const gl_state_index mat = (gl_state_index) state[0];
 756          const GLuint index = (GLuint) state[1];
 757          const GLuint firstRow = (GLuint) state[2];
 758          const GLuint lastRow = (GLuint) state[3];
 759          const gl_state_index modifier = (gl_state_index) state[4];
 760          if (index ||
 761              mat == STATE_TEXTURE_MATRIX ||
 762              mat == STATE_PROGRAM_MATRIX)
 763             append_index(str, index);
 764          if (modifier)
 765             append_token(str, modifier);
 766          if (firstRow == lastRow)
 767             _mesa_sprintf(tmp, ".row[%d]", firstRow);
 768          else
 769             _mesa_sprintf(tmp, ".row[%d..%d]", firstRow, lastRow);
 770          append(str, tmp);
 771       }
 772       break;
 773    case STATE_POINT_SIZE:
 774       break;
 775    case STATE_POINT_ATTENUATION:
 776       break;
 777    case STATE_FOG_PARAMS:
 778       break;
 779    case STATE_FOG_COLOR:
 780       break;
 781    case STATE_DEPTH_RANGE:
 782       break;
 783    case STATE_FRAGMENT_PROGRAM:
 784    case STATE_VERTEX_PROGRAM:
 785       /* state[1] = {STATE_ENV, STATE_LOCAL} */
 786       /* state[2] = parameter index          */
 787       append_token(str, (gl_state_index) state[1]);
 788       append_index(str, state[2]);
 789       break;
 790    case STATE_INTERNAL:
 791       break;
 792    default:
 793       _mesa_problem(NULL, "Invalid state in _mesa_program_state_string");
 794       break;
 795    }
 796
 797    return _mesa_strdup(str);
 798 }
 799
 800
 801 /**
 802  * Loop over all the parameters in a parameter list.  If the parameter
 803  * is a GL state reference, look up the current value of that state
 804  * variable and put it into the parameter's Value[4] array.
 805  * This would be called at glBegin time when using a fragment program.
 806  */
 807 void
 808 _mesa_load_state_parameters(GLcontext *ctx,
 809                             struct gl_program_parameter_list *paramList)
 810 {
 811    GLuint i;
 812
 813    if (!paramList)
 814       return;
 815
 816    for (i = 0; i < paramList->NumParameters; i++) {
 817       if (paramList->Parameters[i].Type == PROGRAM_STATE_VAR) {
 818          _mesa_fetch_state(ctx,
 819                            (gl_state_index *) paramList->Parameters[i].StateIndexes,
 820                            paramList->ParameterValues[i]);
 821       }
 822    }
 823 }
 824