1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
5 *
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:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
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.
23 */
24
25 /**
26 * \file prog_statevars.c
27 * Program state variable management.
28 * \author Brian Paul
29 */
30
31
32 #include <stdio.h>
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"
44
45
46 #define ONE_DIV_SQRT_LN2 (1.201122408786449815)
47
48
49 /**
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.
55 */
56 static void
_mesa_fetch_state(struct gl_context * ctx,const gl_state_index state[],gl_constant_value * val)57 _mesa_fetch_state(struct gl_context *ctx, const gl_state_index state[],
58 gl_constant_value *val)
59 {
60 GLfloat *value = &val->f;
61
62 switch (state[0]) {
63 case STATE_MATERIAL:
64 {
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().
73 */
74 /* state[2] is the material attribute */
75 switch (state[2]) {
76 case STATE_AMBIENT:
77 COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_AMBIENT + face]);
78 return;
79 case STATE_DIFFUSE:
80 COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_DIFFUSE + face]);
81 return;
82 case STATE_SPECULAR:
83 COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_SPECULAR + face]);
84 return;
85 case STATE_EMISSION:
86 COPY_4V(value, mat->Attrib[MAT_ATTRIB_FRONT_EMISSION + face]);
87 return;
88 case STATE_SHININESS:
89 value[0] = mat->Attrib[MAT_ATTRIB_FRONT_SHININESS + face][0];
90 value[1] = 0.0F;
91 value[2] = 0.0F;
92 value[3] = 1.0F;
93 return;
94 default:
95 _mesa_problem(ctx, "Invalid material state in fetch_state");
96 return;
97 }
98 }
99 case STATE_LIGHT:
100 {
101 /* state[1] is the light number */
102 const GLuint ln = (GLuint) state[1];
103 /* state[2] is the light attribute */
104 switch (state[2]) {
105 case STATE_AMBIENT:
106 COPY_4V(value, ctx->Light.Light[ln].Ambient);
107 return;
108 case STATE_DIFFUSE:
109 COPY_4V(value, ctx->Light.Light[ln].Diffuse);
110 return;
111 case STATE_SPECULAR:
112 COPY_4V(value, ctx->Light.Light[ln].Specular);
113 return;
114 case STATE_POSITION:
115 COPY_4V(value, ctx->Light.Light[ln].EyePosition);
116 return;
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;
122 return;
123 case STATE_SPOT_DIRECTION:
124 COPY_3V(value, ctx->Light.Light[ln].SpotDirection);
125 value[3] = ctx->Light.Light[ln]._CosCutoff;
126 return;
127 case STATE_SPOT_CUTOFF:
128 value[0] = ctx->Light.Light[ln].SpotCutoff;
129 return;
130 case STATE_HALF_VECTOR:
131 {
132 static const GLfloat eye_z[] = {0, 0, 1};
133 GLfloat p[3];
134 /* Compute infinite half angle vector:
135 * halfVector = normalize(normalize(lightPos) + (0, 0, 1))
136 * light.EyePosition.w should be 0 for infinite lights.
137 */
138 COPY_3V(p, ctx->Light.Light[ln].EyePosition);
139 NORMALIZE_3FV(p);
140 ADD_3V(value, p, eye_z);
141 NORMALIZE_3FV(value);
142 value[3] = 1.0;
143 }
144 return;
145 default:
146 _mesa_problem(ctx, "Invalid light state in fetch_state");
147 return;
148 }
149 }
150 case STATE_LIGHTMODEL_AMBIENT:
151 COPY_4V(value, ctx->Light.Model.Ambient);
152 return;
153 case STATE_LIGHTMODEL_SCENECOLOR:
154 if (state[1] == 0) {
155 /* front */
156 GLint i;
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];
161 }
162 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE][3];
163 }
164 else {
165 /* back */
166 GLint i;
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];
171 }
172 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_DIFFUSE][3];
173 }
174 return;
175 case STATE_LIGHTPROD:
176 {
177 const GLuint ln = (GLuint) state[1];
178 const GLuint face = (GLuint) state[2];
179 GLint i;
180 assert(face == 0 || face == 1);
181 switch (state[3]) {
182 case STATE_AMBIENT:
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];
186 }
187 /* [3] = material alpha */
188 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][3];
189 return;
190 case STATE_DIFFUSE:
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];
194 }
195 /* [3] = material alpha */
196 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE+face][3];
197 return;
198 case STATE_SPECULAR:
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];
202 }
203 /* [3] = material alpha */
204 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][3];
205 return;
206 default:
207 _mesa_problem(ctx, "Invalid lightprod state in fetch_state");
208 return;
209 }
210 }
211 case STATE_TEXGEN:
212 {
213 /* state[1] is the texture unit */
214 const GLuint unit = (GLuint) state[1];
215 /* state[2] is the texgen attribute */
216 switch (state[2]) {
217 case STATE_TEXGEN_EYE_S:
218 COPY_4V(value, ctx->Texture.Unit[unit].GenS.EyePlane);
219 return;
220 case STATE_TEXGEN_EYE_T:
221 COPY_4V(value, ctx->Texture.Unit[unit].GenT.EyePlane);
222 return;
223 case STATE_TEXGEN_EYE_R:
224 COPY_4V(value, ctx->Texture.Unit[unit].GenR.EyePlane);
225 return;
226 case STATE_TEXGEN_EYE_Q:
227 COPY_4V(value, ctx->Texture.Unit[unit].GenQ.EyePlane);
228 return;
229 case STATE_TEXGEN_OBJECT_S:
230 COPY_4V(value, ctx->Texture.Unit[unit].GenS.ObjectPlane);
231 return;
232 case STATE_TEXGEN_OBJECT_T:
233 COPY_4V(value, ctx->Texture.Unit[unit].GenT.ObjectPlane);
234 return;
235 case STATE_TEXGEN_OBJECT_R:
236 COPY_4V(value, ctx->Texture.Unit[unit].GenR.ObjectPlane);
237 return;
238 case STATE_TEXGEN_OBJECT_Q:
239 COPY_4V(value, ctx->Texture.Unit[unit].GenQ.ObjectPlane);
240 return;
241 default:
242 _mesa_problem(ctx, "Invalid texgen state in fetch_state");
243 return;
244 }
245 }
246 case STATE_TEXENV_COLOR:
247 {
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.Unit[unit].EnvColor);
252 else
253 COPY_4V(value, ctx->Texture.Unit[unit].EnvColorUnclamped);
254 }
255 return;
256 case STATE_FOG_COLOR:
257 if (_mesa_get_clamp_fragment_color(ctx, ctx->DrawBuffer))
258 COPY_4V(value, ctx->Fog.Color);
259 else
260 COPY_4V(value, ctx->Fog.ColorUnclamped);
261 return;
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);
267 return;
268 case STATE_CLIPPLANE:
269 {
270 const GLuint plane = (GLuint) state[1];
271 COPY_4V(value, ctx->Transform.EyeUserPlane[plane]);
272 }
273 return;
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;
279 return;
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];
284 value[3] = 1.0F;
285 return;
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:
291 {
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];
303 const GLfloat *m;
304 GLuint row, i;
305 assert(firstRow < 4);
306 assert(lastRow < 4);
307 if (mat == STATE_MODELVIEW_MATRIX) {
308 matrix = ctx->ModelviewMatrixStack.Top;
309 }
310 else if (mat == STATE_PROJECTION_MATRIX) {
311 matrix = ctx->ProjectionMatrixStack.Top;
312 }
313 else if (mat == STATE_MVP_MATRIX) {
314 matrix = &ctx->_ModelProjectMatrix;
315 }
316 else if (mat == STATE_TEXTURE_MATRIX) {
317 assert(index < ARRAY_SIZE(ctx->TextureMatrixStack));
318 matrix = ctx->TextureMatrixStack[index].Top;
319 }
320 else if (mat == STATE_PROGRAM_MATRIX) {
321 assert(index < ARRAY_SIZE(ctx->ProgramMatrixStack));
322 matrix = ctx->ProgramMatrixStack[index].Top;
323 }
324 else {
325 _mesa_problem(ctx, "Bad matrix name in _mesa_fetch_state()");
326 return;
327 }
328 if (modifier == STATE_MATRIX_INVERSE ||
329 modifier == STATE_MATRIX_INVTRANS) {
330 /* Be sure inverse is up to date:
331 */
332 _math_matrix_analyse( (GLmatrix*) matrix );
333 m = matrix->inv;
334 }
335 else {
336 m = matrix->m;
337 }
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];
345 }
346 }
347 else {
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];
353 }
354 }
355 }
356 return;
357 case STATE_NUM_SAMPLES:
358 val[0].i = MAX2(1, _mesa_geometric_samples(ctx->DrawBuffer));
359 return;
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 */
364 value[3] = 1.0;
365 return;
366 case STATE_FRAGMENT_PROGRAM:
367 {
368 /* state[1] = {STATE_ENV, STATE_LOCAL} */
369 /* state[2] = parameter index */
370 const int idx = (int) state[2];
371 switch (state[1]) {
372 case STATE_ENV:
373 COPY_4V(value, ctx->FragmentProgram.Parameters[idx]);
374 return;
375 case STATE_LOCAL:
376 if (!ctx->FragmentProgram.Current->arb.LocalParams) {
377 ctx->FragmentProgram.Current->arb.LocalParams =
378 rzalloc_array_size(ctx->FragmentProgram.Current,
379 sizeof(float[4]),
380 MAX_PROGRAM_LOCAL_PARAMS);
381 if (!ctx->FragmentProgram.Current->arb.LocalParams)
382 return;
383 }
384
385 COPY_4V(value,
386 ctx->FragmentProgram.Current->arb.LocalParams[idx]);
387 return;
388 default:
389 _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
390 return;
391 }
392 }
393 return;
394
395 case STATE_VERTEX_PROGRAM:
396 {
397 /* state[1] = {STATE_ENV, STATE_LOCAL} */
398 /* state[2] = parameter index */
399 const int idx = (int) state[2];
400 switch (state[1]) {
401 case STATE_ENV:
402 COPY_4V(value, ctx->VertexProgram.Parameters[idx]);
403 return;
404 case STATE_LOCAL:
405 if (!ctx->VertexProgram.Current->arb.LocalParams) {
406 ctx->VertexProgram.Current->arb.LocalParams =
407 rzalloc_array_size(ctx->VertexProgram.Current,
408 sizeof(float[4]),
409 MAX_PROGRAM_LOCAL_PARAMS);
410 if (!ctx->VertexProgram.Current->arb.LocalParams)
411 return;
412 }
413
414 COPY_4V(value,
415 ctx->VertexProgram.Current->arb.LocalParams[idx]);
416 return;
417 default:
418 _mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
419 return;
420 }
421 }
422 return;
423
424 case STATE_NORMAL_SCALE:
425 ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
426 return;
427
428 case STATE_INTERNAL:
429 switch (state[1]) {
430 case STATE_CURRENT_ATTRIB:
431 {
432 const GLuint idx = (GLuint) state[2];
433 COPY_4V(value, ctx->Current.Attrib[idx]);
434 }
435 return;
436
437 case STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED:
438 {
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);
447 }
448 else
449 COPY_4V(value, ctx->Current.Attrib[idx]);
450 }
451 return;
452
453 case STATE_NORMAL_SCALE:
454 ASSIGN_4V(value,
455 ctx->_ModelViewInvScale,
456 ctx->_ModelViewInvScale,
457 ctx->_ModelViewInvScale,
458 1);
459 return;
460
461 case STATE_TEXRECT_SCALE:
462 /* Value = { 1/texWidth, 1/texHeight, 0, 1 }.
463 * Used to convert unnormalized texcoords to normalized texcoords.
464 */
465 {
466 const int unit = (int) state[2];
467 const struct gl_texture_object *texObj
468 = ctx->Texture.Unit[unit]._Current;
469 if (texObj) {
470 struct gl_texture_image *texImage = texObj->Image[0][0];
471 ASSIGN_4V(value,
472 (GLfloat) (1.0 / texImage->Width),
473 (GLfloat) (1.0 / texImage->Height),
474 0.0f, 1.0f);
475 }
476 }
477 return;
478
479 case STATE_FOG_PARAMS_OPTIMIZED:
480 /* for simpler per-vertex/pixel fog calcs. POW (for EXP/EXP2 fog)
481 * might be more expensive than EX2 on some hw, plus it needs
482 * another constant (e) anyway. Linear fog can now be done with a
483 * single MAD.
484 * linear: fogcoord * -1/(end-start) + end/(end-start)
485 * exp: 2^-(density/ln(2) * fogcoord)
486 * exp2: 2^-((density/(sqrt(ln(2))) * fogcoord)^2)
487 */
488 value[0] = (ctx->Fog.End == ctx->Fog.Start)
489 ? 1.0f : (GLfloat)(-1.0F / (ctx->Fog.End - ctx->Fog.Start));
490 value[1] = ctx->Fog.End * -value[0];
491 value[2] = (GLfloat)(ctx->Fog.Density * M_LOG2E); /* M_LOG2E == 1/ln(2) */
492 value[3] = (GLfloat)(ctx->Fog.Density * ONE_DIV_SQRT_LN2);
493 return;
494
495 case STATE_POINT_SIZE_CLAMPED:
496 {
497 /* this includes implementation dependent limits, to avoid
498 * another potentially necessary clamp.
499 * Note: for sprites, point smooth (point AA) is ignored
500 * and we'll clamp to MinPointSizeAA and MaxPointSize, because we
501 * expect drivers will want to say their minimum for AA size is 0.0
502 * but for non-AA it's 1.0 (because normal points with size below 1.0
503 * need to get rounded up to 1.0, hence never disappear). GL does
504 * not specify max clamp size for sprites, other than it needs to be
505 * at least as large as max AA size, hence use non-AA size there.
506 */
507 GLfloat minImplSize;
508 GLfloat maxImplSize;
509 if (ctx->Point.PointSprite) {
510 minImplSize = ctx->Const.MinPointSizeAA;
511 maxImplSize = ctx->Const.MaxPointSize;
512 }
513 else if (ctx->Point.SmoothFlag || _mesa_is_multisample_enabled(ctx)) {
514 minImplSize = ctx->Const.MinPointSizeAA;
515 maxImplSize = ctx->Const.MaxPointSizeAA;
516 }
517 else {
518 minImplSize = ctx->Const.MinPointSize;
519 maxImplSize = ctx->Const.MaxPointSize;
520 }
521 value[0] = ctx->Point.Size;
522 value[1] = ctx->Point.MinSize >= minImplSize ? ctx->Point.MinSize : minImplSize;
523 value[2] = ctx->Point.MaxSize <= maxImplSize ? ctx->Point.MaxSize : maxImplSize;
524 value[3] = ctx->Point.Threshold;
525 }
526 return;
527 case STATE_LIGHT_SPOT_DIR_NORMALIZED:
528 {
529 /* here, state[2] is the light number */
530 /* pre-normalize spot dir */
531 const GLuint ln = (GLuint) state[2];
532 COPY_3V(value, ctx->Light.Light[ln]._NormSpotDirection);
533 value[3] = ctx->Light.Light[ln]._CosCutoff;
534 }
535 return;
536
537 case STATE_LIGHT_POSITION:
538 {
539 const GLuint ln = (GLuint) state[2];
540 COPY_4V(value, ctx->Light.Light[ln]._Position);
541 }
542 return;
543
544 case STATE_LIGHT_POSITION_NORMALIZED:
545 {
546 const GLuint ln = (GLuint) state[2];
547 COPY_4V(value, ctx->Light.Light[ln]._Position);
548 NORMALIZE_3FV( value );
549 }
550 return;
551
552 case STATE_LIGHT_HALF_VECTOR:
553 {
554 const GLuint ln = (GLuint) state[2];
555 GLfloat p[3];
556 /* Compute infinite half angle vector:
557 * halfVector = normalize(normalize(lightPos) + (0, 0, 1))
558 * light.EyePosition.w should be 0 for infinite lights.
559 */
560 COPY_3V(p, ctx->Light.Light[ln]._Position);
561 NORMALIZE_3FV(p);
562 ADD_3V(value, p, ctx->_EyeZDir);
563 NORMALIZE_3FV(value);
564 value[3] = 1.0;
565 }
566 return;
567
568 case STATE_PT_SCALE:
569 value[0] = ctx->Pixel.RedScale;
570 value[1] = ctx->Pixel.GreenScale;
571 value[2] = ctx->Pixel.BlueScale;
572 value[3] = ctx->Pixel.AlphaScale;
573 return;
574
575 case STATE_PT_BIAS:
576 value[0] = ctx->Pixel.RedBias;
577 value[1] = ctx->Pixel.GreenBias;
578 value[2] = ctx->Pixel.BlueBias;
579 value[3] = ctx->Pixel.AlphaBias;
580 return;
581
582 case STATE_FB_SIZE:
583 value[0] = (GLfloat) (ctx->DrawBuffer->Width - 1);
584 value[1] = (GLfloat) (ctx->DrawBuffer->Height - 1);
585 value[2] = 0.0F;
586 value[3] = 0.0F;
587 return;
588
589 case STATE_FB_WPOS_Y_TRANSFORM:
590 /* A driver may negate this conditional by using ZW swizzle
591 * instead of XY (based on e.g. some other state). */
592 if (_mesa_is_user_fbo(ctx->DrawBuffer)) {
593 /* Identity (XY) followed by flipping Y upside down (ZW). */
594 value[0] = 1.0F;
595 value[1] = 0.0F;
596 value[2] = -1.0F;
597 value[3] = (GLfloat) ctx->DrawBuffer->Height;
598 } else {
599 /* Flipping Y upside down (XY) followed by identity (ZW). */
600 value[0] = -1.0F;
601 value[1] = (GLfloat) ctx->DrawBuffer->Height;
602 value[2] = 1.0F;
603 value[3] = 0.0F;
604 }
605 return;
606
607 case STATE_TCS_PATCH_VERTICES_IN:
608 val[0].i = ctx->TessCtrlProgram.patch_vertices;
609 return;
610
611 case STATE_TES_PATCH_VERTICES_IN:
612 if (ctx->TessCtrlProgram._Current)
613 val[0].i = ctx->TessCtrlProgram._Current->info.tess.tcs_vertices_out;
614 else
615 val[0].i = ctx->TessCtrlProgram.patch_vertices;
616 return;
617
618 case STATE_ADVANCED_BLENDING_MODE:
619 val[0].i = ctx->Color.BlendEnabled ? ctx->Color._AdvancedBlendMode : 0;
620 return;
621
622 /* XXX: make sure new tokens added here are also handled in the
623 * _mesa_program_state_flags() switch, below.
624 */
625 default:
626 /* Unknown state indexes are silently ignored here.
627 * Drivers may do something special.
628 */
629 return;
630 }
631 return;
632
633 default:
634 _mesa_problem(ctx, "Invalid state in _mesa_fetch_state");
635 return;
636 }
637 }
638
639
640 /**
641 * Return a bitmask of the Mesa state flags (_NEW_* values) which would
642 * indicate that the given context state may have changed.
643 * The bitmask is used during validation to determine if we need to update
644 * vertex/fragment program parameters (like "state.material.color") when
645 * some GL state has changed.
646 */
647 GLbitfield
_mesa_program_state_flags(const gl_state_index state[STATE_LENGTH])648 _mesa_program_state_flags(const gl_state_index state[STATE_LENGTH])
649 {
650 switch (state[0]) {
651 case STATE_MATERIAL:
652 case STATE_LIGHTPROD:
653 case STATE_LIGHTMODEL_SCENECOLOR:
654 /* these can be effected by glColor when colormaterial mode is used */
655 return _NEW_LIGHT | _NEW_CURRENT_ATTRIB;
656
657 case STATE_LIGHT:
658 case STATE_LIGHTMODEL_AMBIENT:
659 return _NEW_LIGHT;
660
661 case STATE_TEXGEN:
662 return _NEW_TEXTURE;
663 case STATE_TEXENV_COLOR:
664 return _NEW_TEXTURE | _NEW_BUFFERS | _NEW_FRAG_CLAMP;
665
666 case STATE_FOG_COLOR:
667 return _NEW_FOG | _NEW_BUFFERS | _NEW_FRAG_CLAMP;
668 case STATE_FOG_PARAMS:
669 return _NEW_FOG;
670
671 case STATE_CLIPPLANE:
672 return _NEW_TRANSFORM;
673
674 case STATE_POINT_SIZE:
675 case STATE_POINT_ATTENUATION:
676 return _NEW_POINT;
677
678 case STATE_MODELVIEW_MATRIX:
679 return _NEW_MODELVIEW;
680 case STATE_PROJECTION_MATRIX:
681 return _NEW_PROJECTION;
682 case STATE_MVP_MATRIX:
683 return _NEW_MODELVIEW | _NEW_PROJECTION;
684 case STATE_TEXTURE_MATRIX:
685 return _NEW_TEXTURE_MATRIX;
686 case STATE_PROGRAM_MATRIX:
687 return _NEW_TRACK_MATRIX;
688
689 case STATE_NUM_SAMPLES:
690 return _NEW_BUFFERS;
691
692 case STATE_DEPTH_RANGE:
693 return _NEW_VIEWPORT;
694
695 case STATE_FRAGMENT_PROGRAM:
696 case STATE_VERTEX_PROGRAM:
697 return _NEW_PROGRAM;
698
699 case STATE_NORMAL_SCALE:
700 return _NEW_MODELVIEW;
701
702 case STATE_INTERNAL:
703 switch (state[1]) {
704 case STATE_CURRENT_ATTRIB:
705 return _NEW_CURRENT_ATTRIB;
706 case STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED:
707 return _NEW_CURRENT_ATTRIB | _NEW_LIGHT | _NEW_BUFFERS;
708
709 case STATE_NORMAL_SCALE:
710 return _NEW_MODELVIEW;
711
712 case STATE_TEXRECT_SCALE:
713 return _NEW_TEXTURE;
714 case STATE_FOG_PARAMS_OPTIMIZED:
715 return _NEW_FOG;
716 case STATE_POINT_SIZE_CLAMPED:
717 return _NEW_POINT | _NEW_MULTISAMPLE;
718 case STATE_LIGHT_SPOT_DIR_NORMALIZED:
719 case STATE_LIGHT_POSITION:
720 case STATE_LIGHT_POSITION_NORMALIZED:
721 case STATE_LIGHT_HALF_VECTOR:
722 return _NEW_LIGHT;
723
724 case STATE_PT_SCALE:
725 case STATE_PT_BIAS:
726 return _NEW_PIXEL;
727
728 case STATE_FB_SIZE:
729 case STATE_FB_WPOS_Y_TRANSFORM:
730 return _NEW_BUFFERS;
731
732 case STATE_ADVANCED_BLENDING_MODE:
733 return _NEW_COLOR;
734
735 default:
736 /* unknown state indexes are silently ignored and
737 * no flag set, since it is handled by the driver.
738 */
739 return 0;
740 }
741
742 default:
743 _mesa_problem(NULL, "unexpected state[0] in make_state_flags()");
744 return 0;
745 }
746 }
747
748
749 static void
append(char * dst,const char * src)750 append(char *dst, const char *src)
751 {
752 while (*dst)
753 dst++;
754 while (*src)
755 *dst++ = *src++;
756 *dst = 0;
757 }
758
759
760 /**
761 * Convert token 'k' to a string, append it onto 'dst' string.
762 */
763 static void
append_token(char * dst,gl_state_index k)764 append_token(char *dst, gl_state_index k)
765 {
766 switch (k) {
767 case STATE_MATERIAL:
768 append(dst, "material");
769 break;
770 case STATE_LIGHT:
771 append(dst, "light");
772 break;
773 case STATE_LIGHTMODEL_AMBIENT:
774 append(dst, "lightmodel.ambient");
775 break;
776 case STATE_LIGHTMODEL_SCENECOLOR:
777 break;
778 case STATE_LIGHTPROD:
779 append(dst, "lightprod");
780 break;
781 case STATE_TEXGEN:
782 append(dst, "texgen");
783 break;
784 case STATE_FOG_COLOR:
785 append(dst, "fog.color");
786 break;
787 case STATE_FOG_PARAMS:
788 append(dst, "fog.params");
789 break;
790 case STATE_CLIPPLANE:
791 append(dst, "clip");
792 break;
793 case STATE_POINT_SIZE:
794 append(dst, "point.size");
795 break;
796 case STATE_POINT_ATTENUATION:
797 append(dst, "point.attenuation");
798 break;
799 case STATE_MODELVIEW_MATRIX:
800 append(dst, "matrix.modelview");
801 break;
802 case STATE_PROJECTION_MATRIX:
803 append(dst, "matrix.projection");
804 break;
805 case STATE_MVP_MATRIX:
806 append(dst, "matrix.mvp");
807 break;
808 case STATE_TEXTURE_MATRIX:
809 append(dst, "matrix.texture");
810 break;
811 case STATE_PROGRAM_MATRIX:
812 append(dst, "matrix.program");
813 break;
814 case STATE_MATRIX_INVERSE:
815 append(dst, ".inverse");
816 break;
817 case STATE_MATRIX_TRANSPOSE:
818 append(dst, ".transpose");
819 break;
820 case STATE_MATRIX_INVTRANS:
821 append(dst, ".invtrans");
822 break;
823 case STATE_AMBIENT:
824 append(dst, ".ambient");
825 break;
826 case STATE_DIFFUSE:
827 append(dst, ".diffuse");
828 break;
829 case STATE_SPECULAR:
830 append(dst, ".specular");
831 break;
832 case STATE_EMISSION:
833 append(dst, ".emission");
834 break;
835 case STATE_SHININESS:
836 append(dst, "lshininess");
837 break;
838 case STATE_HALF_VECTOR:
839 append(dst, ".half");
840 break;
841 case STATE_POSITION:
842 append(dst, ".position");
843 break;
844 case STATE_ATTENUATION:
845 append(dst, ".attenuation");
846 break;
847 case STATE_SPOT_DIRECTION:
848 append(dst, ".spot.direction");
849 break;
850 case STATE_SPOT_CUTOFF:
851 append(dst, ".spot.cutoff");
852 break;
853 case STATE_TEXGEN_EYE_S:
854 append(dst, ".eye.s");
855 break;
856 case STATE_TEXGEN_EYE_T:
857 append(dst, ".eye.t");
858 break;
859 case STATE_TEXGEN_EYE_R:
860 append(dst, ".eye.r");
861 break;
862 case STATE_TEXGEN_EYE_Q:
863 append(dst, ".eye.q");
864 break;
865 case STATE_TEXGEN_OBJECT_S:
866 append(dst, ".object.s");
867 break;
868 case STATE_TEXGEN_OBJECT_T:
869 append(dst, ".object.t");
870 break;
871 case STATE_TEXGEN_OBJECT_R:
872 append(dst, ".object.r");
873 break;
874 case STATE_TEXGEN_OBJECT_Q:
875 append(dst, ".object.q");
876 break;
877 case STATE_TEXENV_COLOR:
878 append(dst, "texenv");
879 break;
880 case STATE_NUM_SAMPLES:
881 append(dst, "numsamples");
882 break;
883 case STATE_DEPTH_RANGE:
884 append(dst, "depth.range");
885 break;
886 case STATE_VERTEX_PROGRAM:
887 case STATE_FRAGMENT_PROGRAM:
888 break;
889 case STATE_ENV:
890 append(dst, "env");
891 break;
892 case STATE_LOCAL:
893 append(dst, "local");
894 break;
895 /* BEGIN internal state vars */
896 case STATE_INTERNAL:
897 append(dst, ".internal.");
898 break;
899 case STATE_CURRENT_ATTRIB:
900 append(dst, "current");
901 break;
902 case STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED:
903 append(dst, "currentAttribMaybeVPClamped");
904 break;
905 case STATE_NORMAL_SCALE:
906 append(dst, "normalScale");
907 break;
908 case STATE_TEXRECT_SCALE:
909 append(dst, "texrectScale");
910 break;
911 case STATE_FOG_PARAMS_OPTIMIZED:
912 append(dst, "fogParamsOptimized");
913 break;
914 case STATE_POINT_SIZE_CLAMPED:
915 append(dst, "pointSizeClamped");
916 break;
917 case STATE_LIGHT_SPOT_DIR_NORMALIZED:
918 append(dst, "lightSpotDirNormalized");
919 break;
920 case STATE_LIGHT_POSITION:
921 append(dst, "lightPosition");
922 break;
923 case STATE_LIGHT_POSITION_NORMALIZED:
924 append(dst, "light.position.normalized");
925 break;
926 case STATE_LIGHT_HALF_VECTOR:
927 append(dst, "lightHalfVector");
928 break;
929 case STATE_PT_SCALE:
930 append(dst, "PTscale");
931 break;
932 case STATE_PT_BIAS:
933 append(dst, "PTbias");
934 break;
935 case STATE_FB_SIZE:
936 append(dst, "FbSize");
937 break;
938 case STATE_FB_WPOS_Y_TRANSFORM:
939 append(dst, "FbWposYTransform");
940 break;
941 case STATE_ADVANCED_BLENDING_MODE:
942 append(dst, "AdvancedBlendingMode");
943 break;
944 default:
945 /* probably STATE_INTERNAL_DRIVER+i (driver private state) */
946 append(dst, "driverState");
947 }
948 }
949
950 static void
append_face(char * dst,GLint face)951 append_face(char *dst, GLint face)
952 {
953 if (face == 0)
954 append(dst, "front.");
955 else
956 append(dst, "back.");
957 }
958
959 static void
append_index(char * dst,GLint index)960 append_index(char *dst, GLint index)
961 {
962 char s[20];
963 sprintf(s, "[%d]", index);
964 append(dst, s);
965 }
966
967 /**
968 * Make a string from the given state vector.
969 * For example, return "state.matrix.texture[2].inverse".
970 * Use free() to deallocate the string.
971 */
972 char *
_mesa_program_state_string(const gl_state_index state[STATE_LENGTH])973 _mesa_program_state_string(const gl_state_index state[STATE_LENGTH])
974 {
975 char str[1000] = "";
976 char tmp[30];
977
978 append(str, "state.");
979 append_token(str, state[0]);
980
981 switch (state[0]) {
982 case STATE_MATERIAL:
983 append_face(str, state[1]);
984 append_token(str, state[2]);
985 break;
986 case STATE_LIGHT:
987 append_index(str, state[1]); /* light number [i]. */
988 append_token(str, state[2]); /* coefficients */
989 break;
990 case STATE_LIGHTMODEL_AMBIENT:
991 append(str, "lightmodel.ambient");
992 break;
993 case STATE_LIGHTMODEL_SCENECOLOR:
994 if (state[1] == 0) {
995 append(str, "lightmodel.front.scenecolor");
996 }
997 else {
998 append(str, "lightmodel.back.scenecolor");
999 }
1000 break;
1001 case STATE_LIGHTPROD:
1002 append_index(str, state[1]); /* light number [i]. */
1003 append_face(str, state[2]);
1004 append_token(str, state[3]);
1005 break;
1006 case STATE_TEXGEN:
1007 append_index(str, state[1]); /* tex unit [i] */
1008 append_token(str, state[2]); /* plane coef */
1009 break;
1010 case STATE_TEXENV_COLOR:
1011 append_index(str, state[1]); /* tex unit [i] */
1012 append(str, "color");
1013 break;
1014 case STATE_CLIPPLANE:
1015 append_index(str, state[1]); /* plane [i] */
1016 append(str, ".plane");
1017 break;
1018 case STATE_MODELVIEW_MATRIX:
1019 case STATE_PROJECTION_MATRIX:
1020 case STATE_MVP_MATRIX:
1021 case STATE_TEXTURE_MATRIX:
1022 case STATE_PROGRAM_MATRIX:
1023 {
1024 /* state[0] = modelview, projection, texture, etc. */
1025 /* state[1] = which texture matrix or program matrix */
1026 /* state[2] = first row to fetch */
1027 /* state[3] = last row to fetch */
1028 /* state[4] = transpose, inverse or invtrans */
1029 const gl_state_index mat = state[0];
1030 const GLuint index = (GLuint) state[1];
1031 const GLuint firstRow = (GLuint) state[2];
1032 const GLuint lastRow = (GLuint) state[3];
1033 const gl_state_index modifier = state[4];
1034 if (index ||
1035 mat == STATE_TEXTURE_MATRIX ||
1036 mat == STATE_PROGRAM_MATRIX)
1037 append_index(str, index);
1038 if (modifier)
1039 append_token(str, modifier);
1040 if (firstRow == lastRow)
1041 sprintf(tmp, ".row[%d]", firstRow);
1042 else
1043 sprintf(tmp, ".row[%d..%d]", firstRow, lastRow);
1044 append(str, tmp);
1045 }
1046 break;
1047 case STATE_POINT_SIZE:
1048 break;
1049 case STATE_POINT_ATTENUATION:
1050 break;
1051 case STATE_FOG_PARAMS:
1052 break;
1053 case STATE_FOG_COLOR:
1054 break;
1055 case STATE_NUM_SAMPLES:
1056 break;
1057 case STATE_DEPTH_RANGE:
1058 break;
1059 case STATE_FRAGMENT_PROGRAM:
1060 case STATE_VERTEX_PROGRAM:
1061 /* state[1] = {STATE_ENV, STATE_LOCAL} */
1062 /* state[2] = parameter index */
1063 append_token(str, state[1]);
1064 append_index(str, state[2]);
1065 break;
1066 case STATE_NORMAL_SCALE:
1067 break;
1068 case STATE_INTERNAL:
1069 append_token(str, state[1]);
1070 if (state[1] == STATE_CURRENT_ATTRIB)
1071 append_index(str, state[2]);
1072 break;
1073 default:
1074 _mesa_problem(NULL, "Invalid state in _mesa_program_state_string");
1075 break;
1076 }
1077
1078 return strdup(str);
1079 }
1080
1081
1082 /**
1083 * Loop over all the parameters in a parameter list. If the parameter
1084 * is a GL state reference, look up the current value of that state
1085 * variable and put it into the parameter's Value[4] array.
1086 * Other parameter types never change or are explicitly set by the user
1087 * with glUniform() or glProgramParameter(), etc.
1088 * This would be called at glBegin time.
1089 */
1090 void
_mesa_load_state_parameters(struct gl_context * ctx,struct gl_program_parameter_list * paramList)1091 _mesa_load_state_parameters(struct gl_context *ctx,
1092 struct gl_program_parameter_list *paramList)
1093 {
1094 GLuint i;
1095
1096 if (!paramList)
1097 return;
1098
1099 for (i = 0; i < paramList->NumParameters; i++) {
1100 if (paramList->Parameters[i].Type == PROGRAM_STATE_VAR) {
1101 _mesa_fetch_state(ctx,
1102 paramList->Parameters[i].StateIndexes,
1103 ¶mList->ParameterValues[i][0]);
1104 }
1105 }
1106 }
1107