COPY_3V(value, ctx->Light.Light[ln].EyeDirection);
value[3] = ctx->Light.Light[ln]._CosCutoff;
return;
- case STATE_HALF:
+ case STATE_SPOT_CUTOFF:
+ value[0] = ctx->Light.Light[ln].SpotCutoff;
+ return;
+ case STATE_HALF_VECTOR:
{
GLfloat eye_z[] = {0, 0, 1};
value[2] = ctx->Point.Params[2];
value[3] = 1.0F;
return;
- case STATE_MATRIX:
+ case STATE_MODELVIEW_MATRIX:
+ case STATE_PROJECTION_MATRIX:
+ case STATE_MVP_MATRIX:
+ case STATE_TEXTURE_MATRIX:
+ case STATE_PROGRAM_MATRIX:
+ /*case STATE_MATRIX:*/
{
/* state[1] = modelview, projection, texture, etc. */
/* state[2] = which texture matrix or program matrix */
/* state[5] = transpose, inverse or invtrans */
const GLmatrix *matrix;
- const gl_state_index mat = state[1];
- const GLuint index = (GLuint) state[2];
- const GLuint firstRow = (GLuint) state[3];
- const GLuint lastRow = (GLuint) state[4];
- const gl_state_index modifier = state[5];
+ const gl_state_index mat = state[0];
+ const GLuint index = (GLuint) state[1];
+ const GLuint firstRow = (GLuint) state[2];
+ const GLuint lastRow = (GLuint) state[3];
+ const gl_state_index modifier = state[4];
const GLfloat *m;
GLuint row, i;
- if (mat == STATE_MODELVIEW) {
+ ASSERT(firstRow >= 0);
+ ASSERT(firstRow < 4);
+ ASSERT(lastRow >= 0);
+ ASSERT(lastRow < 4);
+ if (mat == STATE_MODELVIEW_MATRIX) {
matrix = ctx->ModelviewMatrixStack.Top;
}
- else if (mat == STATE_PROJECTION) {
+ else if (mat == STATE_PROJECTION_MATRIX) {
matrix = ctx->ProjectionMatrixStack.Top;
}
- else if (mat == STATE_MVP) {
+ else if (mat == STATE_MVP_MATRIX) {
matrix = &ctx->_ModelProjectMatrix;
}
- else if (mat == STATE_TEXTURE) {
+ else if (mat == STATE_TEXTURE_MATRIX) {
matrix = ctx->TextureMatrixStack[index].Top;
}
- else if (mat == STATE_PROGRAM) {
+ else if (mat == STATE_PROGRAM_MATRIX) {
matrix = ctx->ProgramMatrixStack[index].Top;
}
else {
}
return;
+ case STATE_NORMAL_SCALE:
+ ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
+ return;
+
case STATE_INTERNAL:
- {
- switch (state[1]) {
- case STATE_NORMAL_SCALE:
- ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
- break;
- case STATE_TEXRECT_SCALE: {
- const int unit = (int) state[2];
- const struct gl_texture_object *texObj = ctx->Texture.Unit[unit]._Current;
- if (texObj) {
- struct gl_texture_image *texImage = texObj->Image[0][0];
- ASSIGN_4V(value, 1.0 / texImage->Width, 1.0 / texImage->Height, 0, 1);
- }
- break;
- }
- default:
- /* unknown state indexes are silently ignored
- * should be handled by the driver.
- */
- return;
+ switch (state[1]) {
+ case STATE_NORMAL_SCALE:
+ ASSIGN_4V(value, ctx->_ModelViewInvScale, 0, 0, 1);
+ return;
+ case STATE_TEXRECT_SCALE:
+ {
+ const int unit = (int) state[2];
+ const struct gl_texture_object *texObj
+ = ctx->Texture.Unit[unit]._Current;
+ if (texObj) {
+ struct gl_texture_image *texImage = texObj->Image[0][0];
+ ASSIGN_4V(value, 1.0 / texImage->Width,
+ 1.0 / texImage->Height,
+ 0.0, 1.0);
+ }
}
+ return;
+ case STATE_FOG_PARAMS_OPTIMIZED:
+ /* for simpler per-vertex/pixel fog calcs. POW (for EXP/EXP2 fog)
+ * might be more expensive than EX2 on some hw, plus it needs
+ * another constant (e) anyway. Linear fog can now be done with a
+ * single MAD.
+ * linear: fogcoord * -1/(end-start) + end/(end-start)
+ * exp: 2^-(density/ln(2) * fogcoord)
+ * exp2: 2^-((density/(ln(2)^2) * fogcoord)^2)
+ */
+ value[0] = -1.0F / (ctx->Fog.End - ctx->Fog.Start);
+ value[1] = ctx->Fog.End / (ctx->Fog.End - ctx->Fog.Start);
+ value[2] = ctx->Fog.Density * ONE_DIV_LN2;
+ value[3] = ctx->Fog.Density * ONE_DIV_SQRT_LN2;
+ return;
+ case STATE_SPOT_DIR_NORMALIZED: {
+ /* here, state[2] is the light number */
+ /* pre-normalize spot dir */
+ const GLuint ln = (GLuint) state[2];
+ COPY_3V(value, ctx->Light.Light[ln].EyeDirection);
+ NORMALIZE_3FV(value);
+ value[3] = ctx->Light.Light[ln]._CosCutoff;
+ return;
+ }
+ default:
+ /* unknown state indexes are silently ignored
+ * should be handled by the driver.
+ */
+ return;
}
return;
* some GL state has changed.
*/
GLbitfield
-_mesa_program_state_flags(const GLint state[STATE_LENGTH])
+_mesa_program_state_flags(const gl_state_index state[STATE_LENGTH])
{
switch (state[0]) {
case STATE_MATERIAL:
case STATE_POINT_ATTENUATION:
return _NEW_POINT;
- case STATE_MATRIX:
- switch (state[1]) {
- case STATE_MODELVIEW:
- return _NEW_MODELVIEW;
- case STATE_PROJECTION:
- return _NEW_PROJECTION;
- case STATE_MVP:
- return _NEW_MODELVIEW | _NEW_PROJECTION;
- case STATE_TEXTURE:
- return _NEW_TEXTURE_MATRIX;
- case STATE_PROGRAM:
- return _NEW_TRACK_MATRIX;
- default:
- _mesa_problem(NULL,
- "unexpected matrix in _mesa_program_state_flags()");
- return 0;
- }
+ case STATE_MODELVIEW_MATRIX:
+ return _NEW_MODELVIEW;
+ case STATE_PROJECTION_MATRIX:
+ return _NEW_PROJECTION;
+ case STATE_MVP_MATRIX:
+ return _NEW_MODELVIEW | _NEW_PROJECTION;
+ case STATE_TEXTURE_MATRIX:
+ return _NEW_TEXTURE_MATRIX;
+ case STATE_PROGRAM_MATRIX:
+ return _NEW_TRACK_MATRIX;
case STATE_DEPTH_RANGE:
return _NEW_VIEWPORT;
case STATE_VERTEX_PROGRAM:
return _NEW_PROGRAM;
+ case STATE_NORMAL_SCALE:
+ return _NEW_MODELVIEW;
+
case STATE_INTERNAL:
switch (state[1]) {
- case STATE_NORMAL_SCALE:
- return _NEW_MODELVIEW;
case STATE_TEXRECT_SCALE:
return _NEW_TEXTURE;
default:
{
switch (k) {
case STATE_MATERIAL:
- append(dst, "material.");
+ append(dst, "material");
break;
case STATE_LIGHT:
append(dst, "light");
case STATE_POINT_ATTENUATION:
append(dst, "point.attenuation");
break;
- case STATE_MATRIX:
- append(dst, "matrix.");
+ case STATE_MODELVIEW_MATRIX:
+ append(dst, "matrix.modelview");
break;
- case STATE_MODELVIEW:
- append(dst, "modelview");
+ case STATE_PROJECTION_MATRIX:
+ append(dst, "matrix.projection");
break;
- case STATE_PROJECTION:
- append(dst, "projection");
+ case STATE_MVP_MATRIX:
+ append(dst, "matrix.mvp");
break;
- case STATE_MVP:
- append(dst, "mvp");
+ case STATE_TEXTURE_MATRIX:
+ append(dst, "matrix.texture");
break;
- case STATE_TEXTURE:
- append(dst, "texture");
- break;
- case STATE_PROGRAM:
- append(dst, "program");
+ case STATE_PROGRAM_MATRIX:
+ append(dst, "matrix.program");
break;
case STATE_MATRIX_INVERSE:
append(dst, ".inverse");
append(dst, ".invtrans");
break;
case STATE_AMBIENT:
- append(dst, "ambient");
+ append(dst, ".ambient");
break;
case STATE_DIFFUSE:
- append(dst, "diffuse");
+ append(dst, ".diffuse");
break;
case STATE_SPECULAR:
- append(dst, "specular");
+ append(dst, ".specular");
break;
case STATE_EMISSION:
- append(dst, "emission");
+ append(dst, ".emission");
break;
case STATE_SHININESS:
- append(dst, "shininess");
+ append(dst, "lshininess");
break;
- case STATE_HALF:
- append(dst, "half");
+ case STATE_HALF_VECTOR:
+ append(dst, ".half");
break;
case STATE_POSITION:
append(dst, ".position");
case STATE_SPOT_DIRECTION:
append(dst, ".spot.direction");
break;
+ case STATE_SPOT_CUTOFF:
+ append(dst, ".spot.cutoff");
+ break;
case STATE_TEXGEN_EYE_S:
append(dst, "eye.s");
break;
case STATE_LOCAL:
append(dst, "local");
break;
- case STATE_INTERNAL:
case STATE_NORMAL_SCALE:
+ append(dst, "normalScale");
+ break;
+ case STATE_INTERNAL:
case STATE_POSITION_NORMALIZED:
append(dst, "(internal)");
break;
append_index(char *dst, GLint index)
{
char s[20];
- _mesa_sprintf(s, "[%d].", index);
+ _mesa_sprintf(s, "[%d]", index);
append(dst, s);
}
* Use _mesa_free() to deallocate the string.
*/
const char *
-_mesa_program_state_string(const GLint state[STATE_LENGTH])
+_mesa_program_state_string(const gl_state_index state[STATE_LENGTH])
{
char str[1000] = "";
char tmp[30];
append_token(str, (gl_state_index) state[2]);
break;
case STATE_LIGHT:
- append(str, "light");
append_index(str, state[1]); /* light number [i]. */
append_token(str, (gl_state_index) state[2]); /* coefficients */
break;
append_index(str, state[1]); /* tex unit [i] */
append(str, "color");
break;
- case STATE_FOG_COLOR:
- case STATE_FOG_PARAMS:
- break;
case STATE_CLIPPLANE:
append_index(str, state[1]); /* plane [i] */
- append(str, "plane");
- break;
- case STATE_POINT_SIZE:
- case STATE_POINT_ATTENUATION:
+ append(str, ".plane");
break;
- case STATE_MATRIX:
+ case STATE_MODELVIEW_MATRIX:
+ case STATE_PROJECTION_MATRIX:
+ case STATE_MVP_MATRIX:
+ case STATE_TEXTURE_MATRIX:
+ case STATE_PROGRAM_MATRIX:
{
- /* state[1] = modelview, projection, texture, etc. */
- /* state[2] = which texture matrix or program matrix */
- /* state[3] = first row to fetch */
- /* state[4] = last row to fetch */
- /* state[5] = transpose, inverse or invtrans */
- const gl_state_index mat = (gl_state_index) state[1];
- const GLuint index = (GLuint) state[2];
- const GLuint firstRow = (GLuint) state[3];
- const GLuint lastRow = (GLuint) state[4];
- const gl_state_index modifier = (gl_state_index) state[5];
- append_token(str, mat);
- if (index)
+ /* state[0] = modelview, projection, texture, etc. */
+ /* state[1] = which texture matrix or program matrix */
+ /* state[2] = first row to fetch */
+ /* state[3] = last row to fetch */
+ /* state[4] = transpose, inverse or invtrans */
+ const gl_state_index mat = (gl_state_index) state[0];
+ const GLuint index = (GLuint) state[1];
+ const GLuint firstRow = (GLuint) state[2];
+ const GLuint lastRow = (GLuint) state[3];
+ const gl_state_index modifier = (gl_state_index) state[4];
+ if (index ||
+ mat == STATE_TEXTURE_MATRIX ||
+ mat == STATE_PROGRAM_MATRIX)
append_index(str, index);
if (modifier)
append_token(str, modifier);
append(str, tmp);
}
break;
+ case STATE_POINT_SIZE:
+ break;
+ case STATE_POINT_ATTENUATION:
+ break;
+ case STATE_FOG_PARAMS:
+ break;
+ case STATE_FOG_COLOR:
+ break;
case STATE_DEPTH_RANGE:
break;
case STATE_FRAGMENT_PROGRAM: