src/mesa/shader/prog_statevars.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5.3
   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_HALF:
 120             {
 121                GLfloat eye_z[] = {0, 0, 1};
 122
 123                /* Compute infinite half angle vector:
 124                 *   half-vector = light_position + (0, 0, 1)
 125                 * and then normalize.  w = 0
 126                 *
 127                 * light.EyePosition.w should be 0 for infinite lights.
 128                 */
 129                ADD_3V(value, eye_z, ctx->Light.Light[ln].EyePosition);
 130                NORMALIZE_3FV(value);
 131                value[3] = 0;
 132             }
 133             return;
 134          case STATE_POSITION_NORMALIZED:
 135             COPY_4V(value, ctx->Light.Light[ln].EyePosition);
 136             NORMALIZE_3FV( value );
 137             return;
 138          default:
 139             _mesa_problem(ctx, "Invalid light state in fetch_state");
 140             return;
 141          }
 142       }
 143    case STATE_LIGHTMODEL_AMBIENT:
 144       COPY_4V(value, ctx->Light.Model.Ambient);
 145       return;
 146    case STATE_LIGHTMODEL_SCENECOLOR:
 147       if (state[1] == 0) {
 148          /* front */
 149          GLint i;
 150          for (i = 0; i < 3; i++) {
 151             value[i] = ctx->Light.Model.Ambient[i]
 152                * ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT][i]
 153                + ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_EMISSION][i];
 154          }
 155          value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE][3];
 156       }
 157       else {
 158          /* back */
 159          GLint i;
 160          for (i = 0; i < 3; i++) {
 161             value[i] = ctx->Light.Model.Ambient[i]
 162                * ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_AMBIENT][i]
 163                + ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_EMISSION][i];
 164          }
 165          value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_DIFFUSE][3];
 166       }
 167       return;
 168    case STATE_LIGHTPROD:
 169       {
 170          const GLuint ln = (GLuint) state[1];
 171          const GLuint face = (GLuint) state[2];
 172          GLint i;
 173          ASSERT(face == 0 || face == 1);
 174          switch (state[3]) {
 175             case STATE_AMBIENT:
 176                for (i = 0; i < 3; i++) {
 177                   value[i] = ctx->Light.Light[ln].Ambient[i] *
 178                      ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][i];
 179                }
 180                /* [3] = material alpha */
 181                value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][3];
 182                return;
 183             case STATE_DIFFUSE:
 184                for (i = 0; i < 3; i++) {
 185                   value[i] = ctx->Light.Light[ln].Diffuse[i] *
 186                      ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][i];
 187                }
 188                /* [3] = material alpha */
 189                value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][3];
 190                return;
 191             case STATE_SPECULAR:
 192                for (i = 0; i < 3; i++) {
 193                   value[i] = ctx->Light.Light[ln].Specular[i] *
 194                      ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][i];
 195                }
 196                /* [3] = material alpha */
 197                value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][3];
 198                return;
 199             default:
 200                _mesa_problem(ctx, "Invalid lightprod state in fetch_state");
 201                return;
 202          }
 203       }
 204    case STATE_TEXGEN:
 205       {
 206          /* state[1] is the texture unit */
 207          const GLuint unit = (GLuint) state[1];
 208          /* state[2] is the texgen attribute */
 209          switch (state[2]) {
 210          case STATE_TEXGEN_EYE_S:
 211             COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneS);
 212             return;
 213          case STATE_TEXGEN_EYE_T:
 214             COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneT);
 215             return;
 216          case STATE_TEXGEN_EYE_R:
 217             COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneR);
 218             return;
 219          case STATE_TEXGEN_EYE_Q:
 220             COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneQ);
 221             return;
 222          case STATE_TEXGEN_OBJECT_S:
 223             COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneS);
 224             return;
 225          case STATE_TEXGEN_OBJECT_T:
 226             COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneT);
 227             return;
 228          case STATE_TEXGEN_OBJECT_R:
 229             COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneR);
 230             return;
 231          case STATE_TEXGEN_OBJECT_Q:
 232             COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneQ);
 233             return;
 234          default:
 235             _mesa_problem(ctx, "Invalid texgen state in fetch_state");
 236             return;
 237          }
 238       }
 239    case STATE_TEXENV_COLOR:
 240       {
 241          /* state[1] is the texture unit */
 242          const GLuint unit = (GLuint) state[1];
 243          COPY_4V(value, ctx->Texture.Unit[unit].EnvColor);
 244       }
 245       return;
 246    case STATE_FOG_COLOR:
 247       COPY_4V(value, ctx->Fog.Color);
 248       return;
 249    case STATE_FOG_PARAMS:
 250       value[0] = ctx->Fog.Density;
 251       value[1] = ctx->Fog.Start;
 252       value[2] = ctx->Fog.End;
 253       value[3] = 1.0F / (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_MATRIX:
 274       {
 275          /* state[1] = modelview, projection, texture, etc. */
 276          /* state[2] = which texture matrix or program matrix */
 277          /* state[3] = first row to fetch */
 278          /* state[4] = last row to fetch */
 279          /* state[5] = transpose, inverse or invtrans */
 280
 281          const GLmatrix *matrix;
 282          const gl_state_index mat = state[1];
 283          const GLuint index = (GLuint) state[2];
 284          const GLuint firstRow = (GLuint) state[3];
 285          const GLuint lastRow = (GLuint) state[4];
 286          const gl_state_index modifier = state[5];
 287          const GLfloat *m;
 288          GLuint row, i;
 289          if (mat == STATE_MODELVIEW) {
 290             matrix = ctx->ModelviewMatrixStack.Top;
 291          }
 292          else if (mat == STATE_PROJECTION) {
 293             matrix = ctx->ProjectionMatrixStack.Top;
 294          }
 295          else if (mat == STATE_MVP) {
 296             matrix = &ctx->_ModelProjectMatrix;
 297          }
 298          else if (mat == STATE_TEXTURE) {
 299             matrix = ctx->TextureMatrixStack[index].Top;
 300          }
 301          else if (mat == STATE_PROGRAM) {
 302             matrix = ctx->ProgramMatrixStack[index].Top;
 303          }
 304          else {
 305             _mesa_problem(ctx, "Bad matrix name in _mesa_fetch_state()");
 306             return;
 307          }
 308          if (modifier == STATE_MATRIX_INVERSE ||
 309              modifier == STATE_MATRIX_INVTRANS) {
 310             /* Be sure inverse is up to date:
 311              */
 312             _math_matrix_alloc_inv( (GLmatrix *) matrix );
 313             _math_matrix_analyse( (GLmatrix*) matrix );
 314             m = matrix->inv;
 315          }
 316          else {
 317             m = matrix->m;
 318          }
 319          if (modifier == STATE_MATRIX_TRANSPOSE ||
 320              modifier == STATE_MATRIX_INVTRANS) {
 321             for (i = 0, row = firstRow; row <= lastRow; row++) {
 322                value[i++] = m[row * 4 + 0];
 323                value[i++] = m[row * 4 + 1];
 324                value[i++] = m[row * 4 + 2];
 325                value[i++] = m[row * 4 + 3];
 326             }
 327          }
 328          else {
 329             for (i = 0, row = firstRow; row <= lastRow; row++) {
 330                value[i++] = m[row + 0];
 331                value[i++] = m[row + 4];
 332                value[i++] = m[row + 8];
 333                value[i++] = m[row + 12];
 334             }
 335          }
 336       }
 337       return;
 338    case STATE_DEPTH_RANGE:
 339       value[0] = ctx->Viewport.Near;                     /* near       */
 340       value[1] = ctx->Viewport.Far;                      /* far        */
 341       value[2] = ctx->Viewport.Far - ctx->Viewport.Near; /* far - near */
 342       value[3] = 0;
 343       return;
 344    case STATE_FRAGMENT_PROGRAM:
 345       {
 346          /* state[1] = {STATE_ENV, STATE_LOCAL} */
 347          /* state[2] = parameter index          */
 348          const int idx = (int) state[2];
 349          switch (state[1]) {
 350             case STATE_ENV:
 351                COPY_4V(value, ctx->FragmentProgram.Parameters[idx]);
 352                break;
 353             case STATE_LOCAL:
 354                COPY_4V(value, ctx->FragmentProgram.Current->Base.LocalParams[idx]);
 355                break;
 356             default:
 357                _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
 358                return;
 359          }
 360       }
 361       return;
 362
 363    case STATE_VERTEX_PROGRAM:
 364       {
 365          /* state[1] = {STATE_ENV, STATE_LOCAL} */
 366          /* state[2] = parameter index          */
 367          const int idx = (int) state[2];
 368          switch (state[1]) {
 369             case STATE_ENV:
 370                COPY_4V(value, ctx->VertexProgram.Parameters[idx]);
 371                break;
 372             case STATE_LOCAL:
 373                COPY_4V(value, ctx->VertexProgram.Current->Base.LocalParams[idx]);
 374                break;
 375             default:
 376                _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
 377                return;
 378          }
 379       }
 380       return;
 381
 382    case STATE_INTERNAL:
 383       {
 384          switch (state[1]) {
 385             case STATE_NORMAL_SCALE:
 386                ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
 387                break;
 388             case STATE_TEXRECT_SCALE: {
 389                const int unit = (int) state[2];
 390                const struct gl_texture_object *texObj = ctx->Texture.Unit[unit]._Current;
 391                if (texObj) {
 392                   struct gl_texture_image *texImage = texObj->Image[0][0];
 393                   ASSIGN_4V(value, 1.0 / texImage->Width, 1.0 / texImage->Height, 0, 1);
 394                }
 395                break;
 396             }
 397             default:
 398                /* unknown state indexes are silently ignored
 399                *  should be handled by the driver.
 400                */
 401                return;
 402          }
 403       }
 404       return;
 405
 406    default:
 407       _mesa_problem(ctx, "Invalid state in _mesa_fetch_state");
 408       return;
 409    }
 410 }
 411
 412
 413 /**
 414  * Return a bitmask of the Mesa state flags (_NEW_* values) which would
 415  * indicate that the given context state may have changed.
 416  * The bitmask is used during validation to determine if we need to update
 417  * vertex/fragment program parameters (like "state.material.color") when
 418  * some GL state has changed.
 419  */
 420 GLbitfield
 421 _mesa_program_state_flags(const GLint state[STATE_LENGTH])
 422 {
 423    switch (state[0]) {
 424    case STATE_MATERIAL:
 425    case STATE_LIGHT:
 426    case STATE_LIGHTMODEL_AMBIENT:
 427    case STATE_LIGHTMODEL_SCENECOLOR:
 428    case STATE_LIGHTPROD:
 429       return _NEW_LIGHT;
 430
 431    case STATE_TEXGEN:
 432    case STATE_TEXENV_COLOR:
 433       return _NEW_TEXTURE;
 434
 435    case STATE_FOG_COLOR:
 436    case STATE_FOG_PARAMS:
 437       return _NEW_FOG;
 438
 439    case STATE_CLIPPLANE:
 440       return _NEW_TRANSFORM;
 441
 442    case STATE_POINT_SIZE:
 443    case STATE_POINT_ATTENUATION:
 444       return _NEW_POINT;
 445
 446    case STATE_MATRIX:
 447       switch (state[1]) {
 448       case STATE_MODELVIEW:
 449          return _NEW_MODELVIEW;
 450       case STATE_PROJECTION:
 451          return _NEW_PROJECTION;
 452       case STATE_MVP:
 453          return _NEW_MODELVIEW | _NEW_PROJECTION;
 454       case STATE_TEXTURE:
 455          return _NEW_TEXTURE_MATRIX;
 456       case STATE_PROGRAM:
 457          return _NEW_TRACK_MATRIX;
 458       default:
 459          _mesa_problem(NULL,
 460                        "unexpected matrix in _mesa_program_state_flags()");
 461          return 0;
 462       }
 463
 464    case STATE_DEPTH_RANGE:
 465       return _NEW_VIEWPORT;
 466
 467    case STATE_FRAGMENT_PROGRAM:
 468    case STATE_VERTEX_PROGRAM:
 469       return _NEW_PROGRAM;
 470
 471    case STATE_INTERNAL:
 472       switch (state[1]) {
 473       case STATE_NORMAL_SCALE:
 474          return _NEW_MODELVIEW;
 475       case STATE_TEXRECT_SCALE:
 476          return _NEW_TEXTURE;
 477       default:
 478          /* unknown state indexes are silently ignored and
 479          *  no flag set, since it is handled by the driver.
 480          */
 481          return 0;
 482       }
 483
 484    default:
 485       _mesa_problem(NULL, "unexpected state[0] in make_state_flags()");
 486       return 0;
 487    }
 488 }
 489
 490
 491 static void
 492 append(char *dst, const char *src)
 493 {
 494    while (*dst)
 495       dst++;
 496    while (*src)
 497      *dst++ = *src++;
 498    *dst = 0;
 499 }
 500
 501
 502 static void
 503 append_token(char *dst, gl_state_index k)
 504 {
 505    switch (k) {
 506    case STATE_MATERIAL:
 507       append(dst, "material.");
 508       break;
 509    case STATE_LIGHT:
 510       append(dst, "light");
 511       break;
 512    case STATE_LIGHTMODEL_AMBIENT:
 513       append(dst, "lightmodel.ambient");
 514       break;
 515    case STATE_LIGHTMODEL_SCENECOLOR:
 516       break;
 517    case STATE_LIGHTPROD:
 518       append(dst, "lightprod");
 519       break;
 520    case STATE_TEXGEN:
 521       append(dst, "texgen");
 522       break;
 523    case STATE_FOG_COLOR:
 524       append(dst, "fog.color");
 525       break;
 526    case STATE_FOG_PARAMS:
 527       append(dst, "fog.params");
 528       break;
 529    case STATE_CLIPPLANE:
 530       append(dst, "clip");
 531       break;
 532    case STATE_POINT_SIZE:
 533       append(dst, "point.size");
 534       break;
 535    case STATE_POINT_ATTENUATION:
 536       append(dst, "point.attenuation");
 537       break;
 538    case STATE_MATRIX:
 539       append(dst, "matrix.");
 540       break;
 541    case STATE_MODELVIEW:
 542       append(dst, "modelview");
 543       break;
 544    case STATE_PROJECTION:
 545       append(dst, "projection");
 546       break;
 547    case STATE_MVP:
 548       append(dst, "mvp");
 549       break;
 550    case STATE_TEXTURE:
 551       append(dst, "texture");
 552       break;
 553    case STATE_PROGRAM:
 554       append(dst, "program");
 555       break;
 556    case STATE_MATRIX_INVERSE:
 557       append(dst, ".inverse");
 558       break;
 559    case STATE_MATRIX_TRANSPOSE:
 560       append(dst, ".transpose");
 561       break;
 562    case STATE_MATRIX_INVTRANS:
 563       append(dst, ".invtrans");
 564       break;
 565    case STATE_AMBIENT:
 566       append(dst, "ambient");
 567       break;
 568    case STATE_DIFFUSE:
 569       append(dst, "diffuse");
 570       break;
 571    case STATE_SPECULAR:
 572       append(dst, "specular");
 573       break;
 574    case STATE_EMISSION:
 575       append(dst, "emission");
 576       break;
 577    case STATE_SHININESS:
 578       append(dst, "shininess");
 579       break;
 580    case STATE_HALF:
 581       append(dst, "half");
 582       break;
 583    case STATE_POSITION:
 584       append(dst, ".position");
 585       break;
 586    case STATE_ATTENUATION:
 587       append(dst, ".attenuation");
 588       break;
 589    case STATE_SPOT_DIRECTION:
 590       append(dst, ".spot.direction");
 591       break;
 592    case STATE_TEXGEN_EYE_S:
 593       append(dst, "eye.s");
 594       break;
 595    case STATE_TEXGEN_EYE_T:
 596       append(dst, "eye.t");
 597       break;
 598    case STATE_TEXGEN_EYE_R:
 599       append(dst, "eye.r");
 600       break;
 601    case STATE_TEXGEN_EYE_Q:
 602       append(dst, "eye.q");
 603       break;
 604    case STATE_TEXGEN_OBJECT_S:
 605       append(dst, "object.s");
 606       break;
 607    case STATE_TEXGEN_OBJECT_T:
 608       append(dst, "object.t");
 609       break;
 610    case STATE_TEXGEN_OBJECT_R:
 611       append(dst, "object.r");
 612       break;
 613    case STATE_TEXGEN_OBJECT_Q:
 614       append(dst, "object.q");
 615       break;
 616    case STATE_TEXENV_COLOR:
 617       append(dst, "texenv");
 618       break;
 619    case STATE_DEPTH_RANGE:
 620       append(dst, "depth.range");
 621       break;
 622    case STATE_VERTEX_PROGRAM:
 623    case STATE_FRAGMENT_PROGRAM:
 624       break;
 625    case STATE_ENV:
 626       append(dst, "env");
 627       break;
 628    case STATE_LOCAL:
 629       append(dst, "local");
 630       break;
 631    case STATE_INTERNAL:
 632    case STATE_NORMAL_SCALE:
 633    case STATE_POSITION_NORMALIZED:
 634       append(dst, "(internal)");
 635       break;
 636    default:
 637       ;
 638    }
 639 }
 640
 641 static void
 642 append_face(char *dst, GLint face)
 643 {
 644    if (face == 0)
 645       append(dst, "front.");
 646    else
 647       append(dst, "back.");
 648 }
 649
 650 static void
 651 append_index(char *dst, GLint index)
 652 {
 653    char s[20];
 654    _mesa_sprintf(s, "[%d].", index);
 655    append(dst, s);
 656 }
 657
 658 /**
 659  * Make a string from the given state vector.
 660  * For example, return "state.matrix.texture[2].inverse".
 661  * Use _mesa_free() to deallocate the string.
 662  */
 663 const char *
 664 _mesa_program_state_string(const GLint state[STATE_LENGTH])
 665 {
 666    char str[1000] = "";
 667    char tmp[30];
 668
 669    append(str, "state.");
 670    append_token(str, (gl_state_index) state[0]);
 671
 672    switch (state[0]) {
 673    case STATE_MATERIAL:
 674       append_face(str, state[1]);
 675       append_token(str, (gl_state_index) state[2]);
 676       break;
 677    case STATE_LIGHT:
 678       append(str, "light");
 679       append_index(str, state[1]); /* light number [i]. */
 680       append_token(str, (gl_state_index) state[2]); /* coefficients */
 681       break;
 682    case STATE_LIGHTMODEL_AMBIENT:
 683       append(str, "lightmodel.ambient");
 684       break;
 685    case STATE_LIGHTMODEL_SCENECOLOR:
 686       if (state[1] == 0) {
 687          append(str, "lightmodel.front.scenecolor");
 688       }
 689       else {
 690          append(str, "lightmodel.back.scenecolor");
 691       }
 692       break;
 693    case STATE_LIGHTPROD:
 694       append_index(str, state[1]); /* light number [i]. */
 695       append_face(str, state[2]);
 696       append_token(str, (gl_state_index) state[3]);
 697       break;
 698    case STATE_TEXGEN:
 699       append_index(str, state[1]); /* tex unit [i] */
 700       append_token(str, (gl_state_index) state[2]); /* plane coef */
 701       break;
 702    case STATE_TEXENV_COLOR:
 703       append_index(str, state[1]); /* tex unit [i] */
 704       append(str, "color");
 705       break;
 706    case STATE_FOG_COLOR:
 707    case STATE_FOG_PARAMS:
 708       break;
 709    case STATE_CLIPPLANE:
 710       append_index(str, state[1]); /* plane [i] */
 711       append(str, "plane");
 712       break;
 713    case STATE_POINT_SIZE:
 714    case STATE_POINT_ATTENUATION:
 715       break;
 716    case STATE_MATRIX:
 717       {
 718          /* state[1] = modelview, projection, texture, etc. */
 719          /* state[2] = which texture matrix or program matrix */
 720          /* state[3] = first row to fetch */
 721          /* state[4] = last row to fetch */
 722          /* state[5] = transpose, inverse or invtrans */
 723          const gl_state_index mat = (gl_state_index) state[1];
 724          const GLuint index = (GLuint) state[2];
 725          const GLuint firstRow = (GLuint) state[3];
 726          const GLuint lastRow = (GLuint) state[4];
 727          const gl_state_index modifier = (gl_state_index) state[5];
 728          append_token(str, mat);
 729          if (index)
 730             append_index(str, index);
 731          if (modifier)
 732             append_token(str, modifier);
 733          if (firstRow == lastRow)
 734             _mesa_sprintf(tmp, ".row[%d]", firstRow);
 735          else
 736             _mesa_sprintf(tmp, ".row[%d..%d]", firstRow, lastRow);
 737          append(str, tmp);
 738       }
 739       break;
 740    case STATE_DEPTH_RANGE:
 741       break;
 742    case STATE_FRAGMENT_PROGRAM:
 743    case STATE_VERTEX_PROGRAM:
 744       /* state[1] = {STATE_ENV, STATE_LOCAL} */
 745       /* state[2] = parameter index          */
 746       append_token(str, (gl_state_index) state[1]);
 747       append_index(str, state[2]);
 748       break;
 749    case STATE_INTERNAL:
 750       break;
 751    default:
 752       _mesa_problem(NULL, "Invalid state in _mesa_program_state_string");
 753       break;
 754    }
 755
 756    return _mesa_strdup(str);
 757 }
 758
 759
 760 /**
 761  * Loop over all the parameters in a parameter list.  If the parameter
 762  * is a GL state reference, look up the current value of that state
 763  * variable and put it into the parameter's Value[4] array.
 764  * This would be called at glBegin time when using a fragment program.
 765  */
 766 void
 767 _mesa_load_state_parameters(GLcontext *ctx,
 768                             struct gl_program_parameter_list *paramList)
 769 {
 770    GLuint i;
 771
 772    if (!paramList)
 773       return;
 774
 775    for (i = 0; i < paramList->NumParameters; i++) {
 776       if (paramList->Parameters[i].Type == PROGRAM_STATE_VAR) {
 777          _mesa_fetch_state(ctx,
 778                            paramList->Parameters[i].StateIndexes,
 779                            paramList->ParameterValues[i]);
 780       }
 781    }
 782 }
 783