2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2006 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
;
121 GLfloat eye_z
[] = {0, 0, 1};
123 /* Compute infinite half angle vector:
124 * half-vector = light_position + (0, 0, 1)
125 * and then normalize. w = 0
127 * light.EyePosition.w should be 0 for infinite lights.
129 ADD_3V(value
, eye_z
, ctx
->Light
.Light
[ln
].EyePosition
);
130 NORMALIZE_3FV(value
);
134 case STATE_POSITION_NORMALIZED
:
135 COPY_4V(value
, ctx
->Light
.Light
[ln
].EyePosition
);
136 NORMALIZE_3FV( value
);
139 _mesa_problem(ctx
, "Invalid light state in fetch_state");
143 case STATE_LIGHTMODEL_AMBIENT
:
144 COPY_4V(value
, ctx
->Light
.Model
.Ambient
);
146 case STATE_LIGHTMODEL_SCENECOLOR
:
150 for (i
= 0; i
< 3; i
++) {
151 value
[i
] = ctx
->Light
.Model
.Ambient
[i
]
152 * ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_AMBIENT
][i
]
153 + ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_EMISSION
][i
];
155 value
[3] = ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_DIFFUSE
][3];
160 for (i
= 0; i
< 3; i
++) {
161 value
[i
] = ctx
->Light
.Model
.Ambient
[i
]
162 * ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_BACK_AMBIENT
][i
]
163 + ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_BACK_EMISSION
][i
];
165 value
[3] = ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_BACK_DIFFUSE
][3];
168 case STATE_LIGHTPROD
:
170 const GLuint ln
= (GLuint
) state
[1];
171 const GLuint face
= (GLuint
) state
[2];
173 ASSERT(face
== 0 || face
== 1);
176 for (i
= 0; i
< 3; i
++) {
177 value
[i
] = ctx
->Light
.Light
[ln
].Ambient
[i
] *
178 ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_AMBIENT
+face
][i
];
180 /* [3] = material alpha */
181 value
[3] = ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_DIFFUSE
+face
][3];
184 for (i
= 0; i
< 3; i
++) {
185 value
[i
] = ctx
->Light
.Light
[ln
].Diffuse
[i
] *
186 ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_DIFFUSE
+face
][i
];
188 /* [3] = material alpha */
189 value
[3] = ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_DIFFUSE
+face
][3];
192 for (i
= 0; i
< 3; i
++) {
193 value
[i
] = ctx
->Light
.Light
[ln
].Specular
[i
] *
194 ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_SPECULAR
+face
][i
];
196 /* [3] = material alpha */
197 value
[3] = ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_DIFFUSE
+face
][3];
200 _mesa_problem(ctx
, "Invalid lightprod state in fetch_state");
206 /* state[1] is the texture unit */
207 const GLuint unit
= (GLuint
) state
[1];
208 /* state[2] is the texgen attribute */
210 case STATE_TEXGEN_EYE_S
:
211 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].EyePlaneS
);
213 case STATE_TEXGEN_EYE_T
:
214 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].EyePlaneT
);
216 case STATE_TEXGEN_EYE_R
:
217 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].EyePlaneR
);
219 case STATE_TEXGEN_EYE_Q
:
220 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].EyePlaneQ
);
222 case STATE_TEXGEN_OBJECT_S
:
223 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].ObjectPlaneS
);
225 case STATE_TEXGEN_OBJECT_T
:
226 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].ObjectPlaneT
);
228 case STATE_TEXGEN_OBJECT_R
:
229 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].ObjectPlaneR
);
231 case STATE_TEXGEN_OBJECT_Q
:
232 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].ObjectPlaneQ
);
235 _mesa_problem(ctx
, "Invalid texgen state in fetch_state");
239 case STATE_TEXENV_COLOR
:
241 /* state[1] is the texture unit */
242 const GLuint unit
= (GLuint
) state
[1];
243 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].EnvColor
);
246 case STATE_FOG_COLOR
:
247 COPY_4V(value
, ctx
->Fog
.Color
);
249 case STATE_FOG_PARAMS
:
250 value
[0] = ctx
->Fog
.Density
;
251 value
[1] = ctx
->Fog
.Start
;
252 value
[2] = ctx
->Fog
.End
;
253 value
[3] = 1.0F
/ (ctx
->Fog
.End
- ctx
->Fog
.Start
);
255 case STATE_CLIPPLANE
:
257 const GLuint plane
= (GLuint
) state
[1];
258 COPY_4V(value
, ctx
->Transform
.EyeUserPlane
[plane
]);
261 case STATE_POINT_SIZE
:
262 value
[0] = ctx
->Point
.Size
;
263 value
[1] = ctx
->Point
.MinSize
;
264 value
[2] = ctx
->Point
.MaxSize
;
265 value
[3] = ctx
->Point
.Threshold
;
267 case STATE_POINT_ATTENUATION
:
268 value
[0] = ctx
->Point
.Params
[0];
269 value
[1] = ctx
->Point
.Params
[1];
270 value
[2] = ctx
->Point
.Params
[2];
275 /* state[1] = modelview, projection, texture, etc. */
276 /* state[2] = which texture matrix or program matrix */
277 /* state[3] = first row to fetch */
278 /* state[4] = last row to fetch */
279 /* state[5] = transpose, inverse or invtrans */
281 const GLmatrix
*matrix
;
282 const gl_state_index mat
= state
[1];
283 const GLuint index
= (GLuint
) state
[2];
284 const GLuint firstRow
= (GLuint
) state
[3];
285 const GLuint lastRow
= (GLuint
) state
[4];
286 const gl_state_index modifier
= state
[5];
289 if (mat
== STATE_MODELVIEW
) {
290 matrix
= ctx
->ModelviewMatrixStack
.Top
;
292 else if (mat
== STATE_PROJECTION
) {
293 matrix
= ctx
->ProjectionMatrixStack
.Top
;
295 else if (mat
== STATE_MVP
) {
296 matrix
= &ctx
->_ModelProjectMatrix
;
298 else if (mat
== STATE_TEXTURE
) {
299 matrix
= ctx
->TextureMatrixStack
[index
].Top
;
301 else if (mat
== STATE_PROGRAM
) {
302 matrix
= ctx
->ProgramMatrixStack
[index
].Top
;
305 _mesa_problem(ctx
, "Bad matrix name in _mesa_fetch_state()");
308 if (modifier
== STATE_MATRIX_INVERSE
||
309 modifier
== STATE_MATRIX_INVTRANS
) {
310 /* Be sure inverse is up to date:
312 _math_matrix_alloc_inv( (GLmatrix
*) matrix
);
313 _math_matrix_analyse( (GLmatrix
*) matrix
);
319 if (modifier
== STATE_MATRIX_TRANSPOSE
||
320 modifier
== STATE_MATRIX_INVTRANS
) {
321 for (i
= 0, row
= firstRow
; row
<= lastRow
; row
++) {
322 value
[i
++] = m
[row
* 4 + 0];
323 value
[i
++] = m
[row
* 4 + 1];
324 value
[i
++] = m
[row
* 4 + 2];
325 value
[i
++] = m
[row
* 4 + 3];
329 for (i
= 0, row
= firstRow
; row
<= lastRow
; row
++) {
330 value
[i
++] = m
[row
+ 0];
331 value
[i
++] = m
[row
+ 4];
332 value
[i
++] = m
[row
+ 8];
333 value
[i
++] = m
[row
+ 12];
338 case STATE_DEPTH_RANGE
:
339 value
[0] = ctx
->Viewport
.Near
; /* near */
340 value
[1] = ctx
->Viewport
.Far
; /* far */
341 value
[2] = ctx
->Viewport
.Far
- ctx
->Viewport
.Near
; /* far - near */
344 case STATE_FRAGMENT_PROGRAM
:
346 /* state[1] = {STATE_ENV, STATE_LOCAL} */
347 /* state[2] = parameter index */
348 const int idx
= (int) state
[2];
351 COPY_4V(value
, ctx
->FragmentProgram
.Parameters
[idx
]);
354 COPY_4V(value
, ctx
->FragmentProgram
.Current
->Base
.LocalParams
[idx
]);
357 _mesa_problem(ctx
, "Bad state switch in _mesa_fetch_state()");
363 case STATE_VERTEX_PROGRAM
:
365 /* state[1] = {STATE_ENV, STATE_LOCAL} */
366 /* state[2] = parameter index */
367 const int idx
= (int) state
[2];
370 COPY_4V(value
, ctx
->VertexProgram
.Parameters
[idx
]);
373 COPY_4V(value
, ctx
->VertexProgram
.Current
->Base
.LocalParams
[idx
]);
376 _mesa_problem(ctx
, "Bad state switch in _mesa_fetch_state()");
385 case STATE_NORMAL_SCALE
:
386 ASSIGN_4V(value
, ctx
->_ModelViewInvScale
, 0, 0, 1);
388 case STATE_TEXRECT_SCALE
: {
389 const int unit
= (int) state
[2];
390 const struct gl_texture_object
*texObj
= ctx
->Texture
.Unit
[unit
]._Current
;
392 struct gl_texture_image
*texImage
= texObj
->Image
[0][0];
393 ASSIGN_4V(value
, 1.0 / texImage
->Width
, 1.0 / texImage
->Height
, 0, 1);
398 /* unknown state indexes are silently ignored
399 * should be handled by the driver.
407 _mesa_problem(ctx
, "Invalid state in _mesa_fetch_state");
414 * Return a bitmask of the Mesa state flags (_NEW_* values) which would
415 * indicate that the given context state may have changed.
416 * The bitmask is used during validation to determine if we need to update
417 * vertex/fragment program parameters (like "state.material.color") when
418 * some GL state has changed.
421 _mesa_program_state_flags(const GLint state
[])
426 case STATE_LIGHTMODEL_AMBIENT
:
427 case STATE_LIGHTMODEL_SCENECOLOR
:
428 case STATE_LIGHTPROD
:
432 case STATE_TEXENV_COLOR
:
435 case STATE_FOG_COLOR
:
436 case STATE_FOG_PARAMS
:
439 case STATE_CLIPPLANE
:
440 return _NEW_TRANSFORM
;
442 case STATE_POINT_SIZE
:
443 case STATE_POINT_ATTENUATION
:
448 case STATE_MODELVIEW
:
449 return _NEW_MODELVIEW
;
450 case STATE_PROJECTION
:
451 return _NEW_PROJECTION
;
453 return _NEW_MODELVIEW
| _NEW_PROJECTION
;
455 return _NEW_TEXTURE_MATRIX
;
457 return _NEW_TRACK_MATRIX
;
460 "unexpected matrix in _mesa_program_state_flags()");
464 case STATE_DEPTH_RANGE
:
465 return _NEW_VIEWPORT
;
467 case STATE_FRAGMENT_PROGRAM
:
468 case STATE_VERTEX_PROGRAM
:
473 case STATE_NORMAL_SCALE
:
474 return _NEW_MODELVIEW
;
475 case STATE_TEXRECT_SCALE
:
478 /* unknown state indexes are silently ignored and
479 * no flag set, since it is handled by the driver.
485 _mesa_problem(NULL
, "unexpected state[0] in make_state_flags()");
492 append(char *dst
, const char *src
)
503 append_token(char *dst
, gl_state_index k
)
507 append(dst
, "material.");
510 append(dst
, "light");
512 case STATE_LIGHTMODEL_AMBIENT
:
513 append(dst
, "lightmodel.ambient");
515 case STATE_LIGHTMODEL_SCENECOLOR
:
517 case STATE_LIGHTPROD
:
518 append(dst
, "lightprod");
521 append(dst
, "texgen");
523 case STATE_FOG_COLOR
:
524 append(dst
, "fog.color");
526 case STATE_FOG_PARAMS
:
527 append(dst
, "fog.params");
529 case STATE_CLIPPLANE
:
532 case STATE_POINT_SIZE
:
533 append(dst
, "point.size");
535 case STATE_POINT_ATTENUATION
:
536 append(dst
, "point.attenuation");
539 append(dst
, "matrix.");
541 case STATE_MODELVIEW
:
542 append(dst
, "modelview");
544 case STATE_PROJECTION
:
545 append(dst
, "projection");
551 append(dst
, "texture");
554 append(dst
, "program");
556 case STATE_MATRIX_INVERSE
:
557 append(dst
, ".inverse");
559 case STATE_MATRIX_TRANSPOSE
:
560 append(dst
, ".transpose");
562 case STATE_MATRIX_INVTRANS
:
563 append(dst
, ".invtrans");
566 append(dst
, "ambient");
569 append(dst
, "diffuse");
572 append(dst
, "specular");
575 append(dst
, "emission");
577 case STATE_SHININESS
:
578 append(dst
, "shininess");
584 append(dst
, ".position");
586 case STATE_ATTENUATION
:
587 append(dst
, ".attenuation");
589 case STATE_SPOT_DIRECTION
:
590 append(dst
, ".spot.direction");
592 case STATE_TEXGEN_EYE_S
:
593 append(dst
, "eye.s");
595 case STATE_TEXGEN_EYE_T
:
596 append(dst
, "eye.t");
598 case STATE_TEXGEN_EYE_R
:
599 append(dst
, "eye.r");
601 case STATE_TEXGEN_EYE_Q
:
602 append(dst
, "eye.q");
604 case STATE_TEXGEN_OBJECT_S
:
605 append(dst
, "object.s");
607 case STATE_TEXGEN_OBJECT_T
:
608 append(dst
, "object.t");
610 case STATE_TEXGEN_OBJECT_R
:
611 append(dst
, "object.r");
613 case STATE_TEXGEN_OBJECT_Q
:
614 append(dst
, "object.q");
616 case STATE_TEXENV_COLOR
:
617 append(dst
, "texenv");
619 case STATE_DEPTH_RANGE
:
620 append(dst
, "depth.range");
622 case STATE_VERTEX_PROGRAM
:
623 case STATE_FRAGMENT_PROGRAM
:
629 append(dst
, "local");
632 case STATE_NORMAL_SCALE
:
633 case STATE_POSITION_NORMALIZED
:
634 append(dst
, "(internal)");
642 append_face(char *dst
, GLint face
)
645 append(dst
, "front.");
647 append(dst
, "back.");
651 append_index(char *dst
, GLint index
)
654 _mesa_sprintf(s
, "[%d].", index
);
659 * Make a string from the given state vector.
660 * For example, return "state.matrix.texture[2].inverse".
661 * Use _mesa_free() to deallocate the string.
664 _mesa_program_state_string(const GLint state
[6])
669 append(str
, "state.");
670 append_token(str
, (gl_state_index
) state
[0]);
674 append_face(str
, state
[1]);
675 append_token(str
, (gl_state_index
) state
[2]);
678 append(str
, "light");
679 append_index(str
, state
[1]); /* light number [i]. */
680 append_token(str
, (gl_state_index
) state
[2]); /* coefficients */
682 case STATE_LIGHTMODEL_AMBIENT
:
683 append(str
, "lightmodel.ambient");
685 case STATE_LIGHTMODEL_SCENECOLOR
:
687 append(str
, "lightmodel.front.scenecolor");
690 append(str
, "lightmodel.back.scenecolor");
693 case STATE_LIGHTPROD
:
694 append_index(str
, state
[1]); /* light number [i]. */
695 append_face(str
, state
[2]);
696 append_token(str
, (gl_state_index
) state
[3]);
699 append_index(str
, state
[1]); /* tex unit [i] */
700 append_token(str
, (gl_state_index
) state
[2]); /* plane coef */
702 case STATE_TEXENV_COLOR
:
703 append_index(str
, state
[1]); /* tex unit [i] */
704 append(str
, "color");
706 case STATE_FOG_COLOR
:
707 case STATE_FOG_PARAMS
:
709 case STATE_CLIPPLANE
:
710 append_index(str
, state
[1]); /* plane [i] */
711 append(str
, "plane");
713 case STATE_POINT_SIZE
:
714 case STATE_POINT_ATTENUATION
:
718 /* state[1] = modelview, projection, texture, etc. */
719 /* state[2] = which texture matrix or program matrix */
720 /* state[3] = first row to fetch */
721 /* state[4] = last row to fetch */
722 /* state[5] = transpose, inverse or invtrans */
723 const gl_state_index mat
= (gl_state_index
) state
[1];
724 const GLuint index
= (GLuint
) state
[2];
725 const GLuint firstRow
= (GLuint
) state
[3];
726 const GLuint lastRow
= (GLuint
) state
[4];
727 const gl_state_index modifier
= (gl_state_index
) state
[5];
728 append_token(str
, mat
);
730 append_index(str
, index
);
732 append_token(str
, modifier
);
733 if (firstRow
== lastRow
)
734 _mesa_sprintf(tmp
, ".row[%d]", firstRow
);
736 _mesa_sprintf(tmp
, ".row[%d..%d]", firstRow
, lastRow
);
740 case STATE_DEPTH_RANGE
:
742 case STATE_FRAGMENT_PROGRAM
:
743 case STATE_VERTEX_PROGRAM
:
744 /* state[1] = {STATE_ENV, STATE_LOCAL} */
745 /* state[2] = parameter index */
746 append_token(str
, (gl_state_index
) state
[1]);
747 append_index(str
, state
[2]);
752 _mesa_problem(NULL
, "Invalid state in _mesa_program_state_string");
756 return _mesa_strdup(str
);
761 * Loop over all the parameters in a parameter list. If the parameter
762 * is a GL state reference, look up the current value of that state
763 * variable and put it into the parameter's Value[4] array.
764 * This would be called at glBegin time when using a fragment program.
767 _mesa_load_state_parameters(GLcontext
*ctx
,
768 struct gl_program_parameter_list
*paramList
)
775 for (i
= 0; i
< paramList
->NumParameters
; i
++) {
776 if (paramList
->Parameters
[i
].Type
== PROGRAM_STATE_VAR
) {
777 _mesa_fetch_state(ctx
,
778 paramList
->Parameters
[i
].StateIndexes
,
779 paramList
->ParameterValues
[i
]);