2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
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:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
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.
26 * \file prog_statevars.c
27 * Program state variable management.
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 "prog_statevars.h"
38 #include "prog_parameter.h"
42 * Use the list of tokens in the state[] array to find global GL state
43 * and return it in <value>. Usually, four values are returned in <value>
44 * but matrix queries may return as many as 16 values.
45 * This function is used for ARB vertex/fragment programs.
46 * The program parser will produce the state[] values.
49 _mesa_fetch_state(struct gl_context *ctx, const gl_state_index state[],
55 /* state[1] is either 0=front or 1=back side */
56 const GLuint face = (GLuint) state[1];
57 const struct gl_material *mat = &ctx->Light.Material;
58 ASSERT(face == 0 || face == 1);
59 /* we rely on tokens numbered so that _BACK_ == _FRONT_+ 1 */
60 ASSERT(MAT_ATTRIB_FRONT_AMBIENT + 1 == MAT_ATTRIB_BACK_AMBIENT);
61 /* XXX we could get rid of this switch entirely with a little
62 * work in arbprogparse.c's parse_state_single_item().
64 /* state[2] is the material attribute */
67 COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_AMBIENT + face]);
70 COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_DIFFUSE + face]);
73 COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_SPECULAR + face]);
76 COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_EMISSION + face]);
79 value[0] = mat->Attrib[MAT_ATTRIB_FRONT_SHININESS + face][0];
85 _mesa_problem(ctx, "Invalid material state in fetch_state");
91 /* state[1] is the light number */
92 const GLuint ln = (GLuint) state[1];
93 /* state[2] is the light attribute */
96 COPY_4V(value, ctx->Light.Light[ln].Ambient);
99 COPY_4V(value, ctx->Light.Light[ln].Diffuse);
102 COPY_4V(value, ctx->Light.Light[ln].Specular);
105 COPY_4V(value, ctx->Light.Light[ln].EyePosition);
107 case STATE_ATTENUATION:
108 value[0] = ctx->Light.Light[ln].ConstantAttenuation;
109 value[1] = ctx->Light.Light[ln].LinearAttenuation;
110 value[2] = ctx->Light.Light[ln].QuadraticAttenuation;
111 value[3] = ctx->Light.Light[ln].SpotExponent;
113 case STATE_SPOT_DIRECTION:
114 COPY_3V(value, ctx->Light.Light[ln].SpotDirection);
115 value[3] = ctx->Light.Light[ln]._CosCutoff;
117 case STATE_SPOT_CUTOFF:
118 value[0] = ctx->Light.Light[ln].SpotCutoff;
120 case STATE_HALF_VECTOR:
122 static const GLfloat eye_z[] = {0, 0, 1};
124 /* Compute infinite half angle vector:
125 * halfVector = normalize(normalize(lightPos) + (0, 0, 1))
126 * light.EyePosition.w should be 0 for infinite lights.
128 COPY_3V(p, ctx->Light.Light[ln].EyePosition);
130 ADD_3V(value, p, eye_z);
131 NORMALIZE_3FV(value);
136 _mesa_problem(ctx, "Invalid light state in fetch_state");
140 case STATE_LIGHTMODEL_AMBIENT:
141 COPY_4V(value, ctx->Light.Model.Ambient);
143 case STATE_LIGHTMODEL_SCENECOLOR:
147 for (i = 0; i < 3; i++) {
148 value[i] = ctx->Light.Model.Ambient[i]
149 * ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT][i]
150 + ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_EMISSION][i];
152 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE][3];
157 for (i = 0; i < 3; i++) {
158 value[i] = ctx->Light.Model.Ambient[i]
159 * ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_AMBIENT][i]
160 + ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_EMISSION][i];
162 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_DIFFUSE][3];
165 case STATE_LIGHTPROD:
167 const GLuint ln = (GLuint) state[1];
168 const GLuint face = (GLuint) state[2];
170 ASSERT(face == 0 || face == 1);
173 for (i = 0; i < 3; i++) {
174 value[i] = ctx->Light.Light[ln].Ambient[i] *
175 ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][i];
177 /* [3] = material alpha */
178 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][3];
181 for (i = 0; i < 3; i++) {
182 value[i] = ctx->Light.Light[ln].Diffuse[i] *
183 ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][i];
185 /* [3] = material alpha */
186 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][3];
189 for (i = 0; i < 3; i++) {
190 value[i] = ctx->Light.Light[ln].Specular[i] *
191 ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][i];
193 /* [3] = material alpha */
194 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][3];
197 _mesa_problem(ctx, "Invalid lightprod state in fetch_state");
203 /* state[1] is the texture unit */
204 const GLuint unit = (GLuint) state[1];
205 /* state[2] is the texgen attribute */
207 case STATE_TEXGEN_EYE_S:
208 COPY_4V(value, ctx->Texture.Unit[unit].GenS.EyePlane);
210 case STATE_TEXGEN_EYE_T:
211 COPY_4V(value, ctx->Texture.Unit[unit].GenT.EyePlane);
213 case STATE_TEXGEN_EYE_R:
214 COPY_4V(value, ctx->Texture.Unit[unit].GenR.EyePlane);
216 case STATE_TEXGEN_EYE_Q:
217 COPY_4V(value, ctx->Texture.Unit[unit].GenQ.EyePlane);
219 case STATE_TEXGEN_OBJECT_S:
220 COPY_4V(value, ctx->Texture.Unit[unit].GenS.ObjectPlane);
222 case STATE_TEXGEN_OBJECT_T:
223 COPY_4V(value, ctx->Texture.Unit[unit].GenT.ObjectPlane);
225 case STATE_TEXGEN_OBJECT_R:
226 COPY_4V(value, ctx->Texture.Unit[unit].GenR.ObjectPlane);
228 case STATE_TEXGEN_OBJECT_Q:
229 COPY_4V(value, ctx->Texture.Unit[unit].GenQ.ObjectPlane);
232 _mesa_problem(ctx, "Invalid texgen state in fetch_state");
236 case STATE_TEXENV_COLOR:
238 /* state[1] is the texture unit */
239 const GLuint unit = (GLuint) state[1];
240 if(ctx->Color._ClampFragmentColor)
241 COPY_4V(value, ctx->Texture.Unit[unit].EnvColor);
243 COPY_4V(value, ctx->Texture.Unit[unit].EnvColorUnclamped);
246 case STATE_FOG_COLOR:
247 if(ctx->Color._ClampFragmentColor)
248 COPY_4V(value, ctx->Fog.Color);
250 COPY_4V(value, ctx->Fog.ColorUnclamped);
252 case STATE_FOG_PARAMS:
253 value[0] = ctx->Fog.Density;
254 value[1] = ctx->Fog.Start;
255 value[2] = ctx->Fog.End;
256 value[3] = (ctx->Fog.End == ctx->Fog.Start)
257 ? 1.0f : (GLfloat)(1.0 / (ctx->Fog.End - ctx->Fog.Start));
259 case STATE_CLIPPLANE:
261 const GLuint plane = (GLuint) state[1];
262 COPY_4V(value, ctx->Transform.EyeUserPlane[plane]);
265 case STATE_POINT_SIZE:
266 value[0] = ctx->Point.Size;
267 value[1] = ctx->Point.MinSize;
268 value[2] = ctx->Point.MaxSize;
269 value[3] = ctx->Point.Threshold;
271 case STATE_POINT_ATTENUATION:
272 value[0] = ctx->Point.Params[0];
273 value[1] = ctx->Point.Params[1];
274 value[2] = ctx->Point.Params[2];
277 case STATE_MODELVIEW_MATRIX:
278 case STATE_PROJECTION_MATRIX:
279 case STATE_MVP_MATRIX:
280 case STATE_TEXTURE_MATRIX:
281 case STATE_PROGRAM_MATRIX:
283 /* state[0] = modelview, projection, texture, etc. */
284 /* state[1] = which texture matrix or program matrix */
285 /* state[2] = first row to fetch */
286 /* state[3] = last row to fetch */
287 /* state[4] = transpose, inverse or invtrans */
288 const GLmatrix *matrix;
289 const gl_state_index mat = state[0];
290 const GLuint index = (GLuint) state[1];
291 const GLuint firstRow = (GLuint) state[2];
292 const GLuint lastRow = (GLuint) state[3];
293 const gl_state_index modifier = state[4];
296 ASSERT(firstRow >= 0);
297 ASSERT(firstRow < 4);
298 ASSERT(lastRow >= 0);
300 if (mat == STATE_MODELVIEW_MATRIX) {
301 matrix = ctx->ModelviewMatrixStack.Top;
303 else if (mat == STATE_PROJECTION_MATRIX) {
304 matrix = ctx->ProjectionMatrixStack.Top;
306 else if (mat == STATE_MVP_MATRIX) {
307 matrix = &ctx->_ModelProjectMatrix;
309 else if (mat == STATE_TEXTURE_MATRIX) {
310 ASSERT(index < Elements(ctx->TextureMatrixStack));
311 matrix = ctx->TextureMatrixStack[index].Top;
313 else if (mat == STATE_PROGRAM_MATRIX) {
314 ASSERT(index < Elements(ctx->ProgramMatrixStack));
315 matrix = ctx->ProgramMatrixStack[index].Top;
318 _mesa_problem(ctx, "Bad matrix name in _mesa_fetch_state()");
321 if (modifier == STATE_MATRIX_INVERSE ||
322 modifier == STATE_MATRIX_INVTRANS) {
323 /* Be sure inverse is up to date:
325 _math_matrix_alloc_inv( (GLmatrix *) matrix );
326 _math_matrix_analyse( (GLmatrix*) matrix );
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];
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];
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 */
357 case STATE_FRAGMENT_PROGRAM:
359 /* state[1] = {STATE_ENV, STATE_LOCAL} */
360 /* state[2] = parameter index */
361 const int idx = (int) state[2];
364 COPY_4V(value, ctx->FragmentProgram.Parameters[idx]);
367 COPY_4V(value, ctx->FragmentProgram.Current->Base.LocalParams[idx]);
370 _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
376 case STATE_VERTEX_PROGRAM:
378 /* state[1] = {STATE_ENV, STATE_LOCAL} */
379 /* state[2] = parameter index */
380 const int idx = (int) state[2];
383 COPY_4V(value, ctx->VertexProgram.Parameters[idx]);
386 COPY_4V(value, ctx->VertexProgram.Current->Base.LocalParams[idx]);
389 _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
395 case STATE_NORMAL_SCALE:
396 ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
401 case STATE_CURRENT_ATTRIB:
403 const GLuint idx = (GLuint) state[2];
404 COPY_4V(value, ctx->Current.Attrib[idx]);
408 case STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED:
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);
420 COPY_4V(value, ctx->Current.Attrib[idx]);
424 case STATE_NORMAL_SCALE:
426 ctx->_ModelViewInvScale,
427 ctx->_ModelViewInvScale,
428 ctx->_ModelViewInvScale,
432 case STATE_TEXRECT_SCALE:
433 /* Value = { 1/texWidth, 1/texHeight, 0, 1 }.
434 * Used to convert unnormalized texcoords to normalized texcoords.
437 const int unit = (int) state[2];
438 const struct gl_texture_object *texObj
439 = ctx->Texture.Unit[unit]._Current;
441 struct gl_texture_image *texImage = texObj->Image[0][0];
443 (GLfloat) (1.0 / texImage->Width),
444 (GLfloat) (1.0 / texImage->Height),
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
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)
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);
466 case STATE_POINT_SIZE_CLAMPED:
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.
480 if (ctx->Point.PointSprite) {
481 minImplSize = ctx->Const.MinPointSizeAA;
482 maxImplSize = ctx->Const.MaxPointSize;
484 else if (ctx->Point.SmoothFlag || ctx->Multisample._Enabled) {
485 minImplSize = ctx->Const.MinPointSizeAA;
486 maxImplSize = ctx->Const.MaxPointSizeAA;
489 minImplSize = ctx->Const.MinPointSize;
490 maxImplSize = ctx->Const.MaxPointSize;
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;
498 case STATE_POINT_SIZE_IMPL_CLAMP:
500 /* for implementation clamp only in vs */
503 if (ctx->Point.PointSprite) {
504 minImplSize = ctx->Const.MinPointSizeAA;
505 maxImplSize = ctx->Const.MaxPointSize;
507 else if (ctx->Point.SmoothFlag || ctx->Multisample._Enabled) {
508 minImplSize = ctx->Const.MinPointSizeAA;
509 maxImplSize = ctx->Const.MaxPointSizeAA;
512 minImplSize = ctx->Const.MinPointSize;
513 maxImplSize = ctx->Const.MaxPointSize;
515 value[0] = ctx->Point.Size;
516 value[1] = minImplSize;
517 value[2] = maxImplSize;
518 value[3] = ctx->Point.Threshold;
521 case STATE_LIGHT_SPOT_DIR_NORMALIZED:
523 /* here, state[2] is the light number */
524 /* pre-normalize spot dir */
525 const GLuint ln = (GLuint) state[2];
526 COPY_3V(value, ctx->Light.Light[ln]._NormSpotDirection);
527 value[3] = ctx->Light.Light[ln]._CosCutoff;
531 case STATE_LIGHT_POSITION:
533 const GLuint ln = (GLuint) state[2];
534 COPY_4V(value, ctx->Light.Light[ln]._Position);
538 case STATE_LIGHT_POSITION_NORMALIZED:
540 const GLuint ln = (GLuint) state[2];
541 COPY_4V(value, ctx->Light.Light[ln]._Position);
542 NORMALIZE_3FV( value );
546 case STATE_LIGHT_HALF_VECTOR:
548 const GLuint ln = (GLuint) state[2];
550 /* Compute infinite half angle vector:
551 * halfVector = normalize(normalize(lightPos) + (0, 0, 1))
552 * light.EyePosition.w should be 0 for infinite lights.
554 COPY_3V(p, ctx->Light.Light[ln]._Position);
556 ADD_3V(value, p, ctx->_EyeZDir);
557 NORMALIZE_3FV(value);
563 value[0] = ctx->Pixel.RedScale;
564 value[1] = ctx->Pixel.GreenScale;
565 value[2] = ctx->Pixel.BlueScale;
566 value[3] = ctx->Pixel.AlphaScale;
570 value[0] = ctx->Pixel.RedBias;
571 value[1] = ctx->Pixel.GreenBias;
572 value[2] = ctx->Pixel.BlueBias;
573 value[3] = ctx->Pixel.AlphaBias;
576 case STATE_SHADOW_AMBIENT:
578 const int unit = (int) state[2];
579 const struct gl_texture_object *texObj
580 = ctx->Texture.Unit[unit]._Current;
585 value[3] = texObj->Sampler.CompareFailValue;
591 value[0] = (GLfloat) (ctx->DrawBuffer->Width - 1);
592 value[1] = (GLfloat) (ctx->DrawBuffer->Height - 1);
597 case STATE_FB_WPOS_Y_TRANSFORM:
598 /* A driver may negate this conditional by using ZW swizzle
599 * instead of XY (based on e.g. some other state). */
600 if (ctx->DrawBuffer->Name != 0) {
601 /* Identity (XY) followed by flipping Y upside down (ZW). */
605 value[3] = (GLfloat) ctx->DrawBuffer->Height;
607 /* Flipping Y upside down (XY) followed by identity (ZW). */
609 value[1] = (GLfloat) ctx->DrawBuffer->Height;
615 case STATE_ROT_MATRIX_0:
617 const int unit = (int) state[2];
618 GLfloat *rotMat22 = ctx->Texture.Unit[unit].RotMatrix;
619 value[0] = rotMat22[0];
620 value[1] = rotMat22[2];
626 case STATE_ROT_MATRIX_1:
628 const int unit = (int) state[2];
629 GLfloat *rotMat22 = ctx->Texture.Unit[unit].RotMatrix;
630 value[0] = rotMat22[1];
631 value[1] = rotMat22[3];
637 /* XXX: make sure new tokens added here are also handled in the
638 * _mesa_program_state_flags() switch, below.
641 /* Unknown state indexes are silently ignored here.
642 * Drivers may do something special.
649 _mesa_problem(ctx, "Invalid state in _mesa_fetch_state");
656 * Return a bitmask of the Mesa state flags (_NEW_* values) which would
657 * indicate that the given context state may have changed.
658 * The bitmask is used during validation to determine if we need to update
659 * vertex/fragment program parameters (like "state.material.color") when
660 * some GL state has changed.
663 _mesa_program_state_flags(const gl_state_index state[STATE_LENGTH])
667 case STATE_LIGHTPROD:
668 case STATE_LIGHTMODEL_SCENECOLOR:
669 /* these can be effected by glColor when colormaterial mode is used */
670 return _NEW_LIGHT | _NEW_CURRENT_ATTRIB;
673 case STATE_LIGHTMODEL_AMBIENT:
678 case STATE_TEXENV_COLOR:
679 return _NEW_TEXTURE | _NEW_BUFFERS | _NEW_FRAG_CLAMP;
681 case STATE_FOG_COLOR:
682 return _NEW_FOG | _NEW_BUFFERS | _NEW_FRAG_CLAMP;
683 case STATE_FOG_PARAMS:
686 case STATE_CLIPPLANE:
687 return _NEW_TRANSFORM;
689 case STATE_POINT_SIZE:
690 case STATE_POINT_ATTENUATION:
693 case STATE_MODELVIEW_MATRIX:
694 return _NEW_MODELVIEW;
695 case STATE_PROJECTION_MATRIX:
696 return _NEW_PROJECTION;
697 case STATE_MVP_MATRIX:
698 return _NEW_MODELVIEW | _NEW_PROJECTION;
699 case STATE_TEXTURE_MATRIX:
700 return _NEW_TEXTURE_MATRIX;
701 case STATE_PROGRAM_MATRIX:
702 return _NEW_TRACK_MATRIX;
704 case STATE_DEPTH_RANGE:
705 return _NEW_VIEWPORT;
707 case STATE_FRAGMENT_PROGRAM:
708 case STATE_VERTEX_PROGRAM:
711 case STATE_NORMAL_SCALE:
712 return _NEW_MODELVIEW;
716 case STATE_CURRENT_ATTRIB:
717 return _NEW_CURRENT_ATTRIB;
718 case STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED:
719 return _NEW_CURRENT_ATTRIB | _NEW_LIGHT | _NEW_BUFFERS;
721 case STATE_NORMAL_SCALE:
722 return _NEW_MODELVIEW;
724 case STATE_TEXRECT_SCALE:
725 case STATE_SHADOW_AMBIENT:
726 case STATE_ROT_MATRIX_0:
727 case STATE_ROT_MATRIX_1:
729 case STATE_FOG_PARAMS_OPTIMIZED:
731 case STATE_POINT_SIZE_CLAMPED:
732 case STATE_POINT_SIZE_IMPL_CLAMP:
733 return _NEW_POINT | _NEW_MULTISAMPLE;
734 case STATE_LIGHT_SPOT_DIR_NORMALIZED:
735 case STATE_LIGHT_POSITION:
736 case STATE_LIGHT_POSITION_NORMALIZED:
737 case STATE_LIGHT_HALF_VECTOR:
745 case STATE_FB_WPOS_Y_TRANSFORM:
749 /* unknown state indexes are silently ignored and
750 * no flag set, since it is handled by the driver.
756 _mesa_problem(NULL, "unexpected state[0] in make_state_flags()");
763 append(char *dst, const char *src)
774 * Convert token 'k' to a string, append it onto 'dst' string.
777 append_token(char *dst, gl_state_index k)
781 append(dst, "material");
784 append(dst, "light");
786 case STATE_LIGHTMODEL_AMBIENT:
787 append(dst, "lightmodel.ambient");
789 case STATE_LIGHTMODEL_SCENECOLOR:
791 case STATE_LIGHTPROD:
792 append(dst, "lightprod");
795 append(dst, "texgen");
797 case STATE_FOG_COLOR:
798 append(dst, "fog.color");
800 case STATE_FOG_PARAMS:
801 append(dst, "fog.params");
803 case STATE_CLIPPLANE:
806 case STATE_POINT_SIZE:
807 append(dst, "point.size");
809 case STATE_POINT_ATTENUATION:
810 append(dst, "point.attenuation");
812 case STATE_MODELVIEW_MATRIX:
813 append(dst, "matrix.modelview");
815 case STATE_PROJECTION_MATRIX:
816 append(dst, "matrix.projection");
818 case STATE_MVP_MATRIX:
819 append(dst, "matrix.mvp");
821 case STATE_TEXTURE_MATRIX:
822 append(dst, "matrix.texture");
824 case STATE_PROGRAM_MATRIX:
825 append(dst, "matrix.program");
827 case STATE_MATRIX_INVERSE:
828 append(dst, ".inverse");
830 case STATE_MATRIX_TRANSPOSE:
831 append(dst, ".transpose");
833 case STATE_MATRIX_INVTRANS:
834 append(dst, ".invtrans");
837 append(dst, ".ambient");
840 append(dst, ".diffuse");
843 append(dst, ".specular");
846 append(dst, ".emission");
848 case STATE_SHININESS:
849 append(dst, "lshininess");
851 case STATE_HALF_VECTOR:
852 append(dst, ".half");
855 append(dst, ".position");
857 case STATE_ATTENUATION:
858 append(dst, ".attenuation");
860 case STATE_SPOT_DIRECTION:
861 append(dst, ".spot.direction");
863 case STATE_SPOT_CUTOFF:
864 append(dst, ".spot.cutoff");
866 case STATE_TEXGEN_EYE_S:
867 append(dst, ".eye.s");
869 case STATE_TEXGEN_EYE_T:
870 append(dst, ".eye.t");
872 case STATE_TEXGEN_EYE_R:
873 append(dst, ".eye.r");
875 case STATE_TEXGEN_EYE_Q:
876 append(dst, ".eye.q");
878 case STATE_TEXGEN_OBJECT_S:
879 append(dst, ".object.s");
881 case STATE_TEXGEN_OBJECT_T:
882 append(dst, ".object.t");
884 case STATE_TEXGEN_OBJECT_R:
885 append(dst, ".object.r");
887 case STATE_TEXGEN_OBJECT_Q:
888 append(dst, ".object.q");
890 case STATE_TEXENV_COLOR:
891 append(dst, "texenv");
893 case STATE_DEPTH_RANGE:
894 append(dst, "depth.range");
896 case STATE_VERTEX_PROGRAM:
897 case STATE_FRAGMENT_PROGRAM:
903 append(dst, "local");
905 /* BEGIN internal state vars */
907 append(dst, ".internal.");
909 case STATE_CURRENT_ATTRIB:
910 append(dst, "current");
912 case STATE_NORMAL_SCALE:
913 append(dst, "normalScale");
915 case STATE_TEXRECT_SCALE:
916 append(dst, "texrectScale");
918 case STATE_FOG_PARAMS_OPTIMIZED:
919 append(dst, "fogParamsOptimized");
921 case STATE_POINT_SIZE_CLAMPED:
922 append(dst, "pointSizeClamped");
924 case STATE_POINT_SIZE_IMPL_CLAMP:
925 append(dst, "pointSizeImplClamp");
927 case STATE_LIGHT_SPOT_DIR_NORMALIZED:
928 append(dst, "lightSpotDirNormalized");
930 case STATE_LIGHT_POSITION:
931 append(dst, "lightPosition");
933 case STATE_LIGHT_POSITION_NORMALIZED:
934 append(dst, "light.position.normalized");
936 case STATE_LIGHT_HALF_VECTOR:
937 append(dst, "lightHalfVector");
940 append(dst, "PTscale");
943 append(dst, "PTbias");
945 case STATE_SHADOW_AMBIENT:
946 append(dst, "CompareFailValue");
949 append(dst, "FbSize");
951 case STATE_FB_WPOS_Y_TRANSFORM:
952 append(dst, "FbWposYTransform");
954 case STATE_ROT_MATRIX_0:
955 append(dst, "rotMatrixRow0");
957 case STATE_ROT_MATRIX_1:
958 append(dst, "rotMatrixRow1");
961 /* probably STATE_INTERNAL_DRIVER+i (driver private state) */
962 append(dst, "driverState");
967 append_face(char *dst, GLint face)
970 append(dst, "front.");
972 append(dst, "back.");
976 append_index(char *dst, GLint index)
979 sprintf(s, "[%d]", index);
984 * Make a string from the given state vector.
985 * For example, return "state.matrix.texture[2].inverse".
986 * Use free() to deallocate the string.
989 _mesa_program_state_string(const gl_state_index state[STATE_LENGTH])
994 append(str, "state.");
995 append_token(str, state[0]);
999 append_face(str, state[1]);
1000 append_token(str, state[2]);
1003 append_index(str, state[1]); /* light number [i]. */
1004 append_token(str, state[2]); /* coefficients */
1006 case STATE_LIGHTMODEL_AMBIENT:
1007 append(str, "lightmodel.ambient");
1009 case STATE_LIGHTMODEL_SCENECOLOR:
1010 if (state[1] == 0) {
1011 append(str, "lightmodel.front.scenecolor");
1014 append(str, "lightmodel.back.scenecolor");
1017 case STATE_LIGHTPROD:
1018 append_index(str, state[1]); /* light number [i]. */
1019 append_face(str, state[2]);
1020 append_token(str, state[3]);
1023 append_index(str, state[1]); /* tex unit [i] */
1024 append_token(str, state[2]); /* plane coef */
1026 case STATE_TEXENV_COLOR:
1027 append_index(str, state[1]); /* tex unit [i] */
1028 append(str, "color");
1030 case STATE_CLIPPLANE:
1031 append_index(str, state[1]); /* plane [i] */
1032 append(str, ".plane");
1034 case STATE_MODELVIEW_MATRIX:
1035 case STATE_PROJECTION_MATRIX:
1036 case STATE_MVP_MATRIX:
1037 case STATE_TEXTURE_MATRIX:
1038 case STATE_PROGRAM_MATRIX:
1040 /* state[0] = modelview, projection, texture, etc. */
1041 /* state[1] = which texture matrix or program matrix */
1042 /* state[2] = first row to fetch */
1043 /* state[3] = last row to fetch */
1044 /* state[4] = transpose, inverse or invtrans */
1045 const gl_state_index mat = state[0];
1046 const GLuint index = (GLuint) state[1];
1047 const GLuint firstRow = (GLuint) state[2];
1048 const GLuint lastRow = (GLuint) state[3];
1049 const gl_state_index modifier = state[4];
1051 mat == STATE_TEXTURE_MATRIX ||
1052 mat == STATE_PROGRAM_MATRIX)
1053 append_index(str, index);
1055 append_token(str, modifier);
1056 if (firstRow == lastRow)
1057 sprintf(tmp, ".row[%d]", firstRow);
1059 sprintf(tmp, ".row[%d..%d]", firstRow, lastRow);
1063 case STATE_POINT_SIZE:
1065 case STATE_POINT_ATTENUATION:
1067 case STATE_FOG_PARAMS:
1069 case STATE_FOG_COLOR:
1071 case STATE_DEPTH_RANGE:
1073 case STATE_FRAGMENT_PROGRAM:
1074 case STATE_VERTEX_PROGRAM:
1075 /* state[1] = {STATE_ENV, STATE_LOCAL} */
1076 /* state[2] = parameter index */
1077 append_token(str, state[1]);
1078 append_index(str, state[2]);
1080 case STATE_NORMAL_SCALE:
1082 case STATE_INTERNAL:
1083 append_token(str, state[1]);
1084 if (state[1] == STATE_CURRENT_ATTRIB)
1085 append_index(str, state[2]);
1088 _mesa_problem(NULL, "Invalid state in _mesa_program_state_string");
1092 return _mesa_strdup(str);
1097 * Loop over all the parameters in a parameter list. If the parameter
1098 * is a GL state reference, look up the current value of that state
1099 * variable and put it into the parameter's Value[4] array.
1100 * Other parameter types never change or are explicitly set by the user
1101 * with glUniform() or glProgramParameter(), etc.
1102 * This would be called at glBegin time.
1105 _mesa_load_state_parameters(struct gl_context *ctx,
1106 struct gl_program_parameter_list *paramList)
1113 for (i = 0; i < paramList->NumParameters; i++) {
1114 if (paramList->Parameters[i].Type == PROGRAM_STATE_VAR) {
1115 _mesa_fetch_state(ctx,
1116 paramList->Parameters[i].StateIndexes,
1117 ¶mList->ParameterValues[i][0].f);
1124 * Copy the 16 elements of a matrix into four consecutive program
1125 * registers starting at 'pos'.
1128 load_matrix(GLfloat registers[][4], GLuint pos, const GLfloat mat[16])
1131 for (i = 0; i < 4; i++) {
1132 registers[pos + i][0] = mat[0 + i];
1133 registers[pos + i][1] = mat[4 + i];
1134 registers[pos + i][2] = mat[8 + i];
1135 registers[pos + i][3] = mat[12 + i];
1141 * As above, but transpose the matrix.
1144 load_transpose_matrix(GLfloat registers[][4], GLuint pos,
1145 const GLfloat mat[16])
1147 memcpy(registers[pos], mat, 16 * sizeof(GLfloat));
1152 * Load current vertex program's parameter registers with tracked
1153 * matrices (if NV program). This only needs to be done per
1154 * glBegin/glEnd, not per-vertex.
1157 _mesa_load_tracked_matrices(struct gl_context *ctx)
1161 for (i = 0; i < MAX_NV_VERTEX_PROGRAM_PARAMS / 4; i++) {
1162 /* point 'mat' at source matrix */
1164 if (ctx->VertexProgram.TrackMatrix[i] == GL_MODELVIEW) {
1165 mat = ctx->ModelviewMatrixStack.Top;
1167 else if (ctx->VertexProgram.TrackMatrix[i] == GL_PROJECTION) {
1168 mat = ctx->ProjectionMatrixStack.Top;
1170 else if (ctx->VertexProgram.TrackMatrix[i] == GL_TEXTURE) {
1171 GLuint unit = MIN2(ctx->Texture.CurrentUnit,
1172 Elements(ctx->TextureMatrixStack) - 1);
1173 mat = ctx->TextureMatrixStack[unit].Top;
1175 else if (ctx->VertexProgram.TrackMatrix[i]==GL_MODELVIEW_PROJECTION_NV) {
1176 /* XXX verify the combined matrix is up to date */
1177 mat = &ctx->_ModelProjectMatrix;
1179 else if (ctx->VertexProgram.TrackMatrix[i] >= GL_MATRIX0_NV &&
1180 ctx->VertexProgram.TrackMatrix[i] <= GL_MATRIX7_NV) {
1181 GLuint n = ctx->VertexProgram.TrackMatrix[i] - GL_MATRIX0_NV;
1182 ASSERT(n < Elements(ctx->ProgramMatrixStack));
1183 mat = ctx->ProgramMatrixStack[n].Top;
1186 /* no matrix is tracked, but we leave the register values as-is */
1187 assert(ctx->VertexProgram.TrackMatrix[i] == GL_NONE);
1191 /* load the matrix values into sequential registers */
1192 if (ctx->VertexProgram.TrackMatrixTransform[i] == GL_IDENTITY_NV) {
1193 load_matrix(ctx->VertexProgram.Parameters, i*4, mat->m);
1195 else if (ctx->VertexProgram.TrackMatrixTransform[i] == GL_INVERSE_NV) {
1196 _math_matrix_analyse(mat); /* update the inverse */
1197 ASSERT(!_math_matrix_is_dirty(mat));
1198 load_matrix(ctx->VertexProgram.Parameters, i*4, mat->inv);
1200 else if (ctx->VertexProgram.TrackMatrixTransform[i] == GL_TRANSPOSE_NV) {
1201 load_transpose_matrix(ctx->VertexProgram.Parameters, i*4, mat->m);
1204 assert(ctx->VertexProgram.TrackMatrixTransform[i]
1205 == GL_INVERSE_TRANSPOSE_NV);
1206 _math_matrix_analyse(mat); /* update the inverse */
1207 ASSERT(!_math_matrix_is_dirty(mat));
1208 load_transpose_matrix(ctx->VertexProgram.Parameters, i*4, mat->inv);