src/mesa/program/prog_statevars.c

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