blob: 37bd17ba4a0f58051c41109cac1fd4713e5bf30e [file] [log] [blame]
Brian00cdc0a2006-12-14 15:01:06 -07001/*
2 * Mesa 3-D graphics library
Brian Paul1036ec92008-05-18 15:32:58 -06003 * Version: 7.1
Brian00cdc0a2006-12-14 15:01:06 -07004 *
Brianb7978af2007-01-09 19:17:17 -07005 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
Brian00cdc0a2006-12-14 15:01:06 -07006 *
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 */
50static 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;
Brianf958aab2007-02-21 15:23:11 -0700119 case STATE_SPOT_CUTOFF:
120 value[0] = ctx->Light.Light[ln].SpotCutoff;
121 return;
122 case STATE_HALF_VECTOR:
Brian00cdc0a2006-12-14 15:01:06 -0700123 {
Brian4fca6bf2007-05-18 07:46:27 -0600124 static const GLfloat eye_z[] = {0, 0, 1};
125 GLfloat p[3];
Brian00cdc0a2006-12-14 15:01:06 -0700126 /* Compute infinite half angle vector:
Brian4fca6bf2007-05-18 07:46:27 -0600127 * halfVector = normalize(normalize(lightPos) + (0, 0, 1))
Brian00cdc0a2006-12-14 15:01:06 -0700128 * light.EyePosition.w should be 0 for infinite lights.
129 */
Brian4fca6bf2007-05-18 07:46:27 -0600130 COPY_3V(p, ctx->Light.Light[ln].EyePosition);
131 NORMALIZE_3FV(p);
132 ADD_3V(value, p, eye_z);
Brian00cdc0a2006-12-14 15:01:06 -0700133 NORMALIZE_3FV(value);
Brian4fca6bf2007-05-18 07:46:27 -0600134 value[3] = 1.0;
Brian00cdc0a2006-12-14 15:01:06 -0700135 }
136 return;
Brian00cdc0a2006-12-14 15:01:06 -0700137 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 */
Brian Paul1036ec92008-05-18 15:32:58 -0600180 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_AMBIENT+face][3];
Brian00cdc0a2006-12-14 15:01:06 -0700181 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 */
Brian Paul1036ec92008-05-18 15:32:58 -0600196 value[3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SPECULAR+face][3];
Brian00cdc0a2006-12-14 15:01:06 -0700197 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;
Brian776bc9c2007-02-22 09:29:46 -0700245 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;
Brian Paulba47aab2008-04-23 11:37:49 -0600252 value[3] = (ctx->Fog.End == ctx->Fog.Start)
253 ? 1.0 : 1.0F / (ctx->Fog.End - ctx->Fog.Start);
Brian00cdc0a2006-12-14 15:01:06 -0700254 return;
255 case STATE_CLIPPLANE:
256 {
257 const GLuint plane = (GLuint) state[1];
258 COPY_4V(value, ctx->Transform.EyeUserPlane[plane]);
259 }
260 return;
Brian776bc9c2007-02-22 09:29:46 -0700261 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;
Brian00cdc0a2006-12-14 15:01:06 -0700272 return;
Brian65319522007-02-21 11:08:21 -0700273 case STATE_MODELVIEW_MATRIX:
274 case STATE_PROJECTION_MATRIX:
275 case STATE_MVP_MATRIX:
276 case STATE_TEXTURE_MATRIX:
277 case STATE_PROGRAM_MATRIX:
Brian068c7bd2007-10-30 12:39:58 -0600278 case STATE_COLOR_MATRIX:
Brian00cdc0a2006-12-14 15:01:06 -0700279 {
Brianfb3f0be2007-03-07 17:37:24 -0700280 /* 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 */
Brian00cdc0a2006-12-14 15:01:06 -0700285 const GLmatrix *matrix;
Brian65319522007-02-21 11:08:21 -0700286 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];
Brian00cdc0a2006-12-14 15:01:06 -0700291 const GLfloat *m;
292 GLuint row, i;
Brian65319522007-02-21 11:08:21 -0700293 ASSERT(firstRow >= 0);
294 ASSERT(firstRow < 4);
295 ASSERT(lastRow >= 0);
296 ASSERT(lastRow < 4);
297 if (mat == STATE_MODELVIEW_MATRIX) {
Brian00cdc0a2006-12-14 15:01:06 -0700298 matrix = ctx->ModelviewMatrixStack.Top;
299 }
Brian65319522007-02-21 11:08:21 -0700300 else if (mat == STATE_PROJECTION_MATRIX) {
Brian00cdc0a2006-12-14 15:01:06 -0700301 matrix = ctx->ProjectionMatrixStack.Top;
302 }
Brian65319522007-02-21 11:08:21 -0700303 else if (mat == STATE_MVP_MATRIX) {
Brian00cdc0a2006-12-14 15:01:06 -0700304 matrix = &ctx->_ModelProjectMatrix;
305 }
Brian65319522007-02-21 11:08:21 -0700306 else if (mat == STATE_TEXTURE_MATRIX) {
Brian00cdc0a2006-12-14 15:01:06 -0700307 matrix = ctx->TextureMatrixStack[index].Top;
308 }
Brian65319522007-02-21 11:08:21 -0700309 else if (mat == STATE_PROGRAM_MATRIX) {
Brian00cdc0a2006-12-14 15:01:06 -0700310 matrix = ctx->ProgramMatrixStack[index].Top;
311 }
Brian068c7bd2007-10-30 12:39:58 -0600312 else if (mat == STATE_COLOR_MATRIX) {
313 matrix = ctx->ColorMatrixStack.Top;
314 }
Brian00cdc0a2006-12-14 15:01:06 -0700315 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 */
Brian Paul1036ec92008-05-18 15:32:58 -0600353 value[3] = 1.0;
Brian00cdc0a2006-12-14 15:01:06 -0700354 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
Brianf958aab2007-02-21 15:23:11 -0700393 case STATE_NORMAL_SCALE:
394 ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
395 return;
396
Brian00cdc0a2006-12-14 15:01:06 -0700397 case STATE_INTERNAL:
Brianfbc49292007-02-24 17:00:50 -0700398 switch (state[1]) {
399 case STATE_NORMAL_SCALE:
400 ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
401 return;
402 case STATE_TEXRECT_SCALE:
403 {
404 const int unit = (int) state[2];
405 const struct gl_texture_object *texObj
406 = ctx->Texture.Unit[unit]._Current;
407 if (texObj) {
408 struct gl_texture_image *texImage = texObj->Image[0][0];
409 ASSIGN_4V(value, 1.0 / texImage->Width,
410 1.0 / texImage->Height,
411 0.0, 1.0);
412 }
Brian00cdc0a2006-12-14 15:01:06 -0700413 }
Brianfbc49292007-02-24 17:00:50 -0700414 return;
415 case STATE_FOG_PARAMS_OPTIMIZED:
416 /* for simpler per-vertex/pixel fog calcs. POW (for EXP/EXP2 fog)
417 * might be more expensive than EX2 on some hw, plus it needs
418 * another constant (e) anyway. Linear fog can now be done with a
419 * single MAD.
420 * linear: fogcoord * -1/(end-start) + end/(end-start)
421 * exp: 2^-(density/ln(2) * fogcoord)
422 * exp2: 2^-((density/(ln(2)^2) * fogcoord)^2)
423 */
Brian Paulba47aab2008-04-23 11:37:49 -0600424 value[0] = (ctx->Fog.End == ctx->Fog.Start)
425 ? 1.0 : -1.0F / (ctx->Fog.End - ctx->Fog.Start);
426 value[1] = ctx->Fog.End * -value[0];
Brianfbc49292007-02-24 17:00:50 -0700427 value[2] = ctx->Fog.Density * ONE_DIV_LN2;
428 value[3] = ctx->Fog.Density * ONE_DIV_SQRT_LN2;
429 return;
Keith Whitwelladc1f882008-05-23 09:10:59 +0100430
431 case STATE_LIGHT_SPOT_DIR_NORMALIZED: {
Brianfbc49292007-02-24 17:00:50 -0700432 /* here, state[2] is the light number */
433 /* pre-normalize spot dir */
434 const GLuint ln = (GLuint) state[2];
Keith Whitwelladc1f882008-05-23 09:10:59 +0100435 COPY_3V(value, ctx->Light.Light[ln]._NormDirection);
Brianfbc49292007-02-24 17:00:50 -0700436 value[3] = ctx->Light.Light[ln]._CosCutoff;
437 return;
438 }
Keith Whitwelladc1f882008-05-23 09:10:59 +0100439
440 case STATE_LIGHT_POSITION: {
441 const GLuint ln = (GLuint) state[2];
442 COPY_4V(value, ctx->Light.Light[ln]._Position);
443 return;
444 }
445
446 case STATE_LIGHT_POSITION_NORMALIZED: {
447 const GLuint ln = (GLuint) state[2];
448 COPY_4V(value, ctx->Light.Light[ln]._Position);
449 NORMALIZE_3FV( value );
450 return;
451 }
452
453 case STATE_LIGHT_HALF_VECTOR: {
454 const GLuint ln = (GLuint) state[2];
455 GLfloat p[3];
456 /* Compute infinite half angle vector:
457 * halfVector = normalize(normalize(lightPos) + (0, 0, 1))
458 * light.EyePosition.w should be 0 for infinite lights.
459 */
460 COPY_3V(p, ctx->Light.Light[ln]._Position);
461 NORMALIZE_3FV(p);
462 ADD_3V(value, p, ctx->_EyeZDir);
463 NORMALIZE_3FV(value);
464 value[3] = 1.0;
465 return;
466 }
467
468
469
Brian068c7bd2007-10-30 12:39:58 -0600470 case STATE_PT_SCALE:
471 value[0] = ctx->Pixel.RedScale;
472 value[1] = ctx->Pixel.GreenScale;
473 value[2] = ctx->Pixel.BlueScale;
474 value[3] = ctx->Pixel.AlphaScale;
475 break;
476 case STATE_PT_BIAS:
477 value[0] = ctx->Pixel.RedBias;
478 value[1] = ctx->Pixel.GreenBias;
479 value[2] = ctx->Pixel.BlueBias;
480 value[3] = ctx->Pixel.AlphaBias;
481 break;
Brian Paul302daeb2008-04-16 09:04:39 -0600482 case STATE_PCM_SCALE:
483 COPY_4V(value, ctx->Pixel.PostColorMatrixScale);
484 break;
485 case STATE_PCM_BIAS:
486 COPY_4V(value, ctx->Pixel.PostColorMatrixBias);
487 break;
Brianfbc49292007-02-24 17:00:50 -0700488 default:
489 /* unknown state indexes are silently ignored
490 * should be handled by the driver.
491 */
492 return;
Brian00cdc0a2006-12-14 15:01:06 -0700493 }
494 return;
495
496 default:
497 _mesa_problem(ctx, "Invalid state in _mesa_fetch_state");
498 return;
499 }
500}
501
502
503/**
504 * Return a bitmask of the Mesa state flags (_NEW_* values) which would
505 * indicate that the given context state may have changed.
506 * The bitmask is used during validation to determine if we need to update
507 * vertex/fragment program parameters (like "state.material.color") when
508 * some GL state has changed.
509 */
510GLbitfield
Brianaa9d22a2007-02-23 11:21:03 -0700511_mesa_program_state_flags(const gl_state_index state[STATE_LENGTH])
Brian00cdc0a2006-12-14 15:01:06 -0700512{
513 switch (state[0]) {
514 case STATE_MATERIAL:
515 case STATE_LIGHT:
516 case STATE_LIGHTMODEL_AMBIENT:
517 case STATE_LIGHTMODEL_SCENECOLOR:
518 case STATE_LIGHTPROD:
519 return _NEW_LIGHT;
520
521 case STATE_TEXGEN:
522 case STATE_TEXENV_COLOR:
523 return _NEW_TEXTURE;
524
525 case STATE_FOG_COLOR:
526 case STATE_FOG_PARAMS:
527 return _NEW_FOG;
528
529 case STATE_CLIPPLANE:
530 return _NEW_TRANSFORM;
531
Brian776bc9c2007-02-22 09:29:46 -0700532 case STATE_POINT_SIZE:
533 case STATE_POINT_ATTENUATION:
Brian00cdc0a2006-12-14 15:01:06 -0700534 return _NEW_POINT;
535
Brian65319522007-02-21 11:08:21 -0700536 case STATE_MODELVIEW_MATRIX:
537 return _NEW_MODELVIEW;
538 case STATE_PROJECTION_MATRIX:
539 return _NEW_PROJECTION;
540 case STATE_MVP_MATRIX:
541 return _NEW_MODELVIEW | _NEW_PROJECTION;
542 case STATE_TEXTURE_MATRIX:
543 return _NEW_TEXTURE_MATRIX;
544 case STATE_PROGRAM_MATRIX:
545 return _NEW_TRACK_MATRIX;
Brian0abd1fc2007-10-30 13:53:38 -0600546 case STATE_COLOR_MATRIX:
547 return _NEW_COLOR_MATRIX;
Brian00cdc0a2006-12-14 15:01:06 -0700548
549 case STATE_DEPTH_RANGE:
550 return _NEW_VIEWPORT;
551
552 case STATE_FRAGMENT_PROGRAM:
553 case STATE_VERTEX_PROGRAM:
554 return _NEW_PROGRAM;
555
Brianf958aab2007-02-21 15:23:11 -0700556 case STATE_NORMAL_SCALE:
557 return _NEW_MODELVIEW;
558
Brian00cdc0a2006-12-14 15:01:06 -0700559 case STATE_INTERNAL:
560 switch (state[1]) {
Brian00cdc0a2006-12-14 15:01:06 -0700561 case STATE_TEXRECT_SCALE:
562 return _NEW_TEXTURE;
Roland Scheidegger7f1879d2007-05-22 02:52:39 +0200563 case STATE_FOG_PARAMS_OPTIMIZED:
564 return _NEW_FOG;
Brian00cdc0a2006-12-14 15:01:06 -0700565 default:
566 /* unknown state indexes are silently ignored and
567 * no flag set, since it is handled by the driver.
568 */
569 return 0;
570 }
571
572 default:
573 _mesa_problem(NULL, "unexpected state[0] in make_state_flags()");
574 return 0;
575 }
576}
577
578
579static void
580append(char *dst, const char *src)
581{
582 while (*dst)
583 dst++;
584 while (*src)
585 *dst++ = *src++;
586 *dst = 0;
587}
588
589
590static void
591append_token(char *dst, gl_state_index k)
592{
593 switch (k) {
594 case STATE_MATERIAL:
Brianf958aab2007-02-21 15:23:11 -0700595 append(dst, "material");
Brian00cdc0a2006-12-14 15:01:06 -0700596 break;
597 case STATE_LIGHT:
598 append(dst, "light");
599 break;
600 case STATE_LIGHTMODEL_AMBIENT:
601 append(dst, "lightmodel.ambient");
602 break;
603 case STATE_LIGHTMODEL_SCENECOLOR:
604 break;
605 case STATE_LIGHTPROD:
606 append(dst, "lightprod");
607 break;
608 case STATE_TEXGEN:
609 append(dst, "texgen");
610 break;
611 case STATE_FOG_COLOR:
Brian776bc9c2007-02-22 09:29:46 -0700612 append(dst, "fog.color");
Brian00cdc0a2006-12-14 15:01:06 -0700613 break;
614 case STATE_FOG_PARAMS:
Brian776bc9c2007-02-22 09:29:46 -0700615 append(dst, "fog.params");
Brian00cdc0a2006-12-14 15:01:06 -0700616 break;
617 case STATE_CLIPPLANE:
618 append(dst, "clip");
619 break;
620 case STATE_POINT_SIZE:
Brian776bc9c2007-02-22 09:29:46 -0700621 append(dst, "point.size");
Brian00cdc0a2006-12-14 15:01:06 -0700622 break;
623 case STATE_POINT_ATTENUATION:
Brian776bc9c2007-02-22 09:29:46 -0700624 append(dst, "point.attenuation");
Brian00cdc0a2006-12-14 15:01:06 -0700625 break;
Brian65319522007-02-21 11:08:21 -0700626 case STATE_MODELVIEW_MATRIX:
Brianf958aab2007-02-21 15:23:11 -0700627 append(dst, "matrix.modelview");
Brian00cdc0a2006-12-14 15:01:06 -0700628 break;
Brian65319522007-02-21 11:08:21 -0700629 case STATE_PROJECTION_MATRIX:
Brianf958aab2007-02-21 15:23:11 -0700630 append(dst, "matrix.projection");
Brian00cdc0a2006-12-14 15:01:06 -0700631 break;
Brian65319522007-02-21 11:08:21 -0700632 case STATE_MVP_MATRIX:
Brianf958aab2007-02-21 15:23:11 -0700633 append(dst, "matrix.mvp");
Brian00cdc0a2006-12-14 15:01:06 -0700634 break;
Brian65319522007-02-21 11:08:21 -0700635 case STATE_TEXTURE_MATRIX:
Brianf958aab2007-02-21 15:23:11 -0700636 append(dst, "matrix.texture");
Brian00cdc0a2006-12-14 15:01:06 -0700637 break;
Brian65319522007-02-21 11:08:21 -0700638 case STATE_PROGRAM_MATRIX:
Brianf958aab2007-02-21 15:23:11 -0700639 append(dst, "matrix.program");
Brian00cdc0a2006-12-14 15:01:06 -0700640 break;
Brian0abd1fc2007-10-30 13:53:38 -0600641 case STATE_COLOR_MATRIX:
642 append(dst, "matrix.color");
643 break;
Brian00cdc0a2006-12-14 15:01:06 -0700644 case STATE_MATRIX_INVERSE:
645 append(dst, ".inverse");
646 break;
647 case STATE_MATRIX_TRANSPOSE:
648 append(dst, ".transpose");
649 break;
650 case STATE_MATRIX_INVTRANS:
651 append(dst, ".invtrans");
652 break;
653 case STATE_AMBIENT:
Brianf958aab2007-02-21 15:23:11 -0700654 append(dst, ".ambient");
Brian00cdc0a2006-12-14 15:01:06 -0700655 break;
656 case STATE_DIFFUSE:
Brianf958aab2007-02-21 15:23:11 -0700657 append(dst, ".diffuse");
Brian00cdc0a2006-12-14 15:01:06 -0700658 break;
659 case STATE_SPECULAR:
Brianf958aab2007-02-21 15:23:11 -0700660 append(dst, ".specular");
Brian00cdc0a2006-12-14 15:01:06 -0700661 break;
662 case STATE_EMISSION:
Brianf958aab2007-02-21 15:23:11 -0700663 append(dst, ".emission");
Brian00cdc0a2006-12-14 15:01:06 -0700664 break;
665 case STATE_SHININESS:
Brianf958aab2007-02-21 15:23:11 -0700666 append(dst, "lshininess");
Brian00cdc0a2006-12-14 15:01:06 -0700667 break;
Brianf958aab2007-02-21 15:23:11 -0700668 case STATE_HALF_VECTOR:
669 append(dst, ".half");
Brian00cdc0a2006-12-14 15:01:06 -0700670 break;
671 case STATE_POSITION:
672 append(dst, ".position");
673 break;
674 case STATE_ATTENUATION:
675 append(dst, ".attenuation");
676 break;
677 case STATE_SPOT_DIRECTION:
678 append(dst, ".spot.direction");
679 break;
Brianf958aab2007-02-21 15:23:11 -0700680 case STATE_SPOT_CUTOFF:
681 append(dst, ".spot.cutoff");
682 break;
Brian00cdc0a2006-12-14 15:01:06 -0700683 case STATE_TEXGEN_EYE_S:
684 append(dst, "eye.s");
685 break;
686 case STATE_TEXGEN_EYE_T:
687 append(dst, "eye.t");
688 break;
689 case STATE_TEXGEN_EYE_R:
690 append(dst, "eye.r");
691 break;
692 case STATE_TEXGEN_EYE_Q:
693 append(dst, "eye.q");
694 break;
695 case STATE_TEXGEN_OBJECT_S:
696 append(dst, "object.s");
697 break;
698 case STATE_TEXGEN_OBJECT_T:
699 append(dst, "object.t");
700 break;
701 case STATE_TEXGEN_OBJECT_R:
702 append(dst, "object.r");
703 break;
704 case STATE_TEXGEN_OBJECT_Q:
705 append(dst, "object.q");
706 break;
707 case STATE_TEXENV_COLOR:
708 append(dst, "texenv");
709 break;
710 case STATE_DEPTH_RANGE:
711 append(dst, "depth.range");
712 break;
713 case STATE_VERTEX_PROGRAM:
714 case STATE_FRAGMENT_PROGRAM:
715 break;
716 case STATE_ENV:
717 append(dst, "env");
718 break;
719 case STATE_LOCAL:
720 append(dst, "local");
721 break;
Brian00cdc0a2006-12-14 15:01:06 -0700722 case STATE_NORMAL_SCALE:
Brianf958aab2007-02-21 15:23:11 -0700723 append(dst, "normalScale");
724 break;
725 case STATE_INTERNAL:
Brian00cdc0a2006-12-14 15:01:06 -0700726 append(dst, "(internal)");
727 break;
Brian0abd1fc2007-10-30 13:53:38 -0600728 case STATE_PT_SCALE:
729 append(dst, "PTscale");
730 break;
731 case STATE_PT_BIAS:
732 append(dst, "PTbias");
733 break;
Brian Paul302daeb2008-04-16 09:04:39 -0600734 case STATE_PCM_SCALE:
735 append(dst, "PCMscale");
736 break;
737 case STATE_PCM_BIAS:
738 append(dst, "PCMbias");
739 break;
Brian00cdc0a2006-12-14 15:01:06 -0700740 default:
741 ;
742 }
743}
744
745static void
746append_face(char *dst, GLint face)
747{
748 if (face == 0)
749 append(dst, "front.");
750 else
751 append(dst, "back.");
752}
753
754static void
755append_index(char *dst, GLint index)
756{
757 char s[20];
Brianf958aab2007-02-21 15:23:11 -0700758 _mesa_sprintf(s, "[%d]", index);
Brian00cdc0a2006-12-14 15:01:06 -0700759 append(dst, s);
760}
761
762/**
763 * Make a string from the given state vector.
764 * For example, return "state.matrix.texture[2].inverse".
765 * Use _mesa_free() to deallocate the string.
766 */
767const char *
Brianaa9d22a2007-02-23 11:21:03 -0700768_mesa_program_state_string(const gl_state_index state[STATE_LENGTH])
Brian00cdc0a2006-12-14 15:01:06 -0700769{
770 char str[1000] = "";
771 char tmp[30];
772
773 append(str, "state.");
774 append_token(str, (gl_state_index) state[0]);
775
776 switch (state[0]) {
777 case STATE_MATERIAL:
778 append_face(str, state[1]);
779 append_token(str, (gl_state_index) state[2]);
780 break;
781 case STATE_LIGHT:
Brian00cdc0a2006-12-14 15:01:06 -0700782 append_index(str, state[1]); /* light number [i]. */
783 append_token(str, (gl_state_index) state[2]); /* coefficients */
784 break;
785 case STATE_LIGHTMODEL_AMBIENT:
786 append(str, "lightmodel.ambient");
787 break;
788 case STATE_LIGHTMODEL_SCENECOLOR:
789 if (state[1] == 0) {
790 append(str, "lightmodel.front.scenecolor");
791 }
792 else {
793 append(str, "lightmodel.back.scenecolor");
794 }
795 break;
796 case STATE_LIGHTPROD:
797 append_index(str, state[1]); /* light number [i]. */
798 append_face(str, state[2]);
799 append_token(str, (gl_state_index) state[3]);
800 break;
801 case STATE_TEXGEN:
802 append_index(str, state[1]); /* tex unit [i] */
803 append_token(str, (gl_state_index) state[2]); /* plane coef */
804 break;
805 case STATE_TEXENV_COLOR:
806 append_index(str, state[1]); /* tex unit [i] */
807 append(str, "color");
808 break;
Brian00cdc0a2006-12-14 15:01:06 -0700809 case STATE_CLIPPLANE:
810 append_index(str, state[1]); /* plane [i] */
Brianf958aab2007-02-21 15:23:11 -0700811 append(str, ".plane");
Brian00cdc0a2006-12-14 15:01:06 -0700812 break;
Brian65319522007-02-21 11:08:21 -0700813 case STATE_MODELVIEW_MATRIX:
814 case STATE_PROJECTION_MATRIX:
815 case STATE_MVP_MATRIX:
816 case STATE_TEXTURE_MATRIX:
817 case STATE_PROGRAM_MATRIX:
Brian0abd1fc2007-10-30 13:53:38 -0600818 case STATE_COLOR_MATRIX:
Brian00cdc0a2006-12-14 15:01:06 -0700819 {
Brian65319522007-02-21 11:08:21 -0700820 /* state[0] = modelview, projection, texture, etc. */
821 /* state[1] = which texture matrix or program matrix */
822 /* state[2] = first row to fetch */
823 /* state[3] = last row to fetch */
824 /* state[4] = transpose, inverse or invtrans */
825 const gl_state_index mat = (gl_state_index) state[0];
826 const GLuint index = (GLuint) state[1];
827 const GLuint firstRow = (GLuint) state[2];
828 const GLuint lastRow = (GLuint) state[3];
829 const gl_state_index modifier = (gl_state_index) state[4];
Brianf958aab2007-02-21 15:23:11 -0700830 if (index ||
831 mat == STATE_TEXTURE_MATRIX ||
832 mat == STATE_PROGRAM_MATRIX)
Brian00cdc0a2006-12-14 15:01:06 -0700833 append_index(str, index);
834 if (modifier)
835 append_token(str, modifier);
836 if (firstRow == lastRow)
837 _mesa_sprintf(tmp, ".row[%d]", firstRow);
838 else
839 _mesa_sprintf(tmp, ".row[%d..%d]", firstRow, lastRow);
840 append(str, tmp);
841 }
842 break;
Briana2786a92007-02-23 17:13:30 -0700843 case STATE_POINT_SIZE:
844 break;
845 case STATE_POINT_ATTENUATION:
846 break;
847 case STATE_FOG_PARAMS:
848 break;
849 case STATE_FOG_COLOR:
850 break;
Brian00cdc0a2006-12-14 15:01:06 -0700851 case STATE_DEPTH_RANGE:
852 break;
853 case STATE_FRAGMENT_PROGRAM:
854 case STATE_VERTEX_PROGRAM:
855 /* state[1] = {STATE_ENV, STATE_LOCAL} */
856 /* state[2] = parameter index */
857 append_token(str, (gl_state_index) state[1]);
858 append_index(str, state[2]);
859 break;
860 case STATE_INTERNAL:
861 break;
862 default:
863 _mesa_problem(NULL, "Invalid state in _mesa_program_state_string");
864 break;
865 }
866
867 return _mesa_strdup(str);
868}
869
870
871/**
872 * Loop over all the parameters in a parameter list. If the parameter
873 * is a GL state reference, look up the current value of that state
874 * variable and put it into the parameter's Value[4] array.
875 * This would be called at glBegin time when using a fragment program.
876 */
877void
878_mesa_load_state_parameters(GLcontext *ctx,
879 struct gl_program_parameter_list *paramList)
880{
881 GLuint i;
882
883 if (!paramList)
884 return;
885
Brian52111362007-10-17 16:19:10 -0600886 /*assert(ctx->Driver.NeedFlush == 0);*/
Brian420c0622007-10-17 15:59:59 -0600887
Brian00cdc0a2006-12-14 15:01:06 -0700888 for (i = 0; i < paramList->NumParameters; i++) {
889 if (paramList->Parameters[i].Type == PROGRAM_STATE_VAR) {
890 _mesa_fetch_state(ctx,
Brian223d7cb2007-01-23 16:37:51 -0700891 (gl_state_index *) paramList->Parameters[i].StateIndexes,
Brian00cdc0a2006-12-14 15:01:06 -0700892 paramList->ParameterValues[i]);
893 }
894 }
895}
896