2 * Mesa 3-D graphics library
4 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * 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/blend.h"
35 #include "main/imports.h"
36 #include "main/macros.h"
37 #include "main/mtypes.h"
38 #include "main/fbobject.h"
39 #include "prog_statevars.h"
40 #include "prog_parameter.h"
41 #include "main/samplerobj.h"
45 * Use the list of tokens in the state[] array to find global GL state
46 * and return it in <value>. Usually, four values are returned in <value>
47 * but matrix queries may return as many as 16 values.
48 * This function is used for ARB vertex/fragment programs.
49 * The program parser will produce the state[] values.
52 _mesa_fetch_state(struct gl_context
*ctx
, const gl_state_index state
[],
58 /* state[1] is either 0=front or 1=back side */
59 const GLuint face
= (GLuint
) state
[1];
60 const struct gl_material
*mat
= &ctx
->Light
.Material
;
61 ASSERT(face
== 0 || face
== 1);
62 /* we rely on tokens numbered so that _BACK_ == _FRONT_+ 1 */
63 ASSERT(MAT_ATTRIB_FRONT_AMBIENT
+ 1 == MAT_ATTRIB_BACK_AMBIENT
);
64 /* XXX we could get rid of this switch entirely with a little
65 * work in arbprogparse.c's parse_state_single_item().
67 /* state[2] is the material attribute */
70 COPY_4V(value
, mat
->Attrib
[MAT_ATTRIB_FRONT_AMBIENT
+ face
]);
73 COPY_4V(value
, mat
->Attrib
[MAT_ATTRIB_FRONT_DIFFUSE
+ face
]);
76 COPY_4V(value
, mat
->Attrib
[MAT_ATTRIB_FRONT_SPECULAR
+ face
]);
79 COPY_4V(value
, mat
->Attrib
[MAT_ATTRIB_FRONT_EMISSION
+ face
]);
82 value
[0] = mat
->Attrib
[MAT_ATTRIB_FRONT_SHININESS
+ face
][0];
88 _mesa_problem(ctx
, "Invalid material state in fetch_state");
94 /* state[1] is the light number */
95 const GLuint ln
= (GLuint
) state
[1];
96 /* state[2] is the light attribute */
99 COPY_4V(value
, ctx
->Light
.Light
[ln
].Ambient
);
102 COPY_4V(value
, ctx
->Light
.Light
[ln
].Diffuse
);
105 COPY_4V(value
, ctx
->Light
.Light
[ln
].Specular
);
108 COPY_4V(value
, ctx
->Light
.Light
[ln
].EyePosition
);
110 case STATE_ATTENUATION
:
111 value
[0] = ctx
->Light
.Light
[ln
].ConstantAttenuation
;
112 value
[1] = ctx
->Light
.Light
[ln
].LinearAttenuation
;
113 value
[2] = ctx
->Light
.Light
[ln
].QuadraticAttenuation
;
114 value
[3] = ctx
->Light
.Light
[ln
].SpotExponent
;
116 case STATE_SPOT_DIRECTION
:
117 COPY_3V(value
, ctx
->Light
.Light
[ln
].SpotDirection
);
118 value
[3] = ctx
->Light
.Light
[ln
]._CosCutoff
;
120 case STATE_SPOT_CUTOFF
:
121 value
[0] = ctx
->Light
.Light
[ln
].SpotCutoff
;
123 case STATE_HALF_VECTOR
:
125 static const GLfloat eye_z
[] = {0, 0, 1};
127 /* Compute infinite half angle vector:
128 * halfVector = normalize(normalize(lightPos) + (0, 0, 1))
129 * light.EyePosition.w should be 0 for infinite lights.
131 COPY_3V(p
, ctx
->Light
.Light
[ln
].EyePosition
);
133 ADD_3V(value
, p
, eye_z
);
134 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_AMBIENT
+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_SPECULAR
+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
].GenS
.EyePlane
);
213 case STATE_TEXGEN_EYE_T
:
214 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].GenT
.EyePlane
);
216 case STATE_TEXGEN_EYE_R
:
217 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].GenR
.EyePlane
);
219 case STATE_TEXGEN_EYE_Q
:
220 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].GenQ
.EyePlane
);
222 case STATE_TEXGEN_OBJECT_S
:
223 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].GenS
.ObjectPlane
);
225 case STATE_TEXGEN_OBJECT_T
:
226 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].GenT
.ObjectPlane
);
228 case STATE_TEXGEN_OBJECT_R
:
229 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].GenR
.ObjectPlane
);
231 case STATE_TEXGEN_OBJECT_Q
:
232 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].GenQ
.ObjectPlane
);
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 if (_mesa_get_clamp_fragment_color(ctx
))
244 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].EnvColor
);
246 COPY_4V(value
, ctx
->Texture
.Unit
[unit
].EnvColorUnclamped
);
249 case STATE_FOG_COLOR
:
250 if (_mesa_get_clamp_fragment_color(ctx
))
251 COPY_4V(value
, ctx
->Fog
.Color
);
253 COPY_4V(value
, ctx
->Fog
.ColorUnclamped
);
255 case STATE_FOG_PARAMS
:
256 value
[0] = ctx
->Fog
.Density
;
257 value
[1] = ctx
->Fog
.Start
;
258 value
[2] = ctx
->Fog
.End
;
259 value
[3] = 1.0f
/ (ctx
->Fog
.End
- ctx
->Fog
.Start
);
261 case STATE_CLIPPLANE
:
263 const GLuint plane
= (GLuint
) state
[1];
264 COPY_4V(value
, ctx
->Transform
.EyeUserPlane
[plane
]);
267 case STATE_POINT_SIZE
:
268 value
[0] = ctx
->Point
.Size
;
269 value
[1] = ctx
->Point
.MinSize
;
270 value
[2] = ctx
->Point
.MaxSize
;
271 value
[3] = ctx
->Point
.Threshold
;
273 case STATE_POINT_ATTENUATION
:
274 value
[0] = ctx
->Point
.Params
[0];
275 value
[1] = ctx
->Point
.Params
[1];
276 value
[2] = ctx
->Point
.Params
[2];
279 case STATE_MODELVIEW_MATRIX
:
280 case STATE_PROJECTION_MATRIX
:
281 case STATE_MVP_MATRIX
:
282 case STATE_TEXTURE_MATRIX
:
283 case STATE_PROGRAM_MATRIX
:
285 /* state[0] = modelview, projection, texture, etc. */
286 /* state[1] = which texture matrix or program matrix */
287 /* state[2] = first row to fetch */
288 /* state[3] = last row to fetch */
289 /* state[4] = transpose, inverse or invtrans */
290 const GLmatrix
*matrix
;
291 const gl_state_index mat
= state
[0];
292 const GLuint index
= (GLuint
) state
[1];
293 const GLuint firstRow
= (GLuint
) state
[2];
294 const GLuint lastRow
= (GLuint
) state
[3];
295 const gl_state_index modifier
= state
[4];
298 ASSERT(firstRow
>= 0);
299 ASSERT(firstRow
< 4);
300 ASSERT(lastRow
>= 0);
302 if (mat
== STATE_MODELVIEW_MATRIX
) {
303 matrix
= ctx
->ModelviewMatrixStack
.Top
;
305 else if (mat
== STATE_PROJECTION_MATRIX
) {
306 matrix
= ctx
->ProjectionMatrixStack
.Top
;
308 else if (mat
== STATE_MVP_MATRIX
) {
309 matrix
= &ctx
->_ModelProjectMatrix
;
311 else if (mat
== STATE_TEXTURE_MATRIX
) {
312 ASSERT(index
< Elements(ctx
->TextureMatrixStack
));
313 matrix
= ctx
->TextureMatrixStack
[index
].Top
;
315 else if (mat
== STATE_PROGRAM_MATRIX
) {
316 ASSERT(index
< Elements(ctx
->ProgramMatrixStack
));
317 matrix
= ctx
->ProgramMatrixStack
[index
].Top
;
320 _mesa_problem(ctx
, "Bad matrix name in _mesa_fetch_state()");
323 if (modifier
== STATE_MATRIX_INVERSE
||
324 modifier
== STATE_MATRIX_INVTRANS
) {
325 /* Be sure inverse is up to date:
327 _math_matrix_analyse( (GLmatrix
*) matrix
);
333 if (modifier
== STATE_MATRIX_TRANSPOSE
||
334 modifier
== STATE_MATRIX_INVTRANS
) {
335 for (i
= 0, row
= firstRow
; row
<= lastRow
; row
++) {
336 value
[i
++] = m
[row
* 4 + 0];
337 value
[i
++] = m
[row
* 4 + 1];
338 value
[i
++] = m
[row
* 4 + 2];
339 value
[i
++] = m
[row
* 4 + 3];
343 for (i
= 0, row
= firstRow
; row
<= lastRow
; row
++) {
344 value
[i
++] = m
[row
+ 0];
345 value
[i
++] = m
[row
+ 4];
346 value
[i
++] = m
[row
+ 8];
347 value
[i
++] = m
[row
+ 12];
352 case STATE_NUM_SAMPLES
:
353 ((int *)value
)[0] = ctx
->DrawBuffer
->Visual
.samples
;
355 case STATE_DEPTH_RANGE
:
356 value
[0] = ctx
->Viewport
.Near
; /* near */
357 value
[1] = ctx
->Viewport
.Far
; /* far */
358 value
[2] = ctx
->Viewport
.Far
- ctx
->Viewport
.Near
; /* far - near */
361 case STATE_FRAGMENT_PROGRAM
:
363 /* state[1] = {STATE_ENV, STATE_LOCAL} */
364 /* state[2] = parameter index */
365 const int idx
= (int) state
[2];
368 COPY_4V(value
, ctx
->FragmentProgram
.Parameters
[idx
]);
371 COPY_4V(value
, ctx
->FragmentProgram
.Current
->Base
.LocalParams
[idx
]);
374 _mesa_problem(ctx
, "Bad state switch in _mesa_fetch_state()");
380 case STATE_VERTEX_PROGRAM
:
382 /* state[1] = {STATE_ENV, STATE_LOCAL} */
383 /* state[2] = parameter index */
384 const int idx
= (int) state
[2];
387 COPY_4V(value
, ctx
->VertexProgram
.Parameters
[idx
]);
390 COPY_4V(value
, ctx
->VertexProgram
.Current
->Base
.LocalParams
[idx
]);
393 _mesa_problem(ctx
, "Bad state switch in _mesa_fetch_state()");
399 case STATE_NORMAL_SCALE
:
400 ASSIGN_4V(value
, ctx
->_ModelViewInvScale
, 0, 0, 1);
405 case STATE_CURRENT_ATTRIB
:
407 const GLuint idx
= (GLuint
) state
[2];
408 COPY_4V(value
, ctx
->Current
.Attrib
[idx
]);
412 case STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED
:
414 const GLuint idx
= (GLuint
) state
[2];
415 if(ctx
->Light
._ClampVertexColor
&&
416 (idx
== VERT_ATTRIB_COLOR0
||
417 idx
== VERT_ATTRIB_COLOR1
)) {
418 value
[0] = CLAMP(ctx
->Current
.Attrib
[idx
][0], 0.0f
, 1.0f
);
419 value
[1] = CLAMP(ctx
->Current
.Attrib
[idx
][1], 0.0f
, 1.0f
);
420 value
[2] = CLAMP(ctx
->Current
.Attrib
[idx
][2], 0.0f
, 1.0f
);
421 value
[3] = CLAMP(ctx
->Current
.Attrib
[idx
][3], 0.0f
, 1.0f
);
424 COPY_4V(value
, ctx
->Current
.Attrib
[idx
]);
428 case STATE_NORMAL_SCALE
:
430 ctx
->_ModelViewInvScale
,
431 ctx
->_ModelViewInvScale
,
432 ctx
->_ModelViewInvScale
,
436 case STATE_TEXRECT_SCALE
:
437 /* Value = { 1/texWidth, 1/texHeight, 0, 1 }.
438 * Used to convert unnormalized texcoords to normalized texcoords.
441 const int unit
= (int) state
[2];
442 const struct gl_texture_object
*texObj
443 = ctx
->Texture
.Unit
[unit
]._Current
;
445 struct gl_texture_image
*texImage
= texObj
->Image
[0][0];
447 (GLfloat
) (1.0 / texImage
->Width
),
448 (GLfloat
) (1.0 / texImage
->Height
),
454 case STATE_FOG_PARAMS_OPTIMIZED
:
455 /* for simpler per-vertex/pixel fog calcs. POW (for EXP/EXP2 fog)
456 * might be more expensive than EX2 on some hw, plus it needs
457 * another constant (e) anyway. Linear fog can now be done with a
459 * linear: fogcoord * -1/(end-start) + end/(end-start)
460 * exp: 2^-(density/ln(2) * fogcoord)
461 * exp2: 2^-((density/(ln(2)^2) * fogcoord)^2)
463 value
[0] = (ctx
->Fog
.End
== ctx
->Fog
.Start
)
464 ? 1.0f
: (GLfloat
)(-1.0F
/ (ctx
->Fog
.End
- ctx
->Fog
.Start
));
465 value
[1] = ctx
->Fog
.End
* -value
[0];
466 value
[2] = (GLfloat
)(ctx
->Fog
.Density
* M_LOG2E
); /* M_LOG2E == 1/ln(2) */
467 value
[3] = (GLfloat
)(ctx
->Fog
.Density
* ONE_DIV_SQRT_LN2
);
470 case STATE_POINT_SIZE_CLAMPED
:
472 /* this includes implementation dependent limits, to avoid
473 * another potentially necessary clamp.
474 * Note: for sprites, point smooth (point AA) is ignored
475 * and we'll clamp to MinPointSizeAA and MaxPointSize, because we
476 * expect drivers will want to say their minimum for AA size is 0.0
477 * but for non-AA it's 1.0 (because normal points with size below 1.0
478 * need to get rounded up to 1.0, hence never disappear). GL does
479 * not specify max clamp size for sprites, other than it needs to be
480 * at least as large as max AA size, hence use non-AA size there.
484 if (ctx
->Point
.PointSprite
) {
485 minImplSize
= ctx
->Const
.MinPointSizeAA
;
486 maxImplSize
= ctx
->Const
.MaxPointSize
;
488 else if (ctx
->Point
.SmoothFlag
|| ctx
->Multisample
._Enabled
) {
489 minImplSize
= ctx
->Const
.MinPointSizeAA
;
490 maxImplSize
= ctx
->Const
.MaxPointSizeAA
;
493 minImplSize
= ctx
->Const
.MinPointSize
;
494 maxImplSize
= ctx
->Const
.MaxPointSize
;
496 value
[0] = ctx
->Point
.Size
;
497 value
[1] = ctx
->Point
.MinSize
>= minImplSize
? ctx
->Point
.MinSize
: minImplSize
;
498 value
[2] = ctx
->Point
.MaxSize
<= maxImplSize
? ctx
->Point
.MaxSize
: maxImplSize
;
499 value
[3] = ctx
->Point
.Threshold
;
502 case STATE_LIGHT_SPOT_DIR_NORMALIZED
:
504 /* here, state[2] is the light number */
505 /* pre-normalize spot dir */
506 const GLuint ln
= (GLuint
) state
[2];
507 COPY_3V(value
, ctx
->Light
.Light
[ln
]._NormSpotDirection
);
508 value
[3] = ctx
->Light
.Light
[ln
]._CosCutoff
;
512 case STATE_LIGHT_POSITION
:
514 const GLuint ln
= (GLuint
) state
[2];
515 COPY_4V(value
, ctx
->Light
.Light
[ln
]._Position
);
519 case STATE_LIGHT_POSITION_NORMALIZED
:
521 const GLuint ln
= (GLuint
) state
[2];
522 COPY_4V(value
, ctx
->Light
.Light
[ln
]._Position
);
523 NORMALIZE_3FV( value
);
527 case STATE_LIGHT_HALF_VECTOR
:
529 const GLuint ln
= (GLuint
) state
[2];
531 /* Compute infinite half angle vector:
532 * halfVector = normalize(normalize(lightPos) + (0, 0, 1))
533 * light.EyePosition.w should be 0 for infinite lights.
535 COPY_3V(p
, ctx
->Light
.Light
[ln
]._Position
);
537 ADD_3V(value
, p
, ctx
->_EyeZDir
);
538 NORMALIZE_3FV(value
);
544 value
[0] = ctx
->Pixel
.RedScale
;
545 value
[1] = ctx
->Pixel
.GreenScale
;
546 value
[2] = ctx
->Pixel
.BlueScale
;
547 value
[3] = ctx
->Pixel
.AlphaScale
;
551 value
[0] = ctx
->Pixel
.RedBias
;
552 value
[1] = ctx
->Pixel
.GreenBias
;
553 value
[2] = ctx
->Pixel
.BlueBias
;
554 value
[3] = ctx
->Pixel
.AlphaBias
;
558 value
[0] = (GLfloat
) (ctx
->DrawBuffer
->Width
- 1);
559 value
[1] = (GLfloat
) (ctx
->DrawBuffer
->Height
- 1);
564 case STATE_FB_WPOS_Y_TRANSFORM
:
565 /* A driver may negate this conditional by using ZW swizzle
566 * instead of XY (based on e.g. some other state). */
567 if (_mesa_is_user_fbo(ctx
->DrawBuffer
)) {
568 /* Identity (XY) followed by flipping Y upside down (ZW). */
572 value
[3] = (GLfloat
) ctx
->DrawBuffer
->Height
;
574 /* Flipping Y upside down (XY) followed by identity (ZW). */
576 value
[1] = (GLfloat
) ctx
->DrawBuffer
->Height
;
582 case STATE_ROT_MATRIX_0
:
584 const int unit
= (int) state
[2];
585 GLfloat
*rotMat22
= ctx
->Texture
.Unit
[unit
].RotMatrix
;
586 value
[0] = rotMat22
[0];
587 value
[1] = rotMat22
[2];
593 case STATE_ROT_MATRIX_1
:
595 const int unit
= (int) state
[2];
596 GLfloat
*rotMat22
= ctx
->Texture
.Unit
[unit
].RotMatrix
;
597 value
[0] = rotMat22
[1];
598 value
[1] = rotMat22
[3];
604 /* XXX: make sure new tokens added here are also handled in the
605 * _mesa_program_state_flags() switch, below.
608 /* Unknown state indexes are silently ignored here.
609 * Drivers may do something special.
616 _mesa_problem(ctx
, "Invalid state in _mesa_fetch_state");
623 * Return a bitmask of the Mesa state flags (_NEW_* values) which would
624 * indicate that the given context state may have changed.
625 * The bitmask is used during validation to determine if we need to update
626 * vertex/fragment program parameters (like "state.material.color") when
627 * some GL state has changed.
630 _mesa_program_state_flags(const gl_state_index state
[STATE_LENGTH
])
634 case STATE_LIGHTPROD
:
635 case STATE_LIGHTMODEL_SCENECOLOR
:
636 /* these can be effected by glColor when colormaterial mode is used */
637 return _NEW_LIGHT
| _NEW_CURRENT_ATTRIB
;
640 case STATE_LIGHTMODEL_AMBIENT
:
645 case STATE_TEXENV_COLOR
:
646 return _NEW_TEXTURE
| _NEW_BUFFERS
| _NEW_FRAG_CLAMP
;
648 case STATE_FOG_COLOR
:
649 return _NEW_FOG
| _NEW_BUFFERS
| _NEW_FRAG_CLAMP
;
650 case STATE_FOG_PARAMS
:
653 case STATE_CLIPPLANE
:
654 return _NEW_TRANSFORM
;
656 case STATE_POINT_SIZE
:
657 case STATE_POINT_ATTENUATION
:
660 case STATE_MODELVIEW_MATRIX
:
661 return _NEW_MODELVIEW
;
662 case STATE_PROJECTION_MATRIX
:
663 return _NEW_PROJECTION
;
664 case STATE_MVP_MATRIX
:
665 return _NEW_MODELVIEW
| _NEW_PROJECTION
;
666 case STATE_TEXTURE_MATRIX
:
667 return _NEW_TEXTURE_MATRIX
;
668 case STATE_PROGRAM_MATRIX
:
669 return _NEW_TRACK_MATRIX
;
671 case STATE_NUM_SAMPLES
:
674 case STATE_DEPTH_RANGE
:
675 return _NEW_VIEWPORT
;
677 case STATE_FRAGMENT_PROGRAM
:
678 case STATE_VERTEX_PROGRAM
:
681 case STATE_NORMAL_SCALE
:
682 return _NEW_MODELVIEW
;
686 case STATE_CURRENT_ATTRIB
:
687 return _NEW_CURRENT_ATTRIB
;
688 case STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED
:
689 return _NEW_CURRENT_ATTRIB
| _NEW_LIGHT
| _NEW_BUFFERS
;
691 case STATE_NORMAL_SCALE
:
692 return _NEW_MODELVIEW
;
694 case STATE_TEXRECT_SCALE
:
695 case STATE_ROT_MATRIX_0
:
696 case STATE_ROT_MATRIX_1
:
698 case STATE_FOG_PARAMS_OPTIMIZED
:
700 case STATE_POINT_SIZE_CLAMPED
:
701 return _NEW_POINT
| _NEW_MULTISAMPLE
;
702 case STATE_LIGHT_SPOT_DIR_NORMALIZED
:
703 case STATE_LIGHT_POSITION
:
704 case STATE_LIGHT_POSITION_NORMALIZED
:
705 case STATE_LIGHT_HALF_VECTOR
:
713 case STATE_FB_WPOS_Y_TRANSFORM
:
717 /* unknown state indexes are silently ignored and
718 * no flag set, since it is handled by the driver.
724 _mesa_problem(NULL
, "unexpected state[0] in make_state_flags()");
731 append(char *dst
, const char *src
)
742 * Convert token 'k' to a string, append it onto 'dst' string.
745 append_token(char *dst
, gl_state_index k
)
749 append(dst
, "material");
752 append(dst
, "light");
754 case STATE_LIGHTMODEL_AMBIENT
:
755 append(dst
, "lightmodel.ambient");
757 case STATE_LIGHTMODEL_SCENECOLOR
:
759 case STATE_LIGHTPROD
:
760 append(dst
, "lightprod");
763 append(dst
, "texgen");
765 case STATE_FOG_COLOR
:
766 append(dst
, "fog.color");
768 case STATE_FOG_PARAMS
:
769 append(dst
, "fog.params");
771 case STATE_CLIPPLANE
:
774 case STATE_POINT_SIZE
:
775 append(dst
, "point.size");
777 case STATE_POINT_ATTENUATION
:
778 append(dst
, "point.attenuation");
780 case STATE_MODELVIEW_MATRIX
:
781 append(dst
, "matrix.modelview");
783 case STATE_PROJECTION_MATRIX
:
784 append(dst
, "matrix.projection");
786 case STATE_MVP_MATRIX
:
787 append(dst
, "matrix.mvp");
789 case STATE_TEXTURE_MATRIX
:
790 append(dst
, "matrix.texture");
792 case STATE_PROGRAM_MATRIX
:
793 append(dst
, "matrix.program");
795 case STATE_MATRIX_INVERSE
:
796 append(dst
, ".inverse");
798 case STATE_MATRIX_TRANSPOSE
:
799 append(dst
, ".transpose");
801 case STATE_MATRIX_INVTRANS
:
802 append(dst
, ".invtrans");
805 append(dst
, ".ambient");
808 append(dst
, ".diffuse");
811 append(dst
, ".specular");
814 append(dst
, ".emission");
816 case STATE_SHININESS
:
817 append(dst
, "lshininess");
819 case STATE_HALF_VECTOR
:
820 append(dst
, ".half");
823 append(dst
, ".position");
825 case STATE_ATTENUATION
:
826 append(dst
, ".attenuation");
828 case STATE_SPOT_DIRECTION
:
829 append(dst
, ".spot.direction");
831 case STATE_SPOT_CUTOFF
:
832 append(dst
, ".spot.cutoff");
834 case STATE_TEXGEN_EYE_S
:
835 append(dst
, ".eye.s");
837 case STATE_TEXGEN_EYE_T
:
838 append(dst
, ".eye.t");
840 case STATE_TEXGEN_EYE_R
:
841 append(dst
, ".eye.r");
843 case STATE_TEXGEN_EYE_Q
:
844 append(dst
, ".eye.q");
846 case STATE_TEXGEN_OBJECT_S
:
847 append(dst
, ".object.s");
849 case STATE_TEXGEN_OBJECT_T
:
850 append(dst
, ".object.t");
852 case STATE_TEXGEN_OBJECT_R
:
853 append(dst
, ".object.r");
855 case STATE_TEXGEN_OBJECT_Q
:
856 append(dst
, ".object.q");
858 case STATE_TEXENV_COLOR
:
859 append(dst
, "texenv");
861 case STATE_NUM_SAMPLES
:
862 append(dst
, "numsamples");
864 case STATE_DEPTH_RANGE
:
865 append(dst
, "depth.range");
867 case STATE_VERTEX_PROGRAM
:
868 case STATE_FRAGMENT_PROGRAM
:
874 append(dst
, "local");
876 /* BEGIN internal state vars */
878 append(dst
, ".internal.");
880 case STATE_CURRENT_ATTRIB
:
881 append(dst
, "current");
883 case STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED
:
884 append(dst
, "currentAttribMaybeVPClamped");
886 case STATE_NORMAL_SCALE
:
887 append(dst
, "normalScale");
889 case STATE_TEXRECT_SCALE
:
890 append(dst
, "texrectScale");
892 case STATE_FOG_PARAMS_OPTIMIZED
:
893 append(dst
, "fogParamsOptimized");
895 case STATE_POINT_SIZE_CLAMPED
:
896 append(dst
, "pointSizeClamped");
898 case STATE_LIGHT_SPOT_DIR_NORMALIZED
:
899 append(dst
, "lightSpotDirNormalized");
901 case STATE_LIGHT_POSITION
:
902 append(dst
, "lightPosition");
904 case STATE_LIGHT_POSITION_NORMALIZED
:
905 append(dst
, "light.position.normalized");
907 case STATE_LIGHT_HALF_VECTOR
:
908 append(dst
, "lightHalfVector");
911 append(dst
, "PTscale");
914 append(dst
, "PTbias");
917 append(dst
, "FbSize");
919 case STATE_FB_WPOS_Y_TRANSFORM
:
920 append(dst
, "FbWposYTransform");
922 case STATE_ROT_MATRIX_0
:
923 append(dst
, "rotMatrixRow0");
925 case STATE_ROT_MATRIX_1
:
926 append(dst
, "rotMatrixRow1");
929 /* probably STATE_INTERNAL_DRIVER+i (driver private state) */
930 append(dst
, "driverState");
935 append_face(char *dst
, GLint face
)
938 append(dst
, "front.");
940 append(dst
, "back.");
944 append_index(char *dst
, GLint index
)
947 sprintf(s
, "[%d]", index
);
952 * Make a string from the given state vector.
953 * For example, return "state.matrix.texture[2].inverse".
954 * Use free() to deallocate the string.
957 _mesa_program_state_string(const gl_state_index state
[STATE_LENGTH
])
962 append(str
, "state.");
963 append_token(str
, state
[0]);
967 append_face(str
, state
[1]);
968 append_token(str
, state
[2]);
971 append_index(str
, state
[1]); /* light number [i]. */
972 append_token(str
, state
[2]); /* coefficients */
974 case STATE_LIGHTMODEL_AMBIENT
:
975 append(str
, "lightmodel.ambient");
977 case STATE_LIGHTMODEL_SCENECOLOR
:
979 append(str
, "lightmodel.front.scenecolor");
982 append(str
, "lightmodel.back.scenecolor");
985 case STATE_LIGHTPROD
:
986 append_index(str
, state
[1]); /* light number [i]. */
987 append_face(str
, state
[2]);
988 append_token(str
, state
[3]);
991 append_index(str
, state
[1]); /* tex unit [i] */
992 append_token(str
, state
[2]); /* plane coef */
994 case STATE_TEXENV_COLOR
:
995 append_index(str
, state
[1]); /* tex unit [i] */
996 append(str
, "color");
998 case STATE_CLIPPLANE
:
999 append_index(str
, state
[1]); /* plane [i] */
1000 append(str
, ".plane");
1002 case STATE_MODELVIEW_MATRIX
:
1003 case STATE_PROJECTION_MATRIX
:
1004 case STATE_MVP_MATRIX
:
1005 case STATE_TEXTURE_MATRIX
:
1006 case STATE_PROGRAM_MATRIX
:
1008 /* state[0] = modelview, projection, texture, etc. */
1009 /* state[1] = which texture matrix or program matrix */
1010 /* state[2] = first row to fetch */
1011 /* state[3] = last row to fetch */
1012 /* state[4] = transpose, inverse or invtrans */
1013 const gl_state_index mat
= state
[0];
1014 const GLuint index
= (GLuint
) state
[1];
1015 const GLuint firstRow
= (GLuint
) state
[2];
1016 const GLuint lastRow
= (GLuint
) state
[3];
1017 const gl_state_index modifier
= state
[4];
1019 mat
== STATE_TEXTURE_MATRIX
||
1020 mat
== STATE_PROGRAM_MATRIX
)
1021 append_index(str
, index
);
1023 append_token(str
, modifier
);
1024 if (firstRow
== lastRow
)
1025 sprintf(tmp
, ".row[%d]", firstRow
);
1027 sprintf(tmp
, ".row[%d..%d]", firstRow
, lastRow
);
1031 case STATE_POINT_SIZE
:
1033 case STATE_POINT_ATTENUATION
:
1035 case STATE_FOG_PARAMS
:
1037 case STATE_FOG_COLOR
:
1039 case STATE_NUM_SAMPLES
:
1041 case STATE_DEPTH_RANGE
:
1043 case STATE_FRAGMENT_PROGRAM
:
1044 case STATE_VERTEX_PROGRAM
:
1045 /* state[1] = {STATE_ENV, STATE_LOCAL} */
1046 /* state[2] = parameter index */
1047 append_token(str
, state
[1]);
1048 append_index(str
, state
[2]);
1050 case STATE_NORMAL_SCALE
:
1052 case STATE_INTERNAL
:
1053 append_token(str
, state
[1]);
1054 if (state
[1] == STATE_CURRENT_ATTRIB
)
1055 append_index(str
, state
[2]);
1058 _mesa_problem(NULL
, "Invalid state in _mesa_program_state_string");
1062 return _mesa_strdup(str
);
1067 * Loop over all the parameters in a parameter list. If the parameter
1068 * is a GL state reference, look up the current value of that state
1069 * variable and put it into the parameter's Value[4] array.
1070 * Other parameter types never change or are explicitly set by the user
1071 * with glUniform() or glProgramParameter(), etc.
1072 * This would be called at glBegin time.
1075 _mesa_load_state_parameters(struct gl_context
*ctx
,
1076 struct gl_program_parameter_list
*paramList
)
1083 for (i
= 0; i
< paramList
->NumParameters
; i
++) {
1084 if (paramList
->Parameters
[i
].Type
== PROGRAM_STATE_VAR
) {
1085 _mesa_fetch_state(ctx
,
1086 paramList
->Parameters
[i
].StateIndexes
,
1087 ¶mList
->ParameterValues
[i
][0].f
);