Added _mesa_light() helper function so we can avoid transforming then
un-transforming light positions and spot directions when popping light
state off the attribute stack.
diff --git a/src/mesa/main/attrib.c b/src/mesa/main/attrib.c
index 9c2a666..b4a587e 100644
--- a/src/mesa/main/attrib.c
+++ b/src/mesa/main/attrib.c
@@ -951,25 +951,21 @@
_math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
for (i = 0; i < ctx->Const.MaxLights; i++) {
- GLenum lgt = (GLenum) (GL_LIGHT0 + i);
const struct gl_light *l = &light->Light[i];
- GLfloat tmp[4];
- _mesa_set_enable(ctx, lgt, l->Enabled);
- _mesa_Lightfv( lgt, GL_AMBIENT, l->Ambient );
- _mesa_Lightfv( lgt, GL_DIFFUSE, l->Diffuse );
- _mesa_Lightfv( lgt, GL_SPECULAR, l->Specular );
- TRANSFORM_POINT( tmp, ctx->ModelviewMatrixStack.Top->inv, l->EyePosition );
- _mesa_Lightfv( lgt, GL_POSITION, tmp );
- TRANSFORM_NORMAL( tmp, l->EyeDirection, ctx->ModelviewMatrixStack.Top->m );
- _mesa_Lightfv( lgt, GL_SPOT_DIRECTION, tmp );
- _mesa_Lightfv( lgt, GL_SPOT_EXPONENT, &l->SpotExponent );
- _mesa_Lightfv( lgt, GL_SPOT_CUTOFF, &l->SpotCutoff );
- _mesa_Lightfv( lgt, GL_CONSTANT_ATTENUATION,
- &l->ConstantAttenuation );
- _mesa_Lightfv( lgt, GL_LINEAR_ATTENUATION,
- &l->LinearAttenuation );
- _mesa_Lightfv( lgt, GL_QUADRATIC_ATTENUATION,
- &l->QuadraticAttenuation );
+ _mesa_set_enable(ctx, GL_LIGHT0 + i, l->Enabled);
+ _mesa_light(ctx, i, GL_AMBIENT, l->Ambient);
+ _mesa_light(ctx, i, GL_DIFFUSE, l->Diffuse);
+ _mesa_light(ctx, i, GL_SPECULAR, l->Specular );
+ _mesa_light(ctx, i, GL_POSITION, l->EyePosition);
+ _mesa_light(ctx, i, GL_SPOT_DIRECTION, l->EyeDirection);
+ _mesa_light(ctx, i, GL_SPOT_EXPONENT, &l->SpotExponent);
+ _mesa_light(ctx, i, GL_SPOT_CUTOFF, &l->SpotCutoff);
+ _mesa_light(ctx, i, GL_CONSTANT_ATTENUATION,
+ &l->ConstantAttenuation);
+ _mesa_light(ctx, i, GL_LINEAR_ATTENUATION,
+ &l->LinearAttenuation);
+ _mesa_light(ctx, i, GL_QUADRATIC_ATTENUATION,
+ &l->QuadraticAttenuation);
}
/* light model */
_mesa_LightModelfv(GL_LIGHT_MODEL_AMBIENT,
diff --git a/src/mesa/main/dd.h b/src/mesa/main/dd.h
index d07a7a2..f150cf9 100644
--- a/src/mesa/main/dd.h
+++ b/src/mesa/main/dd.h
@@ -658,7 +658,10 @@
void (*Hint)(GLcontext *ctx, GLenum target, GLenum mode);
/** Control the writing of individual bits in the color index buffers */
void (*IndexMask)(GLcontext *ctx, GLuint mask);
- /** Set light source parameters */
+ /** Set light source parameters.
+ * Note: for GL_POSITION and GL_SPOT_DIRECTION, params will have already
+ * been transformed to eye-space.
+ */
void (*Lightfv)(GLcontext *ctx, GLenum light,
GLenum pname, const GLfloat *params );
/** Set the lighting model parameters */
diff --git a/src/mesa/main/light.c b/src/mesa/main/light.c
index f9b5908..8fa62eb 100644
--- a/src/mesa/main/light.c
+++ b/src/mesa/main/light.c
@@ -59,6 +59,112 @@
}
+/**
+ * Helper function called by _mesa_Lightfv and _mesa_PopAttrib to set
+ * per-light state.
+ * For GL_POSITION and GL_SPOT_DIRECTION the params position/direction
+ * will have already been transformed by the modelview matrix!
+ * Also, all error checking should have already been done.
+ */
+void
+_mesa_light(GLcontext *ctx, GLuint lnum, GLenum pname, const GLfloat *params)
+{
+ struct gl_light *light;
+
+ ASSERT(lnum < MAX_LIGHTS);
+ light = &ctx->Light.Light[lnum];
+
+ switch (pname) {
+ case GL_AMBIENT:
+ if (TEST_EQ_4V(light->Ambient, params))
+ return;
+ FLUSH_VERTICES(ctx, _NEW_LIGHT);
+ COPY_4V( light->Ambient, params );
+ break;
+ case GL_DIFFUSE:
+ if (TEST_EQ_4V(light->Diffuse, params))
+ return;
+ FLUSH_VERTICES(ctx, _NEW_LIGHT);
+ COPY_4V( light->Diffuse, params );
+ break;
+ case GL_SPECULAR:
+ if (TEST_EQ_4V(light->Specular, params))
+ return;
+ FLUSH_VERTICES(ctx, _NEW_LIGHT);
+ COPY_4V( light->Specular, params );
+ break;
+ case GL_POSITION:
+ /* NOTE: position has already been transformed by ModelView! */
+ if (TEST_EQ_4V(light->EyePosition, params))
+ return;
+ FLUSH_VERTICES(ctx, _NEW_LIGHT);
+ COPY_4V(light->EyePosition, params);
+ if (light->EyePosition[3] != 0.0F)
+ light->_Flags |= LIGHT_POSITIONAL;
+ else
+ light->_Flags &= ~LIGHT_POSITIONAL;
+ break;
+ case GL_SPOT_DIRECTION:
+ /* NOTE: Direction already transformed by inverse ModelView! */
+ if (TEST_EQ_3V(light->EyeDirection, params))
+ return;
+ FLUSH_VERTICES(ctx, _NEW_LIGHT);
+ COPY_3V(light->EyeDirection, params);
+ break;
+ case GL_SPOT_EXPONENT:
+ ASSERT(params[0] >= 0.0);
+ ASSERT(params[0] <= ctx->Const.MaxSpotExponent);
+ if (light->SpotExponent == params[0])
+ return;
+ FLUSH_VERTICES(ctx, _NEW_LIGHT);
+ light->SpotExponent = params[0];
+ _mesa_invalidate_spot_exp_table(light);
+ break;
+ case GL_SPOT_CUTOFF:
+ ASSERT(params[0] == 180.0 || (params[0] >= 0.0 && params[0] <= 90.0));
+ if (light->SpotCutoff == params[0])
+ return;
+ FLUSH_VERTICES(ctx, _NEW_LIGHT);
+ light->SpotCutoff = params[0];
+ light->_CosCutoff = (GLfloat) _mesa_cos(params[0]*DEG2RAD);
+ if (light->_CosCutoff < 0)
+ light->_CosCutoff = 0;
+ if (light->SpotCutoff != 180.0F)
+ light->_Flags |= LIGHT_SPOT;
+ else
+ light->_Flags &= ~LIGHT_SPOT;
+ break;
+ case GL_CONSTANT_ATTENUATION:
+ ASSERT(params[0] >= 0.0);
+ if (light->ConstantAttenuation == params[0])
+ return;
+ FLUSH_VERTICES(ctx, _NEW_LIGHT);
+ light->ConstantAttenuation = params[0];
+ break;
+ case GL_LINEAR_ATTENUATION:
+ ASSERT(params[0] >= 0.0);
+ if (light->LinearAttenuation == params[0])
+ return;
+ FLUSH_VERTICES(ctx, _NEW_LIGHT);
+ light->LinearAttenuation = params[0];
+ break;
+ case GL_QUADRATIC_ATTENUATION:
+ ASSERT(params[0] >= 0.0);
+ if (light->QuadraticAttenuation == params[0])
+ return;
+ FLUSH_VERTICES(ctx, _NEW_LIGHT);
+ light->QuadraticAttenuation = params[0];
+ break;
+ default:
+ _mesa_problem(ctx, "Unexpected pname in _mesa_light()");
+ return;
+ }
+
+ if (ctx->Driver.Lightfv)
+ ctx->Driver.Lightfv( ctx, GL_LIGHT0 + lnum, pname, params );
+}
+
+
void GLAPIENTRY
_mesa_Lightf( GLenum light, GLenum pname, GLfloat param )
{
@@ -71,124 +177,69 @@
{
GET_CURRENT_CONTEXT(ctx);
GLint i = (GLint) (light - GL_LIGHT0);
- struct gl_light *l = &ctx->Light.Light[i];
+ GLfloat temp[4];
if (i < 0 || i >= (GLint) ctx->Const.MaxLights) {
_mesa_error( ctx, GL_INVALID_ENUM, "glLight(light=0x%x)", light );
return;
}
+ /* do particular error checks, transformations */
switch (pname) {
case GL_AMBIENT:
- if (TEST_EQ_4V(l->Ambient, params))
- return;
- FLUSH_VERTICES(ctx, _NEW_LIGHT);
- COPY_4V( l->Ambient, params );
- break;
case GL_DIFFUSE:
- if (TEST_EQ_4V(l->Diffuse, params))
- return;
- FLUSH_VERTICES(ctx, _NEW_LIGHT);
- COPY_4V( l->Diffuse, params );
- break;
case GL_SPECULAR:
- if (TEST_EQ_4V(l->Specular, params))
- return;
- FLUSH_VERTICES(ctx, _NEW_LIGHT);
- COPY_4V( l->Specular, params );
+ /* nothing */
break;
- case GL_POSITION: {
- GLfloat tmp[4];
+ case GL_POSITION:
/* transform position by ModelView matrix */
- TRANSFORM_POINT( tmp, ctx->ModelviewMatrixStack.Top->m, params );
- if (TEST_EQ_4V(l->EyePosition, tmp))
- return;
- FLUSH_VERTICES(ctx, _NEW_LIGHT);
- COPY_4V(l->EyePosition, tmp);
- if (l->EyePosition[3] != 0.0F)
- l->_Flags |= LIGHT_POSITIONAL;
- else
- l->_Flags &= ~LIGHT_POSITIONAL;
+ TRANSFORM_POINT(temp, ctx->ModelviewMatrixStack.Top->m, params);
+ params = temp;
break;
- }
- case GL_SPOT_DIRECTION: {
- GLfloat tmp[4];
+ case GL_SPOT_DIRECTION:
/* transform direction by inverse modelview */
if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) {
- _math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
+ _math_matrix_analyse(ctx->ModelviewMatrixStack.Top);
}
- TRANSFORM_NORMAL( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
- if (TEST_EQ_3V(l->EyeDirection, tmp))
- return;
- FLUSH_VERTICES(ctx, _NEW_LIGHT);
- COPY_3V(l->EyeDirection, tmp);
+ TRANSFORM_NORMAL(temp, params, ctx->ModelviewMatrixStack.Top->inv);
+ params = temp;
break;
- }
case GL_SPOT_EXPONENT:
- if (params[0]<0.0 || params[0]>ctx->Const.MaxSpotExponent) {
- _mesa_error( ctx, GL_INVALID_VALUE, "glLight" );
+ if (params[0] < 0.0 || params[0] > ctx->Const.MaxSpotExponent) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glLight");
return;
}
- if (l->SpotExponent == params[0])
- return;
- FLUSH_VERTICES(ctx, _NEW_LIGHT);
- l->SpotExponent = params[0];
- _mesa_invalidate_spot_exp_table( l );
break;
case GL_SPOT_CUTOFF:
- if ((params[0]<0.0 || params[0]>90.0) && params[0]!=180.0) {
- _mesa_error( ctx, GL_INVALID_VALUE, "glLight" );
+ if ((params[0] < 0.0 || params[0] > 90.0) && params[0] != 180.0) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glLight");
return;
}
- if (l->SpotCutoff == params[0])
- return;
- FLUSH_VERTICES(ctx, _NEW_LIGHT);
- l->SpotCutoff = params[0];
- l->_CosCutoff = (GLfloat) _mesa_cos(params[0]*DEG2RAD);
- if (l->_CosCutoff < 0)
- l->_CosCutoff = 0;
- if (l->SpotCutoff != 180.0F)
- l->_Flags |= LIGHT_SPOT;
- else
- l->_Flags &= ~LIGHT_SPOT;
break;
case GL_CONSTANT_ATTENUATION:
- if (params[0]<0.0) {
- _mesa_error( ctx, GL_INVALID_VALUE, "glLight" );
+ if (params[0] < 0.0) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glLight");
return;
}
- if (l->ConstantAttenuation == params[0])
- return;
- FLUSH_VERTICES(ctx, _NEW_LIGHT);
- l->ConstantAttenuation = params[0];
break;
case GL_LINEAR_ATTENUATION:
- if (params[0]<0.0) {
- _mesa_error( ctx, GL_INVALID_VALUE, "glLight" );
+ if (params[0] < 0.0) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glLight");
return;
}
- if (l->LinearAttenuation == params[0])
- return;
- FLUSH_VERTICES(ctx, _NEW_LIGHT);
- l->LinearAttenuation = params[0];
break;
case GL_QUADRATIC_ATTENUATION:
- if (params[0]<0.0) {
- _mesa_error( ctx, GL_INVALID_VALUE, "glLight" );
+ if (params[0] < 0.0) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glLight");
return;
}
- if (l->QuadraticAttenuation == params[0])
- return;
- FLUSH_VERTICES(ctx, _NEW_LIGHT);
- l->QuadraticAttenuation = params[0];
break;
default:
- _mesa_error( ctx, GL_INVALID_ENUM, "glLight(pname=0x%x)", pname );
+ _mesa_error(ctx, GL_INVALID_ENUM, "glLight(pname=0x%x)", pname);
return;
}
- if (ctx->Driver.Lightfv)
- ctx->Driver.Lightfv( ctx, light, pname, params );
+ _mesa_light(ctx, i, pname, params);
}
diff --git a/src/mesa/main/light.h b/src/mesa/main/light.h
index 1f19019..f47fe58 100644
--- a/src/mesa/main/light.h
+++ b/src/mesa/main/light.h
@@ -78,6 +78,10 @@
_mesa_GetMaterialiv( GLenum face, GLenum pname, GLint *params );
+extern void
+_mesa_light(GLcontext *ctx, GLuint lnum, GLenum pname, const GLfloat *params);
+
+
/* Lerp between adjacent values in the f(x) lookup table, giving a
* continuous function, with adequeate overall accuracy. (Though
* still pretty good compared to a straight lookup).