X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Flight.c;h=984f7b2abc46b111268c94213761b1507e30c6f3;hb=6340d6bf22ad0bfedf8565500336237a8da887f5;hp=50bd041f190019ec0681e80e9926a241edf79299;hpb=45323646bdf1e5fa4410a89c2e82908a571b546a;p=mesa.git diff --git a/src/mesa/main/light.c b/src/mesa/main/light.c index 50bd041f190..984f7b2abc4 100644 --- a/src/mesa/main/light.c +++ b/src/mesa/main/light.c @@ -1,10 +1,8 @@ -/* $Id: light.c,v 1.36 2001/02/13 23:55:30 brianp Exp $ */ - /* * Mesa 3-D graphics library - * Version: 3.5 + * Version: 6.5 * - * Copyright (C) 1999-2000 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,46 +23,32 @@ */ -#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) - fprintf(stderr, "glShadeModel %s\n", gl_lookup_enum_by_nr(mode)); + _mesa_debug(ctx, "glShadeModel %s\n", _mesa_lookup_enum_by_nr(mode)); if (mode != GL_FLAT && mode != GL_SMOOTH) { - gl_error( ctx, GL_INVALID_ENUM, "glShadeModel" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glShadeModel" ); return; } - if (ctx->Light.ShadeModel == mode) + if (ctx->Light.ShadeModel == mode) return; FLUSH_VERTICES(ctx, _NEW_LIGHT); @@ -75,148 +59,200 @@ _mesa_ShadeModel( GLenum mode ) } - -void -_mesa_Lightf( GLenum light, GLenum pname, GLfloat param ) -{ - _mesa_Lightfv( light, pname, ¶m ); -} - - +/** + * 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_Lightfv( GLenum light, GLenum pname, const GLfloat *params ) +_mesa_light(GLcontext *ctx, GLuint lnum, GLenum pname, const GLfloat *params) { - GET_CURRENT_CONTEXT(ctx); - GLint i = (GLint) (light - GL_LIGHT0); - struct gl_light *l = &ctx->Light.Light[i]; + struct gl_light *light; - if (i < 0 || i >= ctx->Const.MaxLights) { - gl_error( ctx, GL_INVALID_ENUM, "glLight" ); - return; - } + ASSERT(lnum < MAX_LIGHTS); + light = &ctx->Light.Light[lnum]; switch (pname) { case GL_AMBIENT: - if (TEST_EQ_4V(l->Ambient, params)) + if (TEST_EQ_4V(light->Ambient, params)) return; FLUSH_VERTICES(ctx, _NEW_LIGHT); - COPY_4V( l->Ambient, params ); + COPY_4V( light->Ambient, params ); break; case GL_DIFFUSE: - if (TEST_EQ_4V(l->Diffuse, params)) + if (TEST_EQ_4V(light->Diffuse, params)) return; FLUSH_VERTICES(ctx, _NEW_LIGHT); - COPY_4V( l->Diffuse, params ); + COPY_4V( light->Diffuse, params ); break; case GL_SPECULAR: - if (TEST_EQ_4V(l->Specular, params)) + if (TEST_EQ_4V(light->Specular, params)) return; FLUSH_VERTICES(ctx, _NEW_LIGHT); - COPY_4V( l->Specular, params ); + COPY_4V( light->Specular, params ); break; - case GL_POSITION: { - GLfloat tmp[4]; - /* transform position by ModelView matrix */ - TRANSFORM_POINT( tmp, ctx->ModelView.m, params ); - if (TEST_EQ_4V(l->EyePosition, tmp)) + 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(l->EyePosition, tmp); - if (l->EyePosition[3] != 0.0F) - l->_Flags |= LIGHT_POSITIONAL; + COPY_4V(light->EyePosition, params); + if (light->EyePosition[3] != 0.0F) + light->_Flags |= LIGHT_POSITIONAL; else - l->_Flags &= ~LIGHT_POSITIONAL; + light->_Flags &= ~LIGHT_POSITIONAL; break; - } - case GL_SPOT_DIRECTION: { - GLfloat tmp[4]; - /* transform direction by inverse modelview */ - if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) { - _math_matrix_analyse( &ctx->ModelView ); - } - TRANSFORM_NORMAL( tmp, params, ctx->ModelView.inv ); - if (TEST_EQ_3V(l->EyeDirection, tmp)) + 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(l->EyeDirection, tmp); + COPY_3V(light->EyeDirection, params); break; - } case GL_SPOT_EXPONENT: - if (params[0]<0.0 || params[0]>128.0) { - gl_error( ctx, GL_INVALID_VALUE, "glLight" ); - return; - } - if (l->SpotExponent == params[0]) + ASSERT(params[0] >= 0.0); + ASSERT(params[0] <= ctx->Const.MaxSpotExponent); + if (light->SpotExponent == params[0]) return; FLUSH_VERTICES(ctx, _NEW_LIGHT); - l->SpotExponent = params[0]; - gl_invalidate_spot_exp_table( l ); + light->SpotExponent = params[0]; + _mesa_invalidate_spot_exp_table(light); break; case GL_SPOT_CUTOFF: - if ((params[0]<0.0 || params[0]>90.0) && params[0]!=180.0) { - gl_error( ctx, GL_INVALID_VALUE, "glLight" ); - return; - } - if (l->SpotCutoff == params[0]) - return; + ASSERT(params[0] == 180.0 || (params[0] >= 0.0 && params[0] <= 90.0)); + if (light->SpotCutoff == params[0]) + return; FLUSH_VERTICES(ctx, _NEW_LIGHT); - l->SpotCutoff = params[0]; - l->_CosCutoff = cos(params[0]*DEG2RAD); - if (l->_CosCutoff < 0) - l->_CosCutoff = 0; - if (l->SpotCutoff != 180.0F) - l->_Flags |= LIGHT_SPOT; + light->SpotCutoff = params[0]; + light->_CosCutoffNeg = (GLfloat) (_mesa_cos(light->SpotCutoff * DEG2RAD)); + if (light->_CosCutoffNeg < 0) + light->_CosCutoff = 0; else - l->_Flags &= ~LIGHT_SPOT; + light->_CosCutoff = light->_CosCutoffNeg; + if (light->SpotCutoff != 180.0F) + light->_Flags |= LIGHT_SPOT; + else + light->_Flags &= ~LIGHT_SPOT; break; case GL_CONSTANT_ATTENUATION: - if (params[0]<0.0) { - gl_error( ctx, GL_INVALID_VALUE, "glLight" ); - return; - } - if (l->ConstantAttenuation == params[0]) + ASSERT(params[0] >= 0.0); + if (light->ConstantAttenuation == params[0]) return; FLUSH_VERTICES(ctx, _NEW_LIGHT); - l->ConstantAttenuation = params[0]; + light->ConstantAttenuation = params[0]; break; case GL_LINEAR_ATTENUATION: - if (params[0]<0.0) { - gl_error( ctx, GL_INVALID_VALUE, "glLight" ); - return; - } - if (l->LinearAttenuation == params[0]) + ASSERT(params[0] >= 0.0); + if (light->LinearAttenuation == params[0]) return; FLUSH_VERTICES(ctx, _NEW_LIGHT); - l->LinearAttenuation = params[0]; + light->LinearAttenuation = params[0]; break; case GL_QUADRATIC_ATTENUATION: - if (params[0]<0.0) { - gl_error( ctx, GL_INVALID_VALUE, "glLight" ); - return; - } - if (l->QuadraticAttenuation == params[0]) + ASSERT(params[0] >= 0.0); + if (light->QuadraticAttenuation == params[0]) return; FLUSH_VERTICES(ctx, _NEW_LIGHT); - l->QuadraticAttenuation = params[0]; + light->QuadraticAttenuation = params[0]; break; default: - gl_error( ctx, GL_INVALID_ENUM, "glLight" ); + _mesa_problem(ctx, "Unexpected pname in _mesa_light()"); return; } if (ctx->Driver.Lightfv) - ctx->Driver.Lightfv( ctx, light, pname, params ); + ctx->Driver.Lightfv( ctx, GL_LIGHT0 + lnum, pname, params ); } -void +void GLAPIENTRY +_mesa_Lightf( GLenum light, GLenum pname, GLfloat param ) +{ + _mesa_Lightfv( light, pname, ¶m ); +} + + +void GLAPIENTRY +_mesa_Lightfv( GLenum light, GLenum pname, const GLfloat *params ) +{ + GET_CURRENT_CONTEXT(ctx); + GLint i = (GLint) (light - GL_LIGHT0); + 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: + case GL_DIFFUSE: + case GL_SPECULAR: + /* nothing */ + break; + case GL_POSITION: + /* transform position by ModelView matrix */ + TRANSFORM_POINT(temp, ctx->ModelviewMatrixStack.Top->m, params); + params = temp; + break; + case GL_SPOT_DIRECTION: + /* transform direction by inverse modelview */ + if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) { + _math_matrix_analyse(ctx->ModelviewMatrixStack.Top); + } + 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"); + return; + } + 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"); + return; + } + break; + case GL_CONSTANT_ATTENUATION: + if (params[0] < 0.0) { + _mesa_error(ctx, GL_INVALID_VALUE, "glLight"); + return; + } + break; + case GL_LINEAR_ATTENUATION: + if (params[0] < 0.0) { + _mesa_error(ctx, GL_INVALID_VALUE, "glLight"); + return; + } + break; + case GL_QUADRATIC_ATTENUATION: + if (params[0] < 0.0) { + _mesa_error(ctx, GL_INVALID_VALUE, "glLight"); + return; + } + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glLight(pname=0x%x)", pname); + return; + } + + _mesa_light(ctx, i, pname, params); +} + + +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,15 +294,15 @@ _mesa_Lightiv( GLenum light, GLenum pname, const GLint *params ) -void +void GLAPIENTRY _mesa_GetLightfv( GLenum light, GLenum pname, GLfloat *params ) { GET_CURRENT_CONTEXT(ctx); GLint l = (GLint) (light - GL_LIGHT0); ASSERT_OUTSIDE_BEGIN_END(ctx); - if (l < 0 || l >= ctx->Const.MaxLights) { - gl_error( ctx, GL_INVALID_ENUM, "glGetLightfv" ); + if (l < 0 || l >= (GLint) ctx->Const.MaxLights) { + _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightfv" ); return; } @@ -302,22 +338,21 @@ _mesa_GetLightfv( GLenum light, GLenum pname, GLfloat *params ) params[0] = ctx->Light.Light[l].QuadraticAttenuation; break; default: - gl_error( ctx, GL_INVALID_ENUM, "glGetLightfv" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightfv" ); break; } } - -void +void GLAPIENTRY _mesa_GetLightiv( GLenum light, GLenum pname, GLint *params ) { GET_CURRENT_CONTEXT(ctx); GLint l = (GLint) (light - GL_LIGHT0); ASSERT_OUTSIDE_BEGIN_END(ctx); - if (l < 0 || l >= ctx->Const.MaxLights) { - gl_error( ctx, GL_INVALID_ENUM, "glGetLightiv" ); + if (l < 0 || l >= (GLint) ctx->Const.MaxLights) { + _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightiv" ); return; } @@ -367,7 +402,7 @@ _mesa_GetLightiv( GLenum light, GLenum pname, GLint *params ) params[0] = (GLint) ctx->Light.Light[l].QuadraticAttenuation; break; default: - gl_error( ctx, GL_INVALID_ENUM, "glGetLightiv" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightiv" ); break; } } @@ -379,7 +414,7 @@ _mesa_GetLightiv( GLenum light, GLenum pname, GLint *params ) /**********************************************************************/ -void +void GLAPIENTRY _mesa_LightModelfv( GLenum pname, const GLfloat *params ) { GLenum newenum; @@ -407,24 +442,29 @@ _mesa_LightModelfv( GLenum pname, const GLfloat *params ) return; FLUSH_VERTICES(ctx, _NEW_LIGHT); ctx->Light.Model.TwoSide = newbool; + + if (ctx->Light.Enabled && ctx->Light.Model.TwoSide) + ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE; + else + ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE; break; case GL_LIGHT_MODEL_COLOR_CONTROL: - if (params[0] == (GLfloat) GL_SINGLE_COLOR) + if (params[0] == (GLfloat) GL_SINGLE_COLOR) newenum = GL_SINGLE_COLOR; - else if (params[0] == (GLfloat) GL_SEPARATE_SPECULAR_COLOR) + else if (params[0] == (GLfloat) GL_SEPARATE_SPECULAR_COLOR) newenum = GL_SEPARATE_SPECULAR_COLOR; else { - gl_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; - ctx->_TriangleCaps ^= DD_SEPERATE_SPECULAR; break; default: - gl_error( ctx, GL_INVALID_ENUM, "glLightModel" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glLightModel(pname=0x%x)", pname ); break; } @@ -433,7 +473,7 @@ _mesa_LightModelfv( GLenum pname, const GLfloat *params ) } -void +void GLAPIENTRY _mesa_LightModeliv( GLenum pname, const GLint *params ) { GLfloat fparam[4]; @@ -458,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 ); @@ -480,38 +520,38 @@ _mesa_LightModelf( GLenum pname, GLfloat param ) * Given a face and pname value (ala glColorMaterial), compute a bitmask * of the targeted material values. */ -GLuint gl_material_bitmask( GLcontext *ctx, GLenum face, GLenum pname, - GLuint legal, - const char *where ) +GLuint +_mesa_material_bitmask( GLcontext *ctx, GLenum face, GLenum pname, + GLuint legal, const char *where ) { GLuint bitmask = 0; /* 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: - gl_error( ctx, GL_INVALID_ENUM, where ); + _mesa_error( ctx, GL_INVALID_ENUM, where ); return 0; } @@ -522,12 +562,12 @@ GLuint gl_material_bitmask( GLcontext *ctx, GLenum face, GLenum pname, bitmask &= BACK_MATERIAL_BITS; } else if (face != GL_FRONT_AND_BACK) { - gl_error( ctx, GL_INVALID_ENUM, where ); + _mesa_error( ctx, GL_INVALID_ENUM, where ); return 0; } if (bitmask & ~legal) { - gl_error( ctx, GL_INVALID_ENUM, where ); + _mesa_error( ctx, GL_INVALID_ENUM, where ); return 0; } @@ -536,301 +576,141 @@ GLuint gl_material_bitmask( GLcontext *ctx, GLenum face, GLenum pname, -/* - * 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 - * - * KW: Added code here to keep the precomputed variables uptodate. - * This means we can use the faster shade functions when using - * GL_COLOR_MATERIAL, and we can also now use the precomputed - * values in the slower shading functions, which further offsets - * the cost of doing this here. +/* Perform a straight copy between materials. */ -void gl_update_material( GLcontext *ctx, - const struct gl_material src[2], - GLuint bitmask ) +void +_mesa_copy_materials( struct gl_material *dst, + const struct gl_material *src, + GLuint bitmask ) { - struct gl_light *light, *list = &ctx->Light.EnabledList; + int i; + + for (i = 0 ; i < MAT_ATTRIB_MAX ; i++) + if (bitmask & (1<Attrib[i], src->Attrib[i] ); +} - if (ctx->Light.ColorMaterialEnabled) - bitmask &= ~ctx->Light.ColorMaterialBitmask; - if (MESA_VERBOSE&VERBOSE_IMMEDIATE) - fprintf(stderr, "gl_update_material, mask 0x%x\n", bitmask); + +/* Update derived values following a change in ctx->Light.Material + */ +void +_mesa_update_material( GLcontext *ctx, GLuint bitmask ) +{ + struct gl_light *light, *list = &ctx->Light.EnabledList; + GLfloat (*mat)[4] = ctx->Light.Material.Attrib; + + 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 ); -/* fprintf(stderr, "FRONT_DIFFUSE %f %f %f %f\n", */ -/* mat->Diffuse[0], mat->Diffuse[1], */ -/* mat->Diffuse[2], mat->Diffuse[3]); */ + 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] ); } - UNCLAMPED_FLOAT_TO_CHAN(ctx->Light._BaseAlpha[0], mat->Diffuse[3]); } - if (bitmask & BACK_DIFFUSE_BIT) { - struct gl_material *mat = &ctx->Light.Material[1]; - COPY_4FV( mat->Diffuse, src[1].Diffuse ); -/* fprintf(stderr, "BACK_DIFFUSE %f %f %f %f\n", */ -/* mat->Diffuse[0], mat->Diffuse[1], */ -/* mat->Diffuse[2], mat->Diffuse[3]); */ + + 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] ); } - UNCLAMPED_FLOAT_TO_CHAN(ctx->Light._BaseAlpha[1], mat->Diffuse[3]); } /* 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) { -/* fprintf(stderr, "FRONT_SHININESS_BIT %f\n", src[0].Shininess); */ - ctx->Light.Material[0].Shininess = src[0].Shininess; - gl_invalidate_shine_table( ctx, 0 ); - } - if (bitmask & BACK_SHININESS_BIT) { - ctx->Light.Material[1].Shininess = src[1].Shininess; - gl_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 (bitmask & MAT_BIT_FRONT_SHININESS) { + _mesa_invalidate_shine_table( ctx, 0 ); } - if (0) - { - struct gl_material *mat = &ctx->Light.Material[0]; - fprintf(stderr, "update_mat emission : %f %f %f\n", - mat->Emission[0], - mat->Emission[1], - mat->Emission[2]); - fprintf(stderr, "update_mat specular : %f %f %f\n", - mat->Specular[0], - mat->Specular[1], - mat->Specular[2]); - fprintf(stderr, "update_mat diffuse : %f %f %f\n", - mat->Diffuse[0], - mat->Diffuse[1], - mat->Diffuse[2]); - fprintf(stderr, "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 gl_update_color_material( GLcontext *ctx, - const GLchan rgba[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; - GLfloat color[4]; - - color[0] = CHAN_TO_FLOAT(rgba[0]); - color[1] = CHAN_TO_FLOAT(rgba[1]); - color[2] = CHAN_TO_FLOAT(rgba[2]); - color[3] = CHAN_TO_FLOAT(rgba[3]); - - if (MESA_VERBOSE&VERBOSE_IMMEDIATE) - fprintf(stderr, "gl_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 ); - } - - 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 ); - } - UNCLAMPED_FLOAT_TO_CHAN(ctx->Light._BaseAlpha[0], mat->Diffuse[3]); - } - - 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 ); - } - UNCLAMPED_FLOAT_TO_CHAN(ctx->Light._BaseAlpha[1], mat->Diffuse[3]); - } + struct gl_material *mat = &ctx->Light.Material; + int i; - /* 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); - } - } + for (i = 0 ; i < MAT_ATTRIB_MAX ; i++) + if (bitmask & (1<Attrib[i], color ); - 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]; - fprintf(stderr, "update_color_mat emission : %f %f %f\n", - mat->Emission[0], - mat->Emission[1], - mat->Emission[2]); - fprintf(stderr, "update_color_mat specular : %f %f %f\n", - mat->Specular[0], - mat->Specular[1], - mat->Specular[2]); - fprintf(stderr, "update_color_mat diffuse : %f %f %f\n", - mat->Diffuse[0], - mat->Diffuse[1], - mat->Diffuse[2]); - fprintf(stderr, "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) - fprintf(stderr, "glColorMaterial %s %s\n", - gl_lookup_enum_by_nr(face), - gl_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 = gl_material_bitmask( ctx, face, mode, legal, "glColorMaterial" ); + bitmask = _mesa_material_bitmask(ctx, face, mode, legal, "glColorMaterial"); if (ctx->Light.ColorMaterialBitmask == bitmask && ctx->Light.ColorMaterialFace == face && @@ -844,21 +724,24 @@ _mesa_ColorMaterial( GLenum face, GLenum mode ) if (ctx->Light.ColorMaterialEnabled) { FLUSH_CURRENT( ctx, 0 ); - gl_update_color_material( ctx, ctx->Current.Color ); + _mesa_update_color_material(ctx,ctx->Current.Attrib[VERT_ATTRIB_COLOR0]); } -} - - + if (ctx->Driver.ColorMaterial) + (*ctx->Driver.ColorMaterial)( ctx, face, 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; } @@ -866,44 +749,47 @@ _mesa_GetMaterialfv( GLenum face, GLenum pname, GLfloat *params ) f = 1; } else { - gl_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(face)" ); + _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: - gl_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" ); } } - -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; } @@ -911,50 +797,49 @@ _mesa_GetMaterialiv( GLenum face, GLenum pname, GLint *params ) f = 1; } else { - gl_error( ctx, GL_INVALID_ENUM, "glGetMaterialiv(face)" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialiv(face)" ); return; } 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: - gl_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" ); } } - /**********************************************************************/ /***** Lighting computation *****/ /**********************************************************************/ @@ -999,12 +884,14 @@ _mesa_GetMaterialiv( GLenum face, GLenum pname, GLint *params ) * this function to recompute the exponent lookup table. */ void -gl_invalidate_spot_exp_table( struct gl_light *l ) +_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; @@ -1015,16 +902,16 @@ 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; } } - l->_SpotExpTable[i][0] = tmp; + l->_SpotExpTable[i][0] = (GLfloat) tmp; } for (i = 0; i < EXP_TABLE_SIZE - 1; i++) { - l->_SpotExpTable[i][1] = (l->_SpotExpTable[i+1][0] - + l->_SpotExpTable[i][1] = (l->_SpotExpTable[i+1][0] - l->_SpotExpTable[i][0]); } l->_SpotExpTable[EXP_TABLE_SIZE-1][1] = 0.0; @@ -1032,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 -gl_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; @@ -1073,9 +964,9 @@ 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] = t; + m[j] = (GLfloat) t; else m[j] = 0.0; } @@ -1085,59 +976,51 @@ 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 -gl_validate_all_lighting_tables( GLcontext *ctx ) + +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 * source and material ambient, diffuse and specular coefficients. */ void -gl_update_lighting( GLcontext *ctx ) +_mesa_update_lighting( GLcontext *ctx ) { struct gl_light *light; - ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE; - 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; - - if (ctx->Light.Model.TwoSide) - ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE; - foreach(light, &ctx->Light.EnabledList) { ctx->Light._Flags |= light->_Flags; } @@ -1147,51 +1030,41 @@ gl_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 * FLUSH_UPDATE_CURRENT, as when any outstanding material changes - * are flushed, they will update the derived state at that time. + * 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); - - UNCLAMPED_FLOAT_TO_CHAN(ctx->Light._BaseAlpha[side], - ctx->Light.Material[side].Diffuse[3] ); - } - - 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] = { .30, .59, .11 }; + static const GLfloat ci[3] = { .30F, .59F, .11F }; foreach(light, &ctx->Light.EnabledList) { light->_dli = DOT3(ci, light->Diffuse); light->_sli = DOT3(ci, light->Specular); @@ -1200,15 +1073,18 @@ gl_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 -gl_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 }; @@ -1220,16 +1096,18 @@ gl_compute_light_positions( GLcontext *ctx ) COPY_3V( ctx->_EyeZDir, eye_z ); } else { - TRANSFORM_NORMAL( ctx->_EyeZDir, eye_z, ctx->ModelView.m ); + TRANSFORM_NORMAL( ctx->_EyeZDir, eye_z, ctx->ModelviewMatrixStack.Top->m ); } foreach (light, &ctx->Light.EnabledList) { if (ctx->_NeedEyeCoords) { + /* _Position is in eye coordinate space */ COPY_4FV( light->_Position, light->EyePosition ); } else { - TRANSFORM_POINT( light->_Position, ctx->ModelView.inv, + /* _Position is in object coordinate space */ + TRANSFORM_POINT( light->_Position, ctx->ModelviewMatrixStack.Top->inv, light->EyePosition ); } @@ -1253,7 +1131,7 @@ gl_compute_light_positions( GLcontext *ctx ) else { TRANSFORM_NORMAL( light->_NormDirection, light->EyeDirection, - ctx->ModelView.m); + ctx->ModelviewMatrixStack.Top->m); } NORMALIZE_3FV( light->_NormDirection ); @@ -1266,7 +1144,7 @@ gl_compute_light_positions( GLcontext *ctx ) double x = PV_dot_dir * (EXP_TABLE_SIZE-1); int k = (int) x; light->_VP_inf_spot_attenuation = - (light->_SpotExpTable[k][0] + + (GLfloat) (light->_SpotExpTable[k][0] + (x-k)*light->_SpotExpTable[k][1]); } else { @@ -1278,3 +1156,221 @@ gl_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 ); +}