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.
33 #include "main/glheader.h"
34 #include "main/context.h"
35 #include "main/blend.h"
36 #include "main/imports.h"
37 #include "main/macros.h"
38 #include "main/mtypes.h"
39 #include "main/fbobject.h"
40 #include "prog_statevars.h"
41 #include "prog_parameter.h"
42 #include "main/samplerobj.h"
43 #include "main/framebuffer.h"
46 #define ONE_DIV_SQRT_LN2 (1.201122408786449815)
50 * Use the list of tokens in the state[] array to find global GL state
51 * and return it in <value>. Usually, four values are returned in <value>
52 * but matrix queries may return as many as 16 values.
53 * This function is used for ARB vertex/fragment programs.
54 * The program parser will produce the state[] values.
57 _mesa_fetch_state(struct gl_context
*ctx
, const gl_state_index16 state
[],
58 gl_constant_value
*val
)
60 GLfloat
*value
= &val
->f
;
65 /* state[1] is either 0=front or 1=back side */
66 const GLuint face
= (GLuint
) state
[1];
67 const struct gl_material
*mat
= &ctx
->Light
.Material
;
68 assert(face
== 0 || face
== 1);
69 /* we rely on tokens numbered so that _BACK_ == _FRONT_+ 1 */
70 assert(MAT_ATTRIB_FRONT_AMBIENT
+ 1 == MAT_ATTRIB_BACK_AMBIENT
);
71 /* XXX we could get rid of this switch entirely with a little
72 * work in arbprogparse.c's parse_state_single_item().
74 /* state[2] is the material attribute */
77 COPY_4V(value
, mat
->Attrib
[MAT_ATTRIB_FRONT_AMBIENT
+ face
]);
80 COPY_4V(value
, mat
->Attrib
[MAT_ATTRIB_FRONT_DIFFUSE
+ face
]);
83 COPY_4V(value
, mat
->Attrib
[MAT_ATTRIB_FRONT_SPECULAR
+ face
]);
86 COPY_4V(value
, mat
->Attrib
[MAT_ATTRIB_FRONT_EMISSION
+ face
]);
89 value
[0] = mat
->Attrib
[MAT_ATTRIB_FRONT_SHININESS
+ face
][0];
95 _mesa_problem(ctx
, "Invalid material state in fetch_state");
101 /* state[1] is the light number */
102 const GLuint ln
= (GLuint
) state
[1];
103 /* state[2] is the light attribute */
106 COPY_4V(value
, ctx
->Light
.Light
[ln
].Ambient
);
109 COPY_4V(value
, ctx
->Light
.Light
[ln
].Diffuse
);
112 COPY_4V(value
, ctx
->Light
.Light
[ln
].Specular
);
115 COPY_4V(value
, ctx
->Light
.Light
[ln
].EyePosition
);
117 case STATE_ATTENUATION
:
118 value
[0] = ctx
->Light
.Light
[ln
].ConstantAttenuation
;
119 value
[1] = ctx
->Light
.Light
[ln
].LinearAttenuation
;
120 value
[2] = ctx
->Light
.Light
[ln
].QuadraticAttenuation
;
121 value
[3] = ctx
->Light
.Light
[ln
].SpotExponent
;
123 case STATE_SPOT_DIRECTION
:
124 COPY_3V(value
, ctx
->Light
.Light
[ln
].SpotDirection
);
125 value
[3] = ctx
->Light
.Light
[ln
]._CosCutoff
;
127 case STATE_SPOT_CUTOFF
:
128 value
[0] = ctx
->Light
.Light
[ln
].SpotCutoff
;
130 case STATE_HALF_VECTOR
:
132 static const GLfloat eye_z
[] = {0, 0, 1};
134 /* Compute infinite half angle vector:
135 * halfVector = normalize(normalize(lightPos) + (0, 0, 1))
136 * light.EyePosition.w should be 0 for infinite lights.
138 COPY_3V(p
, ctx
->Light
.Light
[ln
].EyePosition
);
140 ADD_3V(value
, p
, eye_z
);
141 NORMALIZE_3FV(value
);
146 _mesa_problem(ctx
, "Invalid light state in fetch_state");
150 case STATE_LIGHTMODEL_AMBIENT
:
151 COPY_4V(value
, ctx
->Light
.Model
.Ambient
);
153 case STATE_LIGHTMODEL_SCENECOLOR
:
157 for (i
= 0; i
< 3; i
++) {
158 value
[i
] = ctx
->Light
.Model
.Ambient
[i
]
159 * ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_AMBIENT
][i
]
160 + ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_EMISSION
][i
];
162 value
[3] = ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_DIFFUSE
][3];
167 for (i
= 0; i
< 3; i
++) {
168 value
[i
] = ctx
->Light
.Model
.Ambient
[i
]
169 * ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_BACK_AMBIENT
][i
]
170 + ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_BACK_EMISSION
][i
];
172 value
[3] = ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_BACK_DIFFUSE
][3];
175 case STATE_LIGHTPROD
:
177 const GLuint ln
= (GLuint
) state
[1];
178 const GLuint face
= (GLuint
) state
[2];
180 assert(face
== 0 || face
== 1);
183 for (i
= 0; i
< 3; i
++) {
184 value
[i
] = ctx
->Light
.Light
[ln
].Ambient
[i
] *
185 ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_AMBIENT
+face
][i
];
187 /* [3] = material alpha */
188 value
[3] = ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_AMBIENT
+face
][3];
191 for (i
= 0; i
< 3; i
++) {
192 value
[i
] = ctx
->Light
.Light
[ln
].Diffuse
[i
] *
193 ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_DIFFUSE
+face
][i
];
195 /* [3] = material alpha */
196 value
[3] = ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_DIFFUSE
+face
][3];
199 for (i
= 0; i
< 3; i
++) {
200 value
[i
] = ctx
->Light
.Light
[ln
].Specular
[i
] *
201 ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_SPECULAR
+face
][i
];
203 /* [3] = material alpha */
204 value
[3] = ctx
->Light
.Material
.Attrib
[MAT_ATTRIB_FRONT_SPECULAR
+face
][3];
207 _mesa_problem(ctx
, "Invalid lightprod state in fetch_state");
213 /* state[1] is the texture unit */
214 const GLuint unit
= (GLuint
) state
[1];
215 /* state[2] is the texgen attribute */
217 case STATE_TEXGEN_EYE_S
:
218 COPY_4V(value
, ctx
->Texture
.FixedFuncUnit
[unit
].GenS
.EyePlane
);
220 case STATE_TEXGEN_EYE_T
:
221 COPY_4V(value
, ctx
->Texture
.FixedFuncUnit
[unit
].GenT
.EyePlane
);
223 case STATE_TEXGEN_EYE_R
:
224 COPY_4V(value
, ctx
->Texture
.FixedFuncUnit
[unit
].GenR
.EyePlane
);
226 case STATE_TEXGEN_EYE_Q
:
227 COPY_4V(value
, ctx
->Texture
.FixedFuncUnit
[unit
].GenQ
.EyePlane
);
229 case STATE_TEXGEN_OBJECT_S
:
230 COPY_4V(value
, ctx
->Texture
.FixedFuncUnit
[unit
].GenS
.ObjectPlane
);
232 case STATE_TEXGEN_OBJECT_T
:
233 COPY_4V(value
, ctx
->Texture
.FixedFuncUnit
[unit
].GenT
.ObjectPlane
);
235 case STATE_TEXGEN_OBJECT_R
:
236 COPY_4V(value
, ctx
->Texture
.FixedFuncUnit
[unit
].GenR
.ObjectPlane
);
238 case STATE_TEXGEN_OBJECT_Q
:
239 COPY_4V(value
, ctx
->Texture
.FixedFuncUnit
[unit
].GenQ
.ObjectPlane
);
242 _mesa_problem(ctx
, "Invalid texgen state in fetch_state");
246 case STATE_TEXENV_COLOR
:
248 /* state[1] is the texture unit */
249 const GLuint unit
= (GLuint
) state
[1];
250 if (_mesa_get_clamp_fragment_color(ctx
, ctx
->DrawBuffer
))
251 COPY_4V(value
, ctx
->Texture
.FixedFuncUnit
[unit
].EnvColor
);
253 COPY_4V(value
, ctx
->Texture
.FixedFuncUnit
[unit
].EnvColorUnclamped
);
256 case STATE_FOG_COLOR
:
257 if (_mesa_get_clamp_fragment_color(ctx
, ctx
->DrawBuffer
))
258 COPY_4V(value
, ctx
->Fog
.Color
);
260 COPY_4V(value
, ctx
->Fog
.ColorUnclamped
);
262 case STATE_FOG_PARAMS
:
263 value
[0] = ctx
->Fog
.Density
;
264 value
[1] = ctx
->Fog
.Start
;
265 value
[2] = ctx
->Fog
.End
;
266 value
[3] = 1.0f
/ (ctx
->Fog
.End
- ctx
->Fog
.Start
);
268 case STATE_CLIPPLANE
:
270 const GLuint plane
= (GLuint
) state
[1];
271 COPY_4V(value
, ctx
->Transform
.EyeUserPlane
[plane
]);
274 case STATE_POINT_SIZE
:
275 value
[0] = ctx
->Point
.Size
;
276 value
[1] = ctx
->Point
.MinSize
;
277 value
[2] = ctx
->Point
.MaxSize
;
278 value
[3] = ctx
->Point
.Threshold
;
280 case STATE_POINT_ATTENUATION
:
281 value
[0] = ctx
->Point
.Params
[0];
282 value
[1] = ctx
->Point
.Params
[1];
283 value
[2] = ctx
->Point
.Params
[2];
286 case STATE_MODELVIEW_MATRIX
:
287 case STATE_PROJECTION_MATRIX
:
288 case STATE_MVP_MATRIX
:
289 case STATE_TEXTURE_MATRIX
:
290 case STATE_PROGRAM_MATRIX
:
292 /* state[0] = modelview, projection, texture, etc. */
293 /* state[1] = which texture matrix or program matrix */
294 /* state[2] = first row to fetch */
295 /* state[3] = last row to fetch */
296 /* state[4] = transpose, inverse or invtrans */
297 const GLmatrix
*matrix
;
298 const gl_state_index mat
= state
[0];
299 const GLuint index
= (GLuint
) state
[1];
300 const GLuint firstRow
= (GLuint
) state
[2];
301 const GLuint lastRow
= (GLuint
) state
[3];
302 const gl_state_index modifier
= state
[4];
305 assert(firstRow
< 4);
307 if (mat
== STATE_MODELVIEW_MATRIX
) {
308 matrix
= ctx
->ModelviewMatrixStack
.Top
;
310 else if (mat
== STATE_PROJECTION_MATRIX
) {
311 matrix
= ctx
->ProjectionMatrixStack
.Top
;
313 else if (mat
== STATE_MVP_MATRIX
) {
314 matrix
= &ctx
->_ModelProjectMatrix
;
316 else if (mat
== STATE_TEXTURE_MATRIX
) {
317 assert(index
< ARRAY_SIZE(ctx
->TextureMatrixStack
));
318 matrix
= ctx
->TextureMatrixStack
[index
].Top
;
320 else if (mat
== STATE_PROGRAM_MATRIX
) {
321 assert(index
< ARRAY_SIZE(ctx
->ProgramMatrixStack
));
322 matrix
= ctx
->ProgramMatrixStack
[index
].Top
;
325 _mesa_problem(ctx
, "Bad matrix name in _mesa_fetch_state()");
328 if (modifier
== STATE_MATRIX_INVERSE
||
329 modifier
== STATE_MATRIX_INVTRANS
) {
330 /* Be sure inverse is up to date:
332 _math_matrix_analyse( (GLmatrix
*) matrix
);
338 if (modifier
== STATE_MATRIX_TRANSPOSE
||
339 modifier
== STATE_MATRIX_INVTRANS
) {
340 for (i
= 0, row
= firstRow
; row
<= lastRow
; row
++) {
341 value
[i
++] = m
[row
* 4 + 0];
342 value
[i
++] = m
[row
* 4 + 1];
343 value
[i
++] = m
[row
* 4 + 2];
344 value
[i
++] = m
[row
* 4 + 3];
348 for (i
= 0, row
= firstRow
; row
<= lastRow
; row
++) {
349 value
[i
++] = m
[row
+ 0];
350 value
[i
++] = m
[row
+ 4];
351 value
[i
++] = m
[row
+ 8];
352 value
[i
++] = m
[row
+ 12];
357 case STATE_NUM_SAMPLES
:
358 val
[0].i
= MAX2(1, _mesa_geometric_samples(ctx
->DrawBuffer
));
360 case STATE_DEPTH_RANGE
:
361 value
[0] = ctx
->ViewportArray
[0].Near
; /* near */
362 value
[1] = ctx
->ViewportArray
[0].Far
; /* far */
363 value
[2] = ctx
->ViewportArray
[0].Far
- ctx
->ViewportArray
[0].Near
; /* far - near */
366 case STATE_FRAGMENT_PROGRAM
:
368 /* state[1] = {STATE_ENV, STATE_LOCAL} */
369 /* state[2] = parameter index */
370 const int idx
= (int) state
[2];
373 COPY_4V(value
, ctx
->FragmentProgram
.Parameters
[idx
]);
376 if (!ctx
->FragmentProgram
.Current
->arb
.LocalParams
) {
377 ctx
->FragmentProgram
.Current
->arb
.LocalParams
=
378 rzalloc_array_size(ctx
->FragmentProgram
.Current
,
380 MAX_PROGRAM_LOCAL_PARAMS
);
381 if (!ctx
->FragmentProgram
.Current
->arb
.LocalParams
)
386 ctx
->FragmentProgram
.Current
->arb
.LocalParams
[idx
]);
389 _mesa_problem(ctx
, "Bad state switch in _mesa_fetch_state()");
395 case STATE_VERTEX_PROGRAM
:
397 /* state[1] = {STATE_ENV, STATE_LOCAL} */
398 /* state[2] = parameter index */
399 const int idx
= (int) state
[2];
402 COPY_4V(value
, ctx
->VertexProgram
.Parameters
[idx
]);
405 if (!ctx
->VertexProgram
.Current
->arb
.LocalParams
) {
406 ctx
->VertexProgram
.Current
->arb
.LocalParams
=
407 rzalloc_array_size(ctx
->VertexProgram
.Current
,
409 MAX_PROGRAM_LOCAL_PARAMS
);
410 if (!ctx
->VertexProgram
.Current
->arb
.LocalParams
)
415 ctx
->VertexProgram
.Current
->arb
.LocalParams
[idx
]);
418 _mesa_problem(ctx
, "Bad state switch in _mesa_fetch_state()");
424 case STATE_NORMAL_SCALE
:
425 ASSIGN_4V(value
, ctx
->_ModelViewInvScaleEyespace
, 0, 0, 1);
430 case STATE_CURRENT_ATTRIB
:
432 const GLuint idx
= (GLuint
) state
[2];
433 COPY_4V(value
, ctx
->Current
.Attrib
[idx
]);
437 case STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED
:
439 const GLuint idx
= (GLuint
) state
[2];
440 if(ctx
->Light
._ClampVertexColor
&&
441 (idx
== VERT_ATTRIB_COLOR0
||
442 idx
== VERT_ATTRIB_COLOR1
)) {
443 value
[0] = CLAMP(ctx
->Current
.Attrib
[idx
][0], 0.0f
, 1.0f
);
444 value
[1] = CLAMP(ctx
->Current
.Attrib
[idx
][1], 0.0f
, 1.0f
);
445 value
[2] = CLAMP(ctx
->Current
.Attrib
[idx
][2], 0.0f
, 1.0f
);
446 value
[3] = CLAMP(ctx
->Current
.Attrib
[idx
][3], 0.0f
, 1.0f
);
449 COPY_4V(value
, ctx
->Current
.Attrib
[idx
]);
453 case STATE_NORMAL_SCALE
:
455 ctx
->_ModelViewInvScale
,
456 ctx
->_ModelViewInvScale
,
457 ctx
->_ModelViewInvScale
,
461 case STATE_FOG_PARAMS_OPTIMIZED
:
462 /* for simpler per-vertex/pixel fog calcs. POW (for EXP/EXP2 fog)
463 * might be more expensive than EX2 on some hw, plus it needs
464 * another constant (e) anyway. Linear fog can now be done with a
466 * linear: fogcoord * -1/(end-start) + end/(end-start)
467 * exp: 2^-(density/ln(2) * fogcoord)
468 * exp2: 2^-((density/(sqrt(ln(2))) * fogcoord)^2)
470 value
[0] = (ctx
->Fog
.End
== ctx
->Fog
.Start
)
471 ? 1.0f
: (GLfloat
)(-1.0F
/ (ctx
->Fog
.End
- ctx
->Fog
.Start
));
472 value
[1] = ctx
->Fog
.End
* -value
[0];
473 value
[2] = (GLfloat
)(ctx
->Fog
.Density
* M_LOG2E
); /* M_LOG2E == 1/ln(2) */
474 value
[3] = (GLfloat
)(ctx
->Fog
.Density
* ONE_DIV_SQRT_LN2
);
477 case STATE_POINT_SIZE_CLAMPED
:
479 /* this includes implementation dependent limits, to avoid
480 * another potentially necessary clamp.
481 * Note: for sprites, point smooth (point AA) is ignored
482 * and we'll clamp to MinPointSizeAA and MaxPointSize, because we
483 * expect drivers will want to say their minimum for AA size is 0.0
484 * but for non-AA it's 1.0 (because normal points with size below 1.0
485 * need to get rounded up to 1.0, hence never disappear). GL does
486 * not specify max clamp size for sprites, other than it needs to be
487 * at least as large as max AA size, hence use non-AA size there.
491 if (ctx
->Point
.PointSprite
) {
492 minImplSize
= ctx
->Const
.MinPointSizeAA
;
493 maxImplSize
= ctx
->Const
.MaxPointSize
;
495 else if (ctx
->Point
.SmoothFlag
|| _mesa_is_multisample_enabled(ctx
)) {
496 minImplSize
= ctx
->Const
.MinPointSizeAA
;
497 maxImplSize
= ctx
->Const
.MaxPointSizeAA
;
500 minImplSize
= ctx
->Const
.MinPointSize
;
501 maxImplSize
= ctx
->Const
.MaxPointSize
;
503 value
[0] = ctx
->Point
.Size
;
504 value
[1] = ctx
->Point
.MinSize
>= minImplSize
? ctx
->Point
.MinSize
: minImplSize
;
505 value
[2] = ctx
->Point
.MaxSize
<= maxImplSize
? ctx
->Point
.MaxSize
: maxImplSize
;
506 value
[3] = ctx
->Point
.Threshold
;
509 case STATE_LIGHT_SPOT_DIR_NORMALIZED
:
511 /* here, state[2] is the light number */
512 /* pre-normalize spot dir */
513 const GLuint ln
= (GLuint
) state
[2];
514 COPY_3V(value
, ctx
->Light
.Light
[ln
]._NormSpotDirection
);
515 value
[3] = ctx
->Light
.Light
[ln
]._CosCutoff
;
519 case STATE_LIGHT_POSITION
:
521 const GLuint ln
= (GLuint
) state
[2];
522 COPY_4V(value
, ctx
->Light
.Light
[ln
]._Position
);
526 case STATE_LIGHT_POSITION_NORMALIZED
:
528 const GLuint ln
= (GLuint
) state
[2];
529 COPY_4V(value
, ctx
->Light
.Light
[ln
]._Position
);
530 NORMALIZE_3FV( value
);
534 case STATE_LIGHT_HALF_VECTOR
:
536 const GLuint ln
= (GLuint
) state
[2];
538 /* Compute infinite half angle vector:
539 * halfVector = normalize(normalize(lightPos) + (0, 0, 1))
540 * light.EyePosition.w should be 0 for infinite lights.
542 COPY_3V(p
, ctx
->Light
.Light
[ln
]._Position
);
544 ADD_3V(value
, p
, ctx
->_EyeZDir
);
545 NORMALIZE_3FV(value
);
551 value
[0] = ctx
->Pixel
.RedScale
;
552 value
[1] = ctx
->Pixel
.GreenScale
;
553 value
[2] = ctx
->Pixel
.BlueScale
;
554 value
[3] = ctx
->Pixel
.AlphaScale
;
558 value
[0] = ctx
->Pixel
.RedBias
;
559 value
[1] = ctx
->Pixel
.GreenBias
;
560 value
[2] = ctx
->Pixel
.BlueBias
;
561 value
[3] = ctx
->Pixel
.AlphaBias
;
565 value
[0] = (GLfloat
) (ctx
->DrawBuffer
->Width
- 1);
566 value
[1] = (GLfloat
) (ctx
->DrawBuffer
->Height
- 1);
571 case STATE_FB_WPOS_Y_TRANSFORM
:
572 /* A driver may negate this conditional by using ZW swizzle
573 * instead of XY (based on e.g. some other state). */
574 if (!ctx
->DrawBuffer
->FlipY
) {
575 /* Identity (XY) followed by flipping Y upside down (ZW). */
579 value
[3] = _mesa_geometric_height(ctx
->DrawBuffer
);
581 /* Flipping Y upside down (XY) followed by identity (ZW). */
583 value
[1] = _mesa_geometric_height(ctx
->DrawBuffer
);
589 case STATE_TCS_PATCH_VERTICES_IN
:
590 val
[0].i
= ctx
->TessCtrlProgram
.patch_vertices
;
593 case STATE_TES_PATCH_VERTICES_IN
:
594 if (ctx
->TessCtrlProgram
._Current
)
595 val
[0].i
= ctx
->TessCtrlProgram
._Current
->info
.tess
.tcs_vertices_out
;
597 val
[0].i
= ctx
->TessCtrlProgram
.patch_vertices
;
600 case STATE_ADVANCED_BLENDING_MODE
:
601 val
[0].i
= _mesa_get_advanced_blend_sh_constant(
602 ctx
->Color
.BlendEnabled
, ctx
->Color
._AdvancedBlendMode
);
605 case STATE_ALPHA_REF
:
606 value
[0] = ctx
->Color
.AlphaRefUnclamped
;
609 case STATE_CLIP_INTERNAL
:
611 const GLuint plane
= (GLuint
) state
[2];
612 COPY_4V(value
, ctx
->Transform
._ClipUserPlane
[plane
]);
616 /* XXX: make sure new tokens added here are also handled in the
617 * _mesa_program_state_flags() switch, below.
620 /* Unknown state indexes are silently ignored here.
621 * Drivers may do something special.
628 _mesa_problem(ctx
, "Invalid state in _mesa_fetch_state");
635 * Return a bitmask of the Mesa state flags (_NEW_* values) which would
636 * indicate that the given context state may have changed.
637 * The bitmask is used during validation to determine if we need to update
638 * vertex/fragment program parameters (like "state.material.color") when
639 * some GL state has changed.
642 _mesa_program_state_flags(const gl_state_index16 state
[STATE_LENGTH
])
646 case STATE_LIGHTPROD
:
647 case STATE_LIGHTMODEL_SCENECOLOR
:
648 /* these can be effected by glColor when colormaterial mode is used */
649 return _NEW_LIGHT
| _NEW_CURRENT_ATTRIB
;
652 case STATE_LIGHTMODEL_AMBIENT
:
656 return _NEW_TEXTURE_STATE
;
657 case STATE_TEXENV_COLOR
:
658 return _NEW_TEXTURE_STATE
| _NEW_BUFFERS
| _NEW_FRAG_CLAMP
;
660 case STATE_FOG_COLOR
:
661 return _NEW_FOG
| _NEW_BUFFERS
| _NEW_FRAG_CLAMP
;
662 case STATE_FOG_PARAMS
:
665 case STATE_CLIPPLANE
:
666 return _NEW_TRANSFORM
;
668 case STATE_POINT_SIZE
:
669 case STATE_POINT_ATTENUATION
:
672 case STATE_MODELVIEW_MATRIX
:
673 return _NEW_MODELVIEW
;
674 case STATE_PROJECTION_MATRIX
:
675 return _NEW_PROJECTION
;
676 case STATE_MVP_MATRIX
:
677 return _NEW_MODELVIEW
| _NEW_PROJECTION
;
678 case STATE_TEXTURE_MATRIX
:
679 return _NEW_TEXTURE_MATRIX
;
680 case STATE_PROGRAM_MATRIX
:
681 return _NEW_TRACK_MATRIX
;
683 case STATE_NUM_SAMPLES
:
686 case STATE_DEPTH_RANGE
:
687 return _NEW_VIEWPORT
;
689 case STATE_FRAGMENT_PROGRAM
:
690 case STATE_VERTEX_PROGRAM
:
693 case STATE_NORMAL_SCALE
:
694 return _NEW_MODELVIEW
;
698 case STATE_CURRENT_ATTRIB
:
699 return _NEW_CURRENT_ATTRIB
;
700 case STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED
:
701 return _NEW_CURRENT_ATTRIB
| _NEW_LIGHT
| _NEW_BUFFERS
;
703 case STATE_NORMAL_SCALE
:
704 return _NEW_MODELVIEW
;
706 case STATE_FOG_PARAMS_OPTIMIZED
:
708 case STATE_POINT_SIZE_CLAMPED
:
709 return _NEW_POINT
| _NEW_MULTISAMPLE
;
710 case STATE_LIGHT_SPOT_DIR_NORMALIZED
:
711 case STATE_LIGHT_POSITION
:
712 case STATE_LIGHT_POSITION_NORMALIZED
:
713 case STATE_LIGHT_HALF_VECTOR
:
721 case STATE_FB_WPOS_Y_TRANSFORM
:
724 case STATE_ADVANCED_BLENDING_MODE
:
727 case STATE_ALPHA_REF
:
730 case STATE_CLIP_INTERNAL
:
731 return _NEW_TRANSFORM
| _NEW_PROJECTION
;
734 /* unknown state indexes are silently ignored and
735 * no flag set, since it is handled by the driver.
741 _mesa_problem(NULL
, "unexpected state[0] in make_state_flags()");
748 append(char *dst
, const char *src
)
759 * Convert token 'k' to a string, append it onto 'dst' string.
762 append_token(char *dst
, gl_state_index k
)
766 append(dst
, "material");
769 append(dst
, "light");
771 case STATE_LIGHTMODEL_AMBIENT
:
772 append(dst
, "lightmodel.ambient");
774 case STATE_LIGHTMODEL_SCENECOLOR
:
776 case STATE_LIGHTPROD
:
777 append(dst
, "lightprod");
780 append(dst
, "texgen");
782 case STATE_FOG_COLOR
:
783 append(dst
, "fog.color");
785 case STATE_FOG_PARAMS
:
786 append(dst
, "fog.params");
788 case STATE_CLIPPLANE
:
791 case STATE_POINT_SIZE
:
792 append(dst
, "point.size");
794 case STATE_POINT_ATTENUATION
:
795 append(dst
, "point.attenuation");
797 case STATE_MODELVIEW_MATRIX
:
798 append(dst
, "matrix.modelview");
800 case STATE_PROJECTION_MATRIX
:
801 append(dst
, "matrix.projection");
803 case STATE_MVP_MATRIX
:
804 append(dst
, "matrix.mvp");
806 case STATE_TEXTURE_MATRIX
:
807 append(dst
, "matrix.texture");
809 case STATE_PROGRAM_MATRIX
:
810 append(dst
, "matrix.program");
812 case STATE_MATRIX_INVERSE
:
813 append(dst
, ".inverse");
815 case STATE_MATRIX_TRANSPOSE
:
816 append(dst
, ".transpose");
818 case STATE_MATRIX_INVTRANS
:
819 append(dst
, ".invtrans");
822 append(dst
, ".ambient");
825 append(dst
, ".diffuse");
828 append(dst
, ".specular");
831 append(dst
, ".emission");
833 case STATE_SHININESS
:
834 append(dst
, "lshininess");
836 case STATE_HALF_VECTOR
:
837 append(dst
, ".half");
840 append(dst
, ".position");
842 case STATE_ATTENUATION
:
843 append(dst
, ".attenuation");
845 case STATE_SPOT_DIRECTION
:
846 append(dst
, ".spot.direction");
848 case STATE_SPOT_CUTOFF
:
849 append(dst
, ".spot.cutoff");
851 case STATE_TEXGEN_EYE_S
:
852 append(dst
, ".eye.s");
854 case STATE_TEXGEN_EYE_T
:
855 append(dst
, ".eye.t");
857 case STATE_TEXGEN_EYE_R
:
858 append(dst
, ".eye.r");
860 case STATE_TEXGEN_EYE_Q
:
861 append(dst
, ".eye.q");
863 case STATE_TEXGEN_OBJECT_S
:
864 append(dst
, ".object.s");
866 case STATE_TEXGEN_OBJECT_T
:
867 append(dst
, ".object.t");
869 case STATE_TEXGEN_OBJECT_R
:
870 append(dst
, ".object.r");
872 case STATE_TEXGEN_OBJECT_Q
:
873 append(dst
, ".object.q");
875 case STATE_TEXENV_COLOR
:
876 append(dst
, "texenv");
878 case STATE_NUM_SAMPLES
:
879 append(dst
, "numsamples");
881 case STATE_DEPTH_RANGE
:
882 append(dst
, "depth.range");
884 case STATE_VERTEX_PROGRAM
:
885 case STATE_FRAGMENT_PROGRAM
:
891 append(dst
, "local");
893 /* BEGIN internal state vars */
895 append(dst
, ".internal.");
897 case STATE_CURRENT_ATTRIB
:
898 append(dst
, "current");
900 case STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED
:
901 append(dst
, "currentAttribMaybeVPClamped");
903 case STATE_NORMAL_SCALE
:
904 append(dst
, "normalScale");
906 case STATE_FOG_PARAMS_OPTIMIZED
:
907 append(dst
, "fogParamsOptimized");
909 case STATE_POINT_SIZE_CLAMPED
:
910 append(dst
, "pointSizeClamped");
912 case STATE_LIGHT_SPOT_DIR_NORMALIZED
:
913 append(dst
, "lightSpotDirNormalized");
915 case STATE_LIGHT_POSITION
:
916 append(dst
, "lightPosition");
918 case STATE_LIGHT_POSITION_NORMALIZED
:
919 append(dst
, "light.position.normalized");
921 case STATE_LIGHT_HALF_VECTOR
:
922 append(dst
, "lightHalfVector");
925 append(dst
, "PTscale");
928 append(dst
, "PTbias");
931 append(dst
, "FbSize");
933 case STATE_FB_WPOS_Y_TRANSFORM
:
934 append(dst
, "FbWposYTransform");
936 case STATE_ADVANCED_BLENDING_MODE
:
937 append(dst
, "AdvancedBlendingMode");
939 case STATE_ALPHA_REF
:
940 append(dst
, "alphaRef");
942 case STATE_CLIP_INTERNAL
:
943 append(dst
, "clipInternal");
946 /* probably STATE_INTERNAL_DRIVER+i (driver private state) */
947 append(dst
, "driverState");
952 append_face(char *dst
, GLint face
)
955 append(dst
, "front.");
957 append(dst
, "back.");
961 append_index(char *dst
, GLint index
)
964 sprintf(s
, "[%d]", index
);
969 * Make a string from the given state vector.
970 * For example, return "state.matrix.texture[2].inverse".
971 * Use free() to deallocate the string.
974 _mesa_program_state_string(const gl_state_index16 state
[STATE_LENGTH
])
979 append(str
, "state.");
980 append_token(str
, state
[0]);
984 append_face(str
, state
[1]);
985 append_token(str
, state
[2]);
988 append_index(str
, state
[1]); /* light number [i]. */
989 append_token(str
, state
[2]); /* coefficients */
991 case STATE_LIGHTMODEL_AMBIENT
:
992 append(str
, "lightmodel.ambient");
994 case STATE_LIGHTMODEL_SCENECOLOR
:
996 append(str
, "lightmodel.front.scenecolor");
999 append(str
, "lightmodel.back.scenecolor");
1002 case STATE_LIGHTPROD
:
1003 append_index(str
, state
[1]); /* light number [i]. */
1004 append_face(str
, state
[2]);
1005 append_token(str
, state
[3]);
1008 append_index(str
, state
[1]); /* tex unit [i] */
1009 append_token(str
, state
[2]); /* plane coef */
1011 case STATE_TEXENV_COLOR
:
1012 append_index(str
, state
[1]); /* tex unit [i] */
1013 append(str
, "color");
1015 case STATE_CLIPPLANE
:
1016 append_index(str
, state
[1]); /* plane [i] */
1017 append(str
, ".plane");
1019 case STATE_MODELVIEW_MATRIX
:
1020 case STATE_PROJECTION_MATRIX
:
1021 case STATE_MVP_MATRIX
:
1022 case STATE_TEXTURE_MATRIX
:
1023 case STATE_PROGRAM_MATRIX
:
1025 /* state[0] = modelview, projection, texture, etc. */
1026 /* state[1] = which texture matrix or program matrix */
1027 /* state[2] = first row to fetch */
1028 /* state[3] = last row to fetch */
1029 /* state[4] = transpose, inverse or invtrans */
1030 const gl_state_index mat
= state
[0];
1031 const GLuint index
= (GLuint
) state
[1];
1032 const GLuint firstRow
= (GLuint
) state
[2];
1033 const GLuint lastRow
= (GLuint
) state
[3];
1034 const gl_state_index modifier
= state
[4];
1036 mat
== STATE_TEXTURE_MATRIX
||
1037 mat
== STATE_PROGRAM_MATRIX
)
1038 append_index(str
, index
);
1040 append_token(str
, modifier
);
1041 if (firstRow
== lastRow
)
1042 sprintf(tmp
, ".row[%d]", firstRow
);
1044 sprintf(tmp
, ".row[%d..%d]", firstRow
, lastRow
);
1048 case STATE_POINT_SIZE
:
1050 case STATE_POINT_ATTENUATION
:
1052 case STATE_FOG_PARAMS
:
1054 case STATE_FOG_COLOR
:
1056 case STATE_NUM_SAMPLES
:
1058 case STATE_DEPTH_RANGE
:
1060 case STATE_FRAGMENT_PROGRAM
:
1061 case STATE_VERTEX_PROGRAM
:
1062 /* state[1] = {STATE_ENV, STATE_LOCAL} */
1063 /* state[2] = parameter index */
1064 append_token(str
, state
[1]);
1065 append_index(str
, state
[2]);
1067 case STATE_NORMAL_SCALE
:
1069 case STATE_INTERNAL
:
1070 append_token(str
, state
[1]);
1071 if (state
[1] == STATE_CURRENT_ATTRIB
)
1072 append_index(str
, state
[2]);
1075 _mesa_problem(NULL
, "Invalid state in _mesa_program_state_string");
1084 * Loop over all the parameters in a parameter list. If the parameter
1085 * is a GL state reference, look up the current value of that state
1086 * variable and put it into the parameter's Value[4] array.
1087 * Other parameter types never change or are explicitly set by the user
1088 * with glUniform() or glProgramParameter(), etc.
1089 * This would be called at glBegin time.
1092 _mesa_load_state_parameters(struct gl_context
*ctx
,
1093 struct gl_program_parameter_list
*paramList
)
1100 for (i
= 0; i
< paramList
->NumParameters
; i
++) {
1101 if (paramList
->Parameters
[i
].Type
== PROGRAM_STATE_VAR
) {
1102 unsigned pvo
= paramList
->ParameterValueOffset
[i
];
1103 _mesa_fetch_state(ctx
,
1104 paramList
->Parameters
[i
].StateIndexes
,
1105 paramList
->ParameterValues
+ pvo
);