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
;
505 value
[3] = texObj
->CompareFailValue
;
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
, "CompareFailValue");
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
);