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.
38 #include "prog_statevars.h"
39 #include "prog_parameter.h"
40 #include "nvvertparse.h"
44 * Use the list of tokens in the state[] array to find global GL state
45 * and return it in <value>. Usually, four values are returned in <value>
46 * but matrix queries may return as many as 16 values.
47 * This function is used for ARB vertex/fragment programs.
48 * The program parser will produce the state[] values.
51 _mesa_fetch_state(GLcontext
*ctx
, const gl_state_index state
[],
57 /* state[1] is either 0=front or 1=back side */
58 const GLuint face
= (GLuint
) state
[1];
59 const struct gl_material
*mat
= &ctx
->Light
.Material
;
60 ASSERT(face
== 0 || face
== 1);
61 /* we rely on tokens numbered so that _BACK_ == _FRONT_+ 1 */
62 ASSERT(MAT_ATTRIB_FRONT_AMBIENT
+ 1 == MAT_ATTRIB_BACK_AMBIENT
);
63 /* XXX we could get rid of this switch entirely with a little
64 * work in arbprogparse.c's parse_state_single_item().
66 /* state[2] is the material attribute */
69 COPY_4V(value
, mat
->Attrib
[MAT_ATTRIB_FRONT_AMBIENT
+ face
]);
72 COPY_4V(value
, mat
->Attrib
[MAT_ATTRIB_FRONT_DIFFUSE
+ face
]);
75 COPY_4V(value
, mat
->Attrib
[MAT_ATTRIB_FRONT_SPECULAR
+ face
]);
78 COPY_4V(value
, mat
->Attrib
[MAT_ATTRIB_FRONT_EMISSION
+ face
]);
81 value
[0] = mat
->Attrib
[MAT_ATTRIB_FRONT_SHININESS
+ face
][0];
87 _mesa_problem(ctx
, "Invalid material state in fetch_state");
93 /* state[1] is the light number */
94 const GLuint ln
= (GLuint
) state
[1];
95 /* state[2] is the light attribute */
98 COPY_4V(value
, ctx
->Light
.Light
[ln
].Ambient
);
101 COPY_4V(value
, ctx
->Light
.Light
[ln
].Diffuse
);
104 COPY_4V(value
, ctx
->Light
.Light
[ln
].Specular
);
107 COPY_4V(value
, ctx
->Light
.Light
[ln
].EyePosition
);
109 case STATE_ATTENUATION
:
110 value
[0] = ctx
->Light
.Light
[ln
].ConstantAttenuation
;
111 value
[1] = ctx
->Light
.Light
[ln
].LinearAttenuation
;
112 value
[2] = ctx
->Light
.Light
[ln
].QuadraticAttenuation
;
113 value
[3] = ctx
->Light
.Light
[ln
].SpotExponent
;
115 case STATE_SPOT_DIRECTION
:
116 COPY_3V(value
, ctx
->Light
.Light
[ln
].EyeDirection
);
117 value
[3] = ctx
->Light
.Light
[ln
]._CosCutoff
;
119 case STATE_SPOT_CUTOFF
:
120 value
[0] = ctx
->Light
.Light
[ln
].SpotCutoff
;
122 case STATE_HALF_VECTOR
:
124 static const GLfloat eye_z
[] = {0, 0, 1};
126 /* Compute infinite half angle vector:
127 * halfVector = normalize(normalize(lightPos) + (0, 0, 1))
128 * light.EyePosition.w should be 0 for infinite lights.
130 COPY_3V(p
, ctx
->Light
.Light
[ln
].EyePosition
);
132 ADD_3V(value
, p
, eye_z
);
133 NORMALIZE_3FV(value
);
137 case STATE_POSITION_NORMALIZED
:
138 COPY_4V(value
, ctx
->Light
.Light
[ln
].EyePosition
);
139 NORMALIZE_3FV( value
);
142 _mesa_problem(ctx
, "Invalid light state in fetch_state");
146 case STATE_LIGHTMODEL_AMBIENT
:
147 COPY_4V(value
, ctx
->Light
.Model
.Ambient
);
149 case STATE_LIGHTMODEL_SCENECOLOR
:
153 for (i
= 0; i
< 3; i
++) {
154 value
[i
] = ctx
->Light
.Model
.Ambient
[i
]
155 * ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_AMBIENT
][i
]
156 + ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_EMISSION
][i
];
158 value
[3] = ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_DIFFUSE
][3];
163 for (i
= 0; i
< 3; i
++) {
164 value
[i
] = ctx
->Light
.Model
.Ambient
[i
]
165 * ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_BACK_AMBIENT
][i
]
166 + ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_BACK_EMISSION
][i
];
168 value
[3] = ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_BACK_DIFFUSE
][3];
171 case STATE_LIGHTPROD
:
173 const GLuint ln
= (GLuint
) state
[1];
174 const GLuint face
= (GLuint
) state
[2];
176 ASSERT(face
== 0 || face
== 1);
179 for (i
= 0; i
< 3; i
++) {
180 value
[i
] = ctx
->Light
.Light
[ln
].Ambient
[i
] *
181 ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_AMBIENT
+face
][i
];
183 /* [3] = material alpha */
184 value
[3] = ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_DIFFUSE
+face
][3];
187 for (i
= 0; i
< 3; i
++) {
188 value
[i
] = ctx
->Light
.Light
[ln
].Diffuse
[i
] *
189 ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_DIFFUSE
+face
][i
];
191 /* [3] = material alpha */
192 value
[3] = ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_DIFFUSE
+face
][3];
195 for (i
= 0; i
< 3; i
++) {
196 value
[i
] = ctx
->Light
.Light
[ln
].Specular
[i
] *
197 ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_SPECULAR
+face
][i
];
199 /* [3] = material alpha */
200 value
[3] = ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_DIFFUSE
+face
][3];
203 _mesa_problem(ctx
, "Invalid lightprod state in fetch_state");
209 /* state[1] is the texture unit */
210 const GLuint unit
= (GLuint
) state
[1];
211 /* state[2] is the texgen attribute */
213 case STATE_TEXGEN_EYE_S
:
214 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].EyePlaneS
);
216 case STATE_TEXGEN_EYE_T
:
217 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].EyePlaneT
);
219 case STATE_TEXGEN_EYE_R
:
220 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].EyePlaneR
);
222 case STATE_TEXGEN_EYE_Q
:
223 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].EyePlaneQ
);
225 case STATE_TEXGEN_OBJECT_S
:
226 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].ObjectPlaneS
);
228 case STATE_TEXGEN_OBJECT_T
:
229 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].ObjectPlaneT
);
231 case STATE_TEXGEN_OBJECT_R
:
232 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].ObjectPlaneR
);
234 case STATE_TEXGEN_OBJECT_Q
:
235 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].ObjectPlaneQ
);
238 _mesa_problem(ctx
, "Invalid texgen state in fetch_state");
242 case STATE_TEXENV_COLOR
:
244 /* state[1] is the texture unit */
245 const GLuint unit
= (GLuint
) state
[1];
246 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].EnvColor
);
249 case STATE_FOG_COLOR
:
250 COPY_4V(value
, ctx
->Fog
.Color
);
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] = 1.0F
/ (ctx
->Fog
.End
- ctx
->Fog
.Start
);
258 case STATE_CLIPPLANE
:
260 const GLuint plane
= (GLuint
) state
[1];
261 COPY_4V(value
, ctx
->Transform
.EyeUserPlane
[plane
]);
264 case STATE_POINT_SIZE
:
265 value
[0] = ctx
->Point
.Size
;
266 value
[1] = ctx
->Point
.MinSize
;
267 value
[2] = ctx
->Point
.MaxSize
;
268 value
[3] = ctx
->Point
.Threshold
;
270 case STATE_POINT_ATTENUATION
:
271 value
[0] = ctx
->Point
.Params
[0];
272 value
[1] = ctx
->Point
.Params
[1];
273 value
[2] = ctx
->Point
.Params
[2];
276 case STATE_MODELVIEW_MATRIX
:
277 case STATE_PROJECTION_MATRIX
:
278 case STATE_MVP_MATRIX
:
279 case STATE_TEXTURE_MATRIX
:
280 case STATE_PROGRAM_MATRIX
:
282 /* state[0] = modelview, projection, texture, etc. */
283 /* state[1] = which texture matrix or program matrix */
284 /* state[2] = first row to fetch */
285 /* state[3] = last row to fetch */
286 /* state[4] = transpose, inverse or invtrans */
287 const GLmatrix
*matrix
;
288 const gl_state_index mat
= state
[0];
289 const GLuint index
= (GLuint
) state
[1];
290 const GLuint firstRow
= (GLuint
) state
[2];
291 const GLuint lastRow
= (GLuint
) state
[3];
292 const gl_state_index modifier
= state
[4];
295 ASSERT(firstRow
>= 0);
296 ASSERT(firstRow
< 4);
297 ASSERT(lastRow
>= 0);
299 if (mat
== STATE_MODELVIEW_MATRIX
) {
300 matrix
= ctx
->ModelviewMatrixStack
.Top
;
302 else if (mat
== STATE_PROJECTION_MATRIX
) {
303 matrix
= ctx
->ProjectionMatrixStack
.Top
;
305 else if (mat
== STATE_MVP_MATRIX
) {
306 matrix
= &ctx
->_ModelProjectMatrix
;
308 else if (mat
== STATE_TEXTURE_MATRIX
) {
309 matrix
= ctx
->TextureMatrixStack
[index
].Top
;
311 else if (mat
== STATE_PROGRAM_MATRIX
) {
312 matrix
= ctx
->ProgramMatrixStack
[index
].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_NORMAL_SCALE
:
399 ASSIGN_4V(value
, ctx
->_ModelViewInvScale
, 0, 0, 1);
401 case STATE_TEXRECT_SCALE
:
403 const int unit
= (int) state
[2];
404 const struct gl_texture_object
*texObj
405 = ctx
->Texture
.Unit
[unit
]._Current
;
407 struct gl_texture_image
*texImage
= texObj
->Image
[0][0];
408 ASSIGN_4V(value
, 1.0 / texImage
->Width
,
409 1.0 / texImage
->Height
,
414 case STATE_FOG_PARAMS_OPTIMIZED
:
415 /* for simpler per-vertex/pixel fog calcs. POW (for EXP/EXP2 fog)
416 * might be more expensive than EX2 on some hw, plus it needs
417 * another constant (e) anyway. Linear fog can now be done with a
419 * linear: fogcoord * -1/(end-start) + end/(end-start)
420 * exp: 2^-(density/ln(2) * fogcoord)
421 * exp2: 2^-((density/(ln(2)^2) * fogcoord)^2)
423 value
[0] = -1.0F
/ (ctx
->Fog
.End
- ctx
->Fog
.Start
);
424 value
[1] = ctx
->Fog
.End
/ (ctx
->Fog
.End
- ctx
->Fog
.Start
);
425 value
[2] = ctx
->Fog
.Density
* ONE_DIV_LN2
;
426 value
[3] = ctx
->Fog
.Density
* ONE_DIV_SQRT_LN2
;
428 case STATE_SPOT_DIR_NORMALIZED
: {
429 /* here, state[2] is the light number */
430 /* pre-normalize spot dir */
431 const GLuint ln
= (GLuint
) state
[2];
432 COPY_3V(value
, ctx
->Light
.Light
[ln
].EyeDirection
);
433 NORMALIZE_3FV(value
);
434 value
[3] = ctx
->Light
.Light
[ln
]._CosCutoff
;
438 /* unknown state indexes are silently ignored
439 * should be handled by the driver.
446 _mesa_problem(ctx
, "Invalid state in _mesa_fetch_state");
453 * Return a bitmask of the Mesa state flags (_NEW_* values) which would
454 * indicate that the given context state may have changed.
455 * The bitmask is used during validation to determine if we need to update
456 * vertex/fragment program parameters (like "state.material.color") when
457 * some GL state has changed.
460 _mesa_program_state_flags(const gl_state_index state
[STATE_LENGTH
])
465 case STATE_LIGHTMODEL_AMBIENT
:
466 case STATE_LIGHTMODEL_SCENECOLOR
:
467 case STATE_LIGHTPROD
:
471 case STATE_TEXENV_COLOR
:
474 case STATE_FOG_COLOR
:
475 case STATE_FOG_PARAMS
:
478 case STATE_CLIPPLANE
:
479 return _NEW_TRANSFORM
;
481 case STATE_POINT_SIZE
:
482 case STATE_POINT_ATTENUATION
:
485 case STATE_MODELVIEW_MATRIX
:
486 return _NEW_MODELVIEW
;
487 case STATE_PROJECTION_MATRIX
:
488 return _NEW_PROJECTION
;
489 case STATE_MVP_MATRIX
:
490 return _NEW_MODELVIEW
| _NEW_PROJECTION
;
491 case STATE_TEXTURE_MATRIX
:
492 return _NEW_TEXTURE_MATRIX
;
493 case STATE_PROGRAM_MATRIX
:
494 return _NEW_TRACK_MATRIX
;
496 case STATE_DEPTH_RANGE
:
497 return _NEW_VIEWPORT
;
499 case STATE_FRAGMENT_PROGRAM
:
500 case STATE_VERTEX_PROGRAM
:
503 case STATE_NORMAL_SCALE
:
504 return _NEW_MODELVIEW
;
508 case STATE_TEXRECT_SCALE
:
510 case STATE_FOG_PARAMS_OPTIMIZED
:
513 /* unknown state indexes are silently ignored and
514 * no flag set, since it is handled by the driver.
520 _mesa_problem(NULL
, "unexpected state[0] in make_state_flags()");
527 append(char *dst
, const char *src
)
538 append_token(char *dst
, gl_state_index k
)
542 append(dst
, "material");
545 append(dst
, "light");
547 case STATE_LIGHTMODEL_AMBIENT
:
548 append(dst
, "lightmodel.ambient");
550 case STATE_LIGHTMODEL_SCENECOLOR
:
552 case STATE_LIGHTPROD
:
553 append(dst
, "lightprod");
556 append(dst
, "texgen");
558 case STATE_FOG_COLOR
:
559 append(dst
, "fog.color");
561 case STATE_FOG_PARAMS
:
562 append(dst
, "fog.params");
564 case STATE_CLIPPLANE
:
567 case STATE_POINT_SIZE
:
568 append(dst
, "point.size");
570 case STATE_POINT_ATTENUATION
:
571 append(dst
, "point.attenuation");
573 case STATE_MODELVIEW_MATRIX
:
574 append(dst
, "matrix.modelview");
576 case STATE_PROJECTION_MATRIX
:
577 append(dst
, "matrix.projection");
579 case STATE_MVP_MATRIX
:
580 append(dst
, "matrix.mvp");
582 case STATE_TEXTURE_MATRIX
:
583 append(dst
, "matrix.texture");
585 case STATE_PROGRAM_MATRIX
:
586 append(dst
, "matrix.program");
588 case STATE_MATRIX_INVERSE
:
589 append(dst
, ".inverse");
591 case STATE_MATRIX_TRANSPOSE
:
592 append(dst
, ".transpose");
594 case STATE_MATRIX_INVTRANS
:
595 append(dst
, ".invtrans");
598 append(dst
, ".ambient");
601 append(dst
, ".diffuse");
604 append(dst
, ".specular");
607 append(dst
, ".emission");
609 case STATE_SHININESS
:
610 append(dst
, "lshininess");
612 case STATE_HALF_VECTOR
:
613 append(dst
, ".half");
616 append(dst
, ".position");
618 case STATE_ATTENUATION
:
619 append(dst
, ".attenuation");
621 case STATE_SPOT_DIRECTION
:
622 append(dst
, ".spot.direction");
624 case STATE_SPOT_CUTOFF
:
625 append(dst
, ".spot.cutoff");
627 case STATE_TEXGEN_EYE_S
:
628 append(dst
, "eye.s");
630 case STATE_TEXGEN_EYE_T
:
631 append(dst
, "eye.t");
633 case STATE_TEXGEN_EYE_R
:
634 append(dst
, "eye.r");
636 case STATE_TEXGEN_EYE_Q
:
637 append(dst
, "eye.q");
639 case STATE_TEXGEN_OBJECT_S
:
640 append(dst
, "object.s");
642 case STATE_TEXGEN_OBJECT_T
:
643 append(dst
, "object.t");
645 case STATE_TEXGEN_OBJECT_R
:
646 append(dst
, "object.r");
648 case STATE_TEXGEN_OBJECT_Q
:
649 append(dst
, "object.q");
651 case STATE_TEXENV_COLOR
:
652 append(dst
, "texenv");
654 case STATE_DEPTH_RANGE
:
655 append(dst
, "depth.range");
657 case STATE_VERTEX_PROGRAM
:
658 case STATE_FRAGMENT_PROGRAM
:
664 append(dst
, "local");
666 case STATE_NORMAL_SCALE
:
667 append(dst
, "normalScale");
670 case STATE_POSITION_NORMALIZED
:
671 append(dst
, "(internal)");
679 append_face(char *dst
, GLint face
)
682 append(dst
, "front.");
684 append(dst
, "back.");
688 append_index(char *dst
, GLint index
)
691 _mesa_sprintf(s
, "[%d]", index
);
696 * Make a string from the given state vector.
697 * For example, return "state.matrix.texture[2].inverse".
698 * Use _mesa_free() to deallocate the string.
701 _mesa_program_state_string(const gl_state_index state
[STATE_LENGTH
])
706 append(str
, "state.");
707 append_token(str
, (gl_state_index
) state
[0]);
711 append_face(str
, state
[1]);
712 append_token(str
, (gl_state_index
) state
[2]);
715 append_index(str
, state
[1]); /* light number [i]. */
716 append_token(str
, (gl_state_index
) state
[2]); /* coefficients */
718 case STATE_LIGHTMODEL_AMBIENT
:
719 append(str
, "lightmodel.ambient");
721 case STATE_LIGHTMODEL_SCENECOLOR
:
723 append(str
, "lightmodel.front.scenecolor");
726 append(str
, "lightmodel.back.scenecolor");
729 case STATE_LIGHTPROD
:
730 append_index(str
, state
[1]); /* light number [i]. */
731 append_face(str
, state
[2]);
732 append_token(str
, (gl_state_index
) state
[3]);
735 append_index(str
, state
[1]); /* tex unit [i] */
736 append_token(str
, (gl_state_index
) state
[2]); /* plane coef */
738 case STATE_TEXENV_COLOR
:
739 append_index(str
, state
[1]); /* tex unit [i] */
740 append(str
, "color");
742 case STATE_CLIPPLANE
:
743 append_index(str
, state
[1]); /* plane [i] */
744 append(str
, ".plane");
746 case STATE_MODELVIEW_MATRIX
:
747 case STATE_PROJECTION_MATRIX
:
748 case STATE_MVP_MATRIX
:
749 case STATE_TEXTURE_MATRIX
:
750 case STATE_PROGRAM_MATRIX
:
752 /* state[0] = modelview, projection, texture, etc. */
753 /* state[1] = which texture matrix or program matrix */
754 /* state[2] = first row to fetch */
755 /* state[3] = last row to fetch */
756 /* state[4] = transpose, inverse or invtrans */
757 const gl_state_index mat
= (gl_state_index
) state
[0];
758 const GLuint index
= (GLuint
) state
[1];
759 const GLuint firstRow
= (GLuint
) state
[2];
760 const GLuint lastRow
= (GLuint
) state
[3];
761 const gl_state_index modifier
= (gl_state_index
) state
[4];
763 mat
== STATE_TEXTURE_MATRIX
||
764 mat
== STATE_PROGRAM_MATRIX
)
765 append_index(str
, index
);
767 append_token(str
, modifier
);
768 if (firstRow
== lastRow
)
769 _mesa_sprintf(tmp
, ".row[%d]", firstRow
);
771 _mesa_sprintf(tmp
, ".row[%d..%d]", firstRow
, lastRow
);
775 case STATE_POINT_SIZE
:
777 case STATE_POINT_ATTENUATION
:
779 case STATE_FOG_PARAMS
:
781 case STATE_FOG_COLOR
:
783 case STATE_DEPTH_RANGE
:
785 case STATE_FRAGMENT_PROGRAM
:
786 case STATE_VERTEX_PROGRAM
:
787 /* state[1] = {STATE_ENV, STATE_LOCAL} */
788 /* state[2] = parameter index */
789 append_token(str
, (gl_state_index
) state
[1]);
790 append_index(str
, state
[2]);
795 _mesa_problem(NULL
, "Invalid state in _mesa_program_state_string");
799 return _mesa_strdup(str
);
804 * Loop over all the parameters in a parameter list. If the parameter
805 * is a GL state reference, look up the current value of that state
806 * variable and put it into the parameter's Value[4] array.
807 * This would be called at glBegin time when using a fragment program.
810 _mesa_load_state_parameters(GLcontext
*ctx
,
811 struct gl_program_parameter_list
*paramList
)
818 for (i
= 0; i
< paramList
->NumParameters
; i
++) {
819 if (paramList
->Parameters
[i
].Type
== PROGRAM_STATE_VAR
) {
820 _mesa_fetch_state(ctx
,
821 (gl_state_index
*) paramList
->Parameters
[i
].StateIndexes
,
822 paramList
->ParameterValues
[i
]);