src/mesa/main/light.c

   1 /* $Id: light.c,v 1.40 2001/03/07 05:06:12 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.5
   6  *
   7  * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27
  28 #ifdef PC_HEADER
  29 #include "all.h"
  30 #else
  31 #include "glheader.h"
  32 #include "colormac.h"
  33 #include "context.h"
  34 #include "enums.h"
  35 #include "light.h"
  36 #include "macros.h"
  37 #include "mem.h"
  38 #include "mmath.h"
  39 #include "simple_list.h"
  40 #include "mtypes.h"
  41
  42 #include "math/m_xform.h"
  43 #include "math/m_matrix.h"
  44 #endif
  45
  46
  47 /* XXX this is a bit of a hack needed for compilation within XFree86 */
  48 #ifndef FLT_MIN
  49 #define FLT_MIN 1e-37
  50 #endif
  51
  52
  53 void
  54 _mesa_ShadeModel( GLenum mode )
  55 {
  56    GET_CURRENT_CONTEXT(ctx);
  57    ASSERT_OUTSIDE_BEGIN_END(ctx);
  58
  59    if (MESA_VERBOSE & VERBOSE_API)
  60       fprintf(stderr, "glShadeModel %s\n", _mesa_lookup_enum_by_nr(mode));
  61
  62    if (mode != GL_FLAT && mode != GL_SMOOTH) {
  63       _mesa_error( ctx, GL_INVALID_ENUM, "glShadeModel" );
  64       return;
  65    }
  66
  67    if (ctx->Light.ShadeModel == mode)
  68       return;
  69
  70    FLUSH_VERTICES(ctx, _NEW_LIGHT);
  71    ctx->Light.ShadeModel = mode;
  72    ctx->_TriangleCaps ^= DD_FLATSHADE;
  73    if (ctx->Driver.ShadeModel)
  74       (*ctx->Driver.ShadeModel)( ctx, mode );
  75 }
  76
  77
  78
  79 void
  80 _mesa_Lightf( GLenum light, GLenum pname, GLfloat param )
  81 {
  82    _mesa_Lightfv( light, pname, &param );
  83 }
  84
  85
  86 void
  87 _mesa_Lightfv( GLenum light, GLenum pname, const GLfloat *params )
  88 {
  89    GET_CURRENT_CONTEXT(ctx);
  90    GLint i = (GLint) (light - GL_LIGHT0);
  91    struct gl_light *l = &ctx->Light.Light[i];
  92
  93    if (i < 0 || i >= (GLint) ctx->Const.MaxLights) {
  94       _mesa_error( ctx, GL_INVALID_ENUM, "glLight" );
  95       return;
  96    }
  97
  98    switch (pname) {
  99    case GL_AMBIENT:
 100       if (TEST_EQ_4V(l->Ambient, params))
 101          return;
 102       FLUSH_VERTICES(ctx, _NEW_LIGHT);
 103       COPY_4V( l->Ambient, params );
 104       break;
 105    case GL_DIFFUSE:
 106       if (TEST_EQ_4V(l->Diffuse, params))
 107          return;
 108       FLUSH_VERTICES(ctx, _NEW_LIGHT);
 109       COPY_4V( l->Diffuse, params );
 110       break;
 111    case GL_SPECULAR:
 112       if (TEST_EQ_4V(l->Specular, params))
 113          return;
 114       FLUSH_VERTICES(ctx, _NEW_LIGHT);
 115       COPY_4V( l->Specular, params );
 116       break;
 117    case GL_POSITION: {
 118       GLfloat tmp[4];
 119       /* transform position by ModelView matrix */
 120       TRANSFORM_POINT( tmp, ctx->ModelView.m, params );
 121       if (TEST_EQ_4V(l->EyePosition, tmp))
 122          return;
 123       FLUSH_VERTICES(ctx, _NEW_LIGHT);
 124       COPY_4V(l->EyePosition, tmp);
 125       if (l->EyePosition[3] != 0.0F)
 126          l->_Flags |= LIGHT_POSITIONAL;
 127       else
 128          l->_Flags &= ~LIGHT_POSITIONAL;
 129       break;
 130    }
 131    case GL_SPOT_DIRECTION: {
 132       GLfloat tmp[4];
 133       /* transform direction by inverse modelview */
 134       if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
 135          _math_matrix_analyse( &ctx->ModelView );
 136       }
 137       TRANSFORM_NORMAL( tmp, params, ctx->ModelView.inv );
 138       if (TEST_EQ_3V(l->EyeDirection, tmp))
 139          return;
 140       FLUSH_VERTICES(ctx, _NEW_LIGHT);
 141       COPY_3V(l->EyeDirection, tmp);
 142       break;
 143    }
 144    case GL_SPOT_EXPONENT:
 145       if (params[0]<0.0 || params[0]>128.0) {
 146          _mesa_error( ctx, GL_INVALID_VALUE, "glLight" );
 147          return;
 148       }
 149       if (l->SpotExponent == params[0])
 150          return;
 151       FLUSH_VERTICES(ctx, _NEW_LIGHT);
 152       l->SpotExponent = params[0];
 153       _mesa_invalidate_spot_exp_table( l );
 154       break;
 155    case GL_SPOT_CUTOFF:
 156       if ((params[0]<0.0 || params[0]>90.0) && params[0]!=180.0) {
 157          _mesa_error( ctx, GL_INVALID_VALUE, "glLight" );
 158          return;
 159       }
 160       if (l->SpotCutoff == params[0])
 161          return;
 162       FLUSH_VERTICES(ctx, _NEW_LIGHT);
 163       l->SpotCutoff = params[0];
 164       l->_CosCutoff = cos(params[0]*DEG2RAD);
 165       if (l->_CosCutoff < 0)
 166          l->_CosCutoff = 0;
 167       if (l->SpotCutoff != 180.0F)
 168          l->_Flags |= LIGHT_SPOT;
 169       else
 170          l->_Flags &= ~LIGHT_SPOT;
 171       break;
 172    case GL_CONSTANT_ATTENUATION:
 173       if (params[0]<0.0) {
 174          _mesa_error( ctx, GL_INVALID_VALUE, "glLight" );
 175          return;
 176       }
 177       if (l->ConstantAttenuation == params[0])
 178          return;
 179       FLUSH_VERTICES(ctx, _NEW_LIGHT);
 180       l->ConstantAttenuation = params[0];
 181       break;
 182    case GL_LINEAR_ATTENUATION:
 183       if (params[0]<0.0) {
 184          _mesa_error( ctx, GL_INVALID_VALUE, "glLight" );
 185          return;
 186       }
 187       if (l->LinearAttenuation == params[0])
 188          return;
 189       FLUSH_VERTICES(ctx, _NEW_LIGHT);
 190       l->LinearAttenuation = params[0];
 191       break;
 192    case GL_QUADRATIC_ATTENUATION:
 193       if (params[0]<0.0) {
 194          _mesa_error( ctx, GL_INVALID_VALUE, "glLight" );
 195          return;
 196       }
 197       if (l->QuadraticAttenuation == params[0])
 198          return;
 199       FLUSH_VERTICES(ctx, _NEW_LIGHT);
 200       l->QuadraticAttenuation = params[0];
 201       break;
 202    default:
 203       _mesa_error( ctx, GL_INVALID_ENUM, "glLight" );
 204       return;
 205    }
 206
 207    if (ctx->Driver.Lightfv)
 208       ctx->Driver.Lightfv( ctx, light, pname, params );
 209 }
 210
 211
 212 void
 213 _mesa_Lighti( GLenum light, GLenum pname, GLint param )
 214 {
 215    _mesa_Lightiv( light, pname, &param );
 216 }
 217
 218
 219 void
 220 _mesa_Lightiv( GLenum light, GLenum pname, const GLint *params )
 221 {
 222    GLfloat fparam[4];
 223
 224    switch (pname) {
 225       case GL_AMBIENT:
 226       case GL_DIFFUSE:
 227       case GL_SPECULAR:
 228          fparam[0] = INT_TO_FLOAT( params[0] );
 229          fparam[1] = INT_TO_FLOAT( params[1] );
 230          fparam[2] = INT_TO_FLOAT( params[2] );
 231          fparam[3] = INT_TO_FLOAT( params[3] );
 232          break;
 233       case GL_POSITION:
 234          fparam[0] = (GLfloat) params[0];
 235          fparam[1] = (GLfloat) params[1];
 236          fparam[2] = (GLfloat) params[2];
 237          fparam[3] = (GLfloat) params[3];
 238          break;
 239       case GL_SPOT_DIRECTION:
 240          fparam[0] = (GLfloat) params[0];
 241          fparam[1] = (GLfloat) params[1];
 242          fparam[2] = (GLfloat) params[2];
 243          break;
 244       case GL_SPOT_EXPONENT:
 245       case GL_SPOT_CUTOFF:
 246       case GL_CONSTANT_ATTENUATION:
 247       case GL_LINEAR_ATTENUATION:
 248       case GL_QUADRATIC_ATTENUATION:
 249          fparam[0] = (GLfloat) params[0];
 250          break;
 251       default:
 252          /* error will be caught later in gl_Lightfv */
 253          ;
 254    }
 255
 256    _mesa_Lightfv( light, pname, fparam );
 257 }
 258
 259
 260
 261 void
 262 _mesa_GetLightfv( GLenum light, GLenum pname, GLfloat *params )
 263 {
 264    GET_CURRENT_CONTEXT(ctx);
 265    GLint l = (GLint) (light - GL_LIGHT0);
 266    ASSERT_OUTSIDE_BEGIN_END(ctx);
 267
 268    if (l < 0 || l >= (GLint) ctx->Const.MaxLights) {
 269       _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightfv" );
 270       return;
 271    }
 272
 273    switch (pname) {
 274       case GL_AMBIENT:
 275          COPY_4V( params, ctx->Light.Light[l].Ambient );
 276          break;
 277       case GL_DIFFUSE:
 278          COPY_4V( params, ctx->Light.Light[l].Diffuse );
 279          break;
 280       case GL_SPECULAR:
 281          COPY_4V( params, ctx->Light.Light[l].Specular );
 282          break;
 283       case GL_POSITION:
 284          COPY_4V( params, ctx->Light.Light[l].EyePosition );
 285          break;
 286       case GL_SPOT_DIRECTION:
 287          COPY_3V( params, ctx->Light.Light[l].EyeDirection );
 288          break;
 289       case GL_SPOT_EXPONENT:
 290          params[0] = ctx->Light.Light[l].SpotExponent;
 291          break;
 292       case GL_SPOT_CUTOFF:
 293          params[0] = ctx->Light.Light[l].SpotCutoff;
 294          break;
 295       case GL_CONSTANT_ATTENUATION:
 296          params[0] = ctx->Light.Light[l].ConstantAttenuation;
 297          break;
 298       case GL_LINEAR_ATTENUATION:
 299          params[0] = ctx->Light.Light[l].LinearAttenuation;
 300          break;
 301       case GL_QUADRATIC_ATTENUATION:
 302          params[0] = ctx->Light.Light[l].QuadraticAttenuation;
 303          break;
 304       default:
 305          _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightfv" );
 306          break;
 307    }
 308 }
 309
 310
 311
 312 void
 313 _mesa_GetLightiv( GLenum light, GLenum pname, GLint *params )
 314 {
 315    GET_CURRENT_CONTEXT(ctx);
 316    GLint l = (GLint) (light - GL_LIGHT0);
 317    ASSERT_OUTSIDE_BEGIN_END(ctx);
 318
 319    if (l < 0 || l >= (GLint) ctx->Const.MaxLights) {
 320       _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightiv" );
 321       return;
 322    }
 323
 324    switch (pname) {
 325       case GL_AMBIENT:
 326          params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[0]);
 327          params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[1]);
 328          params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[2]);
 329          params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[3]);
 330          break;
 331       case GL_DIFFUSE:
 332          params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[0]);
 333          params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[1]);
 334          params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[2]);
 335          params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[3]);
 336          break;
 337       case GL_SPECULAR:
 338          params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[0]);
 339          params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[1]);
 340          params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[2]);
 341          params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[3]);
 342          break;
 343       case GL_POSITION:
 344          params[0] = (GLint) ctx->Light.Light[l].EyePosition[0];
 345          params[1] = (GLint) ctx->Light.Light[l].EyePosition[1];
 346          params[2] = (GLint) ctx->Light.Light[l].EyePosition[2];
 347          params[3] = (GLint) ctx->Light.Light[l].EyePosition[3];
 348          break;
 349       case GL_SPOT_DIRECTION:
 350          params[0] = (GLint) ctx->Light.Light[l].EyeDirection[0];
 351          params[1] = (GLint) ctx->Light.Light[l].EyeDirection[1];
 352          params[2] = (GLint) ctx->Light.Light[l].EyeDirection[2];
 353          break;
 354       case GL_SPOT_EXPONENT:
 355          params[0] = (GLint) ctx->Light.Light[l].SpotExponent;
 356          break;
 357       case GL_SPOT_CUTOFF:
 358          params[0] = (GLint) ctx->Light.Light[l].SpotCutoff;
 359          break;
 360       case GL_CONSTANT_ATTENUATION:
 361          params[0] = (GLint) ctx->Light.Light[l].ConstantAttenuation;
 362          break;
 363       case GL_LINEAR_ATTENUATION:
 364          params[0] = (GLint) ctx->Light.Light[l].LinearAttenuation;
 365          break;
 366       case GL_QUADRATIC_ATTENUATION:
 367          params[0] = (GLint) ctx->Light.Light[l].QuadraticAttenuation;
 368          break;
 369       default:
 370          _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightiv" );
 371          break;
 372    }
 373 }
 374
 375
 376
 377 /**********************************************************************/
 378 /***                        Light Model                             ***/
 379 /**********************************************************************/
 380
 381
 382 void
 383 _mesa_LightModelfv( GLenum pname, const GLfloat *params )
 384 {
 385    GLenum newenum;
 386    GLboolean newbool;
 387    GET_CURRENT_CONTEXT(ctx);
 388    ASSERT_OUTSIDE_BEGIN_END(ctx);
 389
 390    switch (pname) {
 391       case GL_LIGHT_MODEL_AMBIENT:
 392          if (TEST_EQ_4V( ctx->Light.Model.Ambient, params ))
 393             return;
 394          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 395          COPY_4V( ctx->Light.Model.Ambient, params );
 396          break;
 397       case GL_LIGHT_MODEL_LOCAL_VIEWER:
 398          newbool = (params[0]!=0.0);
 399          if (ctx->Light.Model.LocalViewer == newbool)
 400             return;
 401          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 402          ctx->Light.Model.LocalViewer = newbool;
 403          break;
 404       case GL_LIGHT_MODEL_TWO_SIDE:
 405          newbool = (params[0]!=0.0);
 406          if (ctx->Light.Model.TwoSide == newbool)
 407             return;
 408          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 409          ctx->Light.Model.TwoSide = newbool;
 410          break;
 411       case GL_LIGHT_MODEL_COLOR_CONTROL:
 412          if (params[0] == (GLfloat) GL_SINGLE_COLOR)
 413             newenum = GL_SINGLE_COLOR;
 414          else if (params[0] == (GLfloat) GL_SEPARATE_SPECULAR_COLOR)
 415             newenum = GL_SEPARATE_SPECULAR_COLOR;
 416          else {
 417             _mesa_error( ctx, GL_INVALID_ENUM, "glLightModel(param)" );
 418             return;
 419          }
 420          if (ctx->Light.Model.ColorControl == newenum)
 421             return;
 422          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 423          ctx->Light.Model.ColorControl = newenum;
 424
 425          if ((ctx->Light.Enabled &&
 426               ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
 427              || ctx->Fog.ColorSumEnabled)
 428             ctx->_TriangleCaps |= DD_SEPERATE_SPECULAR;
 429          else
 430             ctx->_TriangleCaps &= ~DD_SEPERATE_SPECULAR;
 431
 432          break;
 433       default:
 434          _mesa_error( ctx, GL_INVALID_ENUM, "glLightModel" );
 435          break;
 436    }
 437
 438    if (ctx->Driver.LightModelfv)
 439       ctx->Driver.LightModelfv( ctx, pname, params );
 440 }
 441
 442
 443 void
 444 _mesa_LightModeliv( GLenum pname, const GLint *params )
 445 {
 446    GLfloat fparam[4];
 447
 448    switch (pname) {
 449       case GL_LIGHT_MODEL_AMBIENT:
 450          fparam[0] = INT_TO_FLOAT( params[0] );
 451          fparam[1] = INT_TO_FLOAT( params[1] );
 452          fparam[2] = INT_TO_FLOAT( params[2] );
 453          fparam[3] = INT_TO_FLOAT( params[3] );
 454          break;
 455       case GL_LIGHT_MODEL_LOCAL_VIEWER:
 456       case GL_LIGHT_MODEL_TWO_SIDE:
 457       case GL_LIGHT_MODEL_COLOR_CONTROL:
 458          fparam[0] = (GLfloat) params[0];
 459          break;
 460       default:
 461          /* Error will be caught later in gl_LightModelfv */
 462          ;
 463    }
 464    _mesa_LightModelfv( pname, fparam );
 465 }
 466
 467
 468 void
 469 _mesa_LightModeli( GLenum pname, GLint param )
 470 {
 471    _mesa_LightModeliv( pname, &param );
 472 }
 473
 474
 475 void
 476 _mesa_LightModelf( GLenum pname, GLfloat param )
 477 {
 478    _mesa_LightModelfv( pname, &param );
 479 }
 480
 481
 482
 483 /********** MATERIAL **********/
 484
 485
 486 /*
 487  * Given a face and pname value (ala glColorMaterial), compute a bitmask
 488  * of the targeted material values.
 489  */
 490 GLuint
 491 _mesa_material_bitmask( GLcontext *ctx, GLenum face, GLenum pname,
 492                         GLuint legal, const char *where )
 493 {
 494    GLuint bitmask = 0;
 495
 496    /* Make a bitmask indicating what material attribute(s) we're updating */
 497    switch (pname) {
 498       case GL_EMISSION:
 499          bitmask |= FRONT_EMISSION_BIT | BACK_EMISSION_BIT;
 500          break;
 501       case GL_AMBIENT:
 502          bitmask |= FRONT_AMBIENT_BIT | BACK_AMBIENT_BIT;
 503          break;
 504       case GL_DIFFUSE:
 505          bitmask |= FRONT_DIFFUSE_BIT | BACK_DIFFUSE_BIT;
 506          break;
 507       case GL_SPECULAR:
 508          bitmask |= FRONT_SPECULAR_BIT | BACK_SPECULAR_BIT;
 509          break;
 510       case GL_SHININESS:
 511          bitmask |= FRONT_SHININESS_BIT | BACK_SHININESS_BIT;
 512          break;
 513       case GL_AMBIENT_AND_DIFFUSE:
 514          bitmask |= FRONT_AMBIENT_BIT | BACK_AMBIENT_BIT;
 515          bitmask |= FRONT_DIFFUSE_BIT | BACK_DIFFUSE_BIT;
 516          break;
 517       case GL_COLOR_INDEXES:
 518          bitmask |= FRONT_INDEXES_BIT  | BACK_INDEXES_BIT;
 519          break;
 520       default:
 521          _mesa_error( ctx, GL_INVALID_ENUM, where );
 522          return 0;
 523    }
 524
 525    if (face==GL_FRONT) {
 526       bitmask &= FRONT_MATERIAL_BITS;
 527    }
 528    else if (face==GL_BACK) {
 529       bitmask &= BACK_MATERIAL_BITS;
 530    }
 531    else if (face != GL_FRONT_AND_BACK) {
 532       _mesa_error( ctx, GL_INVALID_ENUM, where );
 533       return 0;
 534    }
 535
 536    if (bitmask & ~legal) {
 537       _mesa_error( ctx, GL_INVALID_ENUM, where );
 538       return 0;
 539    }
 540
 541    return bitmask;
 542 }
 543
 544
 545 /* Perform a straight copy between pairs of materials.
 546  */
 547 void _mesa_copy_material_pairs( struct gl_material dst[2],
 548                              const struct gl_material src[2],
 549                              GLuint bitmask )
 550 {
 551    if (bitmask & FRONT_EMISSION_BIT) {
 552       COPY_4FV( dst[0].Emission, src[0].Emission );
 553    }
 554    if (bitmask & BACK_EMISSION_BIT) {
 555       COPY_4FV( dst[1].Emission, src[1].Emission );
 556    }
 557    if (bitmask & FRONT_AMBIENT_BIT) {
 558       COPY_4FV( dst[0].Ambient, src[0].Ambient );
 559    }
 560    if (bitmask & BACK_AMBIENT_BIT) {
 561       COPY_4FV( dst[1].Ambient, src[1].Ambient );
 562    }
 563    if (bitmask & FRONT_DIFFUSE_BIT) {
 564       COPY_4FV( dst[0].Diffuse, src[0].Diffuse );
 565    }
 566    if (bitmask & BACK_DIFFUSE_BIT) {
 567       COPY_4FV( dst[1].Diffuse, src[1].Diffuse );
 568    }
 569    if (bitmask & FRONT_SPECULAR_BIT) {
 570       COPY_4FV( dst[0].Specular, src[0].Specular );
 571    }
 572    if (bitmask & BACK_SPECULAR_BIT) {
 573       COPY_4FV( dst[1].Specular, src[1].Specular );
 574    }
 575    if (bitmask & FRONT_SHININESS_BIT) {
 576       dst[0].Shininess = src[0].Shininess;
 577    }
 578    if (bitmask & BACK_SHININESS_BIT) {
 579       dst[1].Shininess = src[1].Shininess;
 580    }
 581    if (bitmask & FRONT_INDEXES_BIT) {
 582       dst[0].AmbientIndex = src[0].AmbientIndex;
 583       dst[0].DiffuseIndex = src[0].DiffuseIndex;
 584       dst[0].SpecularIndex = src[0].SpecularIndex;
 585    }
 586    if (bitmask & BACK_INDEXES_BIT) {
 587       dst[1].AmbientIndex = src[1].AmbientIndex;
 588       dst[1].DiffuseIndex = src[1].DiffuseIndex;
 589       dst[1].SpecularIndex = src[1].SpecularIndex;
 590    }
 591 }
 592
 593
 594 /*
 595  * Check if the global material has to be updated with info that was
 596  * associated with a vertex via glMaterial.
 597  * This function is used when any material values get changed between
 598  * glBegin/glEnd either by calling glMaterial() or by calling glColor()
 599  * when GL_COLOR_MATERIAL is enabled.
 600  *
 601  * src[0] is front material, src[1] is back material
 602  *
 603  * Additionally keeps the precomputed lighting state uptodate.
 604  */
 605 void _mesa_update_material( GLcontext *ctx,
 606                          const struct gl_material src[2],
 607                          GLuint bitmask )
 608 {
 609    struct gl_light *light, *list = &ctx->Light.EnabledList;
 610
 611    if (ctx->Light.ColorMaterialEnabled)
 612       bitmask &= ~ctx->Light.ColorMaterialBitmask;
 613
 614    if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
 615       fprintf(stderr, "_mesa_update_material, mask 0x%x\n", bitmask);
 616
 617    if (!bitmask)
 618       return;
 619
 620    /* update material emission */
 621    if (bitmask & FRONT_EMISSION_BIT) {
 622       struct gl_material *mat = &ctx->Light.Material[0];
 623       COPY_4FV( mat->Emission, src[0].Emission );
 624    }
 625    if (bitmask & BACK_EMISSION_BIT) {
 626       struct gl_material *mat = &ctx->Light.Material[1];
 627       COPY_4FV( mat->Emission, src[1].Emission );
 628    }
 629
 630    /* update material ambience */
 631    if (bitmask & FRONT_AMBIENT_BIT) {
 632       struct gl_material *mat = &ctx->Light.Material[0];
 633       COPY_4FV( mat->Ambient, src[0].Ambient );
 634       foreach (light, list) {
 635          SCALE_3V( light->_MatAmbient[0], light->Ambient, src[0].Ambient);
 636       }
 637    }
 638    if (bitmask & BACK_AMBIENT_BIT) {
 639       struct gl_material *mat = &ctx->Light.Material[1];
 640       COPY_4FV( mat->Ambient, src[1].Ambient );
 641       foreach (light, list) {
 642          SCALE_3V( light->_MatAmbient[1], light->Ambient, src[1].Ambient);
 643       }
 644    }
 645
 646    /* update BaseColor = emission + scene's ambience * material's ambience */
 647    if (bitmask & (FRONT_EMISSION_BIT | FRONT_AMBIENT_BIT)) {
 648       struct gl_material *mat = &ctx->Light.Material[0];
 649       COPY_3V( ctx->Light._BaseColor[0], mat->Emission );
 650       ACC_SCALE_3V( ctx->Light._BaseColor[0], mat->Ambient,
 651                     ctx->Light.Model.Ambient );
 652    }
 653    if (bitmask & (BACK_EMISSION_BIT | BACK_AMBIENT_BIT)) {
 654       struct gl_material *mat = &ctx->Light.Material[1];
 655       COPY_3V( ctx->Light._BaseColor[1], mat->Emission );
 656       ACC_SCALE_3V( ctx->Light._BaseColor[1], mat->Ambient,
 657                     ctx->Light.Model.Ambient );
 658    }
 659
 660    /* update material diffuse values */
 661    if (bitmask & FRONT_DIFFUSE_BIT) {
 662       struct gl_material *mat = &ctx->Light.Material[0];
 663       COPY_4FV( mat->Diffuse, src[0].Diffuse );
 664       foreach (light, list) {
 665          SCALE_3V( light->_MatDiffuse[0], light->Diffuse, mat->Diffuse );
 666       }
 667       UNCLAMPED_FLOAT_TO_CHAN(ctx->Light._BaseAlpha[0], mat->Diffuse[3]);
 668    }
 669    if (bitmask & BACK_DIFFUSE_BIT) {
 670       struct gl_material *mat = &ctx->Light.Material[1];
 671       COPY_4FV( mat->Diffuse, src[1].Diffuse );
 672       foreach (light, list) {
 673          SCALE_3V( light->_MatDiffuse[1], light->Diffuse, mat->Diffuse );
 674       }
 675       UNCLAMPED_FLOAT_TO_CHAN(ctx->Light._BaseAlpha[1], mat->Diffuse[3]);
 676    }
 677
 678    /* update material specular values */
 679    if (bitmask & FRONT_SPECULAR_BIT) {
 680       struct gl_material *mat = &ctx->Light.Material[0];
 681       COPY_4FV( mat->Specular, src[0].Specular );
 682       foreach (light, list) {
 683          SCALE_3V( light->_MatSpecular[0], light->Specular, mat->Specular);
 684       }
 685    }
 686    if (bitmask & BACK_SPECULAR_BIT) {
 687       struct gl_material *mat = &ctx->Light.Material[1];
 688       COPY_4FV( mat->Specular, src[1].Specular );
 689       foreach (light, list) {
 690          SCALE_3V( light->_MatSpecular[1], light->Specular, mat->Specular);
 691       }
 692    }
 693
 694    if (bitmask & FRONT_SHININESS_BIT) {
 695       ctx->Light.Material[0].Shininess = src[0].Shininess;
 696       _mesa_invalidate_shine_table( ctx, 0 );
 697    }
 698    if (bitmask & BACK_SHININESS_BIT) {
 699       ctx->Light.Material[1].Shininess = src[1].Shininess;
 700       _mesa_invalidate_shine_table( ctx, 1 );
 701    }
 702
 703    if (bitmask & FRONT_INDEXES_BIT) {
 704       ctx->Light.Material[0].AmbientIndex = src[0].AmbientIndex;
 705       ctx->Light.Material[0].DiffuseIndex = src[0].DiffuseIndex;
 706       ctx->Light.Material[0].SpecularIndex = src[0].SpecularIndex;
 707    }
 708    if (bitmask & BACK_INDEXES_BIT) {
 709       ctx->Light.Material[1].AmbientIndex = src[1].AmbientIndex;
 710       ctx->Light.Material[1].DiffuseIndex = src[1].DiffuseIndex;
 711       ctx->Light.Material[1].SpecularIndex = src[1].SpecularIndex;
 712    }
 713
 714    if (0)
 715    {
 716       struct gl_material *mat = &ctx->Light.Material[0];
 717       fprintf(stderr, "update_mat  emission : %f %f %f\n",
 718               mat->Emission[0],
 719               mat->Emission[1],
 720               mat->Emission[2]);
 721       fprintf(stderr, "update_mat  specular : %f %f %f\n",
 722               mat->Specular[0],
 723               mat->Specular[1],
 724               mat->Specular[2]);
 725       fprintf(stderr, "update_mat  diffuse : %f %f %f\n",
 726               mat->Diffuse[0],
 727               mat->Diffuse[1],
 728               mat->Diffuse[2]);
 729       fprintf(stderr, "update_mat  ambient : %f %f %f\n",
 730               mat->Ambient[0],
 731               mat->Ambient[1],
 732               mat->Ambient[2]);
 733    }
 734 }
 735
 736
 737
 738
 739
 740
 741
 742 /*
 743  * Update the current materials from the given rgba color
 744  * according to the bitmask in ColorMaterialBitmask, which is
 745  * set by glColorMaterial().
 746  */
 747 void _mesa_update_color_material( GLcontext *ctx,
 748                                const GLchan rgba[4] )
 749 {
 750    struct gl_light *light, *list = &ctx->Light.EnabledList;
 751    GLuint bitmask = ctx->Light.ColorMaterialBitmask;
 752    GLfloat color[4];
 753
 754    color[0] = CHAN_TO_FLOAT(rgba[0]);
 755    color[1] = CHAN_TO_FLOAT(rgba[1]);
 756    color[2] = CHAN_TO_FLOAT(rgba[2]);
 757    color[3] = CHAN_TO_FLOAT(rgba[3]);
 758
 759    if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
 760       fprintf(stderr, "_mesa_update_color_material, mask 0x%x\n", bitmask);
 761
 762    /* update emissive colors */
 763    if (bitmask & FRONT_EMISSION_BIT) {
 764       struct gl_material *mat = &ctx->Light.Material[0];
 765       COPY_4FV( mat->Emission, color );
 766    }
 767
 768    if (bitmask & BACK_EMISSION_BIT) {
 769       struct gl_material *mat = &ctx->Light.Material[1];
 770       COPY_4FV( mat->Emission, color );
 771    }
 772
 773    /* update light->_MatAmbient = light's ambient * material's ambient */
 774    if (bitmask & FRONT_AMBIENT_BIT) {
 775       struct gl_material *mat = &ctx->Light.Material[0];
 776       foreach (light, list) {
 777          SCALE_3V( light->_MatAmbient[0], light->Ambient, color);
 778       }
 779       COPY_4FV( mat->Ambient, color );
 780    }
 781
 782    if (bitmask & BACK_AMBIENT_BIT) {
 783       struct gl_material *mat = &ctx->Light.Material[1];
 784       foreach (light, list) {
 785          SCALE_3V( light->_MatAmbient[1], light->Ambient, color);
 786       }
 787       COPY_4FV( mat->Ambient, color );
 788    }
 789
 790    /* update BaseColor = emission + scene's ambience * material's ambience */
 791    if (bitmask & (FRONT_EMISSION_BIT | FRONT_AMBIENT_BIT)) {
 792       struct gl_material *mat = &ctx->Light.Material[0];
 793       COPY_3V( ctx->Light._BaseColor[0], mat->Emission );
 794       ACC_SCALE_3V( ctx->Light._BaseColor[0], mat->Ambient, ctx->Light.Model.Ambient );
 795    }
 796
 797    if (bitmask & (BACK_EMISSION_BIT | BACK_AMBIENT_BIT)) {
 798       struct gl_material *mat = &ctx->Light.Material[1];
 799       COPY_3V( ctx->Light._BaseColor[1], mat->Emission );
 800       ACC_SCALE_3V( ctx->Light._BaseColor[1], mat->Ambient, ctx->Light.Model.Ambient );
 801    }
 802
 803    /* update light->_MatDiffuse = light's diffuse * material's diffuse */
 804    if (bitmask & FRONT_DIFFUSE_BIT) {
 805       struct gl_material *mat = &ctx->Light.Material[0];
 806       COPY_4FV( mat->Diffuse, color );
 807       foreach (light, list) {
 808          SCALE_3V( light->_MatDiffuse[0], light->Diffuse, mat->Diffuse );
 809       }
 810       UNCLAMPED_FLOAT_TO_CHAN(ctx->Light._BaseAlpha[0], mat->Diffuse[3]);
 811    }
 812
 813    if (bitmask & BACK_DIFFUSE_BIT) {
 814       struct gl_material *mat = &ctx->Light.Material[1];
 815       COPY_4FV( mat->Diffuse, color );
 816       foreach (light, list) {
 817          SCALE_3V( light->_MatDiffuse[1], light->Diffuse, mat->Diffuse );
 818       }
 819       UNCLAMPED_FLOAT_TO_CHAN(ctx->Light._BaseAlpha[1], mat->Diffuse[3]);
 820    }
 821
 822    /* update light->_MatSpecular = light's specular * material's specular */
 823    if (bitmask & FRONT_SPECULAR_BIT) {
 824       struct gl_material *mat = &ctx->Light.Material[0];
 825       COPY_4FV( mat->Specular, color );
 826       foreach (light, list) {
 827          ACC_SCALE_3V( light->_MatSpecular[0], light->Specular, mat->Specular);
 828       }
 829    }
 830
 831    if (bitmask & BACK_SPECULAR_BIT) {
 832       struct gl_material *mat = &ctx->Light.Material[1];
 833       COPY_4FV( mat->Specular, color );
 834       foreach (light, list) {
 835          ACC_SCALE_3V( light->_MatSpecular[1], light->Specular, mat->Specular);
 836       }
 837    }
 838
 839    if (0)
 840    {
 841       struct gl_material *mat = &ctx->Light.Material[0];
 842       fprintf(stderr, "update_color_mat  emission : %f %f %f\n",
 843               mat->Emission[0],
 844               mat->Emission[1],
 845               mat->Emission[2]);
 846       fprintf(stderr, "update_color_mat  specular : %f %f %f\n",
 847               mat->Specular[0],
 848               mat->Specular[1],
 849               mat->Specular[2]);
 850       fprintf(stderr, "update_color_mat  diffuse : %f %f %f\n",
 851               mat->Diffuse[0],
 852               mat->Diffuse[1],
 853               mat->Diffuse[2]);
 854       fprintf(stderr, "update_color_mat  ambient : %f %f %f\n",
 855               mat->Ambient[0],
 856               mat->Ambient[1],
 857               mat->Ambient[2]);
 858    }
 859 }
 860
 861
 862
 863
 864 void
 865 _mesa_ColorMaterial( GLenum face, GLenum mode )
 866 {
 867    GET_CURRENT_CONTEXT(ctx);
 868    GLuint bitmask;
 869    GLuint legal = (FRONT_EMISSION_BIT | BACK_EMISSION_BIT |
 870                    FRONT_SPECULAR_BIT | BACK_SPECULAR_BIT |
 871                    FRONT_DIFFUSE_BIT  | BACK_DIFFUSE_BIT  |
 872                    FRONT_AMBIENT_BIT  | BACK_AMBIENT_BIT);
 873    ASSERT_OUTSIDE_BEGIN_END(ctx);
 874
 875    if (MESA_VERBOSE&VERBOSE_API)
 876       fprintf(stderr, "glColorMaterial %s %s\n",
 877               _mesa_lookup_enum_by_nr(face),
 878               _mesa_lookup_enum_by_nr(mode));
 879
 880    bitmask = _mesa_material_bitmask(ctx, face, mode, legal, "glColorMaterial");
 881
 882    if (ctx->Light.ColorMaterialBitmask == bitmask &&
 883        ctx->Light.ColorMaterialFace == face &&
 884        ctx->Light.ColorMaterialMode == mode)
 885       return;
 886
 887    FLUSH_VERTICES(ctx, _NEW_LIGHT);
 888    ctx->Light.ColorMaterialBitmask = bitmask;
 889    ctx->Light.ColorMaterialFace = face;
 890    ctx->Light.ColorMaterialMode = mode;
 891
 892    if (ctx->Light.ColorMaterialEnabled) {
 893       FLUSH_CURRENT( ctx, 0 );
 894       _mesa_update_color_material( ctx, ctx->Current.Color );
 895    }
 896 }
 897
 898
 899
 900
 901
 902 void
 903 _mesa_GetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
 904 {
 905    GET_CURRENT_CONTEXT(ctx);
 906    GLuint f;
 907    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* update materials */
 908
 909    if (face==GL_FRONT) {
 910       f = 0;
 911    }
 912    else if (face==GL_BACK) {
 913       f = 1;
 914    }
 915    else {
 916       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(face)" );
 917       return;
 918    }
 919    switch (pname) {
 920       case GL_AMBIENT:
 921          COPY_4FV( params, ctx->Light.Material[f].Ambient );
 922          break;
 923       case GL_DIFFUSE:
 924          COPY_4FV( params, ctx->Light.Material[f].Diffuse );
 925          break;
 926       case GL_SPECULAR:
 927          COPY_4FV( params, ctx->Light.Material[f].Specular );
 928          break;
 929       case GL_EMISSION:
 930          COPY_4FV( params, ctx->Light.Material[f].Emission );
 931          break;
 932       case GL_SHININESS:
 933          *params = ctx->Light.Material[f].Shininess;
 934          break;
 935       case GL_COLOR_INDEXES:
 936          params[0] = ctx->Light.Material[f].AmbientIndex;
 937          params[1] = ctx->Light.Material[f].DiffuseIndex;
 938          params[2] = ctx->Light.Material[f].SpecularIndex;
 939          break;
 940       default:
 941          _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" );
 942    }
 943 }
 944
 945
 946
 947 void
 948 _mesa_GetMaterialiv( GLenum face, GLenum pname, GLint *params )
 949 {
 950    GET_CURRENT_CONTEXT(ctx);
 951    GLuint f;
 952    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* update materials */
 953
 954    if (face==GL_FRONT) {
 955       f = 0;
 956    }
 957    else if (face==GL_BACK) {
 958       f = 1;
 959    }
 960    else {
 961       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialiv(face)" );
 962       return;
 963    }
 964    switch (pname) {
 965       case GL_AMBIENT:
 966          params[0] = FLOAT_TO_INT( ctx->Light.Material[f].Ambient[0] );
 967          params[1] = FLOAT_TO_INT( ctx->Light.Material[f].Ambient[1] );
 968          params[2] = FLOAT_TO_INT( ctx->Light.Material[f].Ambient[2] );
 969          params[3] = FLOAT_TO_INT( ctx->Light.Material[f].Ambient[3] );
 970          break;
 971       case GL_DIFFUSE:
 972          params[0] = FLOAT_TO_INT( ctx->Light.Material[f].Diffuse[0] );
 973          params[1] = FLOAT_TO_INT( ctx->Light.Material[f].Diffuse[1] );
 974          params[2] = FLOAT_TO_INT( ctx->Light.Material[f].Diffuse[2] );
 975          params[3] = FLOAT_TO_INT( ctx->Light.Material[f].Diffuse[3] );
 976          break;
 977       case GL_SPECULAR:
 978          params[0] = FLOAT_TO_INT( ctx->Light.Material[f].Specular[0] );
 979          params[1] = FLOAT_TO_INT( ctx->Light.Material[f].Specular[1] );
 980          params[2] = FLOAT_TO_INT( ctx->Light.Material[f].Specular[2] );
 981          params[3] = FLOAT_TO_INT( ctx->Light.Material[f].Specular[3] );
 982          break;
 983       case GL_EMISSION:
 984          params[0] = FLOAT_TO_INT( ctx->Light.Material[f].Emission[0] );
 985          params[1] = FLOAT_TO_INT( ctx->Light.Material[f].Emission[1] );
 986          params[2] = FLOAT_TO_INT( ctx->Light.Material[f].Emission[2] );
 987          params[3] = FLOAT_TO_INT( ctx->Light.Material[f].Emission[3] );
 988          break;
 989       case GL_SHININESS:
 990          *params = ROUNDF( ctx->Light.Material[f].Shininess );
 991          break;
 992       case GL_COLOR_INDEXES:
 993          params[0] = ROUNDF( ctx->Light.Material[f].AmbientIndex );
 994          params[1] = ROUNDF( ctx->Light.Material[f].DiffuseIndex );
 995          params[2] = ROUNDF( ctx->Light.Material[f].SpecularIndex );
 996          break;
 997       default:
 998          _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" );
 999    }
1000 }
1001
1002
1003
1004
1005 /**********************************************************************/
1006 /*****                  Lighting computation                      *****/
1007 /**********************************************************************/
1008
1009
1010 /*
1011  * Notes:
1012  *   When two-sided lighting is enabled we compute the color (or index)
1013  *   for both the front and back side of the primitive.  Then, when the
1014  *   orientation of the facet is later learned, we can determine which
1015  *   color (or index) to use for rendering.
1016  *
1017  *   KW: We now know orientation in advance and only shade for
1018  *       the side or sides which are actually required.
1019  *
1020  * Variables:
1021  *   n = normal vector
1022  *   V = vertex position
1023  *   P = light source position
1024  *   Pe = (0,0,0,1)
1025  *
1026  * Precomputed:
1027  *   IF P[3]==0 THEN
1028  *       // light at infinity
1029  *       IF local_viewer THEN
1030  *           _VP_inf_norm = unit vector from V to P      // Precompute
1031  *       ELSE
1032  *           // eye at infinity
1033  *           _h_inf_norm = Normalize( VP + <0,0,1> )     // Precompute
1034  *       ENDIF
1035  *   ENDIF
1036  *
1037  * Functions:
1038  *   Normalize( v ) = normalized vector v
1039  *   Magnitude( v ) = length of vector v
1040  */
1041
1042
1043
1044 /*
1045  * Whenever the spotlight exponent for a light changes we must call
1046  * this function to recompute the exponent lookup table.
1047  */
1048 void
1049 _mesa_invalidate_spot_exp_table( struct gl_light *l )
1050 {
1051    l->_SpotExpTable[0][0] = -1;
1052 }
1053
1054 static void validate_spot_exp_table( struct gl_light *l )
1055 {
1056    GLint i;
1057    GLdouble exponent = l->SpotExponent;
1058    GLdouble tmp = 0;
1059    GLint clamp = 0;
1060
1061    l->_SpotExpTable[0][0] = 0.0;
1062
1063    for (i = EXP_TABLE_SIZE - 1; i > 0 ;i--) {
1064       if (clamp == 0) {
1065          tmp = pow(i / (GLdouble) (EXP_TABLE_SIZE - 1), exponent);
1066          if (tmp < FLT_MIN * 100.0) {
1067             tmp = 0.0;
1068             clamp = 1;
1069          }
1070       }
1071       l->_SpotExpTable[i][0] = tmp;
1072    }
1073    for (i = 0; i < EXP_TABLE_SIZE - 1; i++) {
1074       l->_SpotExpTable[i][1] = (l->_SpotExpTable[i+1][0] -
1075                                 l->_SpotExpTable[i][0]);
1076    }
1077    l->_SpotExpTable[EXP_TABLE_SIZE-1][1] = 0.0;
1078 }
1079
1080
1081
1082
1083 /* Calculate a new shine table.  Doing this here saves a branch in
1084  * lighting, and the cost of doing it early may be partially offset
1085  * by keeping a MRU cache of shine tables for various shine values.
1086  */
1087 void
1088 _mesa_invalidate_shine_table( GLcontext *ctx, GLuint i )
1089 {
1090    if (ctx->_ShineTable[i])
1091       ctx->_ShineTable[i]->refcount--;
1092    ctx->_ShineTable[i] = 0;
1093 }
1094
1095 static void validate_shine_table( GLcontext *ctx, GLuint i, GLfloat shininess )
1096 {
1097    struct gl_shine_tab *list = ctx->_ShineTabList;
1098    struct gl_shine_tab *s;
1099
1100    foreach(s, list)
1101       if ( s->shininess == shininess )
1102          break;
1103
1104    if (s == list) {
1105       GLint j;
1106       GLfloat *m;
1107
1108       foreach(s, list)
1109          if (s->refcount == 0)
1110             break;
1111
1112       m = s->tab;
1113       m[0] = 0.0;
1114       if (shininess == 0.0) {
1115          for (j = 1 ; j <= SHINE_TABLE_SIZE ; j++)
1116             m[j] = 1.0;
1117       }
1118       else {
1119          for (j = 1 ; j < SHINE_TABLE_SIZE ; j++) {
1120             GLdouble t, x = j / (GLfloat) (SHINE_TABLE_SIZE - 1);
1121             if (x < 0.005) /* underflow check */
1122                x = 0.005;
1123             t = pow(x, shininess);
1124             if (t > 1e-20)
1125                m[j] = t;
1126             else
1127                m[j] = 0.0;
1128          }
1129          m[SHINE_TABLE_SIZE] = 1.0;
1130       }
1131
1132       s->shininess = shininess;
1133    }
1134
1135    if (ctx->_ShineTable[i])
1136       ctx->_ShineTable[i]->refcount--;
1137
1138    ctx->_ShineTable[i] = s;
1139    move_to_tail( list, s );
1140    s->refcount++;
1141 }
1142
1143 void
1144 _mesa_validate_all_lighting_tables( GLcontext *ctx )
1145 {
1146    GLint i;
1147    GLfloat shininess;
1148
1149    shininess = ctx->Light.Material[0].Shininess;
1150    if (!ctx->_ShineTable[0] || ctx->_ShineTable[0]->shininess != shininess)
1151       validate_shine_table( ctx, 0, shininess );
1152
1153    shininess = ctx->Light.Material[1].Shininess;
1154    if (!ctx->_ShineTable[1] || ctx->_ShineTable[1]->shininess != shininess)
1155       validate_shine_table( ctx, 1, shininess );
1156
1157    for (i = 0 ; i < MAX_LIGHTS ; i++)
1158       if (ctx->Light.Light[i]._SpotExpTable[0][0] == -1)
1159          validate_spot_exp_table( &ctx->Light.Light[i] );
1160 }
1161
1162
1163
1164
1165 /*
1166  * Examine current lighting parameters to determine if the optimized lighting
1167  * function can be used.
1168  * Also, precompute some lighting values such as the products of light
1169  * source and material ambient, diffuse and specular coefficients.
1170  */
1171 void
1172 _mesa_update_lighting( GLcontext *ctx )
1173 {
1174    struct gl_light *light;
1175    ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE;
1176    ctx->_NeedEyeCoords &= ~NEED_EYE_LIGHT;
1177    ctx->_NeedNormals &= ~NEED_NORMALS_LIGHT;
1178    ctx->Light._Flags = 0;
1179
1180    if (!ctx->Light.Enabled)
1181       return;
1182
1183    ctx->_NeedNormals |= NEED_NORMALS_LIGHT;
1184
1185    if (ctx->Light.Model.TwoSide)
1186       ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE;
1187
1188    foreach(light, &ctx->Light.EnabledList) {
1189       ctx->Light._Flags |= light->_Flags;
1190    }
1191
1192    ctx->Light._NeedVertices =
1193       ((ctx->Light._Flags & (LIGHT_POSITIONAL|LIGHT_SPOT)) ||
1194        ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR ||
1195        ctx->Light.Model.LocalViewer);
1196
1197    if ((ctx->Light._Flags & LIGHT_POSITIONAL) ||
1198        ctx->Light.Model.LocalViewer)
1199       ctx->_NeedEyeCoords |= NEED_EYE_LIGHT;
1200
1201
1202    /* XXX: This test is overkill & needs to be fixed both for software and
1203     * hardware t&l drivers.  The above should be sufficient & should
1204     * be tested to verify this.
1205     */
1206    if (ctx->Light._NeedVertices)
1207       ctx->_NeedEyeCoords |= NEED_EYE_LIGHT;
1208
1209
1210    /* Precompute some shading values.  Although we reference
1211     * Light.Material here, we can get away without flushing
1212     * FLUSH_UPDATE_CURRENT, as when any outstanding material changes
1213     * are flushed, they will update the derived state at that time.
1214     */
1215    if (ctx->Visual.rgbMode) {
1216       GLuint sides = ctx->Light.Model.TwoSide ? 2 : 1;
1217       GLuint side;
1218       for (side=0; side < sides; side++) {
1219          struct gl_material *mat = &ctx->Light.Material[side];
1220
1221          COPY_3V(ctx->Light._BaseColor[side], mat->Emission);
1222          ACC_SCALE_3V(ctx->Light._BaseColor[side],
1223                       ctx->Light.Model.Ambient,
1224                       mat->Ambient);
1225
1226          UNCLAMPED_FLOAT_TO_CHAN(ctx->Light._BaseAlpha[side],
1227                                  ctx->Light.Material[side].Diffuse[3] );
1228       }
1229
1230       foreach (light, &ctx->Light.EnabledList) {
1231          for (side=0; side< sides; side++) {
1232             const struct gl_material *mat = &ctx->Light.Material[side];
1233             SCALE_3V( light->_MatDiffuse[side], light->Diffuse, mat->Diffuse );
1234             SCALE_3V( light->_MatAmbient[side], light->Ambient, mat->Ambient );
1235             SCALE_3V( light->_MatSpecular[side], light->Specular,
1236                       mat->Specular);
1237          }
1238       }
1239    }
1240    else {
1241       static const GLfloat ci[3] = { .30, .59, .11 };
1242       foreach(light, &ctx->Light.EnabledList) {
1243          light->_dli = DOT3(ci, light->Diffuse);
1244          light->_sli = DOT3(ci, light->Specular);
1245       }
1246    }
1247 }
1248
1249
1250 /* _NEW_MODELVIEW
1251  * _NEW_LIGHT
1252  * _TNL_NEW_NEED_EYE_COORDS
1253  *
1254  * Update on (_NEW_MODELVIEW | _NEW_LIGHT) when lighting is enabled.
1255  * Also update on lighting space changes.
1256  */
1257 void
1258 _mesa_compute_light_positions( GLcontext *ctx )
1259 {
1260    struct gl_light *light;
1261    static const GLfloat eye_z[3] = { 0, 0, 1 };
1262
1263    if (!ctx->Light.Enabled)
1264       return;
1265
1266    if (ctx->_NeedEyeCoords) {
1267       COPY_3V( ctx->_EyeZDir, eye_z );
1268    }
1269    else {
1270       TRANSFORM_NORMAL( ctx->_EyeZDir, eye_z, ctx->ModelView.m );
1271    }
1272
1273    foreach (light, &ctx->Light.EnabledList) {
1274
1275       if (ctx->_NeedEyeCoords) {
1276          COPY_4FV( light->_Position, light->EyePosition );
1277       }
1278       else {
1279          TRANSFORM_POINT( light->_Position, ctx->ModelView.inv,
1280                           light->EyePosition );
1281       }
1282
1283       if (!(light->_Flags & LIGHT_POSITIONAL)) {
1284          /* VP (VP) = Normalize( Position ) */
1285          COPY_3V( light->_VP_inf_norm, light->_Position );
1286          NORMALIZE_3FV( light->_VP_inf_norm );
1287
1288          if (!ctx->Light.Model.LocalViewer) {
1289             /* _h_inf_norm = Normalize( V_to_P + <0,0,1> ) */
1290             ADD_3V( light->_h_inf_norm, light->_VP_inf_norm, ctx->_EyeZDir);
1291             NORMALIZE_3FV( light->_h_inf_norm );
1292          }
1293          light->_VP_inf_spot_attenuation = 1.0;
1294       }
1295
1296       if (light->_Flags & LIGHT_SPOT) {
1297          if (ctx->_NeedEyeCoords) {
1298             COPY_3V( light->_NormDirection, light->EyeDirection );
1299          }
1300          else {
1301             TRANSFORM_NORMAL( light->_NormDirection,
1302                               light->EyeDirection,
1303                               ctx->ModelView.m);
1304          }
1305
1306          NORMALIZE_3FV( light->_NormDirection );
1307
1308          if (!(light->_Flags & LIGHT_POSITIONAL)) {
1309             GLfloat PV_dot_dir = - DOT3(light->_VP_inf_norm,
1310                                         light->_NormDirection);
1311
1312             if (PV_dot_dir > light->_CosCutoff) {
1313                double x = PV_dot_dir * (EXP_TABLE_SIZE-1);
1314                int k = (int) x;
1315                light->_VP_inf_spot_attenuation =
1316                   (light->_SpotExpTable[k][0] +
1317                    (x-k)*light->_SpotExpTable[k][1]);
1318             }
1319             else {
1320                light->_VP_inf_spot_attenuation = 0;
1321             }
1322          }
1323       }
1324    }
1325 }
1326
1327