src/mesa/program/prog_statevars.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22  * 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/blend.h"
  35 #include "main/imports.h"
  36 #include "main/macros.h"
  37 #include "main/mtypes.h"
  38 #include "main/fbobject.h"
  39 #include "prog_statevars.h"
  40 #include "prog_parameter.h"
  41 #include "main/samplerobj.h"
  42
  43
  44 #define ONE_DIV_SQRT_LN2 (1.201122408786449815)
  45
  46
  47 /**
  48  * Use the list of tokens in the state[] array to find global GL state
  49  * and return it in <value>.  Usually, four values are returned in <value>
  50  * but matrix queries may return as many as 16 values.
  51  * This function is used for ARB vertex/fragment programs.
  52  * The program parser will produce the state[] values.
  53  */
  54 static void
  55 _mesa_fetch_state(struct gl_context *ctx, const gl_state_index state[],
  56                   GLfloat *value)
  57 {
  58    switch (state[0]) {
  59    case STATE_MATERIAL:
  60       {
  61          /* state[1] is either 0=front or 1=back side */
  62          const GLuint face = (GLuint) state[1];
  63          const struct gl_material *mat = &ctx->Light.Material;
  64          assert(face == 0 || face == 1);
  65          /* we rely on tokens numbered so that _BACK_ == _FRONT_+ 1 */
  66          assert(MAT_ATTRIB_FRONT_AMBIENT + 1 == MAT_ATTRIB_BACK_AMBIENT);
  67          /* XXX we could get rid of this switch entirely with a little
  68           * work in arbprogparse.c's parse_state_single_item().
  69           */
  70          /* state[2] is the material attribute */
  71          switch (state[2]) {
  72          case STATE_AMBIENT:
  73             COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_AMBIENT + face]);
  74             return;
  75          case STATE_DIFFUSE:
  76             COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_DIFFUSE + face]);
  77             return;
  78          case STATE_SPECULAR:
  79             COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_SPECULAR + face]);
  80             return;
  81          case STATE_EMISSION:
  82             COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_EMISSION + face]);
  83             return;
  84          case STATE_SHININESS:
  85             value[0] = mat->Attrib[MAT_ATTRIB_FRONT_SHININESS + face][0];
  86             value[1] = 0.0F;
  87             value[2] = 0.0F;
  88             value[3] = 1.0F;
  89             return;
  90          default:
  91             _mesa_problem(ctx, "Invalid material state in fetch_state");
  92             return;
  93          }
  94       }
  95    case STATE_LIGHT:
  96       {
  97          /* state[1] is the light number */
  98          const GLuint ln = (GLuint) state[1];
  99          /* state[2] is the light attribute */
 100          switch (state[2]) {
 101          case STATE_AMBIENT:
 102             COPY_4V(value, ctx->Light.Light[ln].Ambient);
 103             return;
 104          case STATE_DIFFUSE:
 105             COPY_4V(value, ctx->Light.Light[ln].Diffuse);
 106             return;
 107          case STATE_SPECULAR:
 108             COPY_4V(value, ctx->Light.Light[ln].Specular);
 109             return;
 110          case STATE_POSITION:
 111             COPY_4V(value, ctx->Light.Light[ln].EyePosition);
 112             return;
 113          case STATE_ATTENUATION:
 114             value[0] = ctx->Light.Light[ln].ConstantAttenuation;
 115             value[1] = ctx->Light.Light[ln].LinearAttenuation;
 116             value[2] = ctx->Light.Light[ln].QuadraticAttenuation;
 117             value[3] = ctx->Light.Light[ln].SpotExponent;
 118             return;
 119          case STATE_SPOT_DIRECTION:
 120             COPY_3V(value, ctx->Light.Light[ln].SpotDirection);
 121             value[3] = ctx->Light.Light[ln]._CosCutoff;
 122             return;
 123          case STATE_SPOT_CUTOFF:
 124             value[0] = ctx->Light.Light[ln].SpotCutoff;
 125             return;
 126          case STATE_HALF_VECTOR:
 127             {
 128                static const GLfloat eye_z[] = {0, 0, 1};
 129                GLfloat p[3];
 130                /* Compute infinite half angle vector:
 131                 *   halfVector = normalize(normalize(lightPos) + (0, 0, 1))
 132                 * light.EyePosition.w should be 0 for infinite lights.
 133                 */
 134                COPY_3V(p, ctx->Light.Light[ln].EyePosition);
 135                NORMALIZE_3FV(p);
 136                ADD_3V(value, p, eye_z);
 137                NORMALIZE_3FV(value);
 138                value[3] = 1.0;
 139             }
 140             return;
 141          default:
 142             _mesa_problem(ctx, "Invalid light state in fetch_state");
 143             return;
 144          }
 145       }
 146    case STATE_LIGHTMODEL_AMBIENT:
 147       COPY_4V(value, ctx->Light.Model.Ambient);
 148       return;
 149    case STATE_LIGHTMODEL_SCENECOLOR:
 150       if (state[1] == 0) {
 151          /* front */
 152          GLint i;
 153          for (i = 0; i < 3; i++) {
 154             value[i] = ctx->Light.Model.Ambient[i]
 155                * ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT][i]
 156                + ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_EMISSION][i];
 157          }
 158          value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE][3];
 159       }
 160       else {
 161          /* back */
 162          GLint i;
 163          for (i = 0; i < 3; i++) {
 164             value[i] = ctx->Light.Model.Ambient[i]
 165                * ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_AMBIENT][i]
 166                + ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_EMISSION][i];
 167          }
 168          value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_DIFFUSE][3];
 169       }
 170       return;
 171    case STATE_LIGHTPROD:
 172       {
 173          const GLuint ln = (GLuint) state[1];
 174          const GLuint face = (GLuint) state[2];
 175          GLint i;
 176          assert(face == 0 || face == 1);
 177          switch (state[3]) {
 178             case STATE_AMBIENT:
 179                for (i = 0; i < 3; i++) {
 180                   value[i] = ctx->Light.Light[ln].Ambient[i] *
 181                      ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][i];
 182                }
 183                /* [3] = material alpha */
 184                value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][3];
 185                return;
 186             case STATE_DIFFUSE:
 187                for (i = 0; i < 3; i++) {
 188                   value[i] = ctx->Light.Light[ln].Diffuse[i] *
 189                      ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][i];
 190                }
 191                /* [3] = material alpha */
 192                value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][3];
 193                return;
 194             case STATE_SPECULAR:
 195                for (i = 0; i < 3; i++) {
 196                   value[i] = ctx->Light.Light[ln].Specular[i] *
 197                      ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][i];
 198                }
 199                /* [3] = material alpha */
 200                value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][3];
 201                return;
 202             default:
 203                _mesa_problem(ctx, "Invalid lightprod state in fetch_state");
 204                return;
 205          }
 206       }
 207    case STATE_TEXGEN:
 208       {
 209          /* state[1] is the texture unit */
 210          const GLuint unit = (GLuint) state[1];
 211          /* state[2] is the texgen attribute */
 212          switch (state[2]) {
 213          case STATE_TEXGEN_EYE_S:
 214             COPY_4V(value, ctx->Texture.Unit[unit].GenS.EyePlane);
 215             return;
 216          case STATE_TEXGEN_EYE_T:
 217             COPY_4V(value, ctx->Texture.Unit[unit].GenT.EyePlane);
 218             return;
 219          case STATE_TEXGEN_EYE_R:
 220             COPY_4V(value, ctx->Texture.Unit[unit].GenR.EyePlane);
 221             return;
 222          case STATE_TEXGEN_EYE_Q:
 223             COPY_4V(value, ctx->Texture.Unit[unit].GenQ.EyePlane);
 224             return;
 225          case STATE_TEXGEN_OBJECT_S:
 226             COPY_4V(value, ctx->Texture.Unit[unit].GenS.ObjectPlane);
 227             return;
 228          case STATE_TEXGEN_OBJECT_T:
 229             COPY_4V(value, ctx->Texture.Unit[unit].GenT.ObjectPlane);
 230             return;
 231          case STATE_TEXGEN_OBJECT_R:
 232             COPY_4V(value, ctx->Texture.Unit[unit].GenR.ObjectPlane);
 233             return;
 234          case STATE_TEXGEN_OBJECT_Q:
 235             COPY_4V(value, ctx->Texture.Unit[unit].GenQ.ObjectPlane);
 236             return;
 237          default:
 238             _mesa_problem(ctx, "Invalid texgen state in fetch_state");
 239             return;
 240          }
 241       }
 242    case STATE_TEXENV_COLOR:
 243       {
 244          /* state[1] is the texture unit */
 245          const GLuint unit = (GLuint) state[1];
 246          if (_mesa_get_clamp_fragment_color(ctx))
 247             COPY_4V(value, ctx->Texture.Unit[unit].EnvColor);
 248          else
 249             COPY_4V(value, ctx->Texture.Unit[unit].EnvColorUnclamped);
 250       }
 251       return;
 252    case STATE_FOG_COLOR:
 253       if (_mesa_get_clamp_fragment_color(ctx))
 254          COPY_4V(value, ctx->Fog.Color);
 255       else
 256          COPY_4V(value, ctx->Fog.ColorUnclamped);
 257       return;
 258    case STATE_FOG_PARAMS:
 259       value[0] = ctx->Fog.Density;
 260       value[1] = ctx->Fog.Start;
 261       value[2] = ctx->Fog.End;
 262       value[3] = 1.0f / (ctx->Fog.End - ctx->Fog.Start);
 263       return;
 264    case STATE_CLIPPLANE:
 265       {
 266          const GLuint plane = (GLuint) state[1];
 267          COPY_4V(value, ctx->Transform.EyeUserPlane[plane]);
 268       }
 269       return;
 270    case STATE_POINT_SIZE:
 271       value[0] = ctx->Point.Size;
 272       value[1] = ctx->Point.MinSize;
 273       value[2] = ctx->Point.MaxSize;
 274       value[3] = ctx->Point.Threshold;
 275       return;
 276    case STATE_POINT_ATTENUATION:
 277       value[0] = ctx->Point.Params[0];
 278       value[1] = ctx->Point.Params[1];
 279       value[2] = ctx->Point.Params[2];
 280       value[3] = 1.0F;
 281       return;
 282    case STATE_MODELVIEW_MATRIX:
 283    case STATE_PROJECTION_MATRIX:
 284    case STATE_MVP_MATRIX:
 285    case STATE_TEXTURE_MATRIX:
 286    case STATE_PROGRAM_MATRIX:
 287       {
 288          /* state[0] = modelview, projection, texture, etc. */
 289          /* state[1] = which texture matrix or program matrix */
 290          /* state[2] = first row to fetch */
 291          /* state[3] = last row to fetch */
 292          /* state[4] = transpose, inverse or invtrans */
 293          const GLmatrix *matrix;
 294          const gl_state_index mat = state[0];
 295          const GLuint index = (GLuint) state[1];
 296          const GLuint firstRow = (GLuint) state[2];
 297          const GLuint lastRow = (GLuint) state[3];
 298          const gl_state_index modifier = state[4];
 299          const GLfloat *m;
 300          GLuint row, i;
 301          assert(firstRow < 4);
 302          assert(lastRow < 4);
 303          if (mat == STATE_MODELVIEW_MATRIX) {
 304             matrix = ctx->ModelviewMatrixStack.Top;
 305          }
 306          else if (mat == STATE_PROJECTION_MATRIX) {
 307             matrix = ctx->ProjectionMatrixStack.Top;
 308          }
 309          else if (mat == STATE_MVP_MATRIX) {
 310             matrix = &ctx->_ModelProjectMatrix;
 311          }
 312          else if (mat == STATE_TEXTURE_MATRIX) {
 313             assert(index < ARRAY_SIZE(ctx->TextureMatrixStack));
 314             matrix = ctx->TextureMatrixStack[index].Top;
 315          }
 316          else if (mat == STATE_PROGRAM_MATRIX) {
 317             assert(index < ARRAY_SIZE(ctx->ProgramMatrixStack));
 318             matrix = ctx->ProgramMatrixStack[index].Top;
 319          }
 320          else {
 321             _mesa_problem(ctx, "Bad matrix name in _mesa_fetch_state()");
 322             return;
 323          }
 324          if (modifier == STATE_MATRIX_INVERSE ||
 325              modifier == STATE_MATRIX_INVTRANS) {
 326             /* Be sure inverse is up to date:
 327              */
 328             _math_matrix_analyse( (GLmatrix*) matrix );
 329             m = matrix->inv;
 330          }
 331          else {
 332             m = matrix->m;
 333          }
 334          if (modifier == STATE_MATRIX_TRANSPOSE ||
 335              modifier == STATE_MATRIX_INVTRANS) {
 336             for (i = 0, row = firstRow; row <= lastRow; row++) {
 337                value[i++] = m[row * 4 + 0];
 338                value[i++] = m[row * 4 + 1];
 339                value[i++] = m[row * 4 + 2];
 340                value[i++] = m[row * 4 + 3];
 341             }
 342          }
 343          else {
 344             for (i = 0, row = firstRow; row <= lastRow; row++) {
 345                value[i++] = m[row + 0];
 346                value[i++] = m[row + 4];
 347                value[i++] = m[row + 8];
 348                value[i++] = m[row + 12];
 349             }
 350          }
 351       }
 352       return;
 353    case STATE_NUM_SAMPLES:
 354       ((int *)value)[0] = ctx->DrawBuffer->Visual.samples;
 355       return;
 356    case STATE_DEPTH_RANGE:
 357       value[0] = ctx->ViewportArray[0].Near;                /* near       */
 358       value[1] = ctx->ViewportArray[0].Far;                 /* far        */
 359       value[2] = ctx->ViewportArray[0].Far - ctx->ViewportArray[0].Near; /* far - near */
 360       value[3] = 1.0;
 361       return;
 362    case STATE_FRAGMENT_PROGRAM:
 363       {
 364          /* state[1] = {STATE_ENV, STATE_LOCAL} */
 365          /* state[2] = parameter index          */
 366          const int idx = (int) state[2];
 367          switch (state[1]) {
 368             case STATE_ENV:
 369                COPY_4V(value, ctx->FragmentProgram.Parameters[idx]);
 370                return;
 371             case STATE_LOCAL:
 372                if (!ctx->FragmentProgram.Current->Base.LocalParams) {
 373                   ctx->FragmentProgram.Current->Base.LocalParams =
 374                      calloc(MAX_PROGRAM_LOCAL_PARAMS, sizeof(float[4]));
 375                   if (!ctx->FragmentProgram.Current->Base.LocalParams)
 376                      return;
 377                }
 378
 379                COPY_4V(value, ctx->FragmentProgram.Current->Base.LocalParams[idx]);
 380                return;
 381             default:
 382                _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
 383                return;
 384          }
 385       }
 386       return;
 387
 388    case STATE_VERTEX_PROGRAM:
 389       {
 390          /* state[1] = {STATE_ENV, STATE_LOCAL} */
 391          /* state[2] = parameter index          */
 392          const int idx = (int) state[2];
 393          switch (state[1]) {
 394             case STATE_ENV:
 395                COPY_4V(value, ctx->VertexProgram.Parameters[idx]);
 396                return;
 397             case STATE_LOCAL:
 398                if (!ctx->VertexProgram.Current->Base.LocalParams) {
 399                   ctx->VertexProgram.Current->Base.LocalParams =
 400                      calloc(MAX_PROGRAM_LOCAL_PARAMS, sizeof(float[4]));
 401                   if (!ctx->VertexProgram.Current->Base.LocalParams)
 402                      return;
 403                }
 404
 405                COPY_4V(value, ctx->VertexProgram.Current->Base.LocalParams[idx]);
 406                return;
 407             default:
 408                _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
 409                return;
 410          }
 411       }
 412       return;
 413
 414    case STATE_NORMAL_SCALE:
 415       ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
 416       return;
 417
 418    case STATE_INTERNAL:
 419       switch (state[1]) {
 420       case STATE_CURRENT_ATTRIB:
 421          {
 422             const GLuint idx = (GLuint) state[2];
 423             COPY_4V(value, ctx->Current.Attrib[idx]);
 424          }
 425          return;
 426
 427       case STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED:
 428          {
 429             const GLuint idx = (GLuint) state[2];
 430             if(ctx->Light._ClampVertexColor &&
 431                (idx == VERT_ATTRIB_COLOR0 ||
 432                 idx == VERT_ATTRIB_COLOR1)) {
 433                value[0] = CLAMP(ctx->Current.Attrib[idx][0], 0.0f, 1.0f);
 434                value[1] = CLAMP(ctx->Current.Attrib[idx][1], 0.0f, 1.0f);
 435                value[2] = CLAMP(ctx->Current.Attrib[idx][2], 0.0f, 1.0f);
 436                value[3] = CLAMP(ctx->Current.Attrib[idx][3], 0.0f, 1.0f);
 437             }
 438             else
 439                COPY_4V(value, ctx->Current.Attrib[idx]);
 440          }
 441          return;
 442
 443       case STATE_NORMAL_SCALE:
 444          ASSIGN_4V(value,
 445                    ctx->_ModelViewInvScale,
 446                    ctx->_ModelViewInvScale,
 447                    ctx->_ModelViewInvScale,
 448                    1);
 449          return;
 450
 451       case STATE_TEXRECT_SCALE:
 452          /* Value = { 1/texWidth, 1/texHeight, 0, 1 }.
 453           * Used to convert unnormalized texcoords to normalized texcoords.
 454           */
 455          {
 456             const int unit = (int) state[2];
 457             const struct gl_texture_object *texObj
 458                = ctx->Texture.Unit[unit]._Current;
 459             if (texObj) {
 460                struct gl_texture_image *texImage = texObj->Image[0][0];
 461                ASSIGN_4V(value,
 462                          (GLfloat) (1.0 / texImage->Width),
 463                          (GLfloat) (1.0 / texImage->Height),
 464                          0.0f, 1.0f);
 465             }
 466          }
 467          return;
 468
 469       case STATE_FOG_PARAMS_OPTIMIZED:
 470          /* for simpler per-vertex/pixel fog calcs. POW (for EXP/EXP2 fog)
 471           * might be more expensive than EX2 on some hw, plus it needs
 472           * another constant (e) anyway. Linear fog can now be done with a
 473           * single MAD.
 474           * linear: fogcoord * -1/(end-start) + end/(end-start)
 475           * exp: 2^-(density/ln(2) * fogcoord)
 476           * exp2: 2^-((density/(ln(2)^2) * fogcoord)^2)
 477           */
 478          value[0] = (ctx->Fog.End == ctx->Fog.Start)
 479             ? 1.0f : (GLfloat)(-1.0F / (ctx->Fog.End - ctx->Fog.Start));
 480          value[1] = ctx->Fog.End * -value[0];
 481          value[2] = (GLfloat)(ctx->Fog.Density * M_LOG2E); /* M_LOG2E == 1/ln(2) */
 482          value[3] = (GLfloat)(ctx->Fog.Density * ONE_DIV_SQRT_LN2);
 483          return;
 484
 485       case STATE_POINT_SIZE_CLAMPED:
 486          {
 487            /* this includes implementation dependent limits, to avoid
 488             * another potentially necessary clamp.
 489             * Note: for sprites, point smooth (point AA) is ignored
 490             * and we'll clamp to MinPointSizeAA and MaxPointSize, because we
 491             * expect drivers will want to say their minimum for AA size is 0.0
 492             * but for non-AA it's 1.0 (because normal points with size below 1.0
 493             * need to get rounded up to 1.0, hence never disappear). GL does
 494             * not specify max clamp size for sprites, other than it needs to be
 495             * at least as large as max AA size, hence use non-AA size there.
 496             */
 497             GLfloat minImplSize;
 498             GLfloat maxImplSize;
 499             if (ctx->Point.PointSprite) {
 500                minImplSize = ctx->Const.MinPointSizeAA;
 501                maxImplSize = ctx->Const.MaxPointSize;
 502             }
 503             else if (ctx->Point.SmoothFlag || ctx->Multisample._Enabled) {
 504                minImplSize = ctx->Const.MinPointSizeAA;
 505                maxImplSize = ctx->Const.MaxPointSizeAA;
 506             }
 507             else {
 508                minImplSize = ctx->Const.MinPointSize;
 509                maxImplSize = ctx->Const.MaxPointSize;
 510             }
 511             value[0] = ctx->Point.Size;
 512             value[1] = ctx->Point.MinSize >= minImplSize ? ctx->Point.MinSize : minImplSize;
 513             value[2] = ctx->Point.MaxSize <= maxImplSize ? ctx->Point.MaxSize : maxImplSize;
 514             value[3] = ctx->Point.Threshold;
 515          }
 516          return;
 517       case STATE_LIGHT_SPOT_DIR_NORMALIZED:
 518          {
 519             /* here, state[2] is the light number */
 520             /* pre-normalize spot dir */
 521             const GLuint ln = (GLuint) state[2];
 522             COPY_3V(value, ctx->Light.Light[ln]._NormSpotDirection);
 523             value[3] = ctx->Light.Light[ln]._CosCutoff;
 524          }
 525          return;
 526
 527       case STATE_LIGHT_POSITION:
 528          {
 529             const GLuint ln = (GLuint) state[2];
 530             COPY_4V(value, ctx->Light.Light[ln]._Position);
 531          }
 532          return;
 533
 534       case STATE_LIGHT_POSITION_NORMALIZED:
 535          {
 536             const GLuint ln = (GLuint) state[2];
 537             COPY_4V(value, ctx->Light.Light[ln]._Position);
 538             NORMALIZE_3FV( value );
 539          }
 540          return;
 541
 542       case STATE_LIGHT_HALF_VECTOR:
 543          {
 544             const GLuint ln = (GLuint) state[2];
 545             GLfloat p[3];
 546             /* Compute infinite half angle vector:
 547              *   halfVector = normalize(normalize(lightPos) + (0, 0, 1))
 548              * light.EyePosition.w should be 0 for infinite lights.
 549              */
 550             COPY_3V(p, ctx->Light.Light[ln]._Position);
 551             NORMALIZE_3FV(p);
 552             ADD_3V(value, p, ctx->_EyeZDir);
 553             NORMALIZE_3FV(value);
 554             value[3] = 1.0;
 555          }
 556          return;
 557
 558       case STATE_PT_SCALE:
 559          value[0] = ctx->Pixel.RedScale;
 560          value[1] = ctx->Pixel.GreenScale;
 561          value[2] = ctx->Pixel.BlueScale;
 562          value[3] = ctx->Pixel.AlphaScale;
 563          return;
 564
 565       case STATE_PT_BIAS:
 566          value[0] = ctx->Pixel.RedBias;
 567          value[1] = ctx->Pixel.GreenBias;
 568          value[2] = ctx->Pixel.BlueBias;
 569          value[3] = ctx->Pixel.AlphaBias;
 570          return;
 571
 572       case STATE_FB_SIZE:
 573          value[0] = (GLfloat) (ctx->DrawBuffer->Width - 1);
 574          value[1] = (GLfloat) (ctx->DrawBuffer->Height - 1);
 575          value[2] = 0.0F;
 576          value[3] = 0.0F;
 577          return;
 578
 579       case STATE_FB_WPOS_Y_TRANSFORM:
 580          /* A driver may negate this conditional by using ZW swizzle
 581           * instead of XY (based on e.g. some other state). */
 582          if (_mesa_is_user_fbo(ctx->DrawBuffer)) {
 583             /* Identity (XY) followed by flipping Y upside down (ZW). */
 584             value[0] = 1.0F;
 585             value[1] = 0.0F;
 586             value[2] = -1.0F;
 587             value[3] = (GLfloat) ctx->DrawBuffer->Height;
 588          } else {
 589             /* Flipping Y upside down (XY) followed by identity (ZW). */
 590             value[0] = -1.0F;
 591             value[1] = (GLfloat) ctx->DrawBuffer->Height;
 592             value[2] = 1.0F;
 593             value[3] = 0.0F;
 594          }
 595          return;
 596
 597       /* XXX: make sure new tokens added here are also handled in the
 598        * _mesa_program_state_flags() switch, below.
 599        */
 600       default:
 601          /* Unknown state indexes are silently ignored here.
 602           * Drivers may do something special.
 603           */
 604          return;
 605       }
 606       return;
 607
 608    default:
 609       _mesa_problem(ctx, "Invalid state in _mesa_fetch_state");
 610       return;
 611    }
 612 }
 613
 614
 615 /**
 616  * Return a bitmask of the Mesa state flags (_NEW_* values) which would
 617  * indicate that the given context state may have changed.
 618  * The bitmask is used during validation to determine if we need to update
 619  * vertex/fragment program parameters (like "state.material.color") when
 620  * some GL state has changed.
 621  */
 622 GLbitfield
 623 _mesa_program_state_flags(const gl_state_index state[STATE_LENGTH])
 624 {
 625    switch (state[0]) {
 626    case STATE_MATERIAL:
 627    case STATE_LIGHTPROD:
 628    case STATE_LIGHTMODEL_SCENECOLOR:
 629       /* these can be effected by glColor when colormaterial mode is used */
 630       return _NEW_LIGHT | _NEW_CURRENT_ATTRIB;
 631
 632    case STATE_LIGHT:
 633    case STATE_LIGHTMODEL_AMBIENT:
 634       return _NEW_LIGHT;
 635
 636    case STATE_TEXGEN:
 637       return _NEW_TEXTURE;
 638    case STATE_TEXENV_COLOR:
 639       return _NEW_TEXTURE | _NEW_BUFFERS | _NEW_FRAG_CLAMP;
 640
 641    case STATE_FOG_COLOR:
 642       return _NEW_FOG | _NEW_BUFFERS | _NEW_FRAG_CLAMP;
 643    case STATE_FOG_PARAMS:
 644       return _NEW_FOG;
 645
 646    case STATE_CLIPPLANE:
 647       return _NEW_TRANSFORM;
 648
 649    case STATE_POINT_SIZE:
 650    case STATE_POINT_ATTENUATION:
 651       return _NEW_POINT;
 652
 653    case STATE_MODELVIEW_MATRIX:
 654       return _NEW_MODELVIEW;
 655    case STATE_PROJECTION_MATRIX:
 656       return _NEW_PROJECTION;
 657    case STATE_MVP_MATRIX:
 658       return _NEW_MODELVIEW | _NEW_PROJECTION;
 659    case STATE_TEXTURE_MATRIX:
 660       return _NEW_TEXTURE_MATRIX;
 661    case STATE_PROGRAM_MATRIX:
 662       return _NEW_TRACK_MATRIX;
 663
 664    case STATE_NUM_SAMPLES:
 665       return _NEW_BUFFERS;
 666
 667    case STATE_DEPTH_RANGE:
 668       return _NEW_VIEWPORT;
 669
 670    case STATE_FRAGMENT_PROGRAM:
 671    case STATE_VERTEX_PROGRAM:
 672       return _NEW_PROGRAM;
 673
 674    case STATE_NORMAL_SCALE:
 675       return _NEW_MODELVIEW;
 676
 677    case STATE_INTERNAL:
 678       switch (state[1]) {
 679       case STATE_CURRENT_ATTRIB:
 680          return _NEW_CURRENT_ATTRIB;
 681       case STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED:
 682          return _NEW_CURRENT_ATTRIB | _NEW_LIGHT | _NEW_BUFFERS;
 683
 684       case STATE_NORMAL_SCALE:
 685          return _NEW_MODELVIEW;
 686
 687       case STATE_TEXRECT_SCALE:
 688          return _NEW_TEXTURE;
 689       case STATE_FOG_PARAMS_OPTIMIZED:
 690          return _NEW_FOG;
 691       case STATE_POINT_SIZE_CLAMPED:
 692          return _NEW_POINT | _NEW_MULTISAMPLE;
 693       case STATE_LIGHT_SPOT_DIR_NORMALIZED:
 694       case STATE_LIGHT_POSITION:
 695       case STATE_LIGHT_POSITION_NORMALIZED:
 696       case STATE_LIGHT_HALF_VECTOR:
 697          return _NEW_LIGHT;
 698
 699       case STATE_PT_SCALE:
 700       case STATE_PT_BIAS:
 701          return _NEW_PIXEL;
 702
 703       case STATE_FB_SIZE:
 704       case STATE_FB_WPOS_Y_TRANSFORM:
 705          return _NEW_BUFFERS;
 706
 707       default:
 708          /* unknown state indexes are silently ignored and
 709          *  no flag set, since it is handled by the driver.
 710          */
 711          return 0;
 712       }
 713
 714    default:
 715       _mesa_problem(NULL, "unexpected state[0] in make_state_flags()");
 716       return 0;
 717    }
 718 }
 719
 720
 721 static void
 722 append(char *dst, const char *src)
 723 {
 724    while (*dst)
 725       dst++;
 726    while (*src)
 727      *dst++ = *src++;
 728    *dst = 0;
 729 }
 730
 731
 732 /**
 733  * Convert token 'k' to a string, append it onto 'dst' string.
 734  */
 735 static void
 736 append_token(char *dst, gl_state_index k)
 737 {
 738    switch (k) {
 739    case STATE_MATERIAL:
 740       append(dst, "material");
 741       break;
 742    case STATE_LIGHT:
 743       append(dst, "light");
 744       break;
 745    case STATE_LIGHTMODEL_AMBIENT:
 746       append(dst, "lightmodel.ambient");
 747       break;
 748    case STATE_LIGHTMODEL_SCENECOLOR:
 749       break;
 750    case STATE_LIGHTPROD:
 751       append(dst, "lightprod");
 752       break;
 753    case STATE_TEXGEN:
 754       append(dst, "texgen");
 755       break;
 756    case STATE_FOG_COLOR:
 757       append(dst, "fog.color");
 758       break;
 759    case STATE_FOG_PARAMS:
 760       append(dst, "fog.params");
 761       break;
 762    case STATE_CLIPPLANE:
 763       append(dst, "clip");
 764       break;
 765    case STATE_POINT_SIZE:
 766       append(dst, "point.size");
 767       break;
 768    case STATE_POINT_ATTENUATION:
 769       append(dst, "point.attenuation");
 770       break;
 771    case STATE_MODELVIEW_MATRIX:
 772       append(dst, "matrix.modelview");
 773       break;
 774    case STATE_PROJECTION_MATRIX:
 775       append(dst, "matrix.projection");
 776       break;
 777    case STATE_MVP_MATRIX:
 778       append(dst, "matrix.mvp");
 779       break;
 780    case STATE_TEXTURE_MATRIX:
 781       append(dst, "matrix.texture");
 782       break;
 783    case STATE_PROGRAM_MATRIX:
 784       append(dst, "matrix.program");
 785       break;
 786    case STATE_MATRIX_INVERSE:
 787       append(dst, ".inverse");
 788       break;
 789    case STATE_MATRIX_TRANSPOSE:
 790       append(dst, ".transpose");
 791       break;
 792    case STATE_MATRIX_INVTRANS:
 793       append(dst, ".invtrans");
 794       break;
 795    case STATE_AMBIENT:
 796       append(dst, ".ambient");
 797       break;
 798    case STATE_DIFFUSE:
 799       append(dst, ".diffuse");
 800       break;
 801    case STATE_SPECULAR:
 802       append(dst, ".specular");
 803       break;
 804    case STATE_EMISSION:
 805       append(dst, ".emission");
 806       break;
 807    case STATE_SHININESS:
 808       append(dst, "lshininess");
 809       break;
 810    case STATE_HALF_VECTOR:
 811       append(dst, ".half");
 812       break;
 813    case STATE_POSITION:
 814       append(dst, ".position");
 815       break;
 816    case STATE_ATTENUATION:
 817       append(dst, ".attenuation");
 818       break;
 819    case STATE_SPOT_DIRECTION:
 820       append(dst, ".spot.direction");
 821       break;
 822    case STATE_SPOT_CUTOFF:
 823       append(dst, ".spot.cutoff");
 824       break;
 825    case STATE_TEXGEN_EYE_S:
 826       append(dst, ".eye.s");
 827       break;
 828    case STATE_TEXGEN_EYE_T:
 829       append(dst, ".eye.t");
 830       break;
 831    case STATE_TEXGEN_EYE_R:
 832       append(dst, ".eye.r");
 833       break;
 834    case STATE_TEXGEN_EYE_Q:
 835       append(dst, ".eye.q");
 836       break;
 837    case STATE_TEXGEN_OBJECT_S:
 838       append(dst, ".object.s");
 839       break;
 840    case STATE_TEXGEN_OBJECT_T:
 841       append(dst, ".object.t");
 842       break;
 843    case STATE_TEXGEN_OBJECT_R:
 844       append(dst, ".object.r");
 845       break;
 846    case STATE_TEXGEN_OBJECT_Q:
 847       append(dst, ".object.q");
 848       break;
 849    case STATE_TEXENV_COLOR:
 850       append(dst, "texenv");
 851       break;
 852    case STATE_NUM_SAMPLES:
 853       append(dst, "numsamples");
 854       break;
 855    case STATE_DEPTH_RANGE:
 856       append(dst, "depth.range");
 857       break;
 858    case STATE_VERTEX_PROGRAM:
 859    case STATE_FRAGMENT_PROGRAM:
 860       break;
 861    case STATE_ENV:
 862       append(dst, "env");
 863       break;
 864    case STATE_LOCAL:
 865       append(dst, "local");
 866       break;
 867    /* BEGIN internal state vars */
 868    case STATE_INTERNAL:
 869       append(dst, ".internal.");
 870       break;
 871    case STATE_CURRENT_ATTRIB:
 872       append(dst, "current");
 873       break;
 874    case STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED:
 875       append(dst, "currentAttribMaybeVPClamped");
 876       break;
 877    case STATE_NORMAL_SCALE:
 878       append(dst, "normalScale");
 879       break;
 880    case STATE_TEXRECT_SCALE:
 881       append(dst, "texrectScale");
 882       break;
 883    case STATE_FOG_PARAMS_OPTIMIZED:
 884       append(dst, "fogParamsOptimized");
 885       break;
 886    case STATE_POINT_SIZE_CLAMPED:
 887       append(dst, "pointSizeClamped");
 888       break;
 889    case STATE_LIGHT_SPOT_DIR_NORMALIZED:
 890       append(dst, "lightSpotDirNormalized");
 891       break;
 892    case STATE_LIGHT_POSITION:
 893       append(dst, "lightPosition");
 894       break;
 895    case STATE_LIGHT_POSITION_NORMALIZED:
 896       append(dst, "light.position.normalized");
 897       break;
 898    case STATE_LIGHT_HALF_VECTOR:
 899       append(dst, "lightHalfVector");
 900       break;
 901    case STATE_PT_SCALE:
 902       append(dst, "PTscale");
 903       break;
 904    case STATE_PT_BIAS:
 905       append(dst, "PTbias");
 906       break;
 907    case STATE_FB_SIZE:
 908       append(dst, "FbSize");
 909       break;
 910    case STATE_FB_WPOS_Y_TRANSFORM:
 911       append(dst, "FbWposYTransform");
 912       break;
 913    default:
 914       /* probably STATE_INTERNAL_DRIVER+i (driver private state) */
 915       append(dst, "driverState");
 916    }
 917 }
 918
 919 static void
 920 append_face(char *dst, GLint face)
 921 {
 922    if (face == 0)
 923       append(dst, "front.");
 924    else
 925       append(dst, "back.");
 926 }
 927
 928 static void
 929 append_index(char *dst, GLint index)
 930 {
 931    char s[20];
 932    sprintf(s, "[%d]", index);
 933    append(dst, s);
 934 }
 935
 936 /**
 937  * Make a string from the given state vector.
 938  * For example, return "state.matrix.texture[2].inverse".
 939  * Use free() to deallocate the string.
 940  */
 941 char *
 942 _mesa_program_state_string(const gl_state_index state[STATE_LENGTH])
 943 {
 944    char str[1000] = "";
 945    char tmp[30];
 946
 947    append(str, "state.");
 948    append_token(str, state[0]);
 949
 950    switch (state[0]) {
 951    case STATE_MATERIAL:
 952       append_face(str, state[1]);
 953       append_token(str, state[2]);
 954       break;
 955    case STATE_LIGHT:
 956       append_index(str, state[1]); /* light number [i]. */
 957       append_token(str, state[2]); /* coefficients */
 958       break;
 959    case STATE_LIGHTMODEL_AMBIENT:
 960       append(str, "lightmodel.ambient");
 961       break;
 962    case STATE_LIGHTMODEL_SCENECOLOR:
 963       if (state[1] == 0) {
 964          append(str, "lightmodel.front.scenecolor");
 965       }
 966       else {
 967          append(str, "lightmodel.back.scenecolor");
 968       }
 969       break;
 970    case STATE_LIGHTPROD:
 971       append_index(str, state[1]); /* light number [i]. */
 972       append_face(str, state[2]);
 973       append_token(str, state[3]);
 974       break;
 975    case STATE_TEXGEN:
 976       append_index(str, state[1]); /* tex unit [i] */
 977       append_token(str, state[2]); /* plane coef */
 978       break;
 979    case STATE_TEXENV_COLOR:
 980       append_index(str, state[1]); /* tex unit [i] */
 981       append(str, "color");
 982       break;
 983    case STATE_CLIPPLANE:
 984       append_index(str, state[1]); /* plane [i] */
 985       append(str, ".plane");
 986       break;
 987    case STATE_MODELVIEW_MATRIX:
 988    case STATE_PROJECTION_MATRIX:
 989    case STATE_MVP_MATRIX:
 990    case STATE_TEXTURE_MATRIX:
 991    case STATE_PROGRAM_MATRIX:
 992       {
 993          /* state[0] = modelview, projection, texture, etc. */
 994          /* state[1] = which texture matrix or program matrix */
 995          /* state[2] = first row to fetch */
 996          /* state[3] = last row to fetch */
 997          /* state[4] = transpose, inverse or invtrans */
 998          const gl_state_index mat = state[0];
 999          const GLuint index = (GLuint) state[1];
1000          const GLuint firstRow = (GLuint) state[2];
1001          const GLuint lastRow = (GLuint) state[3];
1002          const gl_state_index modifier = state[4];
1003          if (index ||
1004              mat == STATE_TEXTURE_MATRIX ||
1005              mat == STATE_PROGRAM_MATRIX)
1006             append_index(str, index);
1007          if (modifier)
1008             append_token(str, modifier);
1009          if (firstRow == lastRow)
1010             sprintf(tmp, ".row[%d]", firstRow);
1011          else
1012             sprintf(tmp, ".row[%d..%d]", firstRow, lastRow);
1013          append(str, tmp);
1014       }
1015       break;
1016    case STATE_POINT_SIZE:
1017       break;
1018    case STATE_POINT_ATTENUATION:
1019       break;
1020    case STATE_FOG_PARAMS:
1021       break;
1022    case STATE_FOG_COLOR:
1023       break;
1024    case STATE_NUM_SAMPLES:
1025       break;
1026    case STATE_DEPTH_RANGE:
1027       break;
1028    case STATE_FRAGMENT_PROGRAM:
1029    case STATE_VERTEX_PROGRAM:
1030       /* state[1] = {STATE_ENV, STATE_LOCAL} */
1031       /* state[2] = parameter index          */
1032       append_token(str, state[1]);
1033       append_index(str, state[2]);
1034       break;
1035    case STATE_NORMAL_SCALE:
1036       break;
1037    case STATE_INTERNAL:
1038       append_token(str, state[1]);
1039       if (state[1] == STATE_CURRENT_ATTRIB)
1040          append_index(str, state[2]);
1041        break;
1042    default:
1043       _mesa_problem(NULL, "Invalid state in _mesa_program_state_string");
1044       break;
1045    }
1046
1047    return _mesa_strdup(str);
1048 }
1049
1050
1051 /**
1052  * Loop over all the parameters in a parameter list.  If the parameter
1053  * is a GL state reference, look up the current value of that state
1054  * variable and put it into the parameter's Value[4] array.
1055  * Other parameter types never change or are explicitly set by the user
1056  * with glUniform() or glProgramParameter(), etc.
1057  * This would be called at glBegin time.
1058  */
1059 void
1060 _mesa_load_state_parameters(struct gl_context *ctx,
1061                             struct gl_program_parameter_list *paramList)
1062 {
1063    GLuint i;
1064
1065    if (!paramList)
1066       return;
1067
1068    for (i = 0; i < paramList->NumParameters; i++) {
1069       if (paramList->Parameters[i].Type == PROGRAM_STATE_VAR) {
1070          _mesa_fetch_state(ctx,
1071                            paramList->Parameters[i].StateIndexes,
1072                            &paramList->ParameterValues[i][0].f);
1073       }
1074    }
1075 }