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/hash.h"
35 #include "main/imports.h"
36 #include "main/macros.h"
37 #include "main/mtypes.h"
38 #include "prog_statevars.h"
39 #include "prog_parameter.h"
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.
50 _mesa_fetch_state(GLcontext *ctx, const gl_state_index state[],
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().
65 /* state[2] is the material attribute */
68 COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_AMBIENT + face]);
71 COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_DIFFUSE + face]);
74 COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_SPECULAR + face]);
77 COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_EMISSION + face]);
80 value[0] = mat->Attrib[MAT_ATTRIB_FRONT_SHININESS + face][0];
86 _mesa_problem(ctx, "Invalid material state in fetch_state");
92 /* state[1] is the light number */
93 const GLuint ln = (GLuint) state[1];
94 /* state[2] is the light attribute */
97 COPY_4V(value, ctx->Light.Light[ln].Ambient);
100 COPY_4V(value, ctx->Light.Light[ln].Diffuse);
103 COPY_4V(value, ctx->Light.Light[ln].Specular);
106 COPY_4V(value, ctx->Light.Light[ln].EyePosition);
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;
114 case STATE_SPOT_DIRECTION:
115 COPY_3V(value, ctx->Light.Light[ln].EyeDirection);
116 value[3] = ctx->Light.Light[ln]._CosCutoff;
118 case STATE_SPOT_CUTOFF:
119 value[0] = ctx->Light.Light[ln].SpotCutoff;
121 case STATE_HALF_VECTOR:
123 static const GLfloat eye_z[] = {0, 0, 1};
125 /* Compute infinite half angle vector:
126 * halfVector = normalize(normalize(lightPos) + (0, 0, 1))
127 * light.EyePosition.w should be 0 for infinite lights.
129 COPY_3V(p, ctx->Light.Light[ln].EyePosition);
131 ADD_3V(value, p, eye_z);
132 NORMALIZE_3FV(value);
137 _mesa_problem(ctx, "Invalid light state in fetch_state");
141 case STATE_LIGHTMODEL_AMBIENT:
142 COPY_4V(value, ctx->Light.Model.Ambient);
144 case STATE_LIGHTMODEL_SCENECOLOR:
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];
153 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE][3];
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];
163 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_DIFFUSE][3];
166 case STATE_LIGHTPROD:
168 const GLuint ln = (GLuint) state[1];
169 const GLuint face = (GLuint) state[2];
171 ASSERT(face == 0 || face == 1);
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];
178 /* [3] = material alpha */
179 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][3];
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];
186 /* [3] = material alpha */
187 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][3];
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];
194 /* [3] = material alpha */
195 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][3];
198 _mesa_problem(ctx, "Invalid lightprod state in fetch_state");
204 /* state[1] is the texture unit */
205 const GLuint unit = (GLuint) state[1];
206 /* state[2] is the texgen attribute */
208 case STATE_TEXGEN_EYE_S:
209 COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneS);
211 case STATE_TEXGEN_EYE_T:
212 COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneT);
214 case STATE_TEXGEN_EYE_R:
215 COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneR);
217 case STATE_TEXGEN_EYE_Q:
218 COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneQ);
220 case STATE_TEXGEN_OBJECT_S:
221 COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneS);
223 case STATE_TEXGEN_OBJECT_T:
224 COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneT);
226 case STATE_TEXGEN_OBJECT_R:
227 COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneR);
229 case STATE_TEXGEN_OBJECT_Q:
230 COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneQ);
233 _mesa_problem(ctx, "Invalid texgen state in fetch_state");
237 case STATE_TEXENV_COLOR:
239 /* state[1] is the texture unit */
240 const GLuint unit = (GLuint) state[1];
241 COPY_4V(value, ctx->Texture.Unit[unit].EnvColor);
244 case STATE_FOG_COLOR:
245 COPY_4V(value, ctx->Fog.Color);
247 case STATE_FOG_PARAMS:
248 value[0] = ctx->Fog.Density;
249 value[1] = ctx->Fog.Start;
250 value[2] = ctx->Fog.End;
251 value[3] = (ctx->Fog.End == ctx->Fog.Start)
252 ? 1.0f : (GLfloat)(1.0 / (ctx->Fog.End - ctx->Fog.Start));
254 case STATE_CLIPPLANE:
256 const GLuint plane = (GLuint) state[1];
257 COPY_4V(value, ctx->Transform.EyeUserPlane[plane]);
260 case STATE_POINT_SIZE:
261 value[0] = ctx->Point.Size;
262 value[1] = ctx->Point.MinSize;
263 value[2] = ctx->Point.MaxSize;
264 value[3] = ctx->Point.Threshold;
266 case STATE_POINT_ATTENUATION:
267 value[0] = ctx->Point.Params[0];
268 value[1] = ctx->Point.Params[1];
269 value[2] = ctx->Point.Params[2];
272 case STATE_MODELVIEW_MATRIX:
273 case STATE_PROJECTION_MATRIX:
274 case STATE_MVP_MATRIX:
275 case STATE_TEXTURE_MATRIX:
276 case STATE_PROGRAM_MATRIX:
277 case STATE_COLOR_MATRIX:
279 /* state[0] = modelview, projection, texture, etc. */
280 /* state[1] = which texture matrix or program matrix */
281 /* state[2] = first row to fetch */
282 /* state[3] = last row to fetch */
283 /* state[4] = transpose, inverse or invtrans */
284 const GLmatrix *matrix;
285 const gl_state_index mat = state[0];
286 const GLuint index = (GLuint) state[1];
287 const GLuint firstRow = (GLuint) state[2];
288 const GLuint lastRow = (GLuint) state[3];
289 const gl_state_index modifier = state[4];
292 ASSERT(firstRow >= 0);
293 ASSERT(firstRow < 4);
294 ASSERT(lastRow >= 0);
296 if (mat == STATE_MODELVIEW_MATRIX) {
297 matrix = ctx->ModelviewMatrixStack.Top;
299 else if (mat == STATE_PROJECTION_MATRIX) {
300 matrix = ctx->ProjectionMatrixStack.Top;
302 else if (mat == STATE_MVP_MATRIX) {
303 matrix = &ctx->_ModelProjectMatrix;
305 else if (mat == STATE_TEXTURE_MATRIX) {
306 matrix = ctx->TextureMatrixStack[index].Top;
308 else if (mat == STATE_PROGRAM_MATRIX) {
309 matrix = ctx->ProgramMatrixStack[index].Top;
311 else if (mat == STATE_COLOR_MATRIX) {
312 matrix = ctx->ColorMatrixStack.Top;
315 _mesa_problem(ctx, "Bad matrix name in _mesa_fetch_state()");
318 if (modifier == STATE_MATRIX_INVERSE ||
319 modifier == STATE_MATRIX_INVTRANS) {
320 /* Be sure inverse is up to date:
322 _math_matrix_alloc_inv( (GLmatrix *) matrix );
323 _math_matrix_analyse( (GLmatrix*) matrix );
329 if (modifier == STATE_MATRIX_TRANSPOSE ||
330 modifier == STATE_MATRIX_INVTRANS) {
331 for (i = 0, row = firstRow; row <= lastRow; row++) {
332 value[i++] = m[row * 4 + 0];
333 value[i++] = m[row * 4 + 1];
334 value[i++] = m[row * 4 + 2];
335 value[i++] = m[row * 4 + 3];
339 for (i = 0, row = firstRow; row <= lastRow; row++) {
340 value[i++] = m[row + 0];
341 value[i++] = m[row + 4];
342 value[i++] = m[row + 8];
343 value[i++] = m[row + 12];
348 case STATE_DEPTH_RANGE:
349 value[0] = ctx->Viewport.Near; /* near */
350 value[1] = ctx->Viewport.Far; /* far */
351 value[2] = ctx->Viewport.Far - ctx->Viewport.Near; /* far - near */
354 case STATE_FRAGMENT_PROGRAM:
356 /* state[1] = {STATE_ENV, STATE_LOCAL} */
357 /* state[2] = parameter index */
358 const int idx = (int) state[2];
361 COPY_4V(value, ctx->FragmentProgram.Parameters[idx]);
364 COPY_4V(value, ctx->FragmentProgram.Current->Base.LocalParams[idx]);
367 _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
373 case STATE_VERTEX_PROGRAM:
375 /* state[1] = {STATE_ENV, STATE_LOCAL} */
376 /* state[2] = parameter index */
377 const int idx = (int) state[2];
380 COPY_4V(value, ctx->VertexProgram.Parameters[idx]);
383 COPY_4V(value, ctx->VertexProgram.Current->Base.LocalParams[idx]);
386 _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
392 case STATE_NORMAL_SCALE:
393 ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
398 case STATE_CURRENT_ATTRIB: {
399 const GLuint idx = (GLuint) state[2];
400 COPY_4V(value, ctx->Current.Attrib[idx]);
404 case STATE_NORMAL_SCALE:
406 ctx->_ModelViewInvScale,
407 ctx->_ModelViewInvScale,
408 ctx->_ModelViewInvScale,
411 case STATE_TEXRECT_SCALE:
413 const int unit = (int) state[2];
414 const struct gl_texture_object *texObj
415 = ctx->Texture.Unit[unit]._Current;
417 struct gl_texture_image *texImage = texObj->Image[0][0];
418 ASSIGN_4V(value, (GLfloat) (1.0 / texImage->Width),
419 (GLfloat)(1.0 / texImage->Height),
424 case STATE_FOG_PARAMS_OPTIMIZED:
425 /* for simpler per-vertex/pixel fog calcs. POW (for EXP/EXP2 fog)
426 * might be more expensive than EX2 on some hw, plus it needs
427 * another constant (e) anyway. Linear fog can now be done with a
429 * linear: fogcoord * -1/(end-start) + end/(end-start)
430 * exp: 2^-(density/ln(2) * fogcoord)
431 * exp2: 2^-((density/(ln(2)^2) * fogcoord)^2)
433 value[0] = (ctx->Fog.End == ctx->Fog.Start)
434 ? 1.0f : (GLfloat)(-1.0F / (ctx->Fog.End - ctx->Fog.Start));
435 value[1] = ctx->Fog.End * -value[0];
436 value[2] = (GLfloat)(ctx->Fog.Density * ONE_DIV_LN2);
437 value[3] = (GLfloat)(ctx->Fog.Density * ONE_DIV_SQRT_LN2);
440 case STATE_LIGHT_SPOT_DIR_NORMALIZED: {
441 /* here, state[2] is the light number */
442 /* pre-normalize spot dir */
443 const GLuint ln = (GLuint) state[2];
444 COPY_3V(value, ctx->Light.Light[ln]._NormDirection);
445 value[3] = ctx->Light.Light[ln]._CosCutoff;
449 case STATE_LIGHT_POSITION: {
450 const GLuint ln = (GLuint) state[2];
451 COPY_4V(value, ctx->Light.Light[ln]._Position);
455 case STATE_LIGHT_POSITION_NORMALIZED: {
456 const GLuint ln = (GLuint) state[2];
457 COPY_4V(value, ctx->Light.Light[ln]._Position);
458 NORMALIZE_3FV( value );
462 case STATE_LIGHT_HALF_VECTOR: {
463 const GLuint ln = (GLuint) state[2];
465 /* Compute infinite half angle vector:
466 * halfVector = normalize(normalize(lightPos) + (0, 0, 1))
467 * light.EyePosition.w should be 0 for infinite lights.
469 COPY_3V(p, ctx->Light.Light[ln]._Position);
471 ADD_3V(value, p, ctx->_EyeZDir);
472 NORMALIZE_3FV(value);
479 value[0] = ctx->Pixel.RedScale;
480 value[1] = ctx->Pixel.GreenScale;
481 value[2] = ctx->Pixel.BlueScale;
482 value[3] = ctx->Pixel.AlphaScale;
485 value[0] = ctx->Pixel.RedBias;
486 value[1] = ctx->Pixel.GreenBias;
487 value[2] = ctx->Pixel.BlueBias;
488 value[3] = ctx->Pixel.AlphaBias;
490 case STATE_PCM_SCALE:
491 COPY_4V(value, ctx->Pixel.PostColorMatrixScale);
494 COPY_4V(value, ctx->Pixel.PostColorMatrixBias);
496 case STATE_SHADOW_AMBIENT:
498 const int unit = (int) state[2];
499 const struct gl_texture_object *texObj
500 = ctx->Texture.Unit[unit]._Current;
502 value[0] = texObj->ShadowAmbient;
503 value[1] = texObj->ShadowAmbient;
504 value[2] = texObj->ShadowAmbient;
505 value[3] = texObj->ShadowAmbient;
510 /* XXX: make sure new tokens added here are also handled in the
511 * _mesa_program_state_flags() switch, below.
514 /* unknown state indexes are silently ignored
515 * should be handled by the driver.
522 _mesa_problem(ctx, "Invalid state in _mesa_fetch_state");
529 * Return a bitmask of the Mesa state flags (_NEW_* values) which would
530 * indicate that the given context state may have changed.
531 * The bitmask is used during validation to determine if we need to update
532 * vertex/fragment program parameters (like "state.material.color") when
533 * some GL state has changed.
536 _mesa_program_state_flags(const gl_state_index state[STATE_LENGTH])
541 case STATE_LIGHTMODEL_AMBIENT:
542 case STATE_LIGHTMODEL_SCENECOLOR:
543 case STATE_LIGHTPROD:
547 case STATE_TEXENV_COLOR:
550 case STATE_FOG_COLOR:
551 case STATE_FOG_PARAMS:
554 case STATE_CLIPPLANE:
555 return _NEW_TRANSFORM;
557 case STATE_POINT_SIZE:
558 case STATE_POINT_ATTENUATION:
561 case STATE_MODELVIEW_MATRIX:
562 return _NEW_MODELVIEW;
563 case STATE_PROJECTION_MATRIX:
564 return _NEW_PROJECTION;
565 case STATE_MVP_MATRIX:
566 return _NEW_MODELVIEW | _NEW_PROJECTION;
567 case STATE_TEXTURE_MATRIX:
568 return _NEW_TEXTURE_MATRIX;
569 case STATE_PROGRAM_MATRIX:
570 return _NEW_TRACK_MATRIX;
571 case STATE_COLOR_MATRIX:
572 return _NEW_COLOR_MATRIX;
574 case STATE_DEPTH_RANGE:
575 return _NEW_VIEWPORT;
577 case STATE_FRAGMENT_PROGRAM:
578 case STATE_VERTEX_PROGRAM:
581 case STATE_NORMAL_SCALE:
582 return _NEW_MODELVIEW;
586 case STATE_CURRENT_ATTRIB:
587 return _NEW_CURRENT_ATTRIB;
589 case STATE_NORMAL_SCALE:
590 return _NEW_MODELVIEW;
592 case STATE_TEXRECT_SCALE:
593 case STATE_SHADOW_AMBIENT:
595 case STATE_FOG_PARAMS_OPTIMIZED:
597 case STATE_LIGHT_SPOT_DIR_NORMALIZED:
598 case STATE_LIGHT_POSITION:
599 case STATE_LIGHT_POSITION_NORMALIZED:
600 case STATE_LIGHT_HALF_VECTOR:
605 case STATE_PCM_SCALE:
610 /* unknown state indexes are silently ignored and
611 * no flag set, since it is handled by the driver.
617 _mesa_problem(NULL, "unexpected state[0] in make_state_flags()");
624 append(char *dst, const char *src)
635 * Convert token 'k' to a string, append it onto 'dst' string.
638 append_token(char *dst, gl_state_index k)
642 append(dst, "material");
645 append(dst, "light");
647 case STATE_LIGHTMODEL_AMBIENT:
648 append(dst, "lightmodel.ambient");
650 case STATE_LIGHTMODEL_SCENECOLOR:
652 case STATE_LIGHTPROD:
653 append(dst, "lightprod");
656 append(dst, "texgen");
658 case STATE_FOG_COLOR:
659 append(dst, "fog.color");
661 case STATE_FOG_PARAMS:
662 append(dst, "fog.params");
664 case STATE_CLIPPLANE:
667 case STATE_POINT_SIZE:
668 append(dst, "point.size");
670 case STATE_POINT_ATTENUATION:
671 append(dst, "point.attenuation");
673 case STATE_MODELVIEW_MATRIX:
674 append(dst, "matrix.modelview");
676 case STATE_PROJECTION_MATRIX:
677 append(dst, "matrix.projection");
679 case STATE_MVP_MATRIX:
680 append(dst, "matrix.mvp");
682 case STATE_TEXTURE_MATRIX:
683 append(dst, "matrix.texture");
685 case STATE_PROGRAM_MATRIX:
686 append(dst, "matrix.program");
688 case STATE_COLOR_MATRIX:
689 append(dst, "matrix.color");
691 case STATE_MATRIX_INVERSE:
692 append(dst, ".inverse");
694 case STATE_MATRIX_TRANSPOSE:
695 append(dst, ".transpose");
697 case STATE_MATRIX_INVTRANS:
698 append(dst, ".invtrans");
701 append(dst, ".ambient");
704 append(dst, ".diffuse");
707 append(dst, ".specular");
710 append(dst, ".emission");
712 case STATE_SHININESS:
713 append(dst, "lshininess");
715 case STATE_HALF_VECTOR:
716 append(dst, ".half");
719 append(dst, ".position");
721 case STATE_ATTENUATION:
722 append(dst, ".attenuation");
724 case STATE_SPOT_DIRECTION:
725 append(dst, ".spot.direction");
727 case STATE_SPOT_CUTOFF:
728 append(dst, ".spot.cutoff");
730 case STATE_TEXGEN_EYE_S:
731 append(dst, "eye.s");
733 case STATE_TEXGEN_EYE_T:
734 append(dst, "eye.t");
736 case STATE_TEXGEN_EYE_R:
737 append(dst, "eye.r");
739 case STATE_TEXGEN_EYE_Q:
740 append(dst, "eye.q");
742 case STATE_TEXGEN_OBJECT_S:
743 append(dst, "object.s");
745 case STATE_TEXGEN_OBJECT_T:
746 append(dst, "object.t");
748 case STATE_TEXGEN_OBJECT_R:
749 append(dst, "object.r");
751 case STATE_TEXGEN_OBJECT_Q:
752 append(dst, "object.q");
754 case STATE_TEXENV_COLOR:
755 append(dst, "texenv");
757 case STATE_DEPTH_RANGE:
758 append(dst, "depth.range");
760 case STATE_VERTEX_PROGRAM:
761 case STATE_FRAGMENT_PROGRAM:
767 append(dst, "local");
769 /* BEGIN internal state vars */
771 append(dst, "(internal)");
773 case STATE_NORMAL_SCALE:
774 append(dst, "normalScale");
776 case STATE_TEXRECT_SCALE:
777 append(dst, "texrectScale");
779 case STATE_FOG_PARAMS_OPTIMIZED:
780 append(dst, "fogParamsOptimized");
782 case STATE_LIGHT_SPOT_DIR_NORMALIZED:
783 append(dst, "lightSpotDirNormalized");
785 case STATE_LIGHT_POSITION:
786 append(dst, "lightPosition");
788 case STATE_LIGHT_POSITION_NORMALIZED:
789 append(dst, "light.position.normalized");
791 case STATE_LIGHT_HALF_VECTOR:
792 append(dst, "lightHalfVector");
795 append(dst, "PTscale");
798 append(dst, "PTbias");
800 case STATE_PCM_SCALE:
801 append(dst, "PCMscale");
804 append(dst, "PCMbias");
806 case STATE_SHADOW_AMBIENT:
807 append(dst, "ShadowAmbient");
810 /* probably STATE_INTERNAL_DRIVER+i (driver private state) */
811 append(dst, "driverState");
816 append_face(char *dst, GLint face)
819 append(dst, "front.");
821 append(dst, "back.");
825 append_index(char *dst, GLint index)
828 _mesa_sprintf(s, "[%d]", index);
833 * Make a string from the given state vector.
834 * For example, return "state.matrix.texture[2].inverse".
835 * Use _mesa_free() to deallocate the string.
838 _mesa_program_state_string(const gl_state_index state[STATE_LENGTH])
843 append(str, "state.");
844 append_token(str, state[0]);
848 append_face(str, state[1]);
849 append_token(str, state[2]);
852 append_index(str, state[1]); /* light number [i]. */
853 append_token(str, state[2]); /* coefficients */
855 case STATE_LIGHTMODEL_AMBIENT:
856 append(str, "lightmodel.ambient");
858 case STATE_LIGHTMODEL_SCENECOLOR:
860 append(str, "lightmodel.front.scenecolor");
863 append(str, "lightmodel.back.scenecolor");
866 case STATE_LIGHTPROD:
867 append_index(str, state[1]); /* light number [i]. */
868 append_face(str, state[2]);
869 append_token(str, state[3]);
872 append_index(str, state[1]); /* tex unit [i] */
873 append_token(str, state[2]); /* plane coef */
875 case STATE_TEXENV_COLOR:
876 append_index(str, state[1]); /* tex unit [i] */
877 append(str, "color");
879 case STATE_CLIPPLANE:
880 append_index(str, state[1]); /* plane [i] */
881 append(str, ".plane");
883 case STATE_MODELVIEW_MATRIX:
884 case STATE_PROJECTION_MATRIX:
885 case STATE_MVP_MATRIX:
886 case STATE_TEXTURE_MATRIX:
887 case STATE_PROGRAM_MATRIX:
888 case STATE_COLOR_MATRIX:
890 /* state[0] = modelview, projection, texture, etc. */
891 /* state[1] = which texture matrix or program matrix */
892 /* state[2] = first row to fetch */
893 /* state[3] = last row to fetch */
894 /* state[4] = transpose, inverse or invtrans */
895 const gl_state_index mat = state[0];
896 const GLuint index = (GLuint) state[1];
897 const GLuint firstRow = (GLuint) state[2];
898 const GLuint lastRow = (GLuint) state[3];
899 const gl_state_index modifier = state[4];
901 mat == STATE_TEXTURE_MATRIX ||
902 mat == STATE_PROGRAM_MATRIX)
903 append_index(str, index);
905 append_token(str, modifier);
906 if (firstRow == lastRow)
907 _mesa_sprintf(tmp, ".row[%d]", firstRow);
909 _mesa_sprintf(tmp, ".row[%d..%d]", firstRow, lastRow);
913 case STATE_POINT_SIZE:
915 case STATE_POINT_ATTENUATION:
917 case STATE_FOG_PARAMS:
919 case STATE_FOG_COLOR:
921 case STATE_DEPTH_RANGE:
923 case STATE_FRAGMENT_PROGRAM:
924 case STATE_VERTEX_PROGRAM:
925 /* state[1] = {STATE_ENV, STATE_LOCAL} */
926 /* state[2] = parameter index */
927 append_token(str, state[1]);
928 append_index(str, state[2]);
931 append_token(str, state[1]);
934 _mesa_problem(NULL, "Invalid state in _mesa_program_state_string");
938 return _mesa_strdup(str);
943 * Loop over all the parameters in a parameter list. If the parameter
944 * is a GL state reference, look up the current value of that state
945 * variable and put it into the parameter's Value[4] array.
946 * This would be called at glBegin time when using a fragment program.
949 _mesa_load_state_parameters(GLcontext *ctx,
950 struct gl_program_parameter_list *paramList)
957 /*assert(ctx->Driver.NeedFlush == 0);*/
959 for (i = 0; i < paramList->NumParameters; i++) {
960 if (paramList->Parameters[i].Type == PROGRAM_STATE_VAR) {
961 _mesa_fetch_state(ctx,
962 (gl_state_index *) paramList->Parameters[i].StateIndexes,
963 paramList->ParameterValues[i]);
970 * Copy the 16 elements of a matrix into four consecutive program
971 * registers starting at 'pos'.
974 load_matrix(GLfloat registers[][4], GLuint pos, const GLfloat mat[16])
977 for (i = 0; i < 4; i++) {
978 registers[pos + i][0] = mat[0 + i];
979 registers[pos + i][1] = mat[4 + i];
980 registers[pos + i][2] = mat[8 + i];
981 registers[pos + i][3] = mat[12 + i];
987 * As above, but transpose the matrix.
990 load_transpose_matrix(GLfloat registers[][4], GLuint pos,
991 const GLfloat mat[16])
993 MEMCPY(registers[pos], mat, 16 * sizeof(GLfloat));
998 * Load current vertex program's parameter registers with tracked
999 * matrices (if NV program). This only needs to be done per
1000 * glBegin/glEnd, not per-vertex.
1003 _mesa_load_tracked_matrices(GLcontext *ctx)
1007 for (i = 0; i < MAX_NV_VERTEX_PROGRAM_PARAMS / 4; i++) {
1008 /* point 'mat' at source matrix */
1010 if (ctx->VertexProgram.TrackMatrix[i] == GL_MODELVIEW) {
1011 mat = ctx->ModelviewMatrixStack.Top;
1013 else if (ctx->VertexProgram.TrackMatrix[i] == GL_PROJECTION) {
1014 mat = ctx->ProjectionMatrixStack.Top;
1016 else if (ctx->VertexProgram.TrackMatrix[i] == GL_TEXTURE) {
1017 mat = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top;
1019 else if (ctx->VertexProgram.TrackMatrix[i] == GL_COLOR) {
1020 mat = ctx->ColorMatrixStack.Top;
1022 else if (ctx->VertexProgram.TrackMatrix[i]==GL_MODELVIEW_PROJECTION_NV) {
1023 /* XXX verify the combined matrix is up to date */
1024 mat = &ctx->_ModelProjectMatrix;
1026 else if (ctx->VertexProgram.TrackMatrix[i] >= GL_MATRIX0_NV &&
1027 ctx->VertexProgram.TrackMatrix[i] <= GL_MATRIX7_NV) {
1028 GLuint n = ctx->VertexProgram.TrackMatrix[i] - GL_MATRIX0_NV;
1029 ASSERT(n < MAX_PROGRAM_MATRICES);
1030 mat = ctx->ProgramMatrixStack[n].Top;
1033 /* no matrix is tracked, but we leave the register values as-is */
1034 assert(ctx->VertexProgram.TrackMatrix[i] == GL_NONE);
1038 /* load the matrix values into sequential registers */
1039 if (ctx->VertexProgram.TrackMatrixTransform[i] == GL_IDENTITY_NV) {
1040 load_matrix(ctx->VertexProgram.Parameters, i*4, mat->m);
1042 else if (ctx->VertexProgram.TrackMatrixTransform[i] == GL_INVERSE_NV) {
1043 _math_matrix_analyse(mat); /* update the inverse */
1044 ASSERT(!_math_matrix_is_dirty(mat));
1045 load_matrix(ctx->VertexProgram.Parameters, i*4, mat->inv);
1047 else if (ctx->VertexProgram.TrackMatrixTransform[i] == GL_TRANSPOSE_NV) {
1048 load_transpose_matrix(ctx->VertexProgram.Parameters, i*4, mat->m);
1051 assert(ctx->VertexProgram.TrackMatrixTransform[i]
1052 == GL_INVERSE_TRANSPOSE_NV);
1053 _math_matrix_analyse(mat); /* update the inverse */
1054 ASSERT(!_math_matrix_is_dirty(mat));
1055 load_transpose_matrix(ctx->VertexProgram.Parameters, i*4, mat->inv);