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 #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          default:
 138             _mesa_problem(ctx, "Invalid light state in fetch_state");
 139             return;
 140          }
 141       }
 142    case STATE_LIGHTMODEL_AMBIENT:
 143       COPY_4V(value, ctx->Light.Model.Ambient);
 144       return;
 145    case STATE_LIGHTMODEL_SCENECOLOR:
 146       if (state[1] == 0) {
 147          /* front */
 148          GLint i;
 149          for (i = 0; i < 3; i++) {
 150             value[i] = ctx->Light.Model.Ambient[i]
 151                * ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT][i]
 152                + ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_EMISSION][i];
 153          }
 154          value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE][3];
 155       }
 156       else {
 157          /* back */
 158          GLint i;
 159          for (i = 0; i < 3; i++) {
 160             value[i] = ctx->Light.Model.Ambient[i]
 161                * ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_AMBIENT][i]
 162                + ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_EMISSION][i];
 163          }
 164          value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_DIFFUSE][3];
 165       }
 166       return;
 167    case STATE_LIGHTPROD:
 168       {
 169          const GLuint ln = (GLuint) state[1];
 170          const GLuint face = (GLuint) state[2];
 171          GLint i;
 172          ASSERT(face == 0 || face == 1);
 173          switch (state[3]) {
 174             case STATE_AMBIENT:
 175                for (i = 0; i < 3; i++) {
 176                   value[i] = ctx->Light.Light[ln].Ambient[i] *
 177                      ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][i];
 178                }
 179                /* [3] = material alpha */
 180                value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][3];
 181                return;
 182             case STATE_DIFFUSE:
 183                for (i = 0; i < 3; i++) {
 184                   value[i] = ctx->Light.Light[ln].Diffuse[i] *
 185                      ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][i];
 186                }
 187                /* [3] = material alpha */
 188                value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][3];
 189                return;
 190             case STATE_SPECULAR:
 191                for (i = 0; i < 3; i++) {
 192                   value[i] = ctx->Light.Light[ln].Specular[i] *
 193                      ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][i];
 194                }
 195                /* [3] = material alpha */
 196                value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][3];
 197                return;
 198             default:
 199                _mesa_problem(ctx, "Invalid lightprod state in fetch_state");
 200                return;
 201          }
 202       }
 203    case STATE_TEXGEN:
 204       {
 205          /* state[1] is the texture unit */
 206          const GLuint unit = (GLuint) state[1];
 207          /* state[2] is the texgen attribute */
 208          switch (state[2]) {
 209          case STATE_TEXGEN_EYE_S:
 210             COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneS);
 211             return;
 212          case STATE_TEXGEN_EYE_T:
 213             COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneT);
 214             return;
 215          case STATE_TEXGEN_EYE_R:
 216             COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneR);
 217             return;
 218          case STATE_TEXGEN_EYE_Q:
 219             COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneQ);
 220             return;
 221          case STATE_TEXGEN_OBJECT_S:
 222             COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneS);
 223             return;
 224          case STATE_TEXGEN_OBJECT_T:
 225             COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneT);
 226             return;
 227          case STATE_TEXGEN_OBJECT_R:
 228             COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneR);
 229             return;
 230          case STATE_TEXGEN_OBJECT_Q:
 231             COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneQ);
 232             return;
 233          default:
 234             _mesa_problem(ctx, "Invalid texgen state in fetch_state");
 235             return;
 236          }
 237       }
 238    case STATE_TEXENV_COLOR:
 239       {
 240          /* state[1] is the texture unit */
 241          const GLuint unit = (GLuint) state[1];
 242          COPY_4V(value, ctx->Texture.Unit[unit].EnvColor);
 243       }
 244       return;
 245    case STATE_FOG_COLOR:
 246       COPY_4V(value, ctx->Fog.Color);
 247       return;
 248    case STATE_FOG_PARAMS:
 249       value[0] = ctx->Fog.Density;
 250       value[1] = ctx->Fog.Start;
 251       value[2] = ctx->Fog.End;
 252       value[3] = (ctx->Fog.End == ctx->Fog.Start)
 253          ? 1.0f : (GLfloat)(1.0 / (ctx->Fog.End - ctx->Fog.Start));
 254       return;
 255    case STATE_CLIPPLANE:
 256       {
 257          const GLuint plane = (GLuint) state[1];
 258          COPY_4V(value, ctx->Transform.EyeUserPlane[plane]);
 259       }
 260       return;
 261    case STATE_POINT_SIZE:
 262       value[0] = ctx->Point.Size;
 263       value[1] = ctx->Point.MinSize;
 264       value[2] = ctx->Point.MaxSize;
 265       value[3] = ctx->Point.Threshold;
 266       return;
 267    case STATE_POINT_ATTENUATION:
 268       value[0] = ctx->Point.Params[0];
 269       value[1] = ctx->Point.Params[1];
 270       value[2] = ctx->Point.Params[2];
 271       value[3] = 1.0F;
 272       return;
 273    case STATE_MODELVIEW_MATRIX:
 274    case STATE_PROJECTION_MATRIX:
 275    case STATE_MVP_MATRIX:
 276    case STATE_TEXTURE_MATRIX:
 277    case STATE_PROGRAM_MATRIX:
 278    case STATE_COLOR_MATRIX:
 279       {
 280          /* state[0] = modelview, projection, texture, etc. */
 281          /* state[1] = which texture matrix or program matrix */
 282          /* state[2] = first row to fetch */
 283          /* state[3] = last row to fetch */
 284          /* state[4] = transpose, inverse or invtrans */
 285          const GLmatrix *matrix;
 286          const gl_state_index mat = state[0];
 287          const GLuint index = (GLuint) state[1];
 288          const GLuint firstRow = (GLuint) state[2];
 289          const GLuint lastRow = (GLuint) state[3];
 290          const gl_state_index modifier = state[4];
 291          const GLfloat *m;
 292          GLuint row, i;
 293          ASSERT(firstRow >= 0);
 294          ASSERT(firstRow < 4);
 295          ASSERT(lastRow >= 0);
 296          ASSERT(lastRow < 4);
 297          if (mat == STATE_MODELVIEW_MATRIX) {
 298             matrix = ctx->ModelviewMatrixStack.Top;
 299          }
 300          else if (mat == STATE_PROJECTION_MATRIX) {
 301             matrix = ctx->ProjectionMatrixStack.Top;
 302          }
 303          else if (mat == STATE_MVP_MATRIX) {
 304             matrix = &ctx->_ModelProjectMatrix;
 305          }
 306          else if (mat == STATE_TEXTURE_MATRIX) {
 307             matrix = ctx->TextureMatrixStack[index].Top;
 308          }
 309          else if (mat == STATE_PROGRAM_MATRIX) {
 310             matrix = ctx->ProgramMatrixStack[index].Top;
 311          }
 312          else if (mat == STATE_COLOR_MATRIX) {
 313             matrix = ctx->ColorMatrixStack.Top;
 314          }
 315          else {
 316             _mesa_problem(ctx, "Bad matrix name in _mesa_fetch_state()");
 317             return;
 318          }
 319          if (modifier == STATE_MATRIX_INVERSE ||
 320              modifier == STATE_MATRIX_INVTRANS) {
 321             /* Be sure inverse is up to date:
 322              */
 323             _math_matrix_alloc_inv( (GLmatrix *) matrix );
 324             _math_matrix_analyse( (GLmatrix*) matrix );
 325             m = matrix->inv;
 326          }
 327          else {
 328             m = matrix->m;
 329          }
 330          if (modifier == STATE_MATRIX_TRANSPOSE ||
 331              modifier == STATE_MATRIX_INVTRANS) {
 332             for (i = 0, row = firstRow; row <= lastRow; row++) {
 333                value[i++] = m[row * 4 + 0];
 334                value[i++] = m[row * 4 + 1];
 335                value[i++] = m[row * 4 + 2];
 336                value[i++] = m[row * 4 + 3];
 337             }
 338          }
 339          else {
 340             for (i = 0, row = firstRow; row <= lastRow; row++) {
 341                value[i++] = m[row + 0];
 342                value[i++] = m[row + 4];
 343                value[i++] = m[row + 8];
 344                value[i++] = m[row + 12];
 345             }
 346          }
 347       }
 348       return;
 349    case STATE_DEPTH_RANGE:
 350       value[0] = ctx->Viewport.Near;                     /* near       */
 351       value[1] = ctx->Viewport.Far;                      /* far        */
 352       value[2] = ctx->Viewport.Far - ctx->Viewport.Near; /* far - near */
 353       value[3] = 1.0;
 354       return;
 355    case STATE_FRAGMENT_PROGRAM:
 356       {
 357          /* state[1] = {STATE_ENV, STATE_LOCAL} */
 358          /* state[2] = parameter index          */
 359          const int idx = (int) state[2];
 360          switch (state[1]) {
 361             case STATE_ENV:
 362                COPY_4V(value, ctx->FragmentProgram.Parameters[idx]);
 363                break;
 364             case STATE_LOCAL:
 365                COPY_4V(value, ctx->FragmentProgram.Current->Base.LocalParams[idx]);
 366                break;
 367             default:
 368                _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
 369                return;
 370          }
 371       }
 372       return;
 373
 374    case STATE_VERTEX_PROGRAM:
 375       {
 376          /* state[1] = {STATE_ENV, STATE_LOCAL} */
 377          /* state[2] = parameter index          */
 378          const int idx = (int) state[2];
 379          switch (state[1]) {
 380             case STATE_ENV:
 381                COPY_4V(value, ctx->VertexProgram.Parameters[idx]);
 382                break;
 383             case STATE_LOCAL:
 384                COPY_4V(value, ctx->VertexProgram.Current->Base.LocalParams[idx]);
 385                break;
 386             default:
 387                _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
 388                return;
 389          }
 390       }
 391       return;
 392
 393    case STATE_NORMAL_SCALE:
 394       ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
 395       return;
 396
 397    case STATE_INTERNAL:
 398       switch (state[1]) {
 399       case STATE_NORMAL_SCALE:
 400          ASSIGN_4V(value,
 401                    ctx->_ModelViewInvScale,
 402                    ctx->_ModelViewInvScale,
 403                    ctx->_ModelViewInvScale,
 404                    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, (GLfloat) (1.0 / texImage->Width),
 414                          (GLfloat)(1.0 / texImage->Height),
 415                          0.0f, 1.0f);
 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.0f : (GLfloat)(-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
 435       case STATE_LIGHT_SPOT_DIR_NORMALIZED: {
 436          /* here, state[2] is the light number */
 437          /* pre-normalize spot dir */
 438          const GLuint ln = (GLuint) state[2];
 439          COPY_3V(value, ctx->Light.Light[ln]._NormDirection);
 440          value[3] = ctx->Light.Light[ln]._CosCutoff;
 441          return;
 442       }
 443
 444       case STATE_LIGHT_POSITION: {
 445          const GLuint ln = (GLuint) state[2];
 446          COPY_4V(value, ctx->Light.Light[ln]._Position);
 447          return;
 448       }
 449
 450       case STATE_LIGHT_POSITION_NORMALIZED: {
 451          const GLuint ln = (GLuint) state[2];
 452          COPY_4V(value, ctx->Light.Light[ln]._Position);
 453          NORMALIZE_3FV( value );
 454          return;
 455       }
 456
 457       case STATE_LIGHT_HALF_VECTOR: {
 458          const GLuint ln = (GLuint) state[2];
 459          GLfloat p[3];
 460          /* Compute infinite half angle vector:
 461           *   halfVector = normalize(normalize(lightPos) + (0, 0, 1))
 462           * light.EyePosition.w should be 0 for infinite lights.
 463           */
 464          COPY_3V(p, ctx->Light.Light[ln]._Position);
 465          NORMALIZE_3FV(p);
 466          ADD_3V(value, p, ctx->_EyeZDir);
 467          NORMALIZE_3FV(value);
 468          value[3] = 1.0;
 469          return;
 470       }
 471
 472
 473       case STATE_PT_SCALE:
 474          value[0] = ctx->Pixel.RedScale;
 475          value[1] = ctx->Pixel.GreenScale;
 476          value[2] = ctx->Pixel.BlueScale;
 477          value[3] = ctx->Pixel.AlphaScale;
 478          break;
 479       case STATE_PT_BIAS:
 480          value[0] = ctx->Pixel.RedBias;
 481          value[1] = ctx->Pixel.GreenBias;
 482          value[2] = ctx->Pixel.BlueBias;
 483          value[3] = ctx->Pixel.AlphaBias;
 484          break;
 485       case STATE_PCM_SCALE:
 486          COPY_4V(value, ctx->Pixel.PostColorMatrixScale);
 487          break;
 488       case STATE_PCM_BIAS:
 489          COPY_4V(value, ctx->Pixel.PostColorMatrixBias);
 490          break;
 491       case STATE_SHADOW_AMBIENT:
 492          {
 493             const int unit = (int) state[2];
 494             const struct gl_texture_object *texObj
 495                = ctx->Texture.Unit[unit]._Current;
 496             if (texObj) {
 497                value[0] = texObj->ShadowAmbient;
 498                value[1] = texObj->ShadowAmbient;
 499                value[2] = texObj->ShadowAmbient;
 500                value[3] = texObj->ShadowAmbient;
 501             }
 502          }
 503          return;
 504
 505       default:
 506          /* unknown state indexes are silently ignored
 507           *  should be handled by the driver.
 508           */
 509          return;
 510       }
 511       return;
 512
 513    default:
 514       _mesa_problem(ctx, "Invalid state in _mesa_fetch_state");
 515       return;
 516    }
 517 }
 518
 519
 520 /**
 521  * Return a bitmask of the Mesa state flags (_NEW_* values) which would
 522  * indicate that the given context state may have changed.
 523  * The bitmask is used during validation to determine if we need to update
 524  * vertex/fragment program parameters (like "state.material.color") when
 525  * some GL state has changed.
 526  */
 527 GLbitfield
 528 _mesa_program_state_flags(const gl_state_index state[STATE_LENGTH])
 529 {
 530    switch (state[0]) {
 531    case STATE_MATERIAL:
 532    case STATE_LIGHT:
 533    case STATE_LIGHTMODEL_AMBIENT:
 534    case STATE_LIGHTMODEL_SCENECOLOR:
 535    case STATE_LIGHTPROD:
 536       return _NEW_LIGHT;
 537
 538    case STATE_TEXGEN:
 539    case STATE_TEXENV_COLOR:
 540       return _NEW_TEXTURE;
 541
 542    case STATE_FOG_COLOR:
 543    case STATE_FOG_PARAMS:
 544       return _NEW_FOG;
 545
 546    case STATE_CLIPPLANE:
 547       return _NEW_TRANSFORM;
 548
 549    case STATE_POINT_SIZE:
 550    case STATE_POINT_ATTENUATION:
 551       return _NEW_POINT;
 552
 553    case STATE_MODELVIEW_MATRIX:
 554       return _NEW_MODELVIEW;
 555    case STATE_PROJECTION_MATRIX:
 556       return _NEW_PROJECTION;
 557    case STATE_MVP_MATRIX:
 558       return _NEW_MODELVIEW | _NEW_PROJECTION;
 559    case STATE_TEXTURE_MATRIX:
 560       return _NEW_TEXTURE_MATRIX;
 561    case STATE_PROGRAM_MATRIX:
 562       return _NEW_TRACK_MATRIX;
 563    case STATE_COLOR_MATRIX:
 564       return _NEW_COLOR_MATRIX;
 565
 566    case STATE_DEPTH_RANGE:
 567       return _NEW_VIEWPORT;
 568
 569    case STATE_FRAGMENT_PROGRAM:
 570    case STATE_VERTEX_PROGRAM:
 571       return _NEW_PROGRAM;
 572
 573    case STATE_NORMAL_SCALE:
 574       return _NEW_MODELVIEW;
 575
 576    case STATE_INTERNAL:
 577       switch (state[1]) {
 578       case STATE_TEXRECT_SCALE:
 579       case STATE_SHADOW_AMBIENT:
 580          return _NEW_TEXTURE;
 581       case STATE_FOG_PARAMS_OPTIMIZED:
 582          return _NEW_FOG;
 583       default:
 584          /* unknown state indexes are silently ignored and
 585          *  no flag set, since it is handled by the driver.
 586          */
 587          return 0;
 588       }
 589
 590    default:
 591       _mesa_problem(NULL, "unexpected state[0] in make_state_flags()");
 592       return 0;
 593    }
 594 }
 595
 596
 597 static void
 598 append(char *dst, const char *src)
 599 {
 600    while (*dst)
 601       dst++;
 602    while (*src)
 603      *dst++ = *src++;
 604    *dst = 0;
 605 }
 606
 607
 608 static void
 609 append_token(char *dst, gl_state_index k)
 610 {
 611    switch (k) {
 612    case STATE_MATERIAL:
 613       append(dst, "material");
 614       break;
 615    case STATE_LIGHT:
 616       append(dst, "light");
 617       break;
 618    case STATE_LIGHTMODEL_AMBIENT:
 619       append(dst, "lightmodel.ambient");
 620       break;
 621    case STATE_LIGHTMODEL_SCENECOLOR:
 622       break;
 623    case STATE_LIGHTPROD:
 624       append(dst, "lightprod");
 625       break;
 626    case STATE_TEXGEN:
 627       append(dst, "texgen");
 628       break;
 629    case STATE_FOG_COLOR:
 630       append(dst, "fog.color");
 631       break;
 632    case STATE_FOG_PARAMS:
 633       append(dst, "fog.params");
 634       break;
 635    case STATE_CLIPPLANE:
 636       append(dst, "clip");
 637       break;
 638    case STATE_POINT_SIZE:
 639       append(dst, "point.size");
 640       break;
 641    case STATE_POINT_ATTENUATION:
 642       append(dst, "point.attenuation");
 643       break;
 644    case STATE_MODELVIEW_MATRIX:
 645       append(dst, "matrix.modelview");
 646       break;
 647    case STATE_PROJECTION_MATRIX:
 648       append(dst, "matrix.projection");
 649       break;
 650    case STATE_MVP_MATRIX:
 651       append(dst, "matrix.mvp");
 652       break;
 653    case STATE_TEXTURE_MATRIX:
 654       append(dst, "matrix.texture");
 655       break;
 656    case STATE_PROGRAM_MATRIX:
 657       append(dst, "matrix.program");
 658       break;
 659    case STATE_COLOR_MATRIX:
 660       append(dst, "matrix.color");
 661       break;
 662    case STATE_MATRIX_INVERSE:
 663       append(dst, ".inverse");
 664       break;
 665    case STATE_MATRIX_TRANSPOSE:
 666       append(dst, ".transpose");
 667       break;
 668    case STATE_MATRIX_INVTRANS:
 669       append(dst, ".invtrans");
 670       break;
 671    case STATE_AMBIENT:
 672       append(dst, ".ambient");
 673       break;
 674    case STATE_DIFFUSE:
 675       append(dst, ".diffuse");
 676       break;
 677    case STATE_SPECULAR:
 678       append(dst, ".specular");
 679       break;
 680    case STATE_EMISSION:
 681       append(dst, ".emission");
 682       break;
 683    case STATE_SHININESS:
 684       append(dst, "lshininess");
 685       break;
 686    case STATE_HALF_VECTOR:
 687       append(dst, ".half");
 688       break;
 689    case STATE_POSITION:
 690       append(dst, ".position");
 691       break;
 692    case STATE_ATTENUATION:
 693       append(dst, ".attenuation");
 694       break;
 695    case STATE_SPOT_DIRECTION:
 696       append(dst, ".spot.direction");
 697       break;
 698    case STATE_SPOT_CUTOFF:
 699       append(dst, ".spot.cutoff");
 700       break;
 701    case STATE_TEXGEN_EYE_S:
 702       append(dst, "eye.s");
 703       break;
 704    case STATE_TEXGEN_EYE_T:
 705       append(dst, "eye.t");
 706       break;
 707    case STATE_TEXGEN_EYE_R:
 708       append(dst, "eye.r");
 709       break;
 710    case STATE_TEXGEN_EYE_Q:
 711       append(dst, "eye.q");
 712       break;
 713    case STATE_TEXGEN_OBJECT_S:
 714       append(dst, "object.s");
 715       break;
 716    case STATE_TEXGEN_OBJECT_T:
 717       append(dst, "object.t");
 718       break;
 719    case STATE_TEXGEN_OBJECT_R:
 720       append(dst, "object.r");
 721       break;
 722    case STATE_TEXGEN_OBJECT_Q:
 723       append(dst, "object.q");
 724       break;
 725    case STATE_TEXENV_COLOR:
 726       append(dst, "texenv");
 727       break;
 728    case STATE_DEPTH_RANGE:
 729       append(dst, "depth.range");
 730       break;
 731    case STATE_VERTEX_PROGRAM:
 732    case STATE_FRAGMENT_PROGRAM:
 733       break;
 734    case STATE_ENV:
 735       append(dst, "env");
 736       break;
 737    case STATE_LOCAL:
 738       append(dst, "local");
 739       break;
 740    case STATE_NORMAL_SCALE:
 741       append(dst, "normalScale");
 742       break;
 743    case STATE_INTERNAL:
 744       append(dst, "(internal)");
 745       break;
 746    case STATE_PT_SCALE:
 747       append(dst, "PTscale");
 748       break;
 749    case STATE_PT_BIAS:
 750       append(dst, "PTbias");
 751       break;
 752    case STATE_PCM_SCALE:
 753       append(dst, "PCMscale");
 754       break;
 755    case STATE_PCM_BIAS:
 756       append(dst, "PCMbias");
 757       break;
 758    case STATE_SHADOW_AMBIENT:
 759       append(dst, "ShadowAmbient");
 760       break;
 761    default:
 762       ;
 763    }
 764 }
 765
 766 static void
 767 append_face(char *dst, GLint face)
 768 {
 769    if (face == 0)
 770       append(dst, "front.");
 771    else
 772       append(dst, "back.");
 773 }
 774
 775 static void
 776 append_index(char *dst, GLint index)
 777 {
 778    char s[20];
 779    _mesa_sprintf(s, "[%d]", index);
 780    append(dst, s);
 781 }
 782
 783 /**
 784  * Make a string from the given state vector.
 785  * For example, return "state.matrix.texture[2].inverse".
 786  * Use _mesa_free() to deallocate the string.
 787  */
 788 const char *
 789 _mesa_program_state_string(const gl_state_index state[STATE_LENGTH])
 790 {
 791    char str[1000] = "";
 792    char tmp[30];
 793
 794    append(str, "state.");
 795    append_token(str, (gl_state_index) state[0]);
 796
 797    switch (state[0]) {
 798    case STATE_MATERIAL:
 799       append_face(str, state[1]);
 800       append_token(str, (gl_state_index) state[2]);
 801       break;
 802    case STATE_LIGHT:
 803       append_index(str, state[1]); /* light number [i]. */
 804       append_token(str, (gl_state_index) state[2]); /* coefficients */
 805       break;
 806    case STATE_LIGHTMODEL_AMBIENT:
 807       append(str, "lightmodel.ambient");
 808       break;
 809    case STATE_LIGHTMODEL_SCENECOLOR:
 810       if (state[1] == 0) {
 811          append(str, "lightmodel.front.scenecolor");
 812       }
 813       else {
 814          append(str, "lightmodel.back.scenecolor");
 815       }
 816       break;
 817    case STATE_LIGHTPROD:
 818       append_index(str, state[1]); /* light number [i]. */
 819       append_face(str, state[2]);
 820       append_token(str, (gl_state_index) state[3]);
 821       break;
 822    case STATE_TEXGEN:
 823       append_index(str, state[1]); /* tex unit [i] */
 824       append_token(str, (gl_state_index) state[2]); /* plane coef */
 825       break;
 826    case STATE_TEXENV_COLOR:
 827       append_index(str, state[1]); /* tex unit [i] */
 828       append(str, "color");
 829       break;
 830    case STATE_CLIPPLANE:
 831       append_index(str, state[1]); /* plane [i] */
 832       append(str, ".plane");
 833       break;
 834    case STATE_MODELVIEW_MATRIX:
 835    case STATE_PROJECTION_MATRIX:
 836    case STATE_MVP_MATRIX:
 837    case STATE_TEXTURE_MATRIX:
 838    case STATE_PROGRAM_MATRIX:
 839    case STATE_COLOR_MATRIX:
 840       {
 841          /* state[0] = modelview, projection, texture, etc. */
 842          /* state[1] = which texture matrix or program matrix */
 843          /* state[2] = first row to fetch */
 844          /* state[3] = last row to fetch */
 845          /* state[4] = transpose, inverse or invtrans */
 846          const gl_state_index mat = (gl_state_index) state[0];
 847          const GLuint index = (GLuint) state[1];
 848          const GLuint firstRow = (GLuint) state[2];
 849          const GLuint lastRow = (GLuint) state[3];
 850          const gl_state_index modifier = (gl_state_index) state[4];
 851          if (index ||
 852              mat == STATE_TEXTURE_MATRIX ||
 853              mat == STATE_PROGRAM_MATRIX)
 854             append_index(str, index);
 855          if (modifier)
 856             append_token(str, modifier);
 857          if (firstRow == lastRow)
 858             _mesa_sprintf(tmp, ".row[%d]", firstRow);
 859          else
 860             _mesa_sprintf(tmp, ".row[%d..%d]", firstRow, lastRow);
 861          append(str, tmp);
 862       }
 863       break;
 864    case STATE_POINT_SIZE:
 865       break;
 866    case STATE_POINT_ATTENUATION:
 867       break;
 868    case STATE_FOG_PARAMS:
 869       break;
 870    case STATE_FOG_COLOR:
 871       break;
 872    case STATE_DEPTH_RANGE:
 873       break;
 874    case STATE_FRAGMENT_PROGRAM:
 875    case STATE_VERTEX_PROGRAM:
 876       /* state[1] = {STATE_ENV, STATE_LOCAL} */
 877       /* state[2] = parameter index          */
 878       append_token(str, (gl_state_index) state[1]);
 879       append_index(str, state[2]);
 880       break;
 881    case STATE_INTERNAL:
 882       break;
 883    default:
 884       _mesa_problem(NULL, "Invalid state in _mesa_program_state_string");
 885       break;
 886    }
 887
 888    return _mesa_strdup(str);
 889 }
 890
 891
 892 /**
 893  * Loop over all the parameters in a parameter list.  If the parameter
 894  * is a GL state reference, look up the current value of that state
 895  * variable and put it into the parameter's Value[4] array.
 896  * This would be called at glBegin time when using a fragment program.
 897  */
 898 void
 899 _mesa_load_state_parameters(GLcontext *ctx,
 900                             struct gl_program_parameter_list *paramList)
 901 {
 902    GLuint i;
 903
 904    if (!paramList)
 905       return;
 906
 907    /*assert(ctx->Driver.NeedFlush == 0);*/
 908
 909    for (i = 0; i < paramList->NumParameters; i++) {
 910       if (paramList->Parameters[i].Type == PROGRAM_STATE_VAR) {
 911          _mesa_fetch_state(ctx,
 912                            (gl_state_index *) paramList->Parameters[i].StateIndexes,
 913                            paramList->ParameterValues[i]);
 914       }
 915    }
 916 }
 917
 918
 919 /**
 920  * Copy the 16 elements of a matrix into four consecutive program
 921  * registers starting at 'pos'.
 922  */
 923 static void
 924 load_matrix(GLfloat registers[][4], GLuint pos, const GLfloat mat[16])
 925 {
 926    GLuint i;
 927    for (i = 0; i < 4; i++) {
 928       registers[pos + i][0] = mat[0 + i];
 929       registers[pos + i][1] = mat[4 + i];
 930       registers[pos + i][2] = mat[8 + i];
 931       registers[pos + i][3] = mat[12 + i];
 932    }
 933 }
 934
 935
 936 /**
 937  * As above, but transpose the matrix.
 938  */
 939 static void
 940 load_transpose_matrix(GLfloat registers[][4], GLuint pos,
 941                       const GLfloat mat[16])
 942 {
 943    MEMCPY(registers[pos], mat, 16 * sizeof(GLfloat));
 944 }
 945
 946
 947 /**
 948  * Load current vertex program's parameter registers with tracked
 949  * matrices (if NV program).  This only needs to be done per
 950  * glBegin/glEnd, not per-vertex.
 951  */
 952 void
 953 _mesa_load_tracked_matrices(GLcontext *ctx)
 954 {
 955    GLuint i;
 956
 957    for (i = 0; i < MAX_NV_VERTEX_PROGRAM_PARAMS / 4; i++) {
 958       /* point 'mat' at source matrix */
 959       GLmatrix *mat;
 960       if (ctx->VertexProgram.TrackMatrix[i] == GL_MODELVIEW) {
 961          mat = ctx->ModelviewMatrixStack.Top;
 962       }
 963       else if (ctx->VertexProgram.TrackMatrix[i] == GL_PROJECTION) {
 964          mat = ctx->ProjectionMatrixStack.Top;
 965       }
 966       else if (ctx->VertexProgram.TrackMatrix[i] == GL_TEXTURE) {
 967          mat = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top;
 968       }
 969       else if (ctx->VertexProgram.TrackMatrix[i] == GL_COLOR) {
 970          mat = ctx->ColorMatrixStack.Top;
 971       }
 972       else if (ctx->VertexProgram.TrackMatrix[i]==GL_MODELVIEW_PROJECTION_NV) {
 973          /* XXX verify the combined matrix is up to date */
 974          mat = &ctx->_ModelProjectMatrix;
 975       }
 976       else if (ctx->VertexProgram.TrackMatrix[i] >= GL_MATRIX0_NV &&
 977                ctx->VertexProgram.TrackMatrix[i] <= GL_MATRIX7_NV) {
 978          GLuint n = ctx->VertexProgram.TrackMatrix[i] - GL_MATRIX0_NV;
 979          ASSERT(n < MAX_PROGRAM_MATRICES);
 980          mat = ctx->ProgramMatrixStack[n].Top;
 981       }
 982       else {
 983          /* no matrix is tracked, but we leave the register values as-is */
 984          assert(ctx->VertexProgram.TrackMatrix[i] == GL_NONE);
 985          continue;
 986       }
 987
 988       /* load the matrix values into sequential registers */
 989       if (ctx->VertexProgram.TrackMatrixTransform[i] == GL_IDENTITY_NV) {
 990          load_matrix(ctx->VertexProgram.Parameters, i*4, mat->m);
 991       }
 992       else if (ctx->VertexProgram.TrackMatrixTransform[i] == GL_INVERSE_NV) {
 993          _math_matrix_analyse(mat); /* update the inverse */
 994          ASSERT(!_math_matrix_is_dirty(mat));
 995          load_matrix(ctx->VertexProgram.Parameters, i*4, mat->inv);
 996       }
 997       else if (ctx->VertexProgram.TrackMatrixTransform[i] == GL_TRANSPOSE_NV) {
 998          load_transpose_matrix(ctx->VertexProgram.Parameters, i*4, mat->m);
 999       }
1000       else {
1001          assert(ctx->VertexProgram.TrackMatrixTransform[i]
1002                 == GL_INVERSE_TRANSPOSE_NV);
1003          _math_matrix_analyse(mat); /* update the inverse */
1004          ASSERT(!_math_matrix_is_dirty(mat));
1005          load_transpose_matrix(ctx->VertexProgram.Parameters, i*4, mat->inv);
1006       }
1007    }
1008 }