projects / mesa.git / blob
? search:


8f481558252f2db1fdae455821bdc43e97bb5ade
[mesa.git] / src / mesa / shader / prog_statevars.c
1 /*
2 * Mesa 3-D graphics library
3 * Version: 7.1
4 *
5 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
6 *
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:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
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.
23 */
24
25 /**
26 * \file prog_statevars.c
27 * Program state variable management.
28 * \author Brian Paul
29 */
30
31
32 #include "glheader.h"
33 #include "context.h"
34 #include "hash.h"
35 #include "imports.h"
36 #include "macros.h"
37 #include "mtypes.h"
38 #include "prog_statevars.h"
39 #include "prog_parameter.h"
40 #include "nvvertparse.h"
41
42
43 /**
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.
49 */
50 static void
51 _mesa_fetch_state(GLcontext *ctx, const gl_state_index state[],
52 GLfloat *value)
53 {
54 switch (state[0]) {
55 case STATE_MATERIAL:
56 {
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().
65 */
66 /* state[2] is the material attribute */
67 switch (state[2]) {
68 case STATE_AMBIENT:
69 COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_AMBIENT + face]);
70 return;
71 case STATE_DIFFUSE:
72 COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_DIFFUSE + face]);
73 return;
74 case STATE_SPECULAR:
75 COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_SPECULAR + face]);
76 return;
77 case STATE_EMISSION:
78 COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_EMISSION + face]);
79 return;
80 case STATE_SHININESS:
81 value[0] = mat->Attrib[MAT_ATTRIB_FRONT_SHININESS + face][0];
82 value[1] = 0.0F;
83 value[2] = 0.0F;
84 value[3] = 1.0F;
85 return;
86 default:
87 _mesa_problem(ctx, "Invalid material state in fetch_state");
88 return;
89 }
90 }
91 case STATE_LIGHT:
92 {
93 /* state[1] is the light number */
94 const GLuint ln = (GLuint) state[1];
95 /* state[2] is the light attribute */
96 switch (state[2]) {
97 case STATE_AMBIENT:
98 COPY_4V(value, ctx->Light.Light[ln].Ambient);
99 return;
100 case STATE_DIFFUSE:
101 COPY_4V(value, ctx->Light.Light[ln].Diffuse);
102 return;
103 case STATE_SPECULAR:
104 COPY_4V(value, ctx->Light.Light[ln].Specular);
105 return;
106 case STATE_POSITION:
107 COPY_4V(value, ctx->Light.Light[ln].EyePosition);
108 return;
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;
114 return;
115 case STATE_SPOT_DIRECTION:
116 COPY_3V(value, ctx->Light.Light[ln].EyeDirection);
117 value[3] = ctx->Light.Light[ln]._CosCutoff;
118 return;
119 case STATE_SPOT_CUTOFF:
120 value[0] = ctx->Light.Light[ln].SpotCutoff;
121 return;
122 case STATE_HALF_VECTOR:
123 {
124 static const GLfloat eye_z[] = {0, 0, 1};
125 GLfloat p[3];
126 /* Compute infinite half angle vector:
127 * halfVector = normalize(normalize(lightPos) + (0, 0, 1))
128 * light.EyePosition.w should be 0 for infinite lights.
129 */
130 COPY_3V(p, ctx->Light.Light[ln].EyePosition);
131 NORMALIZE_3FV(p);
132 ADD_3V(value, p, eye_z);
133 NORMALIZE_3FV(value);
134 value[3] = 1.0;
135 }
136 return;
137 default:
138 _mesa_problem(ctx, "Invalid light state in fetch_state");
139 return;
140 }
141 }
142 case STATE_LIGHTMODEL_AMBIENT:
143 COPY_4V(value, ctx->Light.Model.Ambient);
144 return;
145 case STATE_LIGHTMODEL_SCENECOLOR:
146 if (state[1] == 0) {
147 /* front */
148 GLint i;
149 for (i = 0; i < 3; i++) {
150 value[i] = ctx->Light.Model.Ambient[i]
151 * ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT][i]
152 + ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_EMISSION][i];
153 }
154 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE][3];
155 }
156 else {
157 /* back */
158 GLint i;
159 for (i = 0; i < 3; i++) {
160 value[i] = ctx->Light.Model.Ambient[i]
161 * ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_AMBIENT][i]
162 + ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_EMISSION][i];
163 }
164 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_DIFFUSE][3];
165 }
166 return;
167 case STATE_LIGHTPROD:
168 {
169 const GLuint ln = (GLuint) state[1];
170 const GLuint face = (GLuint) state[2];
171 GLint i;
172 ASSERT(face == 0 || face == 1);
173 switch (state[3]) {
174 case STATE_AMBIENT:
175 for (i = 0; i < 3; i++) {
176 value[i] = ctx->Light.Light[ln].Ambient[i] *
177 ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][i];
178 }
179 /* [3] = material alpha */
180 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][3];
181 return;
182 case STATE_DIFFUSE:
183 for (i = 0; i < 3; i++) {
184 value[i] = ctx->Light.Light[ln].Diffuse[i] *
185 ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][i];
186 }
187 /* [3] = material alpha */
188 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][3];
189 return;
190 case STATE_SPECULAR:
191 for (i = 0; i < 3; i++) {
192 value[i] = ctx->Light.Light[ln].Specular[i] *
193 ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][i];
194 }
195 /* [3] = material alpha */
196 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][3];
197 return;
198 default:
199 _mesa_problem(ctx, "Invalid lightprod state in fetch_state");
200 return;
201 }
202 }
203 case STATE_TEXGEN:
204 {
205 /* state[1] is the texture unit */
206 const GLuint unit = (GLuint) state[1];
207 /* state[2] is the texgen attribute */
208 switch (state[2]) {
209 case STATE_TEXGEN_EYE_S:
210 COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneS);
211 return;
212 case STATE_TEXGEN_EYE_T:
213 COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneT);
214 return;
215 case STATE_TEXGEN_EYE_R:
216 COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneR);
217 return;
218 case STATE_TEXGEN_EYE_Q:
219 COPY_4V(value, ctx->Texture.Unit[unit].EyePlaneQ);
220 return;
221 case STATE_TEXGEN_OBJECT_S:
222 COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneS);
223 return;
224 case STATE_TEXGEN_OBJECT_T:
225 COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneT);
226 return;
227 case STATE_TEXGEN_OBJECT_R:
228 COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneR);
229 return;
230 case STATE_TEXGEN_OBJECT_Q:
231 COPY_4V(value, ctx->Texture.Unit[unit].ObjectPlaneQ);
232 return;
233 default:
234 _mesa_problem(ctx, "Invalid texgen state in fetch_state");
235 return;
236 }
237 }
238 case STATE_TEXENV_COLOR:
239 {
240 /* state[1] is the texture unit */
241 const GLuint unit = (GLuint) state[1];
242 COPY_4V(value, ctx->Texture.Unit[unit].EnvColor);
243 }
244 return;
245 case STATE_FOG_COLOR:
246 COPY_4V(value, ctx->Fog.Color);
247 return;
248 case STATE_FOG_PARAMS:
249 value[0] = ctx->Fog.Density;
250 value[1] = ctx->Fog.Start;
251 value[2] = ctx->Fog.End;
252 value[3] = (ctx->Fog.End == ctx->Fog.Start)
253 ? 1.0 : (GLfloat)(1.0 / (ctx->Fog.End - ctx->Fog.Start));
254 return;
255 case STATE_CLIPPLANE:
256 {
257 const GLuint plane = (GLuint) state[1];
258 COPY_4V(value, ctx->Transform.EyeUserPlane[plane]);
259 }
260 return;
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;
266 return;
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];
271 value[3] = 1.0F;
272 return;
273 case STATE_MODELVIEW_MATRIX:
274 case STATE_PROJECTION_MATRIX:
275 case STATE_MVP_MATRIX:
276 case STATE_TEXTURE_MATRIX:
277 case STATE_PROGRAM_MATRIX:
278 case STATE_COLOR_MATRIX:
279 {
280 /* state[0] = modelview, projection, texture, etc. */
281 /* state[1] = which texture matrix or program matrix */
282 /* state[2] = first row to fetch */
283 /* state[3] = last row to fetch */
284 /* state[4] = transpose, inverse or invtrans */
285 const GLmatrix *matrix;
286 const gl_state_index mat = state[0];
287 const GLuint index = (GLuint) state[1];
288 const GLuint firstRow = (GLuint) state[2];
289 const GLuint lastRow = (GLuint) state[3];
290 const gl_state_index modifier = state[4];
291 const GLfloat *m;
292 GLuint row, i;
293 ASSERT(firstRow >= 0);
294 ASSERT(firstRow < 4);
295 ASSERT(lastRow >= 0);
296 ASSERT(lastRow < 4);
297 if (mat == STATE_MODELVIEW_MATRIX) {
298 matrix = ctx->ModelviewMatrixStack.Top;
299 }
300 else if (mat == STATE_PROJECTION_MATRIX) {
301 matrix = ctx->ProjectionMatrixStack.Top;
302 }
303 else if (mat == STATE_MVP_MATRIX) {
304 matrix = &ctx->_ModelProjectMatrix;
305 }
306 else if (mat == STATE_TEXTURE_MATRIX) {
307 matrix = ctx->TextureMatrixStack[index].Top;
308 }
309 else if (mat == STATE_PROGRAM_MATRIX) {
310 matrix = ctx->ProgramMatrixStack[index].Top;
311 }
312 else if (mat == STATE_COLOR_MATRIX) {
313 matrix = ctx->ColorMatrixStack.Top;
314 }
315 else {
316 _mesa_problem(ctx, "Bad matrix name in _mesa_fetch_state()");
317 return;
318 }
319 if (modifier == STATE_MATRIX_INVERSE ||
320 modifier == STATE_MATRIX_INVTRANS) {
321 /* Be sure inverse is up to date:
322 */
323 _math_matrix_alloc_inv( (GLmatrix *) matrix );
324 _math_matrix_analyse( (GLmatrix*) matrix );
325 m = matrix->inv;
326 }
327 else {
328 m = matrix->m;
329 }
330 if (modifier == STATE_MATRIX_TRANSPOSE ||
331 modifier == STATE_MATRIX_INVTRANS) {
332 for (i = 0, row = firstRow; row <= lastRow; row++) {
333 value[i++] = m[row * 4 + 0];
334 value[i++] = m[row * 4 + 1];
335 value[i++] = m[row * 4 + 2];
336 value[i++] = m[row * 4 + 3];
337 }
338 }
339 else {
340 for (i = 0, row = firstRow; row <= lastRow; row++) {
341 value[i++] = m[row + 0];
342 value[i++] = m[row + 4];
343 value[i++] = m[row + 8];
344 value[i++] = m[row + 12];
345 }
346 }
347 }
348 return;
349 case STATE_DEPTH_RANGE:
350 value[0] = ctx->Viewport.Near; /* near */
351 value[1] = ctx->Viewport.Far; /* far */
352 value[2] = ctx->Viewport.Far - ctx->Viewport.Near; /* far - near */
353 value[3] = 1.0;
354 return;
355 case STATE_FRAGMENT_PROGRAM:
356 {
357 /* state[1] = {STATE_ENV, STATE_LOCAL} */
358 /* state[2] = parameter index */
359 const int idx = (int) state[2];
360 switch (state[1]) {
361 case STATE_ENV:
362 COPY_4V(value, ctx->FragmentProgram.Parameters[idx]);
363 break;
364 case STATE_LOCAL:
365 COPY_4V(value, ctx->FragmentProgram.Current->Base.LocalParams[idx]);
366 break;
367 default:
368 _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
369 return;
370 }
371 }
372 return;
373
374 case STATE_VERTEX_PROGRAM:
375 {
376 /* state[1] = {STATE_ENV, STATE_LOCAL} */
377 /* state[2] = parameter index */
378 const int idx = (int) state[2];
379 switch (state[1]) {
380 case STATE_ENV:
381 COPY_4V(value, ctx->VertexProgram.Parameters[idx]);
382 break;
383 case STATE_LOCAL:
384 COPY_4V(value, ctx->VertexProgram.Current->Base.LocalParams[idx]);
385 break;
386 default:
387 _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
388 return;
389 }
390 }
391 return;
392
393 case STATE_NORMAL_SCALE:
394 ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
395 return;
396
397 case STATE_INTERNAL:
398 switch (state[1]) {
399 case STATE_NORMAL_SCALE:
400 ASSIGN_4V(value,
401 ctx->_ModelViewInvScale,
402 ctx->_ModelViewInvScale,
403 ctx->_ModelViewInvScale,
404 1);
405 return;
406 case STATE_TEXRECT_SCALE:
407 {
408 const int unit = (int) state[2];
409 const struct gl_texture_object *texObj
410 = ctx->Texture.Unit[unit]._Current;
411 if (texObj) {
412 struct gl_texture_image *texImage = texObj->Image[0][0];
413 ASSIGN_4V(value, 1.0 / texImage->Width,
414 (GLfloat)(1.0 / texImage->Height),
415 0.0, 1.0);
416 }
417 }
418 return;
419 case STATE_FOG_PARAMS_OPTIMIZED:
420 /* for simpler per-vertex/pixel fog calcs. POW (for EXP/EXP2 fog)
421 * might be more expensive than EX2 on some hw, plus it needs
422 * another constant (e) anyway. Linear fog can now be done with a
423 * single MAD.
424 * linear: fogcoord * -1/(end-start) + end/(end-start)
425 * exp: 2^-(density/ln(2) * fogcoord)
426 * exp2: 2^-((density/(ln(2)^2) * fogcoord)^2)
427 */
428 value[0] = (ctx->Fog.End == ctx->Fog.Start)
429 ? 1.0 : (GLfloat)(-1.0F / (ctx->Fog.End - ctx->Fog.Start));
430 value[1] = ctx->Fog.End * -value[0];
431 value[2] = (GLfloat)(ctx->Fog.Density * ONE_DIV_LN2);
432 value[3] = (GLfloat)(ctx->Fog.Density * ONE_DIV_SQRT_LN2);
433 return;
434
435 case STATE_LIGHT_SPOT_DIR_NORMALIZED: {
436 /* here, state[2] is the light number */
437 /* pre-normalize spot dir */
438 const GLuint ln = (GLuint) state[2];
439 COPY_3V(value, ctx->Light.Light[ln]._NormDirection);
440 value[3] = ctx->Light.Light[ln]._CosCutoff;
441 return;
442 }
443
444 case STATE_LIGHT_POSITION: {
445 const GLuint ln = (GLuint) state[2];
446 COPY_4V(value, ctx->Light.Light[ln]._Position);
447 return;
448 }
449
450 case STATE_LIGHT_POSITION_NORMALIZED: {
451 const GLuint ln = (GLuint) state[2];
452 COPY_4V(value, ctx->Light.Light[ln]._Position);
453 NORMALIZE_3FV( value );
454 return;
455 }
456
457 case STATE_LIGHT_HALF_VECTOR: {
458 const GLuint ln = (GLuint) state[2];
459 GLfloat p[3];
460 /* Compute infinite half angle vector:
461 * halfVector = normalize(normalize(lightPos) + (0, 0, 1))
462 * light.EyePosition.w should be 0 for infinite lights.
463 */
464 COPY_3V(p, ctx->Light.Light[ln]._Position);
465 NORMALIZE_3FV(p);
466 ADD_3V(value, p, ctx->_EyeZDir);
467 NORMALIZE_3FV(value);
468 value[3] = 1.0;
469 return;
470 }
471
472
473
474 case STATE_PT_SCALE:
475 value[0] = ctx->Pixel.RedScale;
476 value[1] = ctx->Pixel.GreenScale;
477 value[2] = ctx->Pixel.BlueScale;
478 value[3] = ctx->Pixel.AlphaScale;
479 break;
480 case STATE_PT_BIAS:
481 value[0] = ctx->Pixel.RedBias;
482 value[1] = ctx->Pixel.GreenBias;
483 value[2] = ctx->Pixel.BlueBias;
484 value[3] = ctx->Pixel.AlphaBias;
485 break;
486 case STATE_PCM_SCALE:
487 COPY_4V(value, ctx->Pixel.PostColorMatrixScale);
488 break;
489 case STATE_PCM_BIAS:
490 COPY_4V(value, ctx->Pixel.PostColorMatrixBias);
491 break;
492 default:
493 /* unknown state indexes are silently ignored
494 * should be handled by the driver.
495 */
496 return;
497 }
498 return;
499
500 default:
501 _mesa_problem(ctx, "Invalid state in _mesa_fetch_state");
502 return;
503 }
504 }
505
506
507 /**
508 * Return a bitmask of the Mesa state flags (_NEW_* values) which would
509 * indicate that the given context state may have changed.
510 * The bitmask is used during validation to determine if we need to update
511 * vertex/fragment program parameters (like "state.material.color") when
512 * some GL state has changed.
513 */
514 GLbitfield
515 _mesa_program_state_flags(const gl_state_index state[STATE_LENGTH])
516 {
517 switch (state[0]) {
518 case STATE_MATERIAL:
519 case STATE_LIGHT:
520 case STATE_LIGHTMODEL_AMBIENT:
521 case STATE_LIGHTMODEL_SCENECOLOR:
522 case STATE_LIGHTPROD:
523 return _NEW_LIGHT;
524
525 case STATE_TEXGEN:
526 case STATE_TEXENV_COLOR:
527 return _NEW_TEXTURE;
528
529 case STATE_FOG_COLOR:
530 case STATE_FOG_PARAMS:
531 return _NEW_FOG;
532
533 case STATE_CLIPPLANE:
534 return _NEW_TRANSFORM;
535
536 case STATE_POINT_SIZE:
537 case STATE_POINT_ATTENUATION:
538 return _NEW_POINT;
539
540 case STATE_MODELVIEW_MATRIX:
541 return _NEW_MODELVIEW;
542 case STATE_PROJECTION_MATRIX:
543 return _NEW_PROJECTION;
544 case STATE_MVP_MATRIX:
545 return _NEW_MODELVIEW | _NEW_PROJECTION;
546 case STATE_TEXTURE_MATRIX:
547 return _NEW_TEXTURE_MATRIX;
548 case STATE_PROGRAM_MATRIX:
549 return _NEW_TRACK_MATRIX;
550 case STATE_COLOR_MATRIX:
551 return _NEW_COLOR_MATRIX;
552
553 case STATE_DEPTH_RANGE:
554 return _NEW_VIEWPORT;
555
556 case STATE_FRAGMENT_PROGRAM:
557 case STATE_VERTEX_PROGRAM:
558 return _NEW_PROGRAM;
559
560 case STATE_NORMAL_SCALE:
561 return _NEW_MODELVIEW;
562
563 case STATE_INTERNAL:
564 switch (state[1]) {
565 case STATE_TEXRECT_SCALE:
566 return _NEW_TEXTURE;
567 case STATE_FOG_PARAMS_OPTIMIZED:
568 return _NEW_FOG;
569 default:
570 /* unknown state indexes are silently ignored and
571 * no flag set, since it is handled by the driver.
572 */
573 return 0;
574 }
575
576 default:
577 _mesa_problem(NULL, "unexpected state[0] in make_state_flags()");
578 return 0;
579 }
580 }
581
582
583 static void
584 append(char *dst, const char *src)
585 {
586 while (*dst)
587 dst++;
588 while (*src)
589 *dst++ = *src++;
590 *dst = 0;
591 }
592
593
594 static void
595 append_token(char *dst, gl_state_index k)
596 {
597 switch (k) {
598 case STATE_MATERIAL:
599 append(dst, "material");
600 break;
601 case STATE_LIGHT:
602 append(dst, "light");
603 break;
604 case STATE_LIGHTMODEL_AMBIENT:
605 append(dst, "lightmodel.ambient");
606 break;
607 case STATE_LIGHTMODEL_SCENECOLOR:
608 break;
609 case STATE_LIGHTPROD:
610 append(dst, "lightprod");
611 break;
612 case STATE_TEXGEN:
613 append(dst, "texgen");
614 break;
615 case STATE_FOG_COLOR:
616 append(dst, "fog.color");
617 break;
618 case STATE_FOG_PARAMS:
619 append(dst, "fog.params");
620 break;
621 case STATE_CLIPPLANE:
622 append(dst, "clip");
623 break;
624 case STATE_POINT_SIZE:
625 append(dst, "point.size");
626 break;
627 case STATE_POINT_ATTENUATION:
628 append(dst, "point.attenuation");
629 break;
630 case STATE_MODELVIEW_MATRIX:
631 append(dst, "matrix.modelview");
632 break;
633 case STATE_PROJECTION_MATRIX:
634 append(dst, "matrix.projection");
635 break;
636 case STATE_MVP_MATRIX:
637 append(dst, "matrix.mvp");
638 break;
639 case STATE_TEXTURE_MATRIX:
640 append(dst, "matrix.texture");
641 break;
642 case STATE_PROGRAM_MATRIX:
643 append(dst, "matrix.program");
644 break;
645 case STATE_COLOR_MATRIX:
646 append(dst, "matrix.color");
647 break;
648 case STATE_MATRIX_INVERSE:
649 append(dst, ".inverse");
650 break;
651 case STATE_MATRIX_TRANSPOSE:
652 append(dst, ".transpose");
653 break;
654 case STATE_MATRIX_INVTRANS:
655 append(dst, ".invtrans");
656 break;
657 case STATE_AMBIENT:
658 append(dst, ".ambient");
659 break;
660 case STATE_DIFFUSE:
661 append(dst, ".diffuse");
662 break;
663 case STATE_SPECULAR:
664 append(dst, ".specular");
665 break;
666 case STATE_EMISSION:
667 append(dst, ".emission");
668 break;
669 case STATE_SHININESS:
670 append(dst, "lshininess");
671 break;
672 case STATE_HALF_VECTOR:
673 append(dst, ".half");
674 break;
675 case STATE_POSITION:
676 append(dst, ".position");
677 break;
678 case STATE_ATTENUATION:
679 append(dst, ".attenuation");
680 break;
681 case STATE_SPOT_DIRECTION:
682 append(dst, ".spot.direction");
683 break;
684 case STATE_SPOT_CUTOFF:
685 append(dst, ".spot.cutoff");
686 break;
687 case STATE_TEXGEN_EYE_S:
688 append(dst, "eye.s");
689 break;
690 case STATE_TEXGEN_EYE_T:
691 append(dst, "eye.t");
692 break;
693 case STATE_TEXGEN_EYE_R:
694 append(dst, "eye.r");
695 break;
696 case STATE_TEXGEN_EYE_Q:
697 append(dst, "eye.q");
698 break;
699 case STATE_TEXGEN_OBJECT_S:
700 append(dst, "object.s");
701 break;
702 case STATE_TEXGEN_OBJECT_T:
703 append(dst, "object.t");
704 break;
705 case STATE_TEXGEN_OBJECT_R:
706 append(dst, "object.r");
707 break;
708 case STATE_TEXGEN_OBJECT_Q:
709 append(dst, "object.q");
710 break;
711 case STATE_TEXENV_COLOR:
712 append(dst, "texenv");
713 break;
714 case STATE_DEPTH_RANGE:
715 append(dst, "depth.range");
716 break;
717 case STATE_VERTEX_PROGRAM:
718 case STATE_FRAGMENT_PROGRAM:
719 break;
720 case STATE_ENV:
721 append(dst, "env");
722 break;
723 case STATE_LOCAL:
724 append(dst, "local");
725 break;
726 case STATE_NORMAL_SCALE:
727 append(dst, "normalScale");
728 break;
729 case STATE_INTERNAL:
730 append(dst, "(internal)");
731 break;
732 case STATE_PT_SCALE:
733 append(dst, "PTscale");
734 break;
735 case STATE_PT_BIAS:
736 append(dst, "PTbias");
737 break;
738 case STATE_PCM_SCALE:
739 append(dst, "PCMscale");
740 break;
741 case STATE_PCM_BIAS:
742 append(dst, "PCMbias");
743 break;
744 default:
745 ;
746 }
747 }
748
749 static void
750 append_face(char *dst, GLint face)
751 {
752 if (face == 0)
753 append(dst, "front.");
754 else
755 append(dst, "back.");
756 }
757
758 static void
759 append_index(char *dst, GLint index)
760 {
761 char s[20];
762 _mesa_sprintf(s, "[%d]", index);
763 append(dst, s);
764 }
765
766 /**
767 * Make a string from the given state vector.
768 * For example, return "state.matrix.texture[2].inverse".
769 * Use _mesa_free() to deallocate the string.
770 */
771 const char *
772 _mesa_program_state_string(const gl_state_index state[STATE_LENGTH])
773 {
774 char str[1000] = "";
775 char tmp[30];
776
777 append(str, "state.");
778 append_token(str, (gl_state_index) state[0]);
779
780 switch (state[0]) {
781 case STATE_MATERIAL:
782 append_face(str, state[1]);
783 append_token(str, (gl_state_index) state[2]);
784 break;
785 case STATE_LIGHT:
786 append_index(str, state[1]); /* light number [i]. */
787 append_token(str, (gl_state_index) state[2]); /* coefficients */
788 break;
789 case STATE_LIGHTMODEL_AMBIENT:
790 append(str, "lightmodel.ambient");
791 break;
792 case STATE_LIGHTMODEL_SCENECOLOR:
793 if (state[1] == 0) {
794 append(str, "lightmodel.front.scenecolor");
795 }
796 else {
797 append(str, "lightmodel.back.scenecolor");
798 }
799 break;
800 case STATE_LIGHTPROD:
801 append_index(str, state[1]); /* light number [i]. */
802 append_face(str, state[2]);
803 append_token(str, (gl_state_index) state[3]);
804 break;
805 case STATE_TEXGEN:
806 append_index(str, state[1]); /* tex unit [i] */
807 append_token(str, (gl_state_index) state[2]); /* plane coef */
808 break;
809 case STATE_TEXENV_COLOR:
810 append_index(str, state[1]); /* tex unit [i] */
811 append(str, "color");
812 break;
813 case STATE_CLIPPLANE:
814 append_index(str, state[1]); /* plane [i] */
815 append(str, ".plane");
816 break;
817 case STATE_MODELVIEW_MATRIX:
818 case STATE_PROJECTION_MATRIX:
819 case STATE_MVP_MATRIX:
820 case STATE_TEXTURE_MATRIX:
821 case STATE_PROGRAM_MATRIX:
822 case STATE_COLOR_MATRIX:
823 {
824 /* state[0] = modelview, projection, texture, etc. */
825 /* state[1] = which texture matrix or program matrix */
826 /* state[2] = first row to fetch */
827 /* state[3] = last row to fetch */
828 /* state[4] = transpose, inverse or invtrans */
829 const gl_state_index mat = (gl_state_index) state[0];
830 const GLuint index = (GLuint) state[1];
831 const GLuint firstRow = (GLuint) state[2];
832 const GLuint lastRow = (GLuint) state[3];
833 const gl_state_index modifier = (gl_state_index) state[4];
834 if (index ||
835 mat == STATE_TEXTURE_MATRIX ||
836 mat == STATE_PROGRAM_MATRIX)
837 append_index(str, index);
838 if (modifier)
839 append_token(str, modifier);
840 if (firstRow == lastRow)
841 _mesa_sprintf(tmp, ".row[%d]", firstRow);
842 else
843 _mesa_sprintf(tmp, ".row[%d..%d]", firstRow, lastRow);
844 append(str, tmp);
845 }
846 break;
847 case STATE_POINT_SIZE:
848 break;
849 case STATE_POINT_ATTENUATION:
850 break;
851 case STATE_FOG_PARAMS:
852 break;
853 case STATE_FOG_COLOR:
854 break;
855 case STATE_DEPTH_RANGE:
856 break;
857 case STATE_FRAGMENT_PROGRAM:
858 case STATE_VERTEX_PROGRAM:
859 /* state[1] = {STATE_ENV, STATE_LOCAL} */
860 /* state[2] = parameter index */
861 append_token(str, (gl_state_index) state[1]);
862 append_index(str, state[2]);
863 break;
864 case STATE_INTERNAL:
865 break;
866 default:
867 _mesa_problem(NULL, "Invalid state in _mesa_program_state_string");
868 break;
869 }
870
871 return _mesa_strdup(str);
872 }
873
874
875 /**
876 * Loop over all the parameters in a parameter list. If the parameter
877 * is a GL state reference, look up the current value of that state
878 * variable and put it into the parameter's Value[4] array.
879 * This would be called at glBegin time when using a fragment program.
880 */
881 void
882 _mesa_load_state_parameters(GLcontext *ctx,
883 struct gl_program_parameter_list *paramList)
884 {
885 GLuint i;
886
887 if (!paramList)
888 return;
889
890 /*assert(ctx->Driver.NeedFlush == 0);*/
891
892 for (i = 0; i < paramList->NumParameters; i++) {
893 if (paramList->Parameters[i].Type == PROGRAM_STATE_VAR) {
894 _mesa_fetch_state(ctx,
895 (gl_state_index *) paramList->Parameters[i].StateIndexes,
896 paramList->ParameterValues[i]);
897 }
898 }
899 }
900