X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Flight.c;h=984f7b2abc46b111268c94213761b1507e30c6f3;hb=6340d6bf22ad0bfedf8565500336237a8da887f5;hp=b50eba7e9d07a95a73e9bb8795aa9e03b3819df7;hpb=9a33a11d714c90162d32781ebbd2c1dfab52cfd1;p=mesa.git diff --git a/src/mesa/main/light.c b/src/mesa/main/light.c index b50eba7e9d0..984f7b2abc4 100644 --- a/src/mesa/main/light.c +++ b/src/mesa/main/light.c @@ -1,10 +1,8 @@ -/* $Id: light.c,v 1.50 2002/06/13 04:28:29 brianp Exp $ */ - /* * Mesa 3-D graphics library - * Version: 4.1 + * Version: 6.5 * - * Copyright (C) 1999-2002 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2005 Brian Paul All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -25,39 +23,25 @@ */ -#ifdef PC_HEADER -#include "all.h" -#else #include "glheader.h" -#include "colormac.h" +#include "imports.h" #include "context.h" #include "enums.h" #include "light.h" #include "macros.h" -#include "mem.h" -#include "mmath.h" #include "simple_list.h" #include "mtypes.h" - -#include "math/m_xform.h" #include "math/m_matrix.h" -#endif - -/* XXX this is a bit of a hack needed for compilation within XFree86 */ -#ifndef FLT_MIN -#define FLT_MIN 1e-37 -#endif - -void +void GLAPIENTRY _mesa_ShadeModel( GLenum mode ) { GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); if (MESA_VERBOSE & VERBOSE_API) - _mesa_debug("glShadeModel %s\n", _mesa_lookup_enum_by_nr(mode)); + _mesa_debug(ctx, "glShadeModel %s\n", _mesa_lookup_enum_by_nr(mode)); if (mode != GL_FLAT && mode != GL_SMOOTH) { _mesa_error( ctx, GL_INVALID_ENUM, "glShadeModel" ); @@ -75,148 +59,200 @@ _mesa_ShadeModel( GLenum mode ) } - +/** + * 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->_CosCutoffNeg = (GLfloat) (_mesa_cos(light->SpotCutoff * DEG2RAD)); + if (light->_CosCutoffNeg < 0) + light->_CosCutoff = 0; + else + light->_CosCutoff = light->_CosCutoffNeg; + 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 ) { _mesa_Lightfv( light, pname, ¶m ); } -void +void GLAPIENTRY _mesa_Lightfv( GLenum light, GLenum pname, const GLfloat *params ) { 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" ); + _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 (ctx->ModelviewMatrixStack.Top->flags & MAT_DIRTY_INVERSE) { - _math_matrix_analyse( ctx->ModelviewMatrixStack.Top ); + if (_math_matrix_is_dirty(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]>128.0) { - _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) 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" ); + _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); } -void +void GLAPIENTRY _mesa_Lighti( GLenum light, GLenum pname, GLint param ) { _mesa_Lightiv( light, pname, ¶m ); } -void +void GLAPIENTRY _mesa_Lightiv( GLenum light, GLenum pname, const GLint *params ) { GLfloat fparam[4]; @@ -258,7 +294,7 @@ _mesa_Lightiv( GLenum light, GLenum pname, const GLint *params ) -void +void GLAPIENTRY _mesa_GetLightfv( GLenum light, GLenum pname, GLfloat *params ) { GET_CURRENT_CONTEXT(ctx); @@ -308,8 +344,7 @@ _mesa_GetLightfv( GLenum light, GLenum pname, GLfloat *params ) } - -void +void GLAPIENTRY _mesa_GetLightiv( GLenum light, GLenum pname, GLint *params ) { GET_CURRENT_CONTEXT(ctx); @@ -379,7 +414,7 @@ _mesa_GetLightiv( GLenum light, GLenum pname, GLint *params ) /**********************************************************************/ -void +void GLAPIENTRY _mesa_LightModelfv( GLenum pname, const GLfloat *params ) { GLenum newenum; @@ -419,24 +454,17 @@ _mesa_LightModelfv( GLenum pname, const GLfloat *params ) else if (params[0] == (GLfloat) GL_SEPARATE_SPECULAR_COLOR) newenum = GL_SEPARATE_SPECULAR_COLOR; else { - _mesa_error( ctx, GL_INVALID_ENUM, "glLightModel(param)" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glLightModel(param=0x0%x)", + (GLint) params[0] ); return; } if (ctx->Light.Model.ColorControl == newenum) return; FLUSH_VERTICES(ctx, _NEW_LIGHT); ctx->Light.Model.ColorControl = newenum; - - if ((ctx->Light.Enabled && - ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR) - || ctx->Fog.ColorSumEnabled) - ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR; - else - ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR; - break; default: - _mesa_error( ctx, GL_INVALID_ENUM, "glLightModel" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glLightModel(pname=0x%x)", pname ); break; } @@ -445,7 +473,7 @@ _mesa_LightModelfv( GLenum pname, const GLfloat *params ) } -void +void GLAPIENTRY _mesa_LightModeliv( GLenum pname, const GLint *params ) { GLfloat fparam[4]; @@ -470,14 +498,14 @@ _mesa_LightModeliv( GLenum pname, const GLint *params ) } -void +void GLAPIENTRY _mesa_LightModeli( GLenum pname, GLint param ) { _mesa_LightModeliv( pname, ¶m ); } -void +void GLAPIENTRY _mesa_LightModelf( GLenum pname, GLfloat param ) { _mesa_LightModelfv( pname, ¶m ); @@ -501,26 +529,26 @@ _mesa_material_bitmask( GLcontext *ctx, GLenum face, GLenum pname, /* Make a bitmask indicating what material attribute(s) we're updating */ switch (pname) { case GL_EMISSION: - bitmask |= FRONT_EMISSION_BIT | BACK_EMISSION_BIT; + bitmask |= MAT_BIT_FRONT_EMISSION | MAT_BIT_BACK_EMISSION; break; case GL_AMBIENT: - bitmask |= FRONT_AMBIENT_BIT | BACK_AMBIENT_BIT; + bitmask |= MAT_BIT_FRONT_AMBIENT | MAT_BIT_BACK_AMBIENT; break; case GL_DIFFUSE: - bitmask |= FRONT_DIFFUSE_BIT | BACK_DIFFUSE_BIT; + bitmask |= MAT_BIT_FRONT_DIFFUSE | MAT_BIT_BACK_DIFFUSE; break; case GL_SPECULAR: - bitmask |= FRONT_SPECULAR_BIT | BACK_SPECULAR_BIT; + bitmask |= MAT_BIT_FRONT_SPECULAR | MAT_BIT_BACK_SPECULAR; break; case GL_SHININESS: - bitmask |= FRONT_SHININESS_BIT | BACK_SHININESS_BIT; + bitmask |= MAT_BIT_FRONT_SHININESS | MAT_BIT_BACK_SHININESS; break; case GL_AMBIENT_AND_DIFFUSE: - bitmask |= FRONT_AMBIENT_BIT | BACK_AMBIENT_BIT; - bitmask |= FRONT_DIFFUSE_BIT | BACK_DIFFUSE_BIT; + bitmask |= MAT_BIT_FRONT_AMBIENT | MAT_BIT_BACK_AMBIENT; + bitmask |= MAT_BIT_FRONT_DIFFUSE | MAT_BIT_BACK_DIFFUSE; break; case GL_COLOR_INDEXES: - bitmask |= FRONT_INDEXES_BIT | BACK_INDEXES_BIT; + bitmask |= MAT_BIT_FRONT_INDEXES | MAT_BIT_BACK_INDEXES; break; default: _mesa_error( ctx, GL_INVALID_ENUM, where ); @@ -547,330 +575,140 @@ _mesa_material_bitmask( GLcontext *ctx, GLenum face, GLenum pname, } -/* Perform a straight copy between pairs of materials. + +/* Perform a straight copy between materials. */ -void _mesa_copy_material_pairs( struct gl_material dst[2], - const struct gl_material src[2], - GLuint bitmask ) +void +_mesa_copy_materials( struct gl_material *dst, + const struct gl_material *src, + GLuint bitmask ) { - if (bitmask & FRONT_EMISSION_BIT) { - COPY_4FV( dst[0].Emission, src[0].Emission ); - } - if (bitmask & BACK_EMISSION_BIT) { - COPY_4FV( dst[1].Emission, src[1].Emission ); - } - if (bitmask & FRONT_AMBIENT_BIT) { - COPY_4FV( dst[0].Ambient, src[0].Ambient ); - } - if (bitmask & BACK_AMBIENT_BIT) { - COPY_4FV( dst[1].Ambient, src[1].Ambient ); - } - if (bitmask & FRONT_DIFFUSE_BIT) { - COPY_4FV( dst[0].Diffuse, src[0].Diffuse ); - } - if (bitmask & BACK_DIFFUSE_BIT) { - COPY_4FV( dst[1].Diffuse, src[1].Diffuse ); - } - if (bitmask & FRONT_SPECULAR_BIT) { - COPY_4FV( dst[0].Specular, src[0].Specular ); - } - if (bitmask & BACK_SPECULAR_BIT) { - COPY_4FV( dst[1].Specular, src[1].Specular ); - } - if (bitmask & FRONT_SHININESS_BIT) { - dst[0].Shininess = src[0].Shininess; - } - if (bitmask & BACK_SHININESS_BIT) { - dst[1].Shininess = src[1].Shininess; - } - if (bitmask & FRONT_INDEXES_BIT) { - dst[0].AmbientIndex = src[0].AmbientIndex; - dst[0].DiffuseIndex = src[0].DiffuseIndex; - dst[0].SpecularIndex = src[0].SpecularIndex; - } - if (bitmask & BACK_INDEXES_BIT) { - dst[1].AmbientIndex = src[1].AmbientIndex; - dst[1].DiffuseIndex = src[1].DiffuseIndex; - dst[1].SpecularIndex = src[1].SpecularIndex; - } + int i; + + for (i = 0 ; i < MAT_ATTRIB_MAX ; i++) + if (bitmask & (1<Attrib[i], src->Attrib[i] ); } -/* - * Check if the global material has to be updated with info that was - * associated with a vertex via glMaterial. - * This function is used when any material values get changed between - * glBegin/glEnd either by calling glMaterial() or by calling glColor() - * when GL_COLOR_MATERIAL is enabled. - * - * src[0] is front material, src[1] is back material - * - * Additionally keeps the precomputed lighting state uptodate. + +/* Update derived values following a change in ctx->Light.Material */ -void _mesa_update_material( GLcontext *ctx, - const struct gl_material src[2], - GLuint bitmask ) +void +_mesa_update_material( GLcontext *ctx, GLuint bitmask ) { struct gl_light *light, *list = &ctx->Light.EnabledList; + GLfloat (*mat)[4] = ctx->Light.Material.Attrib; - if (ctx->Light.ColorMaterialEnabled) - bitmask &= ~ctx->Light.ColorMaterialBitmask; - - if (MESA_VERBOSE&VERBOSE_IMMEDIATE) - _mesa_debug("_mesa_update_material, mask 0x%x\n", bitmask); + if (MESA_VERBOSE&VERBOSE_IMMEDIATE) + _mesa_debug(ctx, "_mesa_update_material, mask 0x%x\n", bitmask); if (!bitmask) return; - /* update material emission */ - if (bitmask & FRONT_EMISSION_BIT) { - struct gl_material *mat = &ctx->Light.Material[0]; - COPY_4FV( mat->Emission, src[0].Emission ); - } - if (bitmask & BACK_EMISSION_BIT) { - struct gl_material *mat = &ctx->Light.Material[1]; - COPY_4FV( mat->Emission, src[1].Emission ); - } - /* update material ambience */ - if (bitmask & FRONT_AMBIENT_BIT) { - struct gl_material *mat = &ctx->Light.Material[0]; - COPY_4FV( mat->Ambient, src[0].Ambient ); + if (bitmask & MAT_BIT_FRONT_AMBIENT) { foreach (light, list) { - SCALE_3V( light->_MatAmbient[0], light->Ambient, src[0].Ambient); + SCALE_3V( light->_MatAmbient[0], light->Ambient, + mat[MAT_ATTRIB_FRONT_AMBIENT]); } } - if (bitmask & BACK_AMBIENT_BIT) { - struct gl_material *mat = &ctx->Light.Material[1]; - COPY_4FV( mat->Ambient, src[1].Ambient ); + + if (bitmask & MAT_BIT_BACK_AMBIENT) { foreach (light, list) { - SCALE_3V( light->_MatAmbient[1], light->Ambient, src[1].Ambient); + SCALE_3V( light->_MatAmbient[1], light->Ambient, + mat[MAT_ATTRIB_BACK_AMBIENT]); } } /* update BaseColor = emission + scene's ambience * material's ambience */ - if (bitmask & (FRONT_EMISSION_BIT | FRONT_AMBIENT_BIT)) { - struct gl_material *mat = &ctx->Light.Material[0]; - COPY_3V( ctx->Light._BaseColor[0], mat->Emission ); - ACC_SCALE_3V( ctx->Light._BaseColor[0], mat->Ambient, + if (bitmask & (MAT_BIT_FRONT_EMISSION | MAT_BIT_FRONT_AMBIENT)) { + COPY_3V( ctx->Light._BaseColor[0], mat[MAT_ATTRIB_FRONT_EMISSION] ); + ACC_SCALE_3V( ctx->Light._BaseColor[0], mat[MAT_ATTRIB_FRONT_AMBIENT], ctx->Light.Model.Ambient ); } - if (bitmask & (BACK_EMISSION_BIT | BACK_AMBIENT_BIT)) { - struct gl_material *mat = &ctx->Light.Material[1]; - COPY_3V( ctx->Light._BaseColor[1], mat->Emission ); - ACC_SCALE_3V( ctx->Light._BaseColor[1], mat->Ambient, + + if (bitmask & (MAT_BIT_BACK_EMISSION | MAT_BIT_BACK_AMBIENT)) { + COPY_3V( ctx->Light._BaseColor[1], mat[MAT_ATTRIB_BACK_EMISSION] ); + ACC_SCALE_3V( ctx->Light._BaseColor[1], mat[MAT_ATTRIB_BACK_AMBIENT], ctx->Light.Model.Ambient ); } /* update material diffuse values */ - if (bitmask & FRONT_DIFFUSE_BIT) { - struct gl_material *mat = &ctx->Light.Material[0]; - COPY_4FV( mat->Diffuse, src[0].Diffuse ); + if (bitmask & MAT_BIT_FRONT_DIFFUSE) { foreach (light, list) { - SCALE_3V( light->_MatDiffuse[0], light->Diffuse, mat->Diffuse ); + SCALE_3V( light->_MatDiffuse[0], light->Diffuse, + mat[MAT_ATTRIB_FRONT_DIFFUSE] ); } } - if (bitmask & BACK_DIFFUSE_BIT) { - struct gl_material *mat = &ctx->Light.Material[1]; - COPY_4FV( mat->Diffuse, src[1].Diffuse ); + + if (bitmask & MAT_BIT_BACK_DIFFUSE) { foreach (light, list) { - SCALE_3V( light->_MatDiffuse[1], light->Diffuse, mat->Diffuse ); + SCALE_3V( light->_MatDiffuse[1], light->Diffuse, + mat[MAT_ATTRIB_BACK_DIFFUSE] ); } } /* update material specular values */ - if (bitmask & FRONT_SPECULAR_BIT) { - struct gl_material *mat = &ctx->Light.Material[0]; - COPY_4FV( mat->Specular, src[0].Specular ); + if (bitmask & MAT_BIT_FRONT_SPECULAR) { foreach (light, list) { - SCALE_3V( light->_MatSpecular[0], light->Specular, mat->Specular); + SCALE_3V( light->_MatSpecular[0], light->Specular, + mat[MAT_ATTRIB_FRONT_SPECULAR]); } } - if (bitmask & BACK_SPECULAR_BIT) { - struct gl_material *mat = &ctx->Light.Material[1]; - COPY_4FV( mat->Specular, src[1].Specular ); + + if (bitmask & MAT_BIT_BACK_SPECULAR) { foreach (light, list) { - SCALE_3V( light->_MatSpecular[1], light->Specular, mat->Specular); + SCALE_3V( light->_MatSpecular[1], light->Specular, + mat[MAT_ATTRIB_BACK_SPECULAR]); } } - if (bitmask & FRONT_SHININESS_BIT) { - ctx->Light.Material[0].Shininess = src[0].Shininess; + if (bitmask & MAT_BIT_FRONT_SHININESS) { _mesa_invalidate_shine_table( ctx, 0 ); } - if (bitmask & BACK_SHININESS_BIT) { - ctx->Light.Material[1].Shininess = src[1].Shininess; - _mesa_invalidate_shine_table( ctx, 1 ); - } - if (bitmask & FRONT_INDEXES_BIT) { - ctx->Light.Material[0].AmbientIndex = src[0].AmbientIndex; - ctx->Light.Material[0].DiffuseIndex = src[0].DiffuseIndex; - ctx->Light.Material[0].SpecularIndex = src[0].SpecularIndex; - } - if (bitmask & BACK_INDEXES_BIT) { - ctx->Light.Material[1].AmbientIndex = src[1].AmbientIndex; - ctx->Light.Material[1].DiffuseIndex = src[1].DiffuseIndex; - ctx->Light.Material[1].SpecularIndex = src[1].SpecularIndex; - } - - if (0) - { - struct gl_material *mat = &ctx->Light.Material[0]; - _mesa_debug("update_mat emission : %f %f %f\n", - mat->Emission[0], - mat->Emission[1], - mat->Emission[2]); - _mesa_debug("update_mat specular : %f %f %f\n", - mat->Specular[0], - mat->Specular[1], - mat->Specular[2]); - _mesa_debug("update_mat diffuse : %f %f %f\n", - mat->Diffuse[0], - mat->Diffuse[1], - mat->Diffuse[2]); - _mesa_debug("update_mat ambient : %f %f %f\n", - mat->Ambient[0], - mat->Ambient[1], - mat->Ambient[2]); + if (bitmask & MAT_BIT_BACK_SHININESS) { + _mesa_invalidate_shine_table( ctx, 1 ); } } - - - - - /* * Update the current materials from the given rgba color * according to the bitmask in ColorMaterialBitmask, which is * set by glColorMaterial(). */ -void _mesa_update_color_material( GLcontext *ctx, - const GLfloat color[4] ) +void +_mesa_update_color_material( GLcontext *ctx, const GLfloat color[4] ) { - struct gl_light *light, *list = &ctx->Light.EnabledList; GLuint bitmask = ctx->Light.ColorMaterialBitmask; + struct gl_material *mat = &ctx->Light.Material; + int i; - if (MESA_VERBOSE&VERBOSE_IMMEDIATE) - _mesa_debug("_mesa_update_color_material, mask 0x%x\n", bitmask); - - /* update emissive colors */ - if (bitmask & FRONT_EMISSION_BIT) { - struct gl_material *mat = &ctx->Light.Material[0]; - COPY_4FV( mat->Emission, color ); - } - - if (bitmask & BACK_EMISSION_BIT) { - struct gl_material *mat = &ctx->Light.Material[1]; - COPY_4FV( mat->Emission, color ); - } - - /* update light->_MatAmbient = light's ambient * material's ambient */ - if (bitmask & FRONT_AMBIENT_BIT) { - struct gl_material *mat = &ctx->Light.Material[0]; - foreach (light, list) { - SCALE_3V( light->_MatAmbient[0], light->Ambient, color); - } - COPY_4FV( mat->Ambient, color ); - } - - if (bitmask & BACK_AMBIENT_BIT) { - struct gl_material *mat = &ctx->Light.Material[1]; - foreach (light, list) { - SCALE_3V( light->_MatAmbient[1], light->Ambient, color); - } - COPY_4FV( mat->Ambient, color ); - } - - /* update BaseColor = emission + scene's ambience * material's ambience */ - if (bitmask & (FRONT_EMISSION_BIT | FRONT_AMBIENT_BIT)) { - struct gl_material *mat = &ctx->Light.Material[0]; - COPY_3V( ctx->Light._BaseColor[0], mat->Emission ); - ACC_SCALE_3V( ctx->Light._BaseColor[0], mat->Ambient, ctx->Light.Model.Ambient ); - } + for (i = 0 ; i < MAT_ATTRIB_MAX ; i++) + if (bitmask & (1<Attrib[i], color ); - if (bitmask & (BACK_EMISSION_BIT | BACK_AMBIENT_BIT)) { - struct gl_material *mat = &ctx->Light.Material[1]; - COPY_3V( ctx->Light._BaseColor[1], mat->Emission ); - ACC_SCALE_3V( ctx->Light._BaseColor[1], mat->Ambient, ctx->Light.Model.Ambient ); - } - - /* update light->_MatDiffuse = light's diffuse * material's diffuse */ - if (bitmask & FRONT_DIFFUSE_BIT) { - struct gl_material *mat = &ctx->Light.Material[0]; - COPY_4FV( mat->Diffuse, color ); - foreach (light, list) { - SCALE_3V( light->_MatDiffuse[0], light->Diffuse, mat->Diffuse ); - } - } - - if (bitmask & BACK_DIFFUSE_BIT) { - struct gl_material *mat = &ctx->Light.Material[1]; - COPY_4FV( mat->Diffuse, color ); - foreach (light, list) { - SCALE_3V( light->_MatDiffuse[1], light->Diffuse, mat->Diffuse ); - } - } - - /* update light->_MatSpecular = light's specular * material's specular */ - if (bitmask & FRONT_SPECULAR_BIT) { - struct gl_material *mat = &ctx->Light.Material[0]; - COPY_4FV( mat->Specular, color ); - foreach (light, list) { - ACC_SCALE_3V( light->_MatSpecular[0], light->Specular, mat->Specular); - } - } - - if (bitmask & BACK_SPECULAR_BIT) { - struct gl_material *mat = &ctx->Light.Material[1]; - COPY_4FV( mat->Specular, color ); - foreach (light, list) { - ACC_SCALE_3V( light->_MatSpecular[1], light->Specular, mat->Specular); - } - } - - if (0) - { - struct gl_material *mat = &ctx->Light.Material[0]; - _mesa_debug("update_color_mat emission : %f %f %f\n", - mat->Emission[0], - mat->Emission[1], - mat->Emission[2]); - _mesa_debug("update_color_mat specular : %f %f %f\n", - mat->Specular[0], - mat->Specular[1], - mat->Specular[2]); - _mesa_debug("update_color_mat diffuse : %f %f %f\n", - mat->Diffuse[0], - mat->Diffuse[1], - mat->Diffuse[2]); - _mesa_debug("update_color_mat ambient : %f %f %f\n", - mat->Ambient[0], - mat->Ambient[1], - mat->Ambient[2]); - } + _mesa_update_material( ctx, bitmask ); } - - -void +void GLAPIENTRY _mesa_ColorMaterial( GLenum face, GLenum mode ) { GET_CURRENT_CONTEXT(ctx); GLuint bitmask; - GLuint legal = (FRONT_EMISSION_BIT | BACK_EMISSION_BIT | - FRONT_SPECULAR_BIT | BACK_SPECULAR_BIT | - FRONT_DIFFUSE_BIT | BACK_DIFFUSE_BIT | - FRONT_AMBIENT_BIT | BACK_AMBIENT_BIT); + GLuint legal = (MAT_BIT_FRONT_EMISSION | MAT_BIT_BACK_EMISSION | + MAT_BIT_FRONT_SPECULAR | MAT_BIT_BACK_SPECULAR | + MAT_BIT_FRONT_DIFFUSE | MAT_BIT_BACK_DIFFUSE | + MAT_BIT_FRONT_AMBIENT | MAT_BIT_BACK_AMBIENT); ASSERT_OUTSIDE_BEGIN_END(ctx); if (MESA_VERBOSE&VERBOSE_API) - _mesa_debug("glColorMaterial %s %s\n", - _mesa_lookup_enum_by_nr(face), - _mesa_lookup_enum_by_nr(mode)); + _mesa_debug(ctx, "glColorMaterial %s %s\n", + _mesa_lookup_enum_by_nr(face), + _mesa_lookup_enum_by_nr(mode)); bitmask = _mesa_material_bitmask(ctx, face, mode, legal, "glColorMaterial"); @@ -894,16 +732,16 @@ _mesa_ColorMaterial( GLenum face, GLenum mode ) } - - - -void +void GLAPIENTRY _mesa_GetMaterialfv( GLenum face, GLenum pname, GLfloat *params ) { GET_CURRENT_CONTEXT(ctx); GLuint f; + GLfloat (*mat)[4] = ctx->Light.Material.Attrib; ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* update materials */ + FLUSH_CURRENT(ctx, 0); /* update ctx->Light.Material from vertex buffer */ + if (face==GL_FRONT) { f = 0; } @@ -914,26 +752,27 @@ _mesa_GetMaterialfv( GLenum face, GLenum pname, GLfloat *params ) _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(face)" ); return; } + switch (pname) { case GL_AMBIENT: - COPY_4FV( params, ctx->Light.Material[f].Ambient ); + COPY_4FV( params, mat[MAT_ATTRIB_AMBIENT(f)] ); break; case GL_DIFFUSE: - COPY_4FV( params, ctx->Light.Material[f].Diffuse ); + COPY_4FV( params, mat[MAT_ATTRIB_DIFFUSE(f)] ); break; case GL_SPECULAR: - COPY_4FV( params, ctx->Light.Material[f].Specular ); + COPY_4FV( params, mat[MAT_ATTRIB_SPECULAR(f)] ); break; case GL_EMISSION: - COPY_4FV( params, ctx->Light.Material[f].Emission ); + COPY_4FV( params, mat[MAT_ATTRIB_EMISSION(f)] ); break; case GL_SHININESS: - *params = ctx->Light.Material[f].Shininess; + *params = mat[MAT_ATTRIB_SHININESS(f)][0]; break; case GL_COLOR_INDEXES: - params[0] = ctx->Light.Material[f].AmbientIndex; - params[1] = ctx->Light.Material[f].DiffuseIndex; - params[2] = ctx->Light.Material[f].SpecularIndex; + params[0] = mat[MAT_ATTRIB_INDEXES(f)][0]; + params[1] = mat[MAT_ATTRIB_INDEXES(f)][1]; + params[2] = mat[MAT_ATTRIB_INDEXES(f)][2]; break; default: _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" ); @@ -941,14 +780,16 @@ _mesa_GetMaterialfv( GLenum face, GLenum pname, GLfloat *params ) } - -void +void GLAPIENTRY _mesa_GetMaterialiv( GLenum face, GLenum pname, GLint *params ) { GET_CURRENT_CONTEXT(ctx); GLuint f; + GLfloat (*mat)[4] = ctx->Light.Material.Attrib; ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* update materials */ + FLUSH_CURRENT(ctx, 0); /* update ctx->Light.Material from vertex buffer */ + if (face==GL_FRONT) { f = 0; } @@ -961,36 +802,36 @@ _mesa_GetMaterialiv( GLenum face, GLenum pname, GLint *params ) } switch (pname) { case GL_AMBIENT: - params[0] = FLOAT_TO_INT( ctx->Light.Material[f].Ambient[0] ); - params[1] = FLOAT_TO_INT( ctx->Light.Material[f].Ambient[1] ); - params[2] = FLOAT_TO_INT( ctx->Light.Material[f].Ambient[2] ); - params[3] = FLOAT_TO_INT( ctx->Light.Material[f].Ambient[3] ); + params[0] = FLOAT_TO_INT( mat[MAT_ATTRIB_AMBIENT(f)][0] ); + params[1] = FLOAT_TO_INT( mat[MAT_ATTRIB_AMBIENT(f)][1] ); + params[2] = FLOAT_TO_INT( mat[MAT_ATTRIB_AMBIENT(f)][2] ); + params[3] = FLOAT_TO_INT( mat[MAT_ATTRIB_AMBIENT(f)][3] ); break; case GL_DIFFUSE: - params[0] = FLOAT_TO_INT( ctx->Light.Material[f].Diffuse[0] ); - params[1] = FLOAT_TO_INT( ctx->Light.Material[f].Diffuse[1] ); - params[2] = FLOAT_TO_INT( ctx->Light.Material[f].Diffuse[2] ); - params[3] = FLOAT_TO_INT( ctx->Light.Material[f].Diffuse[3] ); + params[0] = FLOAT_TO_INT( mat[MAT_ATTRIB_DIFFUSE(f)][0] ); + params[1] = FLOAT_TO_INT( mat[MAT_ATTRIB_DIFFUSE(f)][1] ); + params[2] = FLOAT_TO_INT( mat[MAT_ATTRIB_DIFFUSE(f)][2] ); + params[3] = FLOAT_TO_INT( mat[MAT_ATTRIB_DIFFUSE(f)][3] ); break; case GL_SPECULAR: - params[0] = FLOAT_TO_INT( ctx->Light.Material[f].Specular[0] ); - params[1] = FLOAT_TO_INT( ctx->Light.Material[f].Specular[1] ); - params[2] = FLOAT_TO_INT( ctx->Light.Material[f].Specular[2] ); - params[3] = FLOAT_TO_INT( ctx->Light.Material[f].Specular[3] ); + params[0] = FLOAT_TO_INT( mat[MAT_ATTRIB_SPECULAR(f)][0] ); + params[1] = FLOAT_TO_INT( mat[MAT_ATTRIB_SPECULAR(f)][1] ); + params[2] = FLOAT_TO_INT( mat[MAT_ATTRIB_SPECULAR(f)][2] ); + params[3] = FLOAT_TO_INT( mat[MAT_ATTRIB_SPECULAR(f)][3] ); break; case GL_EMISSION: - params[0] = FLOAT_TO_INT( ctx->Light.Material[f].Emission[0] ); - params[1] = FLOAT_TO_INT( ctx->Light.Material[f].Emission[1] ); - params[2] = FLOAT_TO_INT( ctx->Light.Material[f].Emission[2] ); - params[3] = FLOAT_TO_INT( ctx->Light.Material[f].Emission[3] ); + params[0] = FLOAT_TO_INT( mat[MAT_ATTRIB_EMISSION(f)][0] ); + params[1] = FLOAT_TO_INT( mat[MAT_ATTRIB_EMISSION(f)][1] ); + params[2] = FLOAT_TO_INT( mat[MAT_ATTRIB_EMISSION(f)][2] ); + params[3] = FLOAT_TO_INT( mat[MAT_ATTRIB_EMISSION(f)][3] ); break; case GL_SHININESS: - *params = ROUNDF( ctx->Light.Material[f].Shininess ); + *params = IROUND( mat[MAT_ATTRIB_SHININESS(f)][0] ); break; case GL_COLOR_INDEXES: - params[0] = ROUNDF( ctx->Light.Material[f].AmbientIndex ); - params[1] = ROUNDF( ctx->Light.Material[f].DiffuseIndex ); - params[2] = ROUNDF( ctx->Light.Material[f].SpecularIndex ); + params[0] = IROUND( mat[MAT_ATTRIB_INDEXES(f)][0] ); + params[1] = IROUND( mat[MAT_ATTRIB_INDEXES(f)][1] ); + params[2] = IROUND( mat[MAT_ATTRIB_INDEXES(f)][2] ); break; default: _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" ); @@ -999,7 +840,6 @@ _mesa_GetMaterialiv( GLenum face, GLenum pname, GLint *params ) - /**********************************************************************/ /***** Lighting computation *****/ /**********************************************************************/ @@ -1049,7 +889,9 @@ _mesa_invalidate_spot_exp_table( struct gl_light *l ) l->_SpotExpTable[0][0] = -1; } -static void validate_spot_exp_table( struct gl_light *l ) + +static void +validate_spot_exp_table( struct gl_light *l ) { GLint i; GLdouble exponent = l->SpotExponent; @@ -1060,7 +902,7 @@ static void validate_spot_exp_table( struct gl_light *l ) for (i = EXP_TABLE_SIZE - 1; i > 0 ;i--) { if (clamp == 0) { - tmp = pow(i / (GLdouble) (EXP_TABLE_SIZE - 1), exponent); + tmp = _mesa_pow(i / (GLdouble) (EXP_TABLE_SIZE - 1), exponent); if (tmp < FLT_MIN * 100.0) { tmp = 0.0; clamp = 1; @@ -1077,24 +919,28 @@ static void validate_spot_exp_table( struct gl_light *l ) - /* Calculate a new shine table. Doing this here saves a branch in * lighting, and the cost of doing it early may be partially offset * by keeping a MRU cache of shine tables for various shine values. */ void -_mesa_invalidate_shine_table( GLcontext *ctx, GLuint i ) +_mesa_invalidate_shine_table( GLcontext *ctx, GLuint side ) { - if (ctx->_ShineTable[i]) - ctx->_ShineTable[i]->refcount--; - ctx->_ShineTable[i] = 0; + ASSERT(side < 2); + if (ctx->_ShineTable[side]) + ctx->_ShineTable[side]->refcount--; + ctx->_ShineTable[side] = NULL; } -static void validate_shine_table( GLcontext *ctx, GLuint i, GLfloat shininess ) + +static void +validate_shine_table( GLcontext *ctx, GLuint side, GLfloat shininess ) { struct gl_shine_tab *list = ctx->_ShineTabList; struct gl_shine_tab *s; + ASSERT(side < 2); + foreach(s, list) if ( s->shininess == shininess ) break; @@ -1118,7 +964,7 @@ static void validate_shine_table( GLcontext *ctx, GLuint i, GLfloat shininess ) GLdouble t, x = j / (GLfloat) (SHINE_TABLE_SIZE - 1); if (x < 0.005) /* underflow check */ x = 0.005; - t = pow(x, shininess); + t = _mesa_pow(x, shininess); if (t > 1e-20) m[j] = (GLfloat) t; else @@ -1130,37 +976,36 @@ static void validate_shine_table( GLcontext *ctx, GLuint i, GLfloat shininess ) s->shininess = shininess; } - if (ctx->_ShineTable[i]) - ctx->_ShineTable[i]->refcount--; + if (ctx->_ShineTable[side]) + ctx->_ShineTable[side]->refcount--; - ctx->_ShineTable[i] = s; + ctx->_ShineTable[side] = s; move_to_tail( list, s ); s->refcount++; } + void _mesa_validate_all_lighting_tables( GLcontext *ctx ) { - GLint i; + GLuint i; GLfloat shininess; - - shininess = ctx->Light.Material[0].Shininess; + + shininess = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SHININESS][0]; if (!ctx->_ShineTable[0] || ctx->_ShineTable[0]->shininess != shininess) validate_shine_table( ctx, 0, shininess ); - shininess = ctx->Light.Material[1].Shininess; + shininess = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_SHININESS][0]; if (!ctx->_ShineTable[1] || ctx->_ShineTable[1]->shininess != shininess) validate_shine_table( ctx, 1, shininess ); - for (i = 0 ; i < MAX_LIGHTS ; i++) + for (i = 0; i < ctx->Const.MaxLights; i++) if (ctx->Light.Light[i]._SpotExpTable[0][0] == -1) validate_spot_exp_table( &ctx->Light.Light[i] ); } - - -/* +/** * Examine current lighting parameters to determine if the optimized lighting * function can be used. * Also, precompute some lighting values such as the products of light @@ -1170,15 +1015,12 @@ void _mesa_update_lighting( GLcontext *ctx ) { struct gl_light *light; - ctx->_NeedEyeCoords &= ~NEED_EYE_LIGHT; - ctx->_NeedNormals &= ~NEED_NORMALS_LIGHT; + ctx->Light._NeedEyeCoords = GL_FALSE; ctx->Light._Flags = 0; if (!ctx->Light.Enabled) return; - ctx->_NeedNormals |= NEED_NORMALS_LIGHT; - foreach(light, &ctx->Light.EnabledList) { ctx->Light._Flags |= light->_Flags; } @@ -1188,18 +1030,15 @@ _mesa_update_lighting( GLcontext *ctx ) ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR || ctx->Light.Model.LocalViewer); - if ((ctx->Light._Flags & LIGHT_POSITIONAL) || - ctx->Light.Model.LocalViewer) - ctx->_NeedEyeCoords |= NEED_EYE_LIGHT; - + ctx->Light._NeedEyeCoords = ((ctx->Light._Flags & LIGHT_POSITIONAL) || + ctx->Light.Model.LocalViewer); /* XXX: This test is overkill & needs to be fixed both for software and * hardware t&l drivers. The above should be sufficient & should * be tested to verify this. */ if (ctx->Light._NeedVertices) - ctx->_NeedEyeCoords |= NEED_EYE_LIGHT; - + ctx->Light._NeedEyeCoords = GL_TRUE; /* Precompute some shading values. Although we reference * Light.Material here, we can get away without flushing @@ -1207,26 +1046,22 @@ _mesa_update_lighting( GLcontext *ctx ) * are flushed, they will update the derived state at that time. */ if (ctx->Visual.rgbMode) { - GLuint sides = ctx->Light.Model.TwoSide ? 2 : 1; - GLuint side; - for (side=0; side < sides; side++) { - struct gl_material *mat = &ctx->Light.Material[side]; - - COPY_3V(ctx->Light._BaseColor[side], mat->Emission); - ACC_SCALE_3V(ctx->Light._BaseColor[side], - ctx->Light.Model.Ambient, - mat->Ambient); - } - - foreach (light, &ctx->Light.EnabledList) { - for (side=0; side< sides; side++) { - const struct gl_material *mat = &ctx->Light.Material[side]; - SCALE_3V( light->_MatDiffuse[side], light->Diffuse, mat->Diffuse ); - SCALE_3V( light->_MatAmbient[side], light->Ambient, mat->Ambient ); - SCALE_3V( light->_MatSpecular[side], light->Specular, - mat->Specular); - } - } + if (ctx->Light.Model.TwoSide) + _mesa_update_material( ctx, + MAT_BIT_FRONT_EMISSION | + MAT_BIT_FRONT_AMBIENT | + MAT_BIT_FRONT_DIFFUSE | + MAT_BIT_FRONT_SPECULAR | + MAT_BIT_BACK_EMISSION | + MAT_BIT_BACK_AMBIENT | + MAT_BIT_BACK_DIFFUSE | + MAT_BIT_BACK_SPECULAR); + else + _mesa_update_material( ctx, + MAT_BIT_FRONT_EMISSION | + MAT_BIT_FRONT_AMBIENT | + MAT_BIT_FRONT_DIFFUSE | + MAT_BIT_FRONT_SPECULAR); } else { static const GLfloat ci[3] = { .30F, .59F, .11F }; @@ -1238,15 +1073,18 @@ _mesa_update_lighting( GLcontext *ctx ) } -/* _NEW_MODELVIEW - * _NEW_LIGHT - * _TNL_NEW_NEED_EYE_COORDS +/** + * Update state derived from light position, spot direction. + * Called upon: + * _NEW_MODELVIEW + * _NEW_LIGHT + * _TNL_NEW_NEED_EYE_COORDS * * Update on (_NEW_MODELVIEW | _NEW_LIGHT) when lighting is enabled. * Also update on lighting space changes. */ -void -_mesa_compute_light_positions( GLcontext *ctx ) +static void +compute_light_positions( GLcontext *ctx ) { struct gl_light *light; static const GLfloat eye_z[3] = { 0, 0, 1 }; @@ -1264,9 +1102,11 @@ _mesa_compute_light_positions( GLcontext *ctx ) foreach (light, &ctx->Light.EnabledList) { if (ctx->_NeedEyeCoords) { + /* _Position is in eye coordinate space */ COPY_4FV( light->_Position, light->EyePosition ); } else { + /* _Position is in object coordinate space */ TRANSFORM_POINT( light->_Position, ctx->ModelviewMatrixStack.Top->inv, light->EyePosition ); } @@ -1314,3 +1154,223 @@ _mesa_compute_light_positions( GLcontext *ctx ) } } } + + + +static void +update_modelview_scale( GLcontext *ctx ) +{ + ctx->_ModelViewInvScale = 1.0F; + if (!_math_matrix_is_length_preserving(ctx->ModelviewMatrixStack.Top)) { + const GLfloat *m = ctx->ModelviewMatrixStack.Top->inv; + GLfloat f = m[2] * m[2] + m[6] * m[6] + m[10] * m[10]; + if (f < 1e-12) f = 1.0; + if (ctx->_NeedEyeCoords) + ctx->_ModelViewInvScale = (GLfloat) INV_SQRTF(f); + else + ctx->_ModelViewInvScale = (GLfloat) SQRTF(f); + } +} + + +/** + * Bring up to date any state that relies on _NeedEyeCoords. + */ +void +_mesa_update_tnl_spaces( GLcontext *ctx, GLuint new_state ) +{ + const GLuint oldneedeyecoords = ctx->_NeedEyeCoords; + + (void) new_state; + ctx->_NeedEyeCoords = GL_FALSE; + + if (ctx->_ForceEyeCoords || + (ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD) || + ctx->Point._Attenuated || + ctx->Light._NeedEyeCoords) + ctx->_NeedEyeCoords = GL_TRUE; + + if (ctx->Light.Enabled && + !_math_matrix_is_length_preserving(ctx->ModelviewMatrixStack.Top)) + ctx->_NeedEyeCoords = GL_TRUE; + + /* Check if the truth-value interpretations of the bitfields have + * changed: + */ + if (oldneedeyecoords != ctx->_NeedEyeCoords) { + /* Recalculate all state that depends on _NeedEyeCoords. + */ + update_modelview_scale(ctx); + compute_light_positions( ctx ); + + if (ctx->Driver.LightingSpaceChange) + ctx->Driver.LightingSpaceChange( ctx ); + } + else { + GLuint new_state = ctx->NewState; + + /* Recalculate that same state only if it has been invalidated + * by other statechanges. + */ + if (new_state & _NEW_MODELVIEW) + update_modelview_scale(ctx); + + if (new_state & (_NEW_LIGHT|_NEW_MODELVIEW)) + compute_light_positions( ctx ); + } +} + + +/** + * Drivers may need this if the hardware tnl unit doesn't support the + * light-in-modelspace optimization. It's also useful for debugging. + */ +void +_mesa_allow_light_in_model( GLcontext *ctx, GLboolean flag ) +{ + ctx->_ForceEyeCoords = !flag; + ctx->NewState |= _NEW_POINT; /* one of the bits from + * _MESA_NEW_NEED_EYE_COORDS. + */ +} + + + +/**********************************************************************/ +/***** Initialization *****/ +/**********************************************************************/ + +/** + * Initialize the n-th light data structure. + * + * \param l pointer to the gl_light structure to be initialized. + * \param n number of the light. + * \note The defaults for light 0 are different than the other lights. + */ +static void +init_light( struct gl_light *l, GLuint n ) +{ + make_empty_list( l ); + + ASSIGN_4V( l->Ambient, 0.0, 0.0, 0.0, 1.0 ); + if (n==0) { + ASSIGN_4V( l->Diffuse, 1.0, 1.0, 1.0, 1.0 ); + ASSIGN_4V( l->Specular, 1.0, 1.0, 1.0, 1.0 ); + } + else { + ASSIGN_4V( l->Diffuse, 0.0, 0.0, 0.0, 1.0 ); + ASSIGN_4V( l->Specular, 0.0, 0.0, 0.0, 1.0 ); + } + ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 ); + ASSIGN_3V( l->EyeDirection, 0.0, 0.0, -1.0 ); + l->SpotExponent = 0.0; + _mesa_invalidate_spot_exp_table( l ); + l->SpotCutoff = 180.0; + l->_CosCutoffNeg = -1.0f; + l->_CosCutoff = 0.0; /* KW: -ve values not admitted */ + l->ConstantAttenuation = 1.0; + l->LinearAttenuation = 0.0; + l->QuadraticAttenuation = 0.0; + l->Enabled = GL_FALSE; +} + + +/** + * Initialize the light model data structure. + * + * \param lm pointer to the gl_lightmodel structure to be initialized. + */ +static void +init_lightmodel( struct gl_lightmodel *lm ) +{ + ASSIGN_4V( lm->Ambient, 0.2F, 0.2F, 0.2F, 1.0F ); + lm->LocalViewer = GL_FALSE; + lm->TwoSide = GL_FALSE; + lm->ColorControl = GL_SINGLE_COLOR; +} + + +/** + * Initialize the material data structure. + * + * \param m pointer to the gl_material structure to be initialized. + */ +static void +init_material( struct gl_material *m ) +{ + ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_AMBIENT], 0.2F, 0.2F, 0.2F, 1.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_DIFFUSE], 0.8F, 0.8F, 0.8F, 1.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_SPECULAR], 0.0F, 0.0F, 0.0F, 1.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_EMISSION], 0.0F, 0.0F, 0.0F, 1.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_SHININESS], 0.0F, 0.0F, 0.0F, 0.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_INDEXES], 0.0F, 1.0F, 1.0F, 0.0F ); + + ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_AMBIENT], 0.2F, 0.2F, 0.2F, 1.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_DIFFUSE], 0.8F, 0.8F, 0.8F, 1.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_SPECULAR], 0.0F, 0.0F, 0.0F, 1.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_EMISSION], 0.0F, 0.0F, 0.0F, 1.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_SHININESS], 0.0F, 0.0F, 0.0F, 0.0F ); + ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_INDEXES], 0.0F, 1.0F, 1.0F, 0.0F ); +} + + +/** + * Initialize all lighting state for the given context. + */ +void +_mesa_init_lighting( GLcontext *ctx ) +{ + GLuint i; + + /* Lighting group */ + for (i = 0; i < MAX_LIGHTS; i++) { + init_light( &ctx->Light.Light[i], i ); + } + make_empty_list( &ctx->Light.EnabledList ); + + init_lightmodel( &ctx->Light.Model ); + init_material( &ctx->Light.Material ); + ctx->Light.ShadeModel = GL_SMOOTH; + ctx->Light.Enabled = GL_FALSE; + ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK; + ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE; + ctx->Light.ColorMaterialBitmask = _mesa_material_bitmask( ctx, + GL_FRONT_AND_BACK, + GL_AMBIENT_AND_DIFFUSE, ~0, + NULL ); + + ctx->Light.ColorMaterialEnabled = GL_FALSE; + ctx->Light.ClampVertexColor = GL_TRUE; + + /* Lighting miscellaneous */ + ctx->_ShineTabList = MALLOC_STRUCT( gl_shine_tab ); + make_empty_list( ctx->_ShineTabList ); + /* Allocate 10 (arbitrary) shininess lookup tables */ + for (i = 0 ; i < 10 ; i++) { + struct gl_shine_tab *s = MALLOC_STRUCT( gl_shine_tab ); + s->shininess = -1; + s->refcount = 0; + insert_at_tail( ctx->_ShineTabList, s ); + } + + /* Miscellaneous */ + ctx->Light._NeedEyeCoords = GL_FALSE; + ctx->_NeedEyeCoords = GL_FALSE; + ctx->_ModelViewInvScale = 1.0; +} + + +/** + * Deallocate malloc'd lighting state attached to given context. + */ +void +_mesa_free_lighting_data( GLcontext *ctx ) +{ + struct gl_shine_tab *s, *tmps; + + /* Free lighting shininess exponentiation table */ + foreach_s( s, tmps, ctx->_ShineTabList ) { + _mesa_free( s ); + } + _mesa_free( ctx->_ShineTabList ); +}