src/mesa/shader/prog_statevars.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.1
   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_AMBIENT+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_SPECULAR+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] = (ctx->Fog.End == ctx->Fog.Start)
 257          ? 1.0 : 1.0F / (ctx->Fog.End - ctx->Fog.Start);
 258       return;
 259    case STATE_CLIPPLANE:
 260       {
 261          const GLuint plane = (GLuint) state[1];
 262          COPY_4V(value, ctx->Transform.EyeUserPlane[plane]);
 263       }
 264       return;
 265    case STATE_POINT_SIZE:
 266       value[0] = ctx->Point.Size;
 267       value[1] = ctx->Point.MinSize;
 268       value[2] = ctx->Point.MaxSize;
 269       value[3] = ctx->Point.Threshold;
 270       return;
 271    case STATE_POINT_ATTENUATION:
 272       value[0] = ctx->Point.Params[0];
 273       value[1] = ctx->Point.Params[1];
 274       value[2] = ctx->Point.Params[2];
 275       value[3] = 1.0F;
 276       return;
 277    case STATE_MODELVIEW_MATRIX:
 278    case STATE_PROJECTION_MATRIX:
 279    case STATE_MVP_MATRIX:
 280    case STATE_TEXTURE_MATRIX:
 281    case STATE_PROGRAM_MATRIX:
 282    case STATE_COLOR_MATRIX:
 283       {
 284          /* state[0] = modelview, projection, texture, etc. */
 285          /* state[1] = which texture matrix or program matrix */
 286          /* state[2] = first row to fetch */
 287          /* state[3] = last row to fetch */
 288          /* state[4] = transpose, inverse or invtrans */
 289          const GLmatrix *matrix;
 290          const gl_state_index mat = state[0];
 291          const GLuint index = (GLuint) state[1];
 292          const GLuint firstRow = (GLuint) state[2];
 293          const GLuint lastRow = (GLuint) state[3];
 294          const gl_state_index modifier = state[4];
 295          const GLfloat *m;
 296          GLuint row, i;
 297          ASSERT(firstRow >= 0);
 298          ASSERT(firstRow < 4);
 299          ASSERT(lastRow >= 0);
 300          ASSERT(lastRow < 4);
 301          if (mat == STATE_MODELVIEW_MATRIX) {
 302             matrix = ctx->ModelviewMatrixStack.Top;
 303          }
 304          else if (mat == STATE_PROJECTION_MATRIX) {
 305             matrix = ctx->ProjectionMatrixStack.Top;
 306          }
 307          else if (mat == STATE_MVP_MATRIX) {
 308             matrix = &ctx->_ModelProjectMatrix;
 309          }
 310          else if (mat == STATE_TEXTURE_MATRIX) {
 311             matrix = ctx->TextureMatrixStack[index].Top;
 312          }
 313          else if (mat == STATE_PROGRAM_MATRIX) {
 314             matrix = ctx->ProgramMatrixStack[index].Top;
 315          }
 316          else if (mat == STATE_COLOR_MATRIX) {
 317             matrix = ctx->ColorMatrixStack.Top;
 318          }
 319          else {
 320             _mesa_problem(ctx, "Bad matrix name in _mesa_fetch_state()");
 321             return;
 322          }
 323          if (modifier == STATE_MATRIX_INVERSE ||
 324              modifier == STATE_MATRIX_INVTRANS) {
 325             /* Be sure inverse is up to date:
 326              */
 327             _math_matrix_alloc_inv( (GLmatrix *) matrix );
 328             _math_matrix_analyse( (GLmatrix*) matrix );
 329             m = matrix->inv;
 330          }
 331          else {
 332             m = matrix->m;
 333          }
 334          if (modifier == STATE_MATRIX_TRANSPOSE ||
 335              modifier == STATE_MATRIX_INVTRANS) {
 336             for (i = 0, row = firstRow; row <= lastRow; row++) {
 337                value[i++] = m[row * 4 + 0];
 338                value[i++] = m[row * 4 + 1];
 339                value[i++] = m[row * 4 + 2];
 340                value[i++] = m[row * 4 + 3];
 341             }
 342          }
 343          else {
 344             for (i = 0, row = firstRow; row <= lastRow; row++) {
 345                value[i++] = m[row + 0];
 346                value[i++] = m[row + 4];
 347                value[i++] = m[row + 8];
 348                value[i++] = m[row + 12];
 349             }
 350          }
 351       }
 352       return;
 353    case STATE_DEPTH_RANGE:
 354       value[0] = ctx->Viewport.Near;                     /* near       */
 355       value[1] = ctx->Viewport.Far;                      /* far        */
 356       value[2] = ctx->Viewport.Far - ctx->Viewport.Near; /* far - near */
 357       value[3] = 1.0;
 358       return;
 359    case STATE_FRAGMENT_PROGRAM:
 360       {
 361          /* state[1] = {STATE_ENV, STATE_LOCAL} */
 362          /* state[2] = parameter index          */
 363          const int idx = (int) state[2];
 364          switch (state[1]) {
 365             case STATE_ENV:
 366                COPY_4V(value, ctx->FragmentProgram.Parameters[idx]);
 367                break;
 368             case STATE_LOCAL:
 369                COPY_4V(value, ctx->FragmentProgram.Current->Base.LocalParams[idx]);
 370                break;
 371             default:
 372                _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
 373                return;
 374          }
 375       }
 376       return;
 377
 378    case STATE_VERTEX_PROGRAM:
 379       {
 380          /* state[1] = {STATE_ENV, STATE_LOCAL} */
 381          /* state[2] = parameter index          */
 382          const int idx = (int) state[2];
 383          switch (state[1]) {
 384             case STATE_ENV:
 385                COPY_4V(value, ctx->VertexProgram.Parameters[idx]);
 386                break;
 387             case STATE_LOCAL:
 388                COPY_4V(value, ctx->VertexProgram.Current->Base.LocalParams[idx]);
 389                break;
 390             default:
 391                _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
 392                return;
 393          }
 394       }
 395       return;
 396
 397    case STATE_NORMAL_SCALE:
 398       ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
 399       return;
 400
 401    case STATE_INTERNAL:
 402       switch (state[1]) {
 403       case STATE_NORMAL_SCALE:
 404          ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
 405          return;
 406       case STATE_TEXRECT_SCALE:
 407          {
 408             const int unit = (int) state[2];
 409             const struct gl_texture_object *texObj
 410                = ctx->Texture.Unit[unit]._Current;
 411             if (texObj) {
 412                struct gl_texture_image *texImage = texObj->Image[0][0];
 413                ASSIGN_4V(value, 1.0 / texImage->Width,
 414                          1.0 / texImage->Height,
 415                          0.0, 1.0);
 416             }
 417          }
 418          return;
 419       case STATE_FOG_PARAMS_OPTIMIZED:
 420          /* for simpler per-vertex/pixel fog calcs. POW (for EXP/EXP2 fog)
 421           * might be more expensive than EX2 on some hw, plus it needs
 422           * another constant (e) anyway. Linear fog can now be done with a
 423           * single MAD.
 424           * linear: fogcoord * -1/(end-start) + end/(end-start)
 425           * exp: 2^-(density/ln(2) * fogcoord)
 426           * exp2: 2^-((density/(ln(2)^2) * fogcoord)^2)
 427           */
 428          value[0] = (ctx->Fog.End == ctx->Fog.Start)
 429             ? 1.0 : -1.0F / (ctx->Fog.End - ctx->Fog.Start);
 430          value[1] = ctx->Fog.End * -value[0];
 431          value[2] = ctx->Fog.Density * ONE_DIV_LN2;
 432          value[3] = ctx->Fog.Density * ONE_DIV_SQRT_LN2;
 433          return;
 434       case STATE_SPOT_DIR_NORMALIZED: {
 435          /* here, state[2] is the light number */
 436          /* pre-normalize spot dir */
 437          const GLuint ln = (GLuint) state[2];
 438          COPY_3V(value, ctx->Light.Light[ln].EyeDirection);
 439          NORMALIZE_3FV(value);
 440          value[3] = ctx->Light.Light[ln]._CosCutoff;
 441          return;
 442       }
 443       case STATE_PT_SCALE:
 444          value[0] = ctx->Pixel.RedScale;
 445          value[1] = ctx->Pixel.GreenScale;
 446          value[2] = ctx->Pixel.BlueScale;
 447          value[3] = ctx->Pixel.AlphaScale;
 448          break;
 449       case STATE_PT_BIAS:
 450          value[0] = ctx->Pixel.RedBias;
 451          value[1] = ctx->Pixel.GreenBias;
 452          value[2] = ctx->Pixel.BlueBias;
 453          value[3] = ctx->Pixel.AlphaBias;
 454          break;
 455       case STATE_PCM_SCALE:
 456          COPY_4V(value, ctx->Pixel.PostColorMatrixScale);
 457          break;
 458       case STATE_PCM_BIAS:
 459          COPY_4V(value, ctx->Pixel.PostColorMatrixBias);
 460          break;
 461       default:
 462          /* unknown state indexes are silently ignored
 463           *  should be handled by the driver.
 464           */
 465          return;
 466       }
 467       return;
 468
 469    default:
 470       _mesa_problem(ctx, "Invalid state in _mesa_fetch_state");
 471       return;
 472    }
 473 }
 474
 475
 476 /**
 477  * Return a bitmask of the Mesa state flags (_NEW_* values) which would
 478  * indicate that the given context state may have changed.
 479  * The bitmask is used during validation to determine if we need to update
 480  * vertex/fragment program parameters (like "state.material.color") when
 481  * some GL state has changed.
 482  */
 483 GLbitfield
 484 _mesa_program_state_flags(const gl_state_index state[STATE_LENGTH])
 485 {
 486    switch (state[0]) {
 487    case STATE_MATERIAL:
 488    case STATE_LIGHT:
 489    case STATE_LIGHTMODEL_AMBIENT:
 490    case STATE_LIGHTMODEL_SCENECOLOR:
 491    case STATE_LIGHTPROD:
 492       return _NEW_LIGHT;
 493
 494    case STATE_TEXGEN:
 495    case STATE_TEXENV_COLOR:
 496       return _NEW_TEXTURE;
 497
 498    case STATE_FOG_COLOR:
 499    case STATE_FOG_PARAMS:
 500       return _NEW_FOG;
 501
 502    case STATE_CLIPPLANE:
 503       return _NEW_TRANSFORM;
 504
 505    case STATE_POINT_SIZE:
 506    case STATE_POINT_ATTENUATION:
 507       return _NEW_POINT;
 508
 509    case STATE_MODELVIEW_MATRIX:
 510       return _NEW_MODELVIEW;
 511    case STATE_PROJECTION_MATRIX:
 512       return _NEW_PROJECTION;
 513    case STATE_MVP_MATRIX:
 514       return _NEW_MODELVIEW | _NEW_PROJECTION;
 515    case STATE_TEXTURE_MATRIX:
 516       return _NEW_TEXTURE_MATRIX;
 517    case STATE_PROGRAM_MATRIX:
 518       return _NEW_TRACK_MATRIX;
 519    case STATE_COLOR_MATRIX:
 520       return _NEW_COLOR_MATRIX;
 521
 522    case STATE_DEPTH_RANGE:
 523       return _NEW_VIEWPORT;
 524
 525    case STATE_FRAGMENT_PROGRAM:
 526    case STATE_VERTEX_PROGRAM:
 527       return _NEW_PROGRAM;
 528
 529    case STATE_NORMAL_SCALE:
 530       return _NEW_MODELVIEW;
 531
 532    case STATE_INTERNAL:
 533       switch (state[1]) {
 534       case STATE_TEXRECT_SCALE:
 535          return _NEW_TEXTURE;
 536       case STATE_FOG_PARAMS_OPTIMIZED:
 537          return _NEW_FOG;
 538       default:
 539          /* unknown state indexes are silently ignored and
 540          *  no flag set, since it is handled by the driver.
 541          */
 542          return 0;
 543       }
 544
 545    default:
 546       _mesa_problem(NULL, "unexpected state[0] in make_state_flags()");
 547       return 0;
 548    }
 549 }
 550
 551
 552 static void
 553 append(char *dst, const char *src)
 554 {
 555    while (*dst)
 556       dst++;
 557    while (*src)
 558      *dst++ = *src++;
 559    *dst = 0;
 560 }
 561
 562
 563 static void
 564 append_token(char *dst, gl_state_index k)
 565 {
 566    switch (k) {
 567    case STATE_MATERIAL:
 568       append(dst, "material");
 569       break;
 570    case STATE_LIGHT:
 571       append(dst, "light");
 572       break;
 573    case STATE_LIGHTMODEL_AMBIENT:
 574       append(dst, "lightmodel.ambient");
 575       break;
 576    case STATE_LIGHTMODEL_SCENECOLOR:
 577       break;
 578    case STATE_LIGHTPROD:
 579       append(dst, "lightprod");
 580       break;
 581    case STATE_TEXGEN:
 582       append(dst, "texgen");
 583       break;
 584    case STATE_FOG_COLOR:
 585       append(dst, "fog.color");
 586       break;
 587    case STATE_FOG_PARAMS:
 588       append(dst, "fog.params");
 589       break;
 590    case STATE_CLIPPLANE:
 591       append(dst, "clip");
 592       break;
 593    case STATE_POINT_SIZE:
 594       append(dst, "point.size");
 595       break;
 596    case STATE_POINT_ATTENUATION:
 597       append(dst, "point.attenuation");
 598       break;
 599    case STATE_MODELVIEW_MATRIX:
 600       append(dst, "matrix.modelview");
 601       break;
 602    case STATE_PROJECTION_MATRIX:
 603       append(dst, "matrix.projection");
 604       break;
 605    case STATE_MVP_MATRIX:
 606       append(dst, "matrix.mvp");
 607       break;
 608    case STATE_TEXTURE_MATRIX:
 609       append(dst, "matrix.texture");
 610       break;
 611    case STATE_PROGRAM_MATRIX:
 612       append(dst, "matrix.program");
 613       break;
 614    case STATE_COLOR_MATRIX:
 615       append(dst, "matrix.color");
 616       break;
 617    case STATE_MATRIX_INVERSE:
 618       append(dst, ".inverse");
 619       break;
 620    case STATE_MATRIX_TRANSPOSE:
 621       append(dst, ".transpose");
 622       break;
 623    case STATE_MATRIX_INVTRANS:
 624       append(dst, ".invtrans");
 625       break;
 626    case STATE_AMBIENT:
 627       append(dst, ".ambient");
 628       break;
 629    case STATE_DIFFUSE:
 630       append(dst, ".diffuse");
 631       break;
 632    case STATE_SPECULAR:
 633       append(dst, ".specular");
 634       break;
 635    case STATE_EMISSION:
 636       append(dst, ".emission");
 637       break;
 638    case STATE_SHININESS:
 639       append(dst, "lshininess");
 640       break;
 641    case STATE_HALF_VECTOR:
 642       append(dst, ".half");
 643       break;
 644    case STATE_POSITION:
 645       append(dst, ".position");
 646       break;
 647    case STATE_ATTENUATION:
 648       append(dst, ".attenuation");
 649       break;
 650    case STATE_SPOT_DIRECTION:
 651       append(dst, ".spot.direction");
 652       break;
 653    case STATE_SPOT_CUTOFF:
 654       append(dst, ".spot.cutoff");
 655       break;
 656    case STATE_TEXGEN_EYE_S:
 657       append(dst, "eye.s");
 658       break;
 659    case STATE_TEXGEN_EYE_T:
 660       append(dst, "eye.t");
 661       break;
 662    case STATE_TEXGEN_EYE_R:
 663       append(dst, "eye.r");
 664       break;
 665    case STATE_TEXGEN_EYE_Q:
 666       append(dst, "eye.q");
 667       break;
 668    case STATE_TEXGEN_OBJECT_S:
 669       append(dst, "object.s");
 670       break;
 671    case STATE_TEXGEN_OBJECT_T:
 672       append(dst, "object.t");
 673       break;
 674    case STATE_TEXGEN_OBJECT_R:
 675       append(dst, "object.r");
 676       break;
 677    case STATE_TEXGEN_OBJECT_Q:
 678       append(dst, "object.q");
 679       break;
 680    case STATE_TEXENV_COLOR:
 681       append(dst, "texenv");
 682       break;
 683    case STATE_DEPTH_RANGE:
 684       append(dst, "depth.range");
 685       break;
 686    case STATE_VERTEX_PROGRAM:
 687    case STATE_FRAGMENT_PROGRAM:
 688       break;
 689    case STATE_ENV:
 690       append(dst, "env");
 691       break;
 692    case STATE_LOCAL:
 693       append(dst, "local");
 694       break;
 695    case STATE_NORMAL_SCALE:
 696       append(dst, "normalScale");
 697       break;
 698    case STATE_INTERNAL:
 699    case STATE_POSITION_NORMALIZED:
 700       append(dst, "(internal)");
 701       break;
 702    case STATE_PT_SCALE:
 703       append(dst, "PTscale");
 704       break;
 705    case STATE_PT_BIAS:
 706       append(dst, "PTbias");
 707       break;
 708    case STATE_PCM_SCALE:
 709       append(dst, "PCMscale");
 710       break;
 711    case STATE_PCM_BIAS:
 712       append(dst, "PCMbias");
 713       break;
 714    default:
 715       ;
 716    }
 717 }
 718
 719 static void
 720 append_face(char *dst, GLint face)
 721 {
 722    if (face == 0)
 723       append(dst, "front.");
 724    else
 725       append(dst, "back.");
 726 }
 727
 728 static void
 729 append_index(char *dst, GLint index)
 730 {
 731    char s[20];
 732    _mesa_sprintf(s, "[%d]", index);
 733    append(dst, s);
 734 }
 735
 736 /**
 737  * Make a string from the given state vector.
 738  * For example, return "state.matrix.texture[2].inverse".
 739  * Use _mesa_free() to deallocate the string.
 740  */
 741 const char *
 742 _mesa_program_state_string(const gl_state_index state[STATE_LENGTH])
 743 {
 744    char str[1000] = "";
 745    char tmp[30];
 746
 747    append(str, "state.");
 748    append_token(str, (gl_state_index) state[0]);
 749
 750    switch (state[0]) {
 751    case STATE_MATERIAL:
 752       append_face(str, state[1]);
 753       append_token(str, (gl_state_index) state[2]);
 754       break;
 755    case STATE_LIGHT:
 756       append_index(str, state[1]); /* light number [i]. */
 757       append_token(str, (gl_state_index) state[2]); /* coefficients */
 758       break;
 759    case STATE_LIGHTMODEL_AMBIENT:
 760       append(str, "lightmodel.ambient");
 761       break;
 762    case STATE_LIGHTMODEL_SCENECOLOR:
 763       if (state[1] == 0) {
 764          append(str, "lightmodel.front.scenecolor");
 765       }
 766       else {
 767          append(str, "lightmodel.back.scenecolor");
 768       }
 769       break;
 770    case STATE_LIGHTPROD:
 771       append_index(str, state[1]); /* light number [i]. */
 772       append_face(str, state[2]);
 773       append_token(str, (gl_state_index) state[3]);
 774       break;
 775    case STATE_TEXGEN:
 776       append_index(str, state[1]); /* tex unit [i] */
 777       append_token(str, (gl_state_index) state[2]); /* plane coef */
 778       break;
 779    case STATE_TEXENV_COLOR:
 780       append_index(str, state[1]); /* tex unit [i] */
 781       append(str, "color");
 782       break;
 783    case STATE_CLIPPLANE:
 784       append_index(str, state[1]); /* plane [i] */
 785       append(str, ".plane");
 786       break;
 787    case STATE_MODELVIEW_MATRIX:
 788    case STATE_PROJECTION_MATRIX:
 789    case STATE_MVP_MATRIX:
 790    case STATE_TEXTURE_MATRIX:
 791    case STATE_PROGRAM_MATRIX:
 792    case STATE_COLOR_MATRIX:
 793       {
 794          /* state[0] = modelview, projection, texture, etc. */
 795          /* state[1] = which texture matrix or program matrix */
 796          /* state[2] = first row to fetch */
 797          /* state[3] = last row to fetch */
 798          /* state[4] = transpose, inverse or invtrans */
 799          const gl_state_index mat = (gl_state_index) state[0];
 800          const GLuint index = (GLuint) state[1];
 801          const GLuint firstRow = (GLuint) state[2];
 802          const GLuint lastRow = (GLuint) state[3];
 803          const gl_state_index modifier = (gl_state_index) state[4];
 804          if (index ||
 805              mat == STATE_TEXTURE_MATRIX ||
 806              mat == STATE_PROGRAM_MATRIX)
 807             append_index(str, index);
 808          if (modifier)
 809             append_token(str, modifier);
 810          if (firstRow == lastRow)
 811             _mesa_sprintf(tmp, ".row[%d]", firstRow);
 812          else
 813             _mesa_sprintf(tmp, ".row[%d..%d]", firstRow, lastRow);
 814          append(str, tmp);
 815       }
 816       break;
 817    case STATE_POINT_SIZE:
 818       break;
 819    case STATE_POINT_ATTENUATION:
 820       break;
 821    case STATE_FOG_PARAMS:
 822       break;
 823    case STATE_FOG_COLOR:
 824       break;
 825    case STATE_DEPTH_RANGE:
 826       break;
 827    case STATE_FRAGMENT_PROGRAM:
 828    case STATE_VERTEX_PROGRAM:
 829       /* state[1] = {STATE_ENV, STATE_LOCAL} */
 830       /* state[2] = parameter index          */
 831       append_token(str, (gl_state_index) state[1]);
 832       append_index(str, state[2]);
 833       break;
 834    case STATE_INTERNAL:
 835       break;
 836    default:
 837       _mesa_problem(NULL, "Invalid state in _mesa_program_state_string");
 838       break;
 839    }
 840
 841    return _mesa_strdup(str);
 842 }
 843
 844
 845 /**
 846  * Loop over all the parameters in a parameter list.  If the parameter
 847  * is a GL state reference, look up the current value of that state
 848  * variable and put it into the parameter's Value[4] array.
 849  * This would be called at glBegin time when using a fragment program.
 850  */
 851 void
 852 _mesa_load_state_parameters(GLcontext *ctx,
 853                             struct gl_program_parameter_list *paramList)
 854 {
 855    GLuint i;
 856
 857    if (!paramList)
 858       return;
 859
 860    /*assert(ctx->Driver.NeedFlush == 0);*/
 861
 862    for (i = 0; i < paramList->NumParameters; i++) {
 863       if (paramList->Parameters[i].Type == PROGRAM_STATE_VAR) {
 864          _mesa_fetch_state(ctx,
 865                            (gl_state_index *) paramList->Parameters[i].StateIndexes,
 866                            paramList->ParameterValues[i]);
 867       }
 868    }
 869 }
 870
 871
 872 /**
 873  * Copy the 16 elements of a matrix into four consecutive program
 874  * registers starting at 'pos'.
 875  */
 876 static void
 877 load_matrix(GLfloat registers[][4], GLuint pos, const GLfloat mat[16])
 878 {
 879    GLuint i;
 880    for (i = 0; i < 4; i++) {
 881       registers[pos + i][0] = mat[0 + i];
 882       registers[pos + i][1] = mat[4 + i];
 883       registers[pos + i][2] = mat[8 + i];
 884       registers[pos + i][3] = mat[12 + i];
 885    }
 886 }
 887
 888
 889 /**
 890  * As above, but transpose the matrix.
 891  */
 892 static void
 893 load_transpose_matrix(GLfloat registers[][4], GLuint pos,
 894                       const GLfloat mat[16])
 895 {
 896    MEMCPY(registers[pos], mat, 16 * sizeof(GLfloat));
 897 }
 898
 899
 900 /**
 901  * Load current vertex program's parameter registers with tracked
 902  * matrices (if NV program).  This only needs to be done per
 903  * glBegin/glEnd, not per-vertex.
 904  */
 905 void
 906 _mesa_load_tracked_matrices(GLcontext *ctx)
 907 {
 908    GLuint i;
 909
 910    for (i = 0; i < MAX_NV_VERTEX_PROGRAM_PARAMS / 4; i++) {
 911       /* point 'mat' at source matrix */
 912       GLmatrix *mat;
 913       if (ctx->VertexProgram.TrackMatrix[i] == GL_MODELVIEW) {
 914          mat = ctx->ModelviewMatrixStack.Top;
 915       }
 916       else if (ctx->VertexProgram.TrackMatrix[i] == GL_PROJECTION) {
 917          mat = ctx->ProjectionMatrixStack.Top;
 918       }
 919       else if (ctx->VertexProgram.TrackMatrix[i] == GL_TEXTURE) {
 920          mat = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top;
 921       }
 922       else if (ctx->VertexProgram.TrackMatrix[i] == GL_COLOR) {
 923          mat = ctx->ColorMatrixStack.Top;
 924       }
 925       else if (ctx->VertexProgram.TrackMatrix[i]==GL_MODELVIEW_PROJECTION_NV) {
 926          /* XXX verify the combined matrix is up to date */
 927          mat = &ctx->_ModelProjectMatrix;
 928       }
 929       else if (ctx->VertexProgram.TrackMatrix[i] >= GL_MATRIX0_NV &&
 930                ctx->VertexProgram.TrackMatrix[i] <= GL_MATRIX7_NV) {
 931          GLuint n = ctx->VertexProgram.TrackMatrix[i] - GL_MATRIX0_NV;
 932          ASSERT(n < MAX_PROGRAM_MATRICES);
 933          mat = ctx->ProgramMatrixStack[n].Top;
 934       }
 935       else {
 936          /* no matrix is tracked, but we leave the register values as-is */
 937          assert(ctx->VertexProgram.TrackMatrix[i] == GL_NONE);
 938          continue;
 939       }
 940
 941       /* load the matrix values into sequential registers */
 942       if (ctx->VertexProgram.TrackMatrixTransform[i] == GL_IDENTITY_NV) {
 943          load_matrix(ctx->VertexProgram.Parameters, i*4, mat->m);
 944       }
 945       else if (ctx->VertexProgram.TrackMatrixTransform[i] == GL_INVERSE_NV) {
 946          _math_matrix_analyse(mat); /* update the inverse */
 947          ASSERT(!_math_matrix_is_dirty(mat));
 948          load_matrix(ctx->VertexProgram.Parameters, i*4, mat->inv);
 949       }
 950       else if (ctx->VertexProgram.TrackMatrixTransform[i] == GL_TRANSPOSE_NV) {
 951          load_transpose_matrix(ctx->VertexProgram.Parameters, i*4, mat->m);
 952       }
 953       else {
 954          assert(ctx->VertexProgram.TrackMatrixTransform[i]
 955                 == GL_INVERSE_TRANSPOSE_NV);
 956          _math_matrix_analyse(mat); /* update the inverse */
 957          ASSERT(!_math_matrix_is_dirty(mat));
 958          load_transpose_matrix(ctx->VertexProgram.Parameters, i*4, mat->inv);
 959       }
 960    }
 961 }