light.c File Reference

#include <assert.h>
#include <float.h>
#include <math.h>
#include <stdlib.h>
#include "context.h"
#include "light.h"
#include "dlist.h"
#include "macros.h"
#include "matrix.h"
#include "mmath.h"
#include "types.h"
#include "vb.h"
#include "xform.h"

Include dependency graph for light.c:

Go to the source code of this file.

Functions
void	gl_ShadeModel (GLcontext *ctx, GLenum mode)
void	gl_Lightfv (GLcontext *ctx, GLenum light, GLenum pname, const GLfloat *params, GLint nparams)
void	gl_GetLightfv (GLcontext *ctx, GLenum light, GLenum pname, GLfloat *params)
void	gl_GetLightiv (GLcontext *ctx, GLenum light, GLenum pname, GLint *params)
void	gl_LightModelfv (GLcontext *ctx, GLenum pname, const GLfloat *params)
GLuint	gl_material_bitmask (GLenum face, GLenum pname)
void	gl_set_material (GLcontext *ctx, GLuint bitmask, const GLfloat *params)
void	gl_ColorMaterial (GLcontext *ctx, GLenum face, GLenum mode)
void	gl_Materialfv (GLcontext *ctx, GLenum face, GLenum pname, const GLfloat *params)
void	gl_GetMaterialfv (GLcontext *ctx, GLenum face, GLenum pname, GLfloat *params)
void	gl_GetMaterialiv (GLcontext *ctx, GLenum face, GLenum pname, GLint *params)
void	gl_compute_spot_exp_table (struct gl_light *l)
void	gl_compute_material_shine_table (struct gl_material *m)
void	gl_update_lighting (GLcontext *ctx)

Function Documentation

gl_ColorMaterial()

void gl_ColorMaterial	(	GLcontext *	ctx,
		GLenum	face,
		GLenum	mode
	)

Definition at line 485 of file light.c.

{
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glColorMaterial" );
      return;
   }
   switch (face) {
      case GL_FRONT:
      case GL_BACK:
      case GL_FRONT_AND_BACK:
         ctx->Light.ColorMaterialFace = face;
         break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glColorMaterial(face)" );
         return;
   }
   switch (mode) {
      case GL_EMISSION:
      case GL_AMBIENT:
      case GL_DIFFUSE:
      case GL_SPECULAR:
      case GL_AMBIENT_AND_DIFFUSE:
         ctx->Light.ColorMaterialMode = mode;
         break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glColorMaterial(mode)" );
         return;
   }

   ctx->Light.ColorMaterialBitmask = gl_material_bitmask( face, mode );
}

Referenced by execute_list(), and init_exec_pointers().

gl_compute_material_shine_table()

void gl_compute_material_shine_table

(

struct gl_material *

m

)

Definition at line 741 of file light.c.

{
   int i;

   m->ShineTable[0] = 0.0F;
   for (i=1;i<SHINE_TABLE_SIZE;i++) {
#if 0
      double x = pow( i/(double)(SHINE_TABLE_SIZE-1), exponent );
      if (x<1.0e-10) {
         m->ShineTable[i] = 0.0F;
      }
      else {
         m->ShineTable[i] = x;
      }
#else
      /* just invalidate the table */
      m->ShineTable[i] = -1.0;
#endif
   }
}

Referenced by gl_set_material(), init_material(), and update_material().

gl_compute_spot_exp_table()

void gl_compute_spot_exp_table

(

struct gl_light *

l

)

Definition at line 710 of file light.c.

{
   int i;
   double exponent = l->SpotExponent;
   double tmp;
   int clamp = 0;

   l->SpotExpTable[0][0] = 0.0;

   for (i=EXP_TABLE_SIZE-1;i>0;i--) {
      if (clamp == 0) {
         tmp = pow(i/(double)(EXP_TABLE_SIZE-1), exponent);
         if (tmp < FLT_MIN*100.0) {
            tmp = 0.0;
            clamp = 1;
         }
      }
      l->SpotExpTable[i][0] = tmp;
   }
   for (i=0;i<EXP_TABLE_SIZE-1;i++) {
      l->SpotExpTable[i][1] = l->SpotExpTable[i+1][0] - l->SpotExpTable[i][0];
   }
   l->SpotExpTable[EXP_TABLE_SIZE-1][1] = 0.0;
}

Referenced by gl_Lightfv(), and init_light().

gl_GetLightfv()

void gl_GetLightfv	(	GLcontext *	ctx,
		GLenum	light,
		GLenum	pname,
		GLfloat *	params
	)

Definition at line 211 of file light.c.

{
   GLint l = (GLint) (light - GL_LIGHT0);

   if (l<0 || l>=MAX_LIGHTS) {
      gl_error( ctx, GL_INVALID_ENUM, "glGetLightfv" );
      return;
   }

   switch (pname) {
      case GL_AMBIENT:
         COPY_4V( params, ctx->Light.Light[l].Ambient );
         break;
      case GL_DIFFUSE:
         COPY_4V( params, ctx->Light.Light[l].Diffuse );
         break;
      case GL_SPECULAR:
         COPY_4V( params, ctx->Light.Light[l].Specular );
         break;
      case GL_POSITION:
         COPY_4V( params, ctx->Light.Light[l].Position );
         break;
      case GL_SPOT_DIRECTION:
         COPY_3V( params, ctx->Light.Light[l].Direction );
         break;
      case GL_SPOT_EXPONENT:
         params[0] = ctx->Light.Light[l].SpotExponent;
         break;
      case GL_SPOT_CUTOFF:
         params[0] = ctx->Light.Light[l].SpotCutoff;
         break;
      case GL_CONSTANT_ATTENUATION:
         params[0] = ctx->Light.Light[l].ConstantAttenuation;
         break;
      case GL_LINEAR_ATTENUATION:
         params[0] = ctx->Light.Light[l].LinearAttenuation;
         break;
      case GL_QUADRATIC_ATTENUATION:
         params[0] = ctx->Light.Light[l].QuadraticAttenuation;
         break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glGetLightfv" );
         break;
   }
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_GetLightiv()

void gl_GetLightiv	(	GLcontext *	ctx,
		GLenum	light,
		GLenum	pname,
		GLint *	params
	)

Definition at line 260 of file light.c.

{
   GLint l = (GLint) (light - GL_LIGHT0);

   if (l<0 || l>=MAX_LIGHTS) {
      gl_error( ctx, GL_INVALID_ENUM, "glGetLightiv" );
      return;
   }

   switch (pname) {
      case GL_AMBIENT:
         params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[0]);
         params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[1]);
         params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[2]);
         params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[3]);
         break;
      case GL_DIFFUSE:
         params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[0]);
         params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[1]);
         params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[2]);
         params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[3]);
         break;
      case GL_SPECULAR:
         params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[0]);
         params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[1]);
         params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[2]);
         params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[3]);
         break;
      case GL_POSITION:
         params[0] = ctx->Light.Light[l].Position[0];
         params[1] = ctx->Light.Light[l].Position[1];
         params[2] = ctx->Light.Light[l].Position[2];
         params[3] = ctx->Light.Light[l].Position[3];
         break;
      case GL_SPOT_DIRECTION:
         params[0] = ctx->Light.Light[l].Direction[0];
         params[1] = ctx->Light.Light[l].Direction[1];
         params[2] = ctx->Light.Light[l].Direction[2];
         break;
      case GL_SPOT_EXPONENT:
         params[0] = ctx->Light.Light[l].SpotExponent;
         break;
      case GL_SPOT_CUTOFF:
         params[0] = ctx->Light.Light[l].SpotCutoff;
         break;
      case GL_CONSTANT_ATTENUATION:
         params[0] = ctx->Light.Light[l].ConstantAttenuation;
         break;
      case GL_LINEAR_ATTENUATION:
         params[0] = ctx->Light.Light[l].LinearAttenuation;
         break;
      case GL_QUADRATIC_ATTENUATION:
         params[0] = ctx->Light.Light[l].QuadraticAttenuation;
         break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glGetLightiv" );
         break;
   }
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_GetMaterialfv()

void gl_GetMaterialfv	(	GLcontext *	ctx,
		GLenum	face,
		GLenum	pname,
		GLfloat *	params
	)

Definition at line 563 of file light.c.

{
   GLuint f;

   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glGetMaterialfv" );
      return;
   }
   if (face==GL_FRONT) {
      f = 0;
   }
   else if (face==GL_BACK) {
      f = 1;
   }
   else {
      gl_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(face)" );
      return;
   }
   switch (pname) {
      case GL_AMBIENT:
         COPY_4V( params, ctx->Light.Material[f].Ambient );
         break;
      case GL_DIFFUSE:
         COPY_4V( params, ctx->Light.Material[f].Diffuse );
     break;
      case GL_SPECULAR:
         COPY_4V( params, ctx->Light.Material[f].Specular );
     break;
      case GL_EMISSION:
     COPY_4V( params, ctx->Light.Material[f].Emission );
     break;
      case GL_SHININESS:
     *params = ctx->Light.Material[f].Shininess;
     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;
     break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" );
   }
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_GetMaterialiv()

void gl_GetMaterialiv	(	GLcontext *	ctx,
		GLenum	face,
		GLenum	pname,
		GLint *	params
	)

Definition at line 610 of file light.c.

{
   GLuint f;

   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glGetMaterialiv" );
      return;
   }
   if (face==GL_FRONT) {
      f = 0;
   }
   else if (face==GL_BACK) {
      f = 1;
   }
   else {
      gl_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] );
         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] );
     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] );
     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] );
     break;
      case GL_SHININESS:
         *params = ROUNDF( ctx->Light.Material[f].Shininess );
     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 );
     break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" );
   }
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_Lightfv()

void gl_Lightfv	(	GLcontext *	ctx,
		GLenum	light,
		GLenum	pname,
		const GLfloat *	params,
		GLint	nparams
	)

Definition at line 114 of file light.c.

{
   GLint l;

   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glShadeModel" );
      return;
   }

   l = (GLint) (light - GL_LIGHT0);

   if (l<0 || l>=MAX_LIGHTS) {
      gl_error( ctx, GL_INVALID_ENUM, "glLight" );
      return;
   }

   switch (pname) {
      case GL_AMBIENT:
         COPY_4V( ctx->Light.Light[l].Ambient, params );
         break;
      case GL_DIFFUSE:
         COPY_4V( ctx->Light.Light[l].Diffuse, params );
         break;
      case GL_SPECULAR:
         COPY_4V( ctx->Light.Light[l].Specular, params );
         break;
      case GL_POSITION:
     /* transform position by ModelView matrix */
     TRANSFORM_POINT( ctx->Light.Light[l].Position, ctx->ModelViewMatrix,
                          params );
         break;
      case GL_SPOT_DIRECTION:
     /* transform direction by inverse modelview */
         {
            GLfloat direction[4];
            direction[0] = params[0];
            direction[1] = params[1];
            direction[2] = params[2];
            direction[3] = 0.0;
            if (ctx->NewModelViewMatrix) {
               gl_analyze_modelview_matrix( ctx );
            }
            gl_transform_vector( ctx->Light.Light[l].Direction,
                                 direction, ctx->ModelViewInv);
         }
         break;
      case GL_SPOT_EXPONENT:
         if (params[0]<0.0 || params[0]>128.0) {
            gl_error( ctx, GL_INVALID_VALUE, "glLight" );
            return;
         }
         if (ctx->Light.Light[l].SpotExponent != params[0]) {
            ctx->Light.Light[l].SpotExponent = params[0];
            gl_compute_spot_exp_table( &ctx->Light.Light[l] );
         }
         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;
         }
         ctx->Light.Light[l].SpotCutoff = params[0];
         ctx->Light.Light[l].CosCutoff = cos(params[0]*DEG2RAD);
         break;
      case GL_CONSTANT_ATTENUATION:
         if (params[0]<0.0) {
            gl_error( ctx, GL_INVALID_VALUE, "glLight" );
            return;
         }
         ctx->Light.Light[l].ConstantAttenuation = params[0];
         break;
      case GL_LINEAR_ATTENUATION:
         if (params[0]<0.0) {
            gl_error( ctx, GL_INVALID_VALUE, "glLight" );
            return;
         }
         ctx->Light.Light[l].LinearAttenuation = params[0];
         break;
      case GL_QUADRATIC_ATTENUATION:
         if (params[0]<0.0) {
            gl_error( ctx, GL_INVALID_VALUE, "glLight" );
            return;
         }
         ctx->Light.Light[l].QuadraticAttenuation = params[0];
         break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glLight" );
         break;
   }

   ctx->NewState |= NEW_LIGHTING;
}

Referenced by execute_list(), and init_exec_pointers().

gl_LightModelfv()

void gl_LightModelfv	(	GLcontext *	ctx,
		GLenum	pname,
		const GLfloat *	params
	)

Definition at line 327 of file light.c.

{
   switch (pname) {
      case GL_LIGHT_MODEL_AMBIENT:
         COPY_4V( ctx->Light.Model.Ambient, params );
         break;
      case GL_LIGHT_MODEL_LOCAL_VIEWER:
         if (params[0]==0.0)
            ctx->Light.Model.LocalViewer = GL_FALSE;
         else
            ctx->Light.Model.LocalViewer = GL_TRUE;
         break;
      case GL_LIGHT_MODEL_TWO_SIDE:
         if (params[0]==0.0)
            ctx->Light.Model.TwoSide = GL_FALSE;
         else
            ctx->Light.Model.TwoSide = GL_TRUE;
         break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glLightModel" );
         break;
   }
   ctx->NewState |= NEW_LIGHTING;
}

Referenced by execute_list(), and init_exec_pointers().

gl_material_bitmask()

GLuint gl_material_bitmask	(	GLenum	face,
		GLenum	pname
	)

Definition at line 362 of file light.c.

{
   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;
         break;
      case GL_AMBIENT:
         bitmask |= FRONT_AMBIENT_BIT | BACK_AMBIENT_BIT;
         break;
      case GL_DIFFUSE:
         bitmask |= FRONT_DIFFUSE_BIT | BACK_DIFFUSE_BIT;
         break;
      case GL_SPECULAR:
         bitmask |= FRONT_SPECULAR_BIT | BACK_SPECULAR_BIT;
         break;
      case GL_SHININESS:
         bitmask |= FRONT_SHININESS_BIT | BACK_SHININESS_BIT;
         break;
      case GL_AMBIENT_AND_DIFFUSE:
         bitmask |= FRONT_AMBIENT_BIT | BACK_AMBIENT_BIT;
         bitmask |= FRONT_DIFFUSE_BIT | BACK_DIFFUSE_BIT;
         break;
      case GL_COLOR_INDEXES:
         bitmask |= FRONT_INDEXES_BIT  | BACK_INDEXES_BIT;
         break;
      default:
         gl_problem(NULL, "Bad param in gl_material_bitmask");
         return 0;
   }

   ASSERT( face==GL_FRONT || face==GL_BACK || face==GL_FRONT_AND_BACK );

   if (face==GL_FRONT) {
      bitmask &= FRONT_MATERIAL_BITS;
   }
   else if (face==GL_BACK) {
      bitmask &= BACK_MATERIAL_BITS;
   }

   return bitmask;
}

Referenced by gl_ColorMaterial(), gl_Materialfv(), and initialize_context().

gl_Materialfv()

void gl_Materialfv	(	GLcontext *	ctx,
		GLenum	face,
		GLenum	pname,
		const GLfloat *	params
	)

Definition at line 523 of file light.c.

{
   GLuint bitmask;

   /* error checking */
   if (face!=GL_FRONT && face!=GL_BACK && face!=GL_FRONT_AND_BACK) {
      gl_error( ctx, GL_INVALID_ENUM, "glMaterial(face)" );
      return;
   }
   switch (pname) {
      case GL_EMISSION:
      case GL_AMBIENT:
      case GL_DIFFUSE:
      case GL_SPECULAR:
      case GL_SHININESS:
      case GL_AMBIENT_AND_DIFFUSE:
      case GL_COLOR_INDEXES:
         /* OK */
         break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glMaterial(pname)" );
         return;
   }

   /* convert face and pname to a bitmask */
   bitmask = gl_material_bitmask( face, pname );

   if (ctx->Light.ColorMaterialEnabled) {
      /* The material values specified by glColorMaterial() can't be */
      /* updated by glMaterial() while GL_COLOR_MATERIAL is enabled! */
      bitmask &= ~ctx->Light.ColorMaterialBitmask;
   }

   gl_set_material( ctx, bitmask, params );
}

Referenced by execute_list(), and init_exec_pointers().

gl_set_material()

void gl_set_material	(	GLcontext *	ctx,
		GLuint	bitmask,
		const GLfloat *	params
	)

Definition at line 413 of file light.c.

{
   struct gl_material *mat;

   if (INSIDE_BEGIN_END(ctx)) {
      struct vertex_buffer *VB = ctx->VB;
      /* Save per-vertex material changes in the Vertex Buffer.
       * The update_material function will eventually update the global
       * ctx->Light.Material values.
       */
      mat = VB->Material[VB->Count];
      VB->MaterialMask[VB->Count] |= bitmask;
      VB->MonoMaterial = GL_FALSE;
   }
   else {
      /* just update the global material property */
      mat = ctx->Light.Material;
      ctx->NewState |= NEW_LIGHTING;
   }

   if (bitmask & FRONT_AMBIENT_BIT) {
      COPY_4V( mat[0].Ambient, params );
   }
   if (bitmask & BACK_AMBIENT_BIT) {
      COPY_4V( mat[1].Ambient, params );
   }
   if (bitmask & FRONT_DIFFUSE_BIT) {
      COPY_4V( mat[0].Diffuse, params );
   }
   if (bitmask & BACK_DIFFUSE_BIT) {
      COPY_4V( mat[1].Diffuse, params );
   }
   if (bitmask & FRONT_SPECULAR_BIT) {
      COPY_4V( mat[0].Specular, params );
   }
   if (bitmask & BACK_SPECULAR_BIT) {
      COPY_4V( mat[1].Specular, params );
   }
   if (bitmask & FRONT_EMISSION_BIT) {
      COPY_4V( mat[0].Emission, params );
   }
   if (bitmask & BACK_EMISSION_BIT) {
      COPY_4V( mat[1].Emission, params );
   }
   if (bitmask & FRONT_SHININESS_BIT) {
      GLfloat shininess = CLAMP( params[0], 0.0F, 128.0F );
      if (mat[0].Shininess != shininess) {
         mat[0].Shininess = shininess;
         gl_compute_material_shine_table( &mat[0] );
      }
   }
   if (bitmask & BACK_SHININESS_BIT) {
      GLfloat shininess = CLAMP( params[0], 0.0F, 128.0F );
      if (mat[1].Shininess != shininess) {
         mat[1].Shininess = shininess;
         gl_compute_material_shine_table( &mat[1] );
      }
   }
   if (bitmask & FRONT_INDEXES_BIT) {
      mat[0].AmbientIndex = params[0];
      mat[0].DiffuseIndex = params[1];
      mat[0].SpecularIndex = params[2];
   }
   if (bitmask & BACK_INDEXES_BIT) {
      mat[1].AmbientIndex = params[0];
      mat[1].DiffuseIndex = params[1];
      mat[1].SpecularIndex = params[2];
   }
}

Referenced by gl_ArrayElement(), gl_ColorMat3f(), gl_ColorMat3fv(), gl_ColorMat4f(), gl_ColorMat4fv(), gl_ColorMat4ub(), gl_enable(), gl_eval_vertex(), and gl_Materialfv().

gl_ShadeModel()

void gl_ShadeModel	(	GLcontext *	ctx,
		GLenum	mode
	)

Definition at line 92 of file light.c.

{
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glShadeModel" );
      return;
   }

   switch (mode) {
      case GL_FLAT:
      case GL_SMOOTH:
         if (ctx->Light.ShadeModel!=mode) {
            ctx->Light.ShadeModel = mode;
            ctx->NewState |= NEW_RASTER_OPS;
         }
         break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glShadeModel" );
   }
}

Referenced by execute_list(), and init_exec_pointers().

gl_update_lighting()

void gl_update_lighting

(

GLcontext *

ctx

)

Definition at line 770 of file light.c.

{
   GLint i, side;
   struct gl_light *prev_enabled, *light;

   if (!ctx->Light.Enabled) {
      /* If lighting is not enabled, we can skip all this. */
      return;
   }

   /* Setup linked list of enabled light sources */
   prev_enabled = NULL;
   ctx->Light.FirstEnabled = NULL;
   for (i=0;i<MAX_LIGHTS;i++) {
      ctx->Light.Light[i].NextEnabled = NULL;
      if (ctx->Light.Light[i].Enabled) {
         if (prev_enabled) {
            prev_enabled->NextEnabled = &ctx->Light.Light[i];
         }
         else {
            ctx->Light.FirstEnabled = &ctx->Light.Light[i];
         }
         prev_enabled = &ctx->Light.Light[i];
      }
   }

   /* base color = material_emission + global_ambient * material_ambient */
   for (side=0; side<2; side++) {
      ctx->Light.BaseColor[side][0] = ctx->Light.Material[side].Emission[0]
         + ctx->Light.Model.Ambient[0] * ctx->Light.Material[side].Ambient[0];
      ctx->Light.BaseColor[side][1] = ctx->Light.Material[side].Emission[1]
         + ctx->Light.Model.Ambient[1] * ctx->Light.Material[side].Ambient[1];
      ctx->Light.BaseColor[side][2] = ctx->Light.Material[side].Emission[2]
         + ctx->Light.Model.Ambient[2] * ctx->Light.Material[side].Ambient[2];
      ctx->Light.BaseColor[side][3]
         = MIN2( ctx->Light.Material[side].Diffuse[3], 1.0F );
   }


   /* Precompute some lighting stuff */
   for (light = ctx->Light.FirstEnabled; light; light = light->NextEnabled) {
      for (side=0; side<2; side++) {
         struct gl_material *mat = &ctx->Light.Material[side];
         /* Add each light's ambient component to base color */
         ctx->Light.BaseColor[side][0] += light->Ambient[0] * mat->Ambient[0];
         ctx->Light.BaseColor[side][1] += light->Ambient[1] * mat->Ambient[1];
         ctx->Light.BaseColor[side][2] += light->Ambient[2] * mat->Ambient[2];
         /* compute product of light's ambient with front material ambient */
         light->MatAmbient[side][0] = light->Ambient[0] * mat->Ambient[0];
         light->MatAmbient[side][1] = light->Ambient[1] * mat->Ambient[1];
         light->MatAmbient[side][2] = light->Ambient[2] * mat->Ambient[2];
         /* compute product of light's diffuse with front material diffuse */
         light->MatDiffuse[side][0] = light->Diffuse[0] * mat->Diffuse[0];
         light->MatDiffuse[side][1] = light->Diffuse[1] * mat->Diffuse[1];
         light->MatDiffuse[side][2] = light->Diffuse[2] * mat->Diffuse[2];
         /* compute product of light's specular with front material specular */
         light->MatSpecular[side][0] = light->Specular[0] * mat->Specular[0];
         light->MatSpecular[side][1] = light->Specular[1] * mat->Specular[1];
         light->MatSpecular[side][2] = light->Specular[2] * mat->Specular[2];

         /* VP (VP) = Normalize( Position ) */
         COPY_3V( light->VP_inf_norm, light->Position );
         NORMALIZE_3FV( light->VP_inf_norm );

         /* h_inf_norm = Normalize( V_to_P + <0,0,1> ) */
         COPY_3V( light->h_inf_norm, light->VP_inf_norm );
         light->h_inf_norm[2] += 1.0F;
         NORMALIZE_3FV( light->h_inf_norm );

         COPY_3V( light->NormDirection, light->Direction );
         NORMALIZE_3FV( light->NormDirection );

         /* Compute color index diffuse and specular light intensities */
         light->dli = 0.30F * light->Diffuse[0]
                    + 0.59F * light->Diffuse[1]
                    + 0.11F * light->Diffuse[2];
         light->sli = 0.30F * light->Specular[0]
                    + 0.59F * light->Specular[1]
                    + 0.11F * light->Specular[2];

      } /* loop over materials */
   } /* loop over lights */

   /* Determine if the fast lighting function can be used */
   ctx->Light.Fast = GL_TRUE;
   if (    ctx->Light.BaseColor[0][0]<0.0F
        || ctx->Light.BaseColor[0][1]<0.0F
        || ctx->Light.BaseColor[0][2]<0.0F
        || ctx->Light.BaseColor[0][3]<0.0F
        || ctx->Light.BaseColor[1][0]<0.0F
        || ctx->Light.BaseColor[1][1]<0.0F
        || ctx->Light.BaseColor[1][2]<0.0F
        || ctx->Light.BaseColor[1][3]<0.0F
        || ctx->Light.Model.LocalViewer
        || ctx->Light.ColorMaterialEnabled) {
      ctx->Light.Fast = GL_FALSE;
   }
   else {
      for (light=ctx->Light.FirstEnabled; light; light=light->NextEnabled) {
         if (   light->Position[3]!=0.0F
             || light->SpotCutoff!=180.0F
             || light->MatDiffuse[0][0]<0.0F
             || light->MatDiffuse[0][1]<0.0F
             || light->MatDiffuse[0][2]<0.0F
             || light->MatSpecular[0][0]<0.0F
             || light->MatSpecular[0][1]<0.0F
             || light->MatSpecular[0][2]<0.0F
             || light->MatDiffuse[1][0]<0.0F
             || light->MatDiffuse[1][1]<0.0F
             || light->MatDiffuse[1][2]<0.0F
             || light->MatSpecular[1][0]<0.0F
             || light->MatSpecular[1][1]<0.0F
             || light->MatSpecular[1][2]<0.0F) {
            ctx->Light.Fast = GL_FALSE;
            break;
         }
      }
   }
}

Referenced by gl_reset_vb(), and gl_update_state().