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