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 "main/glheader.h"
  33 #include "main/context.h"
  34 #include "main/hash.h"
  35 #include "main/imports.h"
  36 #include "main/macros.h"
  37 #include "main/mtypes.h"
  38 #include "prog_statevars.h"
  39 #include "prog_parameter.h"
  40
  41
  42 /**
  43  * Use the list of tokens in the state[] array to find global GL state
  44  * and return it in <value>.  Usually, four values are returned in <value>
  45  * but matrix queries may return as many as 16 values.
  46  * This function is used for ARB vertex/fragment programs.
  47  * The program parser will produce the state[] values.
  48  */
  49 static void
  50 _mesa_fetch_state(GLcontext *ctx, const gl_state_index state[],
  51                   GLfloat *value)
  52 {
  53    switch (state[0]) {
  54    case STATE_MATERIAL:
  55       {
  56          /* state[1] is either 0=front or 1=back side */
  57          const GLuint face = (GLuint) state[1];
  58          const struct gl_material *mat = &ctx->Light.Material;
  59          ASSERT(face == 0 || face == 1);
  60          /* we rely on tokens numbered so that _BACK_ == _FRONT_+ 1 */
  61          ASSERT(MAT_ATTRIB_FRONT_AMBIENT + 1 == MAT_ATTRIB_BACK_AMBIENT);
  62          /* XXX we could get rid of this switch entirely with a little
  63           * work in arbprogparse.c's parse_state_single_item().
  64           */
  65          /* state[2] is the material attribute */
  66          switch (state[2]) {
  67          case STATE_AMBIENT:
  68             COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_AMBIENT + face]);
  69             return;
  70          case STATE_DIFFUSE:
  71             COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_DIFFUSE + face]);
  72             return;
  73          case STATE_SPECULAR:
  74             COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_SPECULAR + face]);
  75             return;
  76          case STATE_EMISSION:
  77             COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_EMISSION + face]);
  78             return;
  79          case STATE_SHININESS:
  80             value[0] = mat->Attrib[MAT_ATTRIB_FRONT_SHININESS + face][0];
  81             value[1] = 0.0F;
  82             value[2] = 0.0F;
  83             value[3] = 1.0F;
  84             return;
  85          default:
  86             _mesa_problem(ctx, "Invalid material state in fetch_state");
  87             return;
  88          }
  89       }
  90    case STATE_LIGHT:
  91       {
  92          /* state[1] is the light number */
  93          const GLuint ln = (GLuint) state[1];
  94          /* state[2] is the light attribute */
  95          switch (state[2]) {
  96          case STATE_AMBIENT:
  97             COPY_4V(value, ctx->Light.Light[ln].Ambient);
  98             return;
  99          case STATE_DIFFUSE:
 100             COPY_4V(value, ctx->Light.Light[ln].Diffuse);
 101             return;
 102          case STATE_SPECULAR:
 103             COPY_4V(value, ctx->Light.Light[ln].Specular);
 104             return;
 105          case STATE_POSITION:
 106             COPY_4V(value, ctx->Light.Light[ln].EyePosition);
 107             return;
 108          case STATE_ATTENUATION:
 109             value[0] = ctx->Light.Light[ln].ConstantAttenuation;
 110             value[1] = ctx->Light.Light[ln].LinearAttenuation;
 111             value[2] = ctx->Light.Light[ln].QuadraticAttenuation;
 112             value[3] = ctx->Light.Light[ln].SpotExponent;
 113             return;
 114          case STATE_SPOT_DIRECTION:
 115             COPY_3V(value, ctx->Light.Light[ln].EyeDirection);
 116             value[3] = ctx->Light.Light[ln]._CosCutoff;
 117             return;
 118          case STATE_SPOT_CUTOFF:
 119             value[0] = ctx->Light.Light[ln].SpotCutoff;
 120             return;
 121          case STATE_HALF_VECTOR:
 122             {
 123                static const GLfloat eye_z[] = {0, 0, 1};
 124                GLfloat p[3];
 125                /* Compute infinite half angle vector:
 126                 *   halfVector = normalize(normalize(lightPos) + (0, 0, 1))
 127                 * light.EyePosition.w should be 0 for infinite lights.
 128                 */
 129                COPY_3V(p, ctx->Light.Light[ln].EyePosition);
 130                NORMALIZE_3FV(p);
 131                ADD_3V(value, p, eye_z);
 132                NORMALIZE_3FV(value);
 133                value[3] = 1.0;
 134             }
 135             return;
 136          default:
 137             _mesa_problem(ctx, "Invalid light state in fetch_state");
 138             return;
 139          }
 140       }
 141    case STATE_LIGHTMODEL_AMBIENT:
 142       COPY_4V(value, ctx->Light.Model.Ambient);
 143       return;
 144    case STATE_LIGHTMODEL_SCENECOLOR:
 145       if (state[1] == 0) {
 146          /* front */
 147          GLint i;
 148          for (i = 0; i < 3; i++) {
 149             value[i] = ctx->Light.Model.Ambient[i]
 150                * ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT][i]
 151                + ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_EMISSION][i];
 152          }
 153          value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE][3];
 154       }
 155       else {
 156          /* back */
 157          GLint i;
 158          for (i = 0; i < 3; i++) {
 159             value[i] = ctx->Light.Model.Ambient[i]
 160                * ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_AMBIENT][i]
 161                + ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_EMISSION][i];
 162          }
 163          value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_DIFFUSE][3];
 164       }
 165       return;
 166    case STATE_LIGHTPROD:
 167       {
 168          const GLuint ln = (GLuint) state[1];
 169          const GLuint face = (GLuint) state[2];
 170          GLint i;
 171          ASSERT(face == 0 || face == 1);
 172          switch (state[3]) {
 173             case STATE_AMBIENT:
 174                for (i = 0; i < 3; i++) {
 175                   value[i] = ctx->Light.Light[ln].Ambient[i] *
 176                      ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][i];
 177                }
 178                /* [3] = material alpha */
 179                value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][3];
 180                return;
 181             case STATE_DIFFUSE:
 182                for (i = 0; i < 3; i++) {
 183                   value[i] = ctx->Light.Light[ln].Diffuse[i] *
 184                      ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][i];
 185                }
 186                /* [3] = material alpha */
 187                value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][3];
 188                return;
 189             case STATE_SPECULAR:
 190                for (i = 0; i < 3; i++) {
 191                   value[i] = ctx->Light.Light[ln].Specular[i] *
 192                      ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][i];
 193                }
 194                /* [3] = material alpha */
 195                value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][3];
 196                return;
 197             default:
 198                _mesa_problem(ctx, "Invalid lightprod state in fetch_state");
 199                return;
 200          }
 201       }
 202    case STATE_TEXGEN:
 203       {
 204          /* state[1] is the texture unit */
 205          const GLuint unit = (GLuint) state[1];
 206          /* state[2] is the texgen attribute */
 207          switch (state[2]) {
 208          case STATE_TEXGEN_EYE_S:
 209             COPY_4V(value, ctx->Texture.Unit[unit].GenS.EyePlane);
 210             return;
 211          case STATE_TEXGEN_EYE_T:
 212             COPY_4V(value, ctx->Texture.Unit[unit].GenT.EyePlane);
 213             return;
 214          case STATE_TEXGEN_EYE_R:
 215             COPY_4V(value, ctx->Texture.Unit[unit].GenR.EyePlane);
 216             return;
 217          case STATE_TEXGEN_EYE_Q:
 218             COPY_4V(value, ctx->Texture.Unit[unit].GenQ.EyePlane);
 219             return;
 220          case STATE_TEXGEN_OBJECT_S:
 221             COPY_4V(value, ctx->Texture.Unit[unit].GenS.ObjectPlane);
 222             return;
 223          case STATE_TEXGEN_OBJECT_T:
 224             COPY_4V(value, ctx->Texture.Unit[unit].GenT.ObjectPlane);
 225             return;
 226          case STATE_TEXGEN_OBJECT_R:
 227             COPY_4V(value, ctx->Texture.Unit[unit].GenR.ObjectPlane);
 228             return;
 229          case STATE_TEXGEN_OBJECT_Q:
 230             COPY_4V(value, ctx->Texture.Unit[unit].GenQ.ObjectPlane);
 231             return;
 232          default:
 233             _mesa_problem(ctx, "Invalid texgen state in fetch_state");
 234             return;
 235          }
 236       }
 237    case STATE_TEXENV_COLOR:
 238       {
 239          /* state[1] is the texture unit */
 240          const GLuint unit = (GLuint) state[1];
 241          COPY_4V(value, ctx->Texture.Unit[unit].EnvColor);
 242       }
 243       return;
 244    case STATE_FOG_COLOR:
 245       COPY_4V(value, ctx->Fog.Color);
 246       return;
 247    case STATE_FOG_PARAMS:
 248       value[0] = ctx->Fog.Density;
 249       value[1] = ctx->Fog.Start;
 250       value[2] = ctx->Fog.End;
 251       value[3] = (ctx->Fog.End == ctx->Fog.Start)
 252          ? 1.0f : (GLfloat)(1.0 / (ctx->Fog.End - ctx->Fog.Start));
 253       return;
 254    case STATE_CLIPPLANE:
 255       {
 256          const GLuint plane = (GLuint) state[1];
 257          COPY_4V(value, ctx->Transform.EyeUserPlane[plane]);
 258       }
 259       return;
 260    case STATE_POINT_SIZE:
 261       value[0] = ctx->Point.Size;
 262       value[1] = ctx->Point.MinSize;
 263       value[2] = ctx->Point.MaxSize;
 264       value[3] = ctx->Point.Threshold;
 265       return;
 266    case STATE_POINT_ATTENUATION:
 267       value[0] = ctx->Point.Params[0];
 268       value[1] = ctx->Point.Params[1];
 269       value[2] = ctx->Point.Params[2];
 270       value[3] = 1.0F;
 271       return;
 272    case STATE_MODELVIEW_MATRIX:
 273    case STATE_PROJECTION_MATRIX:
 274    case STATE_MVP_MATRIX:
 275    case STATE_TEXTURE_MATRIX:
 276    case STATE_PROGRAM_MATRIX:
 277    case STATE_COLOR_MATRIX:
 278       {
 279          /* state[0] = modelview, projection, texture, etc. */
 280          /* state[1] = which texture matrix or program matrix */
 281          /* state[2] = first row to fetch */
 282          /* state[3] = last row to fetch */
 283          /* state[4] = transpose, inverse or invtrans */
 284          const GLmatrix *matrix;
 285          const gl_state_index mat = state[0];
 286          const GLuint index = (GLuint) state[1];
 287          const GLuint firstRow = (GLuint) state[2];
 288          const GLuint lastRow = (GLuint) state[3];
 289          const gl_state_index modifier = state[4];
 290          const GLfloat *m;
 291          GLuint row, i;
 292          ASSERT(firstRow >= 0);
 293          ASSERT(firstRow < 4);
 294          ASSERT(lastRow >= 0);
 295          ASSERT(lastRow < 4);
 296          if (mat == STATE_MODELVIEW_MATRIX) {
 297             matrix = ctx->ModelviewMatrixStack.Top;
 298          }
 299          else if (mat == STATE_PROJECTION_MATRIX) {
 300             matrix = ctx->ProjectionMatrixStack.Top;
 301          }
 302          else if (mat == STATE_MVP_MATRIX) {
 303             matrix = &ctx->_ModelProjectMatrix;
 304          }
 305          else if (mat == STATE_TEXTURE_MATRIX) {
 306             matrix = ctx->TextureMatrixStack[index].Top;
 307          }
 308          else if (mat == STATE_PROGRAM_MATRIX) {
 309             matrix = ctx->ProgramMatrixStack[index].Top;
 310          }
 311          else if (mat == STATE_COLOR_MATRIX) {
 312             matrix = ctx->ColorMatrixStack.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] = 1.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_CURRENT_ATTRIB: {
 399          const GLuint idx = (GLuint) state[2];
 400          COPY_4V(value, ctx->Current.Attrib[idx]);
 401          return;
 402       }
 403
 404       case STATE_NORMAL_SCALE:
 405          ASSIGN_4V(value,
 406                    ctx->_ModelViewInvScale,
 407                    ctx->_ModelViewInvScale,
 408                    ctx->_ModelViewInvScale,
 409                    1);
 410          return;
 411       case STATE_TEXRECT_SCALE:
 412          {
 413             const int unit = (int) state[2];
 414             const struct gl_texture_object *texObj
 415                = ctx->Texture.Unit[unit]._Current;
 416             if (texObj) {
 417                struct gl_texture_image *texImage = texObj->Image[0][0];
 418                ASSIGN_4V(value, (GLfloat) (1.0 / texImage->Width),
 419                          (GLfloat)(1.0 / texImage->Height),
 420                          0.0f, 1.0f);
 421             }
 422          }
 423          return;
 424       case STATE_FOG_PARAMS_OPTIMIZED:
 425          /* for simpler per-vertex/pixel fog calcs. POW (for EXP/EXP2 fog)
 426           * might be more expensive than EX2 on some hw, plus it needs
 427           * another constant (e) anyway. Linear fog can now be done with a
 428           * single MAD.
 429           * linear: fogcoord * -1/(end-start) + end/(end-start)
 430           * exp: 2^-(density/ln(2) * fogcoord)
 431           * exp2: 2^-((density/(ln(2)^2) * fogcoord)^2)
 432           */
 433          value[0] = (ctx->Fog.End == ctx->Fog.Start)
 434             ? 1.0f : (GLfloat)(-1.0F / (ctx->Fog.End - ctx->Fog.Start));
 435          value[1] = ctx->Fog.End * -value[0];
 436          value[2] = (GLfloat)(ctx->Fog.Density * ONE_DIV_LN2);
 437          value[3] = (GLfloat)(ctx->Fog.Density * ONE_DIV_SQRT_LN2);
 438          return;
 439
 440       case STATE_LIGHT_SPOT_DIR_NORMALIZED: {
 441          /* here, state[2] is the light number */
 442          /* pre-normalize spot dir */
 443          const GLuint ln = (GLuint) state[2];
 444          COPY_3V(value, ctx->Light.Light[ln]._NormDirection);
 445          value[3] = ctx->Light.Light[ln]._CosCutoff;
 446          return;
 447       }
 448
 449       case STATE_LIGHT_POSITION: {
 450          const GLuint ln = (GLuint) state[2];
 451          COPY_4V(value, ctx->Light.Light[ln]._Position);
 452          return;
 453       }
 454
 455       case STATE_LIGHT_POSITION_NORMALIZED: {
 456          const GLuint ln = (GLuint) state[2];
 457          COPY_4V(value, ctx->Light.Light[ln]._Position);
 458          NORMALIZE_3FV( value );
 459          return;
 460       }
 461
 462       case STATE_LIGHT_HALF_VECTOR: {
 463          const GLuint ln = (GLuint) state[2];
 464          GLfloat p[3];
 465          /* Compute infinite half angle vector:
 466           *   halfVector = normalize(normalize(lightPos) + (0, 0, 1))
 467           * light.EyePosition.w should be 0 for infinite lights.
 468           */
 469          COPY_3V(p, ctx->Light.Light[ln]._Position);
 470          NORMALIZE_3FV(p);
 471          ADD_3V(value, p, ctx->_EyeZDir);
 472          NORMALIZE_3FV(value);
 473          value[3] = 1.0;
 474          return;
 475       }
 476
 477
 478       case STATE_PT_SCALE:
 479          value[0] = ctx->Pixel.RedScale;
 480          value[1] = ctx->Pixel.GreenScale;
 481          value[2] = ctx->Pixel.BlueScale;
 482          value[3] = ctx->Pixel.AlphaScale;
 483          break;
 484       case STATE_PT_BIAS:
 485          value[0] = ctx->Pixel.RedBias;
 486          value[1] = ctx->Pixel.GreenBias;
 487          value[2] = ctx->Pixel.BlueBias;
 488          value[3] = ctx->Pixel.AlphaBias;
 489          break;
 490       case STATE_PCM_SCALE:
 491          COPY_4V(value, ctx->Pixel.PostColorMatrixScale);
 492          break;
 493       case STATE_PCM_BIAS:
 494          COPY_4V(value, ctx->Pixel.PostColorMatrixBias);
 495          break;
 496       case STATE_SHADOW_AMBIENT:
 497          {
 498             const int unit = (int) state[2];
 499             const struct gl_texture_object *texObj
 500                = ctx->Texture.Unit[unit]._Current;
 501             if (texObj) {
 502                value[0] =
 503                value[1] =
 504                value[2] =
 505                value[3] = texObj->CompareFailValue;
 506             }
 507          }
 508          return;
 509       case STATE_FB_SIZE:
 510          value[0] = (GLfloat) (ctx->DrawBuffer->Width - 1);
 511          value[1] = (GLfloat) (ctx->DrawBuffer->Height - 1);
 512          value[2] = 0.0F;
 513          value[3] = 0.0F;
 514          return;
 515
 516       case STATE_ROT_MATRIX_0:
 517          {
 518             const int unit = (int) state[2];
 519             GLfloat *rotMat22 = ctx->Texture.Unit[unit].RotMatrix;
 520             value[0] = rotMat22[0];
 521             value[1] = rotMat22[2];
 522             value[2] = 0.0;
 523             value[3] = 0.0;
 524          }
 525          break;
 526       case STATE_ROT_MATRIX_1:
 527          {
 528             const int unit = (int) state[2];
 529             GLfloat *rotMat22 = ctx->Texture.Unit[unit].RotMatrix;
 530             value[0] = rotMat22[1];
 531             value[1] = rotMat22[3];
 532             value[2] = 0.0;
 533             value[3] = 0.0;
 534          }
 535          break;
 536
 537          /* XXX: make sure new tokens added here are also handled in the
 538           * _mesa_program_state_flags() switch, below.
 539           */
 540       default:
 541          /* unknown state indexes are silently ignored
 542           *  should be handled by the driver.
 543           */
 544          return;
 545       }
 546       return;
 547
 548    default:
 549       _mesa_problem(ctx, "Invalid state in _mesa_fetch_state");
 550       return;
 551    }
 552 }
 553
 554
 555 /**
 556  * Return a bitmask of the Mesa state flags (_NEW_* values) which would
 557  * indicate that the given context state may have changed.
 558  * The bitmask is used during validation to determine if we need to update
 559  * vertex/fragment program parameters (like "state.material.color") when
 560  * some GL state has changed.
 561  */
 562 GLbitfield
 563 _mesa_program_state_flags(const gl_state_index state[STATE_LENGTH])
 564 {
 565    switch (state[0]) {
 566    case STATE_MATERIAL:
 567    case STATE_LIGHT:
 568    case STATE_LIGHTMODEL_AMBIENT:
 569    case STATE_LIGHTMODEL_SCENECOLOR:
 570    case STATE_LIGHTPROD:
 571       return _NEW_LIGHT;
 572
 573    case STATE_TEXGEN:
 574    case STATE_TEXENV_COLOR:
 575       return _NEW_TEXTURE;
 576
 577    case STATE_FOG_COLOR:
 578    case STATE_FOG_PARAMS:
 579       return _NEW_FOG;
 580
 581    case STATE_CLIPPLANE:
 582       return _NEW_TRANSFORM;
 583
 584    case STATE_POINT_SIZE:
 585    case STATE_POINT_ATTENUATION:
 586       return _NEW_POINT;
 587
 588    case STATE_MODELVIEW_MATRIX:
 589       return _NEW_MODELVIEW;
 590    case STATE_PROJECTION_MATRIX:
 591       return _NEW_PROJECTION;
 592    case STATE_MVP_MATRIX:
 593       return _NEW_MODELVIEW | _NEW_PROJECTION;
 594    case STATE_TEXTURE_MATRIX:
 595       return _NEW_TEXTURE_MATRIX;
 596    case STATE_PROGRAM_MATRIX:
 597       return _NEW_TRACK_MATRIX;
 598    case STATE_COLOR_MATRIX:
 599       return _NEW_COLOR_MATRIX;
 600
 601    case STATE_DEPTH_RANGE:
 602       return _NEW_VIEWPORT;
 603
 604    case STATE_FRAGMENT_PROGRAM:
 605    case STATE_VERTEX_PROGRAM:
 606       return _NEW_PROGRAM;
 607
 608    case STATE_NORMAL_SCALE:
 609       return _NEW_MODELVIEW;
 610
 611    case STATE_INTERNAL:
 612       switch (state[1]) {
 613       case STATE_CURRENT_ATTRIB:
 614          return _NEW_CURRENT_ATTRIB;
 615
 616       case STATE_NORMAL_SCALE:
 617          return _NEW_MODELVIEW;
 618
 619       case STATE_TEXRECT_SCALE:
 620       case STATE_SHADOW_AMBIENT:
 621       case STATE_ROT_MATRIX_0:
 622       case STATE_ROT_MATRIX_1:
 623          return _NEW_TEXTURE;
 624       case STATE_FOG_PARAMS_OPTIMIZED:
 625          return _NEW_FOG;
 626       case STATE_LIGHT_SPOT_DIR_NORMALIZED:
 627       case STATE_LIGHT_POSITION:
 628       case STATE_LIGHT_POSITION_NORMALIZED:
 629       case STATE_LIGHT_HALF_VECTOR:
 630          return _NEW_LIGHT;
 631
 632       case STATE_PT_SCALE:
 633       case STATE_PT_BIAS:
 634       case STATE_PCM_SCALE:
 635       case STATE_PCM_BIAS:
 636          return _NEW_PIXEL;
 637
 638       case STATE_FB_SIZE:
 639          return _NEW_BUFFERS;
 640
 641       default:
 642          /* unknown state indexes are silently ignored and
 643          *  no flag set, since it is handled by the driver.
 644          */
 645          return 0;
 646       }
 647
 648    default:
 649       _mesa_problem(NULL, "unexpected state[0] in make_state_flags()");
 650       return 0;
 651    }
 652 }
 653
 654
 655 static void
 656 append(char *dst, const char *src)
 657 {
 658    while (*dst)
 659       dst++;
 660    while (*src)
 661      *dst++ = *src++;
 662    *dst = 0;
 663 }
 664
 665
 666 /**
 667  * Convert token 'k' to a string, append it onto 'dst' string.
 668  */
 669 static void
 670 append_token(char *dst, gl_state_index k)
 671 {
 672    switch (k) {
 673    case STATE_MATERIAL:
 674       append(dst, "material");
 675       break;
 676    case STATE_LIGHT:
 677       append(dst, "light");
 678       break;
 679    case STATE_LIGHTMODEL_AMBIENT:
 680       append(dst, "lightmodel.ambient");
 681       break;
 682    case STATE_LIGHTMODEL_SCENECOLOR:
 683       break;
 684    case STATE_LIGHTPROD:
 685       append(dst, "lightprod");
 686       break;
 687    case STATE_TEXGEN:
 688       append(dst, "texgen");
 689       break;
 690    case STATE_FOG_COLOR:
 691       append(dst, "fog.color");
 692       break;
 693    case STATE_FOG_PARAMS:
 694       append(dst, "fog.params");
 695       break;
 696    case STATE_CLIPPLANE:
 697       append(dst, "clip");
 698       break;
 699    case STATE_POINT_SIZE:
 700       append(dst, "point.size");
 701       break;
 702    case STATE_POINT_ATTENUATION:
 703       append(dst, "point.attenuation");
 704       break;
 705    case STATE_MODELVIEW_MATRIX:
 706       append(dst, "matrix.modelview");
 707       break;
 708    case STATE_PROJECTION_MATRIX:
 709       append(dst, "matrix.projection");
 710       break;
 711    case STATE_MVP_MATRIX:
 712       append(dst, "matrix.mvp");
 713       break;
 714    case STATE_TEXTURE_MATRIX:
 715       append(dst, "matrix.texture");
 716       break;
 717    case STATE_PROGRAM_MATRIX:
 718       append(dst, "matrix.program");
 719       break;
 720    case STATE_COLOR_MATRIX:
 721       append(dst, "matrix.color");
 722       break;
 723    case STATE_MATRIX_INVERSE:
 724       append(dst, ".inverse");
 725       break;
 726    case STATE_MATRIX_TRANSPOSE:
 727       append(dst, ".transpose");
 728       break;
 729    case STATE_MATRIX_INVTRANS:
 730       append(dst, ".invtrans");
 731       break;
 732    case STATE_AMBIENT:
 733       append(dst, ".ambient");
 734       break;
 735    case STATE_DIFFUSE:
 736       append(dst, ".diffuse");
 737       break;
 738    case STATE_SPECULAR:
 739       append(dst, ".specular");
 740       break;
 741    case STATE_EMISSION:
 742       append(dst, ".emission");
 743       break;
 744    case STATE_SHININESS:
 745       append(dst, "lshininess");
 746       break;
 747    case STATE_HALF_VECTOR:
 748       append(dst, ".half");
 749       break;
 750    case STATE_POSITION:
 751       append(dst, ".position");
 752       break;
 753    case STATE_ATTENUATION:
 754       append(dst, ".attenuation");
 755       break;
 756    case STATE_SPOT_DIRECTION:
 757       append(dst, ".spot.direction");
 758       break;
 759    case STATE_SPOT_CUTOFF:
 760       append(dst, ".spot.cutoff");
 761       break;
 762    case STATE_TEXGEN_EYE_S:
 763       append(dst, ".eye.s");
 764       break;
 765    case STATE_TEXGEN_EYE_T:
 766       append(dst, ".eye.t");
 767       break;
 768    case STATE_TEXGEN_EYE_R:
 769       append(dst, ".eye.r");
 770       break;
 771    case STATE_TEXGEN_EYE_Q:
 772       append(dst, ".eye.q");
 773       break;
 774    case STATE_TEXGEN_OBJECT_S:
 775       append(dst, ".object.s");
 776       break;
 777    case STATE_TEXGEN_OBJECT_T:
 778       append(dst, ".object.t");
 779       break;
 780    case STATE_TEXGEN_OBJECT_R:
 781       append(dst, ".object.r");
 782       break;
 783    case STATE_TEXGEN_OBJECT_Q:
 784       append(dst, ".object.q");
 785       break;
 786    case STATE_TEXENV_COLOR:
 787       append(dst, "texenv");
 788       break;
 789    case STATE_DEPTH_RANGE:
 790       append(dst, "depth.range");
 791       break;
 792    case STATE_VERTEX_PROGRAM:
 793    case STATE_FRAGMENT_PROGRAM:
 794       break;
 795    case STATE_ENV:
 796       append(dst, "env");
 797       break;
 798    case STATE_LOCAL:
 799       append(dst, "local");
 800       break;
 801    /* BEGIN internal state vars */
 802    case STATE_INTERNAL:
 803       append(dst, "(internal)");
 804       break;
 805    case STATE_NORMAL_SCALE:
 806       append(dst, "normalScale");
 807       break;
 808    case STATE_TEXRECT_SCALE:
 809       append(dst, "texrectScale");
 810       break;
 811    case STATE_FOG_PARAMS_OPTIMIZED:
 812       append(dst, "fogParamsOptimized");
 813       break;
 814    case STATE_LIGHT_SPOT_DIR_NORMALIZED:
 815       append(dst, "lightSpotDirNormalized");
 816       break;
 817    case STATE_LIGHT_POSITION:
 818       append(dst, "lightPosition");
 819       break;
 820    case STATE_LIGHT_POSITION_NORMALIZED:
 821       append(dst, "light.position.normalized");
 822       break;
 823    case STATE_LIGHT_HALF_VECTOR:
 824       append(dst, "lightHalfVector");
 825       break;
 826    case STATE_PT_SCALE:
 827       append(dst, "PTscale");
 828       break;
 829    case STATE_PT_BIAS:
 830       append(dst, "PTbias");
 831       break;
 832    case STATE_PCM_SCALE:
 833       append(dst, "PCMscale");
 834       break;
 835    case STATE_PCM_BIAS:
 836       append(dst, "PCMbias");
 837       break;
 838    case STATE_SHADOW_AMBIENT:
 839       append(dst, "CompareFailValue");
 840       break;
 841    case STATE_FB_SIZE:
 842       append(dst, "FbSize");
 843       break;
 844    case STATE_ROT_MATRIX_0:
 845       append(dst, "rotMatrixRow0");
 846       break;
 847    case STATE_ROT_MATRIX_1:
 848       append(dst, "rotMatrixRow1");
 849       break;
 850    default:
 851       /* probably STATE_INTERNAL_DRIVER+i (driver private state) */
 852       append(dst, "driverState");
 853    }
 854 }
 855
 856 static void
 857 append_face(char *dst, GLint face)
 858 {
 859    if (face == 0)
 860       append(dst, "front.");
 861    else
 862       append(dst, "back.");
 863 }
 864
 865 static void
 866 append_index(char *dst, GLint index)
 867 {
 868    char s[20];
 869    _mesa_sprintf(s, "[%d]", index);
 870    append(dst, s);
 871 }
 872
 873 /**
 874  * Make a string from the given state vector.
 875  * For example, return "state.matrix.texture[2].inverse".
 876  * Use _mesa_free() to deallocate the string.
 877  */
 878 char *
 879 _mesa_program_state_string(const gl_state_index state[STATE_LENGTH])
 880 {
 881    char str[1000] = "";
 882    char tmp[30];
 883
 884    append(str, "state.");
 885    append_token(str, state[0]);
 886
 887    switch (state[0]) {
 888    case STATE_MATERIAL:
 889       append_face(str, state[1]);
 890       append_token(str, state[2]);
 891       break;
 892    case STATE_LIGHT:
 893       append_index(str, state[1]); /* light number [i]. */
 894       append_token(str, state[2]); /* coefficients */
 895       break;
 896    case STATE_LIGHTMODEL_AMBIENT:
 897       append(str, "lightmodel.ambient");
 898       break;
 899    case STATE_LIGHTMODEL_SCENECOLOR:
 900       if (state[1] == 0) {
 901          append(str, "lightmodel.front.scenecolor");
 902       }
 903       else {
 904          append(str, "lightmodel.back.scenecolor");
 905       }
 906       break;
 907    case STATE_LIGHTPROD:
 908       append_index(str, state[1]); /* light number [i]. */
 909       append_face(str, state[2]);
 910       append_token(str, state[3]);
 911       break;
 912    case STATE_TEXGEN:
 913       append_index(str, state[1]); /* tex unit [i] */
 914       append_token(str, state[2]); /* plane coef */
 915       break;
 916    case STATE_TEXENV_COLOR:
 917       append_index(str, state[1]); /* tex unit [i] */
 918       append(str, "color");
 919       break;
 920    case STATE_CLIPPLANE:
 921       append_index(str, state[1]); /* plane [i] */
 922       append(str, ".plane");
 923       break;
 924    case STATE_MODELVIEW_MATRIX:
 925    case STATE_PROJECTION_MATRIX:
 926    case STATE_MVP_MATRIX:
 927    case STATE_TEXTURE_MATRIX:
 928    case STATE_PROGRAM_MATRIX:
 929    case STATE_COLOR_MATRIX:
 930       {
 931          /* state[0] = modelview, projection, texture, etc. */
 932          /* state[1] = which texture matrix or program matrix */
 933          /* state[2] = first row to fetch */
 934          /* state[3] = last row to fetch */
 935          /* state[4] = transpose, inverse or invtrans */
 936          const gl_state_index mat = state[0];
 937          const GLuint index = (GLuint) state[1];
 938          const GLuint firstRow = (GLuint) state[2];
 939          const GLuint lastRow = (GLuint) state[3];
 940          const gl_state_index modifier = state[4];
 941          if (index ||
 942              mat == STATE_TEXTURE_MATRIX ||
 943              mat == STATE_PROGRAM_MATRIX)
 944             append_index(str, index);
 945          if (modifier)
 946             append_token(str, modifier);
 947          if (firstRow == lastRow)
 948             _mesa_sprintf(tmp, ".row[%d]", firstRow);
 949          else
 950             _mesa_sprintf(tmp, ".row[%d..%d]", firstRow, lastRow);
 951          append(str, tmp);
 952       }
 953       break;
 954    case STATE_POINT_SIZE:
 955       break;
 956    case STATE_POINT_ATTENUATION:
 957       break;
 958    case STATE_FOG_PARAMS:
 959       break;
 960    case STATE_FOG_COLOR:
 961       break;
 962    case STATE_DEPTH_RANGE:
 963       break;
 964    case STATE_FRAGMENT_PROGRAM:
 965    case STATE_VERTEX_PROGRAM:
 966       /* state[1] = {STATE_ENV, STATE_LOCAL} */
 967       /* state[2] = parameter index          */
 968       append_token(str, state[1]);
 969       append_index(str, state[2]);
 970       break;
 971    case STATE_INTERNAL:
 972       append_token(str, state[1]);
 973       break;
 974    default:
 975       _mesa_problem(NULL, "Invalid state in _mesa_program_state_string");
 976       break;
 977    }
 978
 979    return _mesa_strdup(str);
 980 }
 981
 982
 983 /**
 984  * Loop over all the parameters in a parameter list.  If the parameter
 985  * is a GL state reference, look up the current value of that state
 986  * variable and put it into the parameter's Value[4] array.
 987  * This would be called at glBegin time when using a fragment program.
 988  */
 989 void
 990 _mesa_load_state_parameters(GLcontext *ctx,
 991                             struct gl_program_parameter_list *paramList)
 992 {
 993    GLuint i;
 994
 995    if (!paramList)
 996       return;
 997
 998    /*assert(ctx->Driver.NeedFlush == 0);*/
 999
1000    for (i = 0; i < paramList->NumParameters; i++) {
1001       if (paramList->Parameters[i].Type == PROGRAM_STATE_VAR) {
1002          _mesa_fetch_state(ctx,
1003                            (gl_state_index *) paramList->Parameters[i].StateIndexes,
1004                            paramList->ParameterValues[i]);
1005       }
1006    }
1007 }
1008
1009
1010 /**
1011  * Copy the 16 elements of a matrix into four consecutive program
1012  * registers starting at 'pos'.
1013  */
1014 static void
1015 load_matrix(GLfloat registers[][4], GLuint pos, const GLfloat mat[16])
1016 {
1017    GLuint i;
1018    for (i = 0; i < 4; i++) {
1019       registers[pos + i][0] = mat[0 + i];
1020       registers[pos + i][1] = mat[4 + i];
1021       registers[pos + i][2] = mat[8 + i];
1022       registers[pos + i][3] = mat[12 + i];
1023    }
1024 }
1025
1026
1027 /**
1028  * As above, but transpose the matrix.
1029  */
1030 static void
1031 load_transpose_matrix(GLfloat registers[][4], GLuint pos,
1032                       const GLfloat mat[16])
1033 {
1034    MEMCPY(registers[pos], mat, 16 * sizeof(GLfloat));
1035 }
1036
1037
1038 /**
1039  * Load current vertex program's parameter registers with tracked
1040  * matrices (if NV program).  This only needs to be done per
1041  * glBegin/glEnd, not per-vertex.
1042  */
1043 void
1044 _mesa_load_tracked_matrices(GLcontext *ctx)
1045 {
1046    GLuint i;
1047
1048    for (i = 0; i < MAX_NV_VERTEX_PROGRAM_PARAMS / 4; i++) {
1049       /* point 'mat' at source matrix */
1050       GLmatrix *mat;
1051       if (ctx->VertexProgram.TrackMatrix[i] == GL_MODELVIEW) {
1052          mat = ctx->ModelviewMatrixStack.Top;
1053       }
1054       else if (ctx->VertexProgram.TrackMatrix[i] == GL_PROJECTION) {
1055          mat = ctx->ProjectionMatrixStack.Top;
1056       }
1057       else if (ctx->VertexProgram.TrackMatrix[i] == GL_TEXTURE) {
1058          mat = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top;
1059       }
1060       else if (ctx->VertexProgram.TrackMatrix[i] == GL_COLOR) {
1061          mat = ctx->ColorMatrixStack.Top;
1062       }
1063       else if (ctx->VertexProgram.TrackMatrix[i]==GL_MODELVIEW_PROJECTION_NV) {
1064          /* XXX verify the combined matrix is up to date */
1065          mat = &ctx->_ModelProjectMatrix;
1066       }
1067       else if (ctx->VertexProgram.TrackMatrix[i] >= GL_MATRIX0_NV &&
1068                ctx->VertexProgram.TrackMatrix[i] <= GL_MATRIX7_NV) {
1069          GLuint n = ctx->VertexProgram.TrackMatrix[i] - GL_MATRIX0_NV;
1070          ASSERT(n < MAX_PROGRAM_MATRICES);
1071          mat = ctx->ProgramMatrixStack[n].Top;
1072       }
1073       else {
1074          /* no matrix is tracked, but we leave the register values as-is */
1075          assert(ctx->VertexProgram.TrackMatrix[i] == GL_NONE);
1076          continue;
1077       }
1078
1079       /* load the matrix values into sequential registers */
1080       if (ctx->VertexProgram.TrackMatrixTransform[i] == GL_IDENTITY_NV) {
1081          load_matrix(ctx->VertexProgram.Parameters, i*4, mat->m);
1082       }
1083       else if (ctx->VertexProgram.TrackMatrixTransform[i] == GL_INVERSE_NV) {
1084          _math_matrix_analyse(mat); /* update the inverse */
1085          ASSERT(!_math_matrix_is_dirty(mat));
1086          load_matrix(ctx->VertexProgram.Parameters, i*4, mat->inv);
1087       }
1088       else if (ctx->VertexProgram.TrackMatrixTransform[i] == GL_TRANSPOSE_NV) {
1089          load_transpose_matrix(ctx->VertexProgram.Parameters, i*4, mat->m);
1090       }
1091       else {
1092          assert(ctx->VertexProgram.TrackMatrixTransform[i]
1093                 == GL_INVERSE_TRANSPOSE_NV);
1094          _math_matrix_analyse(mat); /* update the inverse */
1095          ASSERT(!_math_matrix_is_dirty(mat));
1096          load_transpose_matrix(ctx->VertexProgram.Parameters, i*4, mat->inv);
1097       }
1098    }
1099 }