1 /* 2 * Mesa 3-D graphics library 3 * 4 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. 5 * Copyright (C) 2009 VMware, Inc. All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included 15 * in all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 23 * OTHER DEALINGS IN THE SOFTWARE. 24 */ 25 26 27 #include "c99_math.h" 28 #include "glheader.h" 29 #include "imports.h" 30 #include "context.h" 31 #include "enums.h" 32 #include "light.h" 33 #include "macros.h" 34 #include "mtypes.h" 35 #include "math/m_matrix.h" 36 #include "util/bitscan.h" 37 38 39 void GLAPIENTRY 40 _mesa_ShadeModel( GLenum mode ) 41 { 42 GET_CURRENT_CONTEXT(ctx); 43 44 if (MESA_VERBOSE & VERBOSE_API) 45 _mesa_debug(ctx, "glShadeModel %s\n", _mesa_enum_to_string(mode)); 46 47 if (ctx->Light.ShadeModel == mode) 48 return; 49 50 if (mode != GL_FLAT && mode != GL_SMOOTH) { 51 _mesa_error(ctx, GL_INVALID_ENUM, "glShadeModel"); 52 return; 53 } 54 55 FLUSH_VERTICES(ctx, _NEW_LIGHT); 56 ctx->Light.ShadeModel = mode; 57 58 if (ctx->Driver.ShadeModel) 59 ctx->Driver.ShadeModel( ctx, mode ); 60 } 61 62 63 /** 64 * Set the provoking vertex (the vertex which specifies the prim's 65 * color when flat shading) to either the first or last vertex of the 66 * triangle or line. 67 */ 68 void GLAPIENTRY 69 _mesa_ProvokingVertex(GLenum mode) 70 { 71 GET_CURRENT_CONTEXT(ctx); 72 73 if (MESA_VERBOSE&VERBOSE_API) 74 _mesa_debug(ctx, "glProvokingVertexEXT 0x%x\n", mode); 75 76 if (ctx->Light.ProvokingVertex == mode) 77 return; 78 79 switch (mode) { 80 case GL_FIRST_VERTEX_CONVENTION_EXT: 81 case GL_LAST_VERTEX_CONVENTION_EXT: 82 break; 83 default: 84 _mesa_error(ctx, GL_INVALID_ENUM, "glProvokingVertexEXT(0x%x)", mode); 85 return; 86 } 87 88 FLUSH_VERTICES(ctx, _NEW_LIGHT); 89 ctx->Light.ProvokingVertex = mode; 90 } 91 92 93 /** 94 * Helper function called by _mesa_Lightfv and _mesa_PopAttrib to set 95 * per-light state. 96 * For GL_POSITION and GL_SPOT_DIRECTION the params position/direction 97 * will have already been transformed by the modelview matrix! 98 * Also, all error checking should have already been done. 99 */ 100 void 101 _mesa_light(struct gl_context *ctx, GLuint lnum, GLenum pname, const GLfloat *params) 102 { 103 struct gl_light *light; 104 105 assert(lnum < MAX_LIGHTS); 106 light = &ctx->Light.Light[lnum]; 107 108 switch (pname) { 109 case GL_AMBIENT: 110 if (TEST_EQ_4V(light->Ambient, params)) 111 return; 112 FLUSH_VERTICES(ctx, _NEW_LIGHT); 113 COPY_4V( light->Ambient, params ); 114 break; 115 case GL_DIFFUSE: 116 if (TEST_EQ_4V(light->Diffuse, params)) 117 return; 118 FLUSH_VERTICES(ctx, _NEW_LIGHT); 119 COPY_4V( light->Diffuse, params ); 120 break; 121 case GL_SPECULAR: 122 if (TEST_EQ_4V(light->Specular, params)) 123 return; 124 FLUSH_VERTICES(ctx, _NEW_LIGHT); 125 COPY_4V( light->Specular, params ); 126 break; 127 case GL_POSITION: 128 /* NOTE: position has already been transformed by ModelView! */ 129 if (TEST_EQ_4V(light->EyePosition, params)) 130 return; 131 FLUSH_VERTICES(ctx, _NEW_LIGHT); 132 COPY_4V(light->EyePosition, params); 133 if (light->EyePosition[3] != 0.0F) 134 light->_Flags |= LIGHT_POSITIONAL; 135 else 136 light->_Flags &= ~LIGHT_POSITIONAL; 137 break; 138 case GL_SPOT_DIRECTION: 139 /* NOTE: Direction already transformed by inverse ModelView! */ 140 if (TEST_EQ_3V(light->SpotDirection, params)) 141 return; 142 FLUSH_VERTICES(ctx, _NEW_LIGHT); 143 COPY_3V(light->SpotDirection, params); 144 break; 145 case GL_SPOT_EXPONENT: 146 assert(params[0] >= 0.0F); 147 assert(params[0] <= ctx->Const.MaxSpotExponent); 148 if (light->SpotExponent == params[0]) 149 return; 150 FLUSH_VERTICES(ctx, _NEW_LIGHT); 151 light->SpotExponent = params[0]; 152 break; 153 case GL_SPOT_CUTOFF: 154 assert(params[0] == 180.0F || (params[0] >= 0.0F && params[0] <= 90.0F)); 155 if (light->SpotCutoff == params[0]) 156 return; 157 FLUSH_VERTICES(ctx, _NEW_LIGHT); 158 light->SpotCutoff = params[0]; 159 light->_CosCutoff = (cosf(light->SpotCutoff * M_PI / 180.0)); 160 if (light->_CosCutoff < 0) 161 light->_CosCutoff = 0; 162 if (light->SpotCutoff != 180.0F) 163 light->_Flags |= LIGHT_SPOT; 164 else 165 light->_Flags &= ~LIGHT_SPOT; 166 break; 167 case GL_CONSTANT_ATTENUATION: 168 assert(params[0] >= 0.0F); 169 if (light->ConstantAttenuation == params[0]) 170 return; 171 FLUSH_VERTICES(ctx, _NEW_LIGHT); 172 light->ConstantAttenuation = params[0]; 173 break; 174 case GL_LINEAR_ATTENUATION: 175 assert(params[0] >= 0.0F); 176 if (light->LinearAttenuation == params[0]) 177 return; 178 FLUSH_VERTICES(ctx, _NEW_LIGHT); 179 light->LinearAttenuation = params[0]; 180 break; 181 case GL_QUADRATIC_ATTENUATION: 182 assert(params[0] >= 0.0F); 183 if (light->QuadraticAttenuation == params[0]) 184 return; 185 FLUSH_VERTICES(ctx, _NEW_LIGHT); 186 light->QuadraticAttenuation = params[0]; 187 break; 188 default: 189 unreachable("Unexpected pname in _mesa_light()"); 190 } 191 192 if (ctx->Driver.Lightfv) 193 ctx->Driver.Lightfv( ctx, GL_LIGHT0 + lnum, pname, params ); 194 } 195 196 197 void GLAPIENTRY 198 _mesa_Lightf( GLenum light, GLenum pname, GLfloat param ) 199 { 200 GLfloat fparam[4]; 201 fparam[0] = param; 202 fparam[1] = fparam[2] = fparam[3] = 0.0F; 203 _mesa_Lightfv( light, pname, fparam ); 204 } 205 206 207 void GLAPIENTRY 208 _mesa_Lightfv( GLenum light, GLenum pname, const GLfloat *params ) 209 { 210 GET_CURRENT_CONTEXT(ctx); 211 GLint i = (GLint) (light - GL_LIGHT0); 212 GLfloat temp[4]; 213 214 if (i < 0 || i >= (GLint) ctx->Const.MaxLights) { 215 _mesa_error( ctx, GL_INVALID_ENUM, "glLight(light=0x%x)", light ); 216 return; 217 } 218 219 /* do particular error checks, transformations */ 220 switch (pname) { 221 case GL_AMBIENT: 222 case GL_DIFFUSE: 223 case GL_SPECULAR: 224 /* nothing */ 225 break; 226 case GL_POSITION: 227 /* transform position by ModelView matrix */ 228 TRANSFORM_POINT(temp, ctx->ModelviewMatrixStack.Top->m, params); 229 params = temp; 230 break; 231 case GL_SPOT_DIRECTION: 232 /* transform direction by inverse modelview */ 233 if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) { 234 _math_matrix_analyse(ctx->ModelviewMatrixStack.Top); 235 } 236 TRANSFORM_DIRECTION(temp, params, ctx->ModelviewMatrixStack.Top->m); 237 params = temp; 238 break; 239 case GL_SPOT_EXPONENT: 240 if (params[0] < 0.0F || params[0] > ctx->Const.MaxSpotExponent) { 241 _mesa_error(ctx, GL_INVALID_VALUE, "glLight"); 242 return; 243 } 244 break; 245 case GL_SPOT_CUTOFF: 246 if ((params[0] < 0.0F || params[0] > 90.0F) && params[0] != 180.0F) { 247 _mesa_error(ctx, GL_INVALID_VALUE, "glLight"); 248 return; 249 } 250 break; 251 case GL_CONSTANT_ATTENUATION: 252 case GL_LINEAR_ATTENUATION: 253 case GL_QUADRATIC_ATTENUATION: 254 if (params[0] < 0.0F) { 255 _mesa_error(ctx, GL_INVALID_VALUE, "glLight"); 256 return; 257 } 258 break; 259 default: 260 _mesa_error(ctx, GL_INVALID_ENUM, "glLight(pname=0x%x)", pname); 261 return; 262 } 263 264 _mesa_light(ctx, i, pname, params); 265 } 266 267 268 void GLAPIENTRY 269 _mesa_Lighti( GLenum light, GLenum pname, GLint param ) 270 { 271 GLint iparam[4]; 272 iparam[0] = param; 273 iparam[1] = iparam[2] = iparam[3] = 0; 274 _mesa_Lightiv( light, pname, iparam ); 275 } 276 277 278 void GLAPIENTRY 279 _mesa_Lightiv( GLenum light, GLenum pname, const GLint *params ) 280 { 281 GLfloat fparam[4]; 282 283 switch (pname) { 284 case GL_AMBIENT: 285 case GL_DIFFUSE: 286 case GL_SPECULAR: 287 fparam[0] = INT_TO_FLOAT( params[0] ); 288 fparam[1] = INT_TO_FLOAT( params[1] ); 289 fparam[2] = INT_TO_FLOAT( params[2] ); 290 fparam[3] = INT_TO_FLOAT( params[3] ); 291 break; 292 case GL_POSITION: 293 fparam[0] = (GLfloat) params[0]; 294 fparam[1] = (GLfloat) params[1]; 295 fparam[2] = (GLfloat) params[2]; 296 fparam[3] = (GLfloat) params[3]; 297 break; 298 case GL_SPOT_DIRECTION: 299 fparam[0] = (GLfloat) params[0]; 300 fparam[1] = (GLfloat) params[1]; 301 fparam[2] = (GLfloat) params[2]; 302 break; 303 case GL_SPOT_EXPONENT: 304 case GL_SPOT_CUTOFF: 305 case GL_CONSTANT_ATTENUATION: 306 case GL_LINEAR_ATTENUATION: 307 case GL_QUADRATIC_ATTENUATION: 308 fparam[0] = (GLfloat) params[0]; 309 break; 310 default: 311 /* error will be caught later in gl_Lightfv */ 312 ; 313 } 314 315 _mesa_Lightfv( light, pname, fparam ); 316 } 317 318 319 320 void GLAPIENTRY 321 _mesa_GetLightfv( GLenum light, GLenum pname, GLfloat *params ) 322 { 323 GET_CURRENT_CONTEXT(ctx); 324 GLint l = (GLint) (light - GL_LIGHT0); 325 326 if (l < 0 || l >= (GLint) ctx->Const.MaxLights) { 327 _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightfv" ); 328 return; 329 } 330 331 switch (pname) { 332 case GL_AMBIENT: 333 COPY_4V( params, ctx->Light.Light[l].Ambient ); 334 break; 335 case GL_DIFFUSE: 336 COPY_4V( params, ctx->Light.Light[l].Diffuse ); 337 break; 338 case GL_SPECULAR: 339 COPY_4V( params, ctx->Light.Light[l].Specular ); 340 break; 341 case GL_POSITION: 342 COPY_4V( params, ctx->Light.Light[l].EyePosition ); 343 break; 344 case GL_SPOT_DIRECTION: 345 COPY_3V( params, ctx->Light.Light[l].SpotDirection ); 346 break; 347 case GL_SPOT_EXPONENT: 348 params[0] = ctx->Light.Light[l].SpotExponent; 349 break; 350 case GL_SPOT_CUTOFF: 351 params[0] = ctx->Light.Light[l].SpotCutoff; 352 break; 353 case GL_CONSTANT_ATTENUATION: 354 params[0] = ctx->Light.Light[l].ConstantAttenuation; 355 break; 356 case GL_LINEAR_ATTENUATION: 357 params[0] = ctx->Light.Light[l].LinearAttenuation; 358 break; 359 case GL_QUADRATIC_ATTENUATION: 360 params[0] = ctx->Light.Light[l].QuadraticAttenuation; 361 break; 362 default: 363 _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightfv" ); 364 break; 365 } 366 } 367 368 369 void GLAPIENTRY 370 _mesa_GetLightiv( GLenum light, GLenum pname, GLint *params ) 371 { 372 GET_CURRENT_CONTEXT(ctx); 373 GLint l = (GLint) (light - GL_LIGHT0); 374 375 if (l < 0 || l >= (GLint) ctx->Const.MaxLights) { 376 _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightiv" ); 377 return; 378 } 379 380 switch (pname) { 381 case GL_AMBIENT: 382 params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[0]); 383 params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[1]); 384 params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[2]); 385 params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[3]); 386 break; 387 case GL_DIFFUSE: 388 params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[0]); 389 params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[1]); 390 params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[2]); 391 params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[3]); 392 break; 393 case GL_SPECULAR: 394 params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[0]); 395 params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[1]); 396 params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[2]); 397 params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[3]); 398 break; 399 case GL_POSITION: 400 params[0] = (GLint) ctx->Light.Light[l].EyePosition[0]; 401 params[1] = (GLint) ctx->Light.Light[l].EyePosition[1]; 402 params[2] = (GLint) ctx->Light.Light[l].EyePosition[2]; 403 params[3] = (GLint) ctx->Light.Light[l].EyePosition[3]; 404 break; 405 case GL_SPOT_DIRECTION: 406 params[0] = (GLint) ctx->Light.Light[l].SpotDirection[0]; 407 params[1] = (GLint) ctx->Light.Light[l].SpotDirection[1]; 408 params[2] = (GLint) ctx->Light.Light[l].SpotDirection[2]; 409 break; 410 case GL_SPOT_EXPONENT: 411 params[0] = (GLint) ctx->Light.Light[l].SpotExponent; 412 break; 413 case GL_SPOT_CUTOFF: 414 params[0] = (GLint) ctx->Light.Light[l].SpotCutoff; 415 break; 416 case GL_CONSTANT_ATTENUATION: 417 params[0] = (GLint) ctx->Light.Light[l].ConstantAttenuation; 418 break; 419 case GL_LINEAR_ATTENUATION: 420 params[0] = (GLint) ctx->Light.Light[l].LinearAttenuation; 421 break; 422 case GL_QUADRATIC_ATTENUATION: 423 params[0] = (GLint) ctx->Light.Light[l].QuadraticAttenuation; 424 break; 425 default: 426 _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightiv" ); 427 break; 428 } 429 } 430 431 432 433 /**********************************************************************/ 434 /*** Light Model ***/ 435 /**********************************************************************/ 436 437 438 void GLAPIENTRY 439 _mesa_LightModelfv( GLenum pname, const GLfloat *params ) 440 { 441 GLenum newenum; 442 GLboolean newbool; 443 GET_CURRENT_CONTEXT(ctx); 444 445 switch (pname) { 446 case GL_LIGHT_MODEL_AMBIENT: 447 if (TEST_EQ_4V( ctx->Light.Model.Ambient, params )) 448 return; 449 FLUSH_VERTICES(ctx, _NEW_LIGHT); 450 COPY_4V( ctx->Light.Model.Ambient, params ); 451 break; 452 case GL_LIGHT_MODEL_LOCAL_VIEWER: 453 if (ctx->API != API_OPENGL_COMPAT) 454 goto invalid_pname; 455 newbool = (params[0] != 0.0F); 456 if (ctx->Light.Model.LocalViewer == newbool) 457 return; 458 FLUSH_VERTICES(ctx, _NEW_LIGHT); 459 ctx->Light.Model.LocalViewer = newbool; 460 break; 461 case GL_LIGHT_MODEL_TWO_SIDE: 462 newbool = (params[0] != 0.0F); 463 if (ctx->Light.Model.TwoSide == newbool) 464 return; 465 FLUSH_VERTICES(ctx, _NEW_LIGHT); 466 ctx->Light.Model.TwoSide = newbool; 467 break; 468 case GL_LIGHT_MODEL_COLOR_CONTROL: 469 if (ctx->API != API_OPENGL_COMPAT) 470 goto invalid_pname; 471 if (params[0] == (GLfloat) GL_SINGLE_COLOR) 472 newenum = GL_SINGLE_COLOR; 473 else if (params[0] == (GLfloat) GL_SEPARATE_SPECULAR_COLOR) 474 newenum = GL_SEPARATE_SPECULAR_COLOR; 475 else { 476 _mesa_error( ctx, GL_INVALID_ENUM, "glLightModel(param=0x0%x)", 477 (GLint) params[0] ); 478 return; 479 } 480 if (ctx->Light.Model.ColorControl == newenum) 481 return; 482 FLUSH_VERTICES(ctx, _NEW_LIGHT); 483 ctx->Light.Model.ColorControl = newenum; 484 break; 485 default: 486 goto invalid_pname; 487 } 488 489 if (ctx->Driver.LightModelfv) 490 ctx->Driver.LightModelfv( ctx, pname, params ); 491 492 return; 493 494 invalid_pname: 495 _mesa_error( ctx, GL_INVALID_ENUM, "glLightModel(pname=0x%x)", pname ); 496 return; 497 } 498 499 500 void GLAPIENTRY 501 _mesa_LightModeliv( GLenum pname, const GLint *params ) 502 { 503 GLfloat fparam[4]; 504 505 switch (pname) { 506 case GL_LIGHT_MODEL_AMBIENT: 507 fparam[0] = INT_TO_FLOAT( params[0] ); 508 fparam[1] = INT_TO_FLOAT( params[1] ); 509 fparam[2] = INT_TO_FLOAT( params[2] ); 510 fparam[3] = INT_TO_FLOAT( params[3] ); 511 break; 512 case GL_LIGHT_MODEL_LOCAL_VIEWER: 513 case GL_LIGHT_MODEL_TWO_SIDE: 514 case GL_LIGHT_MODEL_COLOR_CONTROL: 515 fparam[0] = (GLfloat) params[0]; 516 break; 517 default: 518 /* Error will be caught later in gl_LightModelfv */ 519 ASSIGN_4V(fparam, 0.0F, 0.0F, 0.0F, 0.0F); 520 } 521 _mesa_LightModelfv( pname, fparam ); 522 } 523 524 525 void GLAPIENTRY 526 _mesa_LightModeli( GLenum pname, GLint param ) 527 { 528 GLint iparam[4]; 529 iparam[0] = param; 530 iparam[1] = iparam[2] = iparam[3] = 0; 531 _mesa_LightModeliv( pname, iparam ); 532 } 533 534 535 void GLAPIENTRY 536 _mesa_LightModelf( GLenum pname, GLfloat param ) 537 { 538 GLfloat fparam[4]; 539 fparam[0] = param; 540 fparam[1] = fparam[2] = fparam[3] = 0.0F; 541 _mesa_LightModelfv( pname, fparam ); 542 } 543 544 545 546 /********** MATERIAL **********/ 547 548 549 /* 550 * Given a face and pname value (ala glColorMaterial), compute a bitmask 551 * of the targeted material values. 552 */ 553 GLuint 554 _mesa_material_bitmask( struct gl_context *ctx, GLenum face, GLenum pname, 555 GLuint legal, const char *where ) 556 { 557 GLuint bitmask = 0; 558 559 /* Make a bitmask indicating what material attribute(s) we're updating */ 560 switch (pname) { 561 case GL_EMISSION: 562 bitmask |= MAT_BIT_FRONT_EMISSION | MAT_BIT_BACK_EMISSION; 563 break; 564 case GL_AMBIENT: 565 bitmask |= MAT_BIT_FRONT_AMBIENT | MAT_BIT_BACK_AMBIENT; 566 break; 567 case GL_DIFFUSE: 568 bitmask |= MAT_BIT_FRONT_DIFFUSE | MAT_BIT_BACK_DIFFUSE; 569 break; 570 case GL_SPECULAR: 571 bitmask |= MAT_BIT_FRONT_SPECULAR | MAT_BIT_BACK_SPECULAR; 572 break; 573 case GL_SHININESS: 574 bitmask |= MAT_BIT_FRONT_SHININESS | MAT_BIT_BACK_SHININESS; 575 break; 576 case GL_AMBIENT_AND_DIFFUSE: 577 bitmask |= MAT_BIT_FRONT_AMBIENT | MAT_BIT_BACK_AMBIENT; 578 bitmask |= MAT_BIT_FRONT_DIFFUSE | MAT_BIT_BACK_DIFFUSE; 579 break; 580 case GL_COLOR_INDEXES: 581 bitmask |= MAT_BIT_FRONT_INDEXES | MAT_BIT_BACK_INDEXES; 582 break; 583 default: 584 _mesa_error( ctx, GL_INVALID_ENUM, "%s", where ); 585 return 0; 586 } 587 588 if (face==GL_FRONT) { 589 bitmask &= FRONT_MATERIAL_BITS; 590 } 591 else if (face==GL_BACK) { 592 bitmask &= BACK_MATERIAL_BITS; 593 } 594 else if (face != GL_FRONT_AND_BACK) { 595 _mesa_error( ctx, GL_INVALID_ENUM, "%s", where ); 596 return 0; 597 } 598 599 if (bitmask & ~legal) { 600 _mesa_error( ctx, GL_INVALID_ENUM, "%s", where ); 601 return 0; 602 } 603 604 return bitmask; 605 } 606 607 608 609 /* Update derived values following a change in ctx->Light.Material 610 */ 611 void 612 _mesa_update_material( struct gl_context *ctx, GLuint bitmask ) 613 { 614 GLfloat (*mat)[4] = ctx->Light.Material.Attrib; 615 616 if (MESA_VERBOSE & VERBOSE_MATERIAL) 617 _mesa_debug(ctx, "_mesa_update_material, mask 0x%x\n", bitmask); 618 619 if (!bitmask) 620 return; 621 622 /* update material ambience */ 623 if (bitmask & MAT_BIT_FRONT_AMBIENT) { 624 GLbitfield mask = ctx->Light._EnabledLights; 625 while (mask) { 626 const int i = u_bit_scan(&mask); 627 struct gl_light *light = &ctx->Light.Light[i]; 628 SCALE_3V( light->_MatAmbient[0], light->Ambient, 629 mat[MAT_ATTRIB_FRONT_AMBIENT]); 630 } 631 } 632 633 if (bitmask & MAT_BIT_BACK_AMBIENT) { 634 GLbitfield mask = ctx->Light._EnabledLights; 635 while (mask) { 636 const int i = u_bit_scan(&mask); 637 struct gl_light *light = &ctx->Light.Light[i]; 638 SCALE_3V( light->_MatAmbient[1], light->Ambient, 639 mat[MAT_ATTRIB_BACK_AMBIENT]); 640 } 641 } 642 643 /* update BaseColor = emission + scene's ambience * material's ambience */ 644 if (bitmask & (MAT_BIT_FRONT_EMISSION | MAT_BIT_FRONT_AMBIENT)) { 645 COPY_3V( ctx->Light._BaseColor[0], mat[MAT_ATTRIB_FRONT_EMISSION] ); 646 ACC_SCALE_3V( ctx->Light._BaseColor[0], mat[MAT_ATTRIB_FRONT_AMBIENT], 647 ctx->Light.Model.Ambient ); 648 } 649 650 if (bitmask & (MAT_BIT_BACK_EMISSION | MAT_BIT_BACK_AMBIENT)) { 651 COPY_3V( ctx->Light._BaseColor[1], mat[MAT_ATTRIB_BACK_EMISSION] ); 652 ACC_SCALE_3V( ctx->Light._BaseColor[1], mat[MAT_ATTRIB_BACK_AMBIENT], 653 ctx->Light.Model.Ambient ); 654 } 655 656 /* update material diffuse values */ 657 if (bitmask & MAT_BIT_FRONT_DIFFUSE) { 658 GLbitfield mask = ctx->Light._EnabledLights; 659 while (mask) { 660 const int i = u_bit_scan(&mask); 661 struct gl_light *light = &ctx->Light.Light[i]; 662 SCALE_3V( light->_MatDiffuse[0], light->Diffuse, 663 mat[MAT_ATTRIB_FRONT_DIFFUSE] ); 664 } 665 } 666 667 if (bitmask & MAT_BIT_BACK_DIFFUSE) { 668 GLbitfield mask = ctx->Light._EnabledLights; 669 while (mask) { 670 const int i = u_bit_scan(&mask); 671 struct gl_light *light = &ctx->Light.Light[i]; 672 SCALE_3V( light->_MatDiffuse[1], light->Diffuse, 673 mat[MAT_ATTRIB_BACK_DIFFUSE] ); 674 } 675 } 676 677 /* update material specular values */ 678 if (bitmask & MAT_BIT_FRONT_SPECULAR) { 679 GLbitfield mask = ctx->Light._EnabledLights; 680 while (mask) { 681 const int i = u_bit_scan(&mask); 682 struct gl_light *light = &ctx->Light.Light[i]; 683 SCALE_3V( light->_MatSpecular[0], light->Specular, 684 mat[MAT_ATTRIB_FRONT_SPECULAR]); 685 } 686 } 687 688 if (bitmask & MAT_BIT_BACK_SPECULAR) { 689 GLbitfield mask = ctx->Light._EnabledLights; 690 while (mask) { 691 const int i = u_bit_scan(&mask); 692 struct gl_light *light = &ctx->Light.Light[i]; 693 SCALE_3V( light->_MatSpecular[1], light->Specular, 694 mat[MAT_ATTRIB_BACK_SPECULAR]); 695 } 696 } 697 } 698 699 700 /* 701 * Update the current materials from the given rgba color 702 * according to the bitmask in _ColorMaterialBitmask, which is 703 * set by glColorMaterial(). 704 */ 705 void 706 _mesa_update_color_material( struct gl_context *ctx, const GLfloat color[4] ) 707 { 708 GLbitfield bitmask = ctx->Light._ColorMaterialBitmask; 709 struct gl_material *mat = &ctx->Light.Material; 710 711 while (bitmask) { 712 const int i = u_bit_scan(&bitmask); 713 714 COPY_4FV( mat->Attrib[i], color ); 715 } 716 717 _mesa_update_material( ctx, bitmask ); 718 } 719 720 721 void GLAPIENTRY 722 _mesa_ColorMaterial( GLenum face, GLenum mode ) 723 { 724 GET_CURRENT_CONTEXT(ctx); 725 GLuint bitmask; 726 GLuint legal = (MAT_BIT_FRONT_EMISSION | MAT_BIT_BACK_EMISSION | 727 MAT_BIT_FRONT_SPECULAR | MAT_BIT_BACK_SPECULAR | 728 MAT_BIT_FRONT_DIFFUSE | MAT_BIT_BACK_DIFFUSE | 729 MAT_BIT_FRONT_AMBIENT | MAT_BIT_BACK_AMBIENT); 730 731 if (MESA_VERBOSE&VERBOSE_API) 732 _mesa_debug(ctx, "glColorMaterial %s %s\n", 733 _mesa_enum_to_string(face), 734 _mesa_enum_to_string(mode)); 735 736 bitmask = _mesa_material_bitmask(ctx, face, mode, legal, "glColorMaterial"); 737 if (bitmask == 0) 738 return; /* error was recorded */ 739 740 if (ctx->Light._ColorMaterialBitmask == bitmask && 741 ctx->Light.ColorMaterialFace == face && 742 ctx->Light.ColorMaterialMode == mode) 743 return; 744 745 FLUSH_VERTICES(ctx, _NEW_LIGHT); 746 ctx->Light._ColorMaterialBitmask = bitmask; 747 ctx->Light.ColorMaterialFace = face; 748 ctx->Light.ColorMaterialMode = mode; 749 750 if (ctx->Light.ColorMaterialEnabled) { 751 FLUSH_CURRENT( ctx, 0 ); 752 _mesa_update_color_material(ctx,ctx->Current.Attrib[VERT_ATTRIB_COLOR0]); 753 } 754 755 if (ctx->Driver.ColorMaterial) 756 ctx->Driver.ColorMaterial( ctx, face, mode ); 757 } 758 759 760 void GLAPIENTRY 761 _mesa_GetMaterialfv( GLenum face, GLenum pname, GLfloat *params ) 762 { 763 GET_CURRENT_CONTEXT(ctx); 764 GLuint f; 765 GLfloat (*mat)[4] = ctx->Light.Material.Attrib; 766 FLUSH_VERTICES(ctx, 0); /* update materials */ 767 768 FLUSH_CURRENT(ctx, 0); /* update ctx->Light.Material from vertex buffer */ 769 770 if (face==GL_FRONT) { 771 f = 0; 772 } 773 else if (face==GL_BACK) { 774 f = 1; 775 } 776 else { 777 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(face)" ); 778 return; 779 } 780 781 switch (pname) { 782 case GL_AMBIENT: 783 COPY_4FV( params, mat[MAT_ATTRIB_AMBIENT(f)] ); 784 break; 785 case GL_DIFFUSE: 786 COPY_4FV( params, mat[MAT_ATTRIB_DIFFUSE(f)] ); 787 break; 788 case GL_SPECULAR: 789 COPY_4FV( params, mat[MAT_ATTRIB_SPECULAR(f)] ); 790 break; 791 case GL_EMISSION: 792 COPY_4FV( params, mat[MAT_ATTRIB_EMISSION(f)] ); 793 break; 794 case GL_SHININESS: 795 *params = mat[MAT_ATTRIB_SHININESS(f)][0]; 796 break; 797 case GL_COLOR_INDEXES: 798 if (ctx->API != API_OPENGL_COMPAT) { 799 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" ); 800 return; 801 } 802 params[0] = mat[MAT_ATTRIB_INDEXES(f)][0]; 803 params[1] = mat[MAT_ATTRIB_INDEXES(f)][1]; 804 params[2] = mat[MAT_ATTRIB_INDEXES(f)][2]; 805 break; 806 default: 807 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" ); 808 } 809 } 810 811 812 void GLAPIENTRY 813 _mesa_GetMaterialiv( GLenum face, GLenum pname, GLint *params ) 814 { 815 GET_CURRENT_CONTEXT(ctx); 816 GLuint f; 817 GLfloat (*mat)[4] = ctx->Light.Material.Attrib; 818 819 assert(ctx->API == API_OPENGL_COMPAT); 820 821 FLUSH_VERTICES(ctx, 0); /* update materials */ 822 FLUSH_CURRENT(ctx, 0); /* update ctx->Light.Material from vertex buffer */ 823 824 if (face==GL_FRONT) { 825 f = 0; 826 } 827 else if (face==GL_BACK) { 828 f = 1; 829 } 830 else { 831 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialiv(face)" ); 832 return; 833 } 834 switch (pname) { 835 case GL_AMBIENT: 836 params[0] = FLOAT_TO_INT( mat[MAT_ATTRIB_AMBIENT(f)][0] ); 837 params[1] = FLOAT_TO_INT( mat[MAT_ATTRIB_AMBIENT(f)][1] ); 838 params[2] = FLOAT_TO_INT( mat[MAT_ATTRIB_AMBIENT(f)][2] ); 839 params[3] = FLOAT_TO_INT( mat[MAT_ATTRIB_AMBIENT(f)][3] ); 840 break; 841 case GL_DIFFUSE: 842 params[0] = FLOAT_TO_INT( mat[MAT_ATTRIB_DIFFUSE(f)][0] ); 843 params[1] = FLOAT_TO_INT( mat[MAT_ATTRIB_DIFFUSE(f)][1] ); 844 params[2] = FLOAT_TO_INT( mat[MAT_ATTRIB_DIFFUSE(f)][2] ); 845 params[3] = FLOAT_TO_INT( mat[MAT_ATTRIB_DIFFUSE(f)][3] ); 846 break; 847 case GL_SPECULAR: 848 params[0] = FLOAT_TO_INT( mat[MAT_ATTRIB_SPECULAR(f)][0] ); 849 params[1] = FLOAT_TO_INT( mat[MAT_ATTRIB_SPECULAR(f)][1] ); 850 params[2] = FLOAT_TO_INT( mat[MAT_ATTRIB_SPECULAR(f)][2] ); 851 params[3] = FLOAT_TO_INT( mat[MAT_ATTRIB_SPECULAR(f)][3] ); 852 break; 853 case GL_EMISSION: 854 params[0] = FLOAT_TO_INT( mat[MAT_ATTRIB_EMISSION(f)][0] ); 855 params[1] = FLOAT_TO_INT( mat[MAT_ATTRIB_EMISSION(f)][1] ); 856 params[2] = FLOAT_TO_INT( mat[MAT_ATTRIB_EMISSION(f)][2] ); 857 params[3] = FLOAT_TO_INT( mat[MAT_ATTRIB_EMISSION(f)][3] ); 858 break; 859 case GL_SHININESS: 860 *params = IROUND( mat[MAT_ATTRIB_SHININESS(f)][0] ); 861 break; 862 case GL_COLOR_INDEXES: 863 params[0] = IROUND( mat[MAT_ATTRIB_INDEXES(f)][0] ); 864 params[1] = IROUND( mat[MAT_ATTRIB_INDEXES(f)][1] ); 865 params[2] = IROUND( mat[MAT_ATTRIB_INDEXES(f)][2] ); 866 break; 867 default: 868 _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" ); 869 } 870 } 871 872 873 874 /** 875 * Examine current lighting parameters to determine if the optimized lighting 876 * function can be used. 877 * Also, precompute some lighting values such as the products of light 878 * source and material ambient, diffuse and specular coefficients. 879 */ 880 void 881 _mesa_update_lighting( struct gl_context *ctx ) 882 { 883 GLbitfield flags = 0; 884 ctx->Light._NeedEyeCoords = GL_FALSE; 885 886 if (!ctx->Light.Enabled) 887 return; 888 889 GLbitfield mask = ctx->Light._EnabledLights; 890 while (mask) { 891 const int i = u_bit_scan(&mask); 892 struct gl_light *light = &ctx->Light.Light[i]; 893 flags |= light->_Flags; 894 } 895 896 ctx->Light._NeedVertices = 897 ((flags & (LIGHT_POSITIONAL|LIGHT_SPOT)) || 898 ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR || 899 ctx->Light.Model.LocalViewer); 900 901 ctx->Light._NeedEyeCoords = ((flags & LIGHT_POSITIONAL) || 902 ctx->Light.Model.LocalViewer); 903 904 /* XXX: This test is overkill & needs to be fixed both for software and 905 * hardware t&l drivers. The above should be sufficient & should 906 * be tested to verify this. 907 */ 908 if (ctx->Light._NeedVertices) 909 ctx->Light._NeedEyeCoords = GL_TRUE; 910 911 /* Precompute some shading values. Although we reference 912 * Light.Material here, we can get away without flushing 913 * FLUSH_UPDATE_CURRENT, as when any outstanding material changes 914 * are flushed, they will update the derived state at that time. 915 */ 916 if (ctx->Light.Model.TwoSide) 917 _mesa_update_material(ctx, 918 MAT_BIT_FRONT_EMISSION | 919 MAT_BIT_FRONT_AMBIENT | 920 MAT_BIT_FRONT_DIFFUSE | 921 MAT_BIT_FRONT_SPECULAR | 922 MAT_BIT_BACK_EMISSION | 923 MAT_BIT_BACK_AMBIENT | 924 MAT_BIT_BACK_DIFFUSE | 925 MAT_BIT_BACK_SPECULAR); 926 else 927 _mesa_update_material(ctx, 928 MAT_BIT_FRONT_EMISSION | 929 MAT_BIT_FRONT_AMBIENT | 930 MAT_BIT_FRONT_DIFFUSE | 931 MAT_BIT_FRONT_SPECULAR); 932 } 933 934 935 /** 936 * Update state derived from light position, spot direction. 937 * Called upon: 938 * _NEW_MODELVIEW 939 * _NEW_LIGHT 940 * _TNL_NEW_NEED_EYE_COORDS 941 * 942 * Update on (_NEW_MODELVIEW | _NEW_LIGHT) when lighting is enabled. 943 * Also update on lighting space changes. 944 */ 945 static void 946 compute_light_positions( struct gl_context *ctx ) 947 { 948 static const GLfloat eye_z[3] = { 0, 0, 1 }; 949 950 if (!ctx->Light.Enabled) 951 return; 952 953 if (ctx->_NeedEyeCoords) { 954 COPY_3V( ctx->_EyeZDir, eye_z ); 955 } 956 else { 957 TRANSFORM_NORMAL( ctx->_EyeZDir, eye_z, ctx->ModelviewMatrixStack.Top->m ); 958 } 959 960 GLbitfield mask = ctx->Light._EnabledLights; 961 while (mask) { 962 const int i = u_bit_scan(&mask); 963 struct gl_light *light = &ctx->Light.Light[i]; 964 965 if (ctx->_NeedEyeCoords) { 966 /* _Position is in eye coordinate space */ 967 COPY_4FV( light->_Position, light->EyePosition ); 968 } 969 else { 970 /* _Position is in object coordinate space */ 971 TRANSFORM_POINT( light->_Position, ctx->ModelviewMatrixStack.Top->inv, 972 light->EyePosition ); 973 } 974 975 if (!(light->_Flags & LIGHT_POSITIONAL)) { 976 /* VP (VP) = Normalize( Position ) */ 977 COPY_3V( light->_VP_inf_norm, light->_Position ); 978 NORMALIZE_3FV( light->_VP_inf_norm ); 979 980 if (!ctx->Light.Model.LocalViewer) { 981 /* _h_inf_norm = Normalize( V_to_P + <0,0,1> ) */ 982 ADD_3V( light->_h_inf_norm, light->_VP_inf_norm, ctx->_EyeZDir); 983 NORMALIZE_3FV( light->_h_inf_norm ); 984 } 985 light->_VP_inf_spot_attenuation = 1.0; 986 } 987 else { 988 /* positional light w/ homogeneous coordinate, divide by W */ 989 GLfloat wInv = 1.0F / light->_Position[3]; 990 light->_Position[0] *= wInv; 991 light->_Position[1] *= wInv; 992 light->_Position[2] *= wInv; 993 } 994 995 if (light->_Flags & LIGHT_SPOT) { 996 /* Note: we normalize the spot direction now */ 997 998 if (ctx->_NeedEyeCoords) { 999 COPY_3V( light->_NormSpotDirection, light->SpotDirection ); 1000 NORMALIZE_3FV( light->_NormSpotDirection ); 1001 } 1002 else { 1003 GLfloat spotDir[3]; 1004 COPY_3V(spotDir, light->SpotDirection); 1005 NORMALIZE_3FV(spotDir); 1006 TRANSFORM_NORMAL( light->_NormSpotDirection, 1007 spotDir, 1008 ctx->ModelviewMatrixStack.Top->m); 1009 } 1010 1011 NORMALIZE_3FV( light->_NormSpotDirection ); 1012 1013 if (!(light->_Flags & LIGHT_POSITIONAL)) { 1014 GLfloat PV_dot_dir = - DOT3(light->_VP_inf_norm, 1015 light->_NormSpotDirection); 1016 1017 if (PV_dot_dir > light->_CosCutoff) { 1018 light->_VP_inf_spot_attenuation = 1019 powf(PV_dot_dir, light->SpotExponent); 1020 } 1021 else { 1022 light->_VP_inf_spot_attenuation = 0; 1023 } 1024 } 1025 } 1026 } 1027 } 1028 1029 1030 1031 static void 1032 update_modelview_scale( struct gl_context *ctx ) 1033 { 1034 ctx->_ModelViewInvScale = 1.0F; 1035 ctx->_ModelViewInvScaleEyespace = 1.0F; 1036 if (!_math_matrix_is_length_preserving(ctx->ModelviewMatrixStack.Top)) { 1037 const GLfloat *m = ctx->ModelviewMatrixStack.Top->inv; 1038 GLfloat f = m[2] * m[2] + m[6] * m[6] + m[10] * m[10]; 1039 if (f < 1e-12f) f = 1.0f; 1040 if (ctx->_NeedEyeCoords) 1041 ctx->_ModelViewInvScale = 1.0f / sqrtf(f); 1042 else 1043 ctx->_ModelViewInvScale = sqrtf(f); 1044 ctx->_ModelViewInvScaleEyespace = 1.0f / sqrtf(f); 1045 } 1046 } 1047 1048 1049 /** 1050 * Bring up to date any state that relies on _NeedEyeCoords. 1051 */ 1052 void 1053 _mesa_update_tnl_spaces( struct gl_context *ctx, GLuint new_state ) 1054 { 1055 const GLuint oldneedeyecoords = ctx->_NeedEyeCoords; 1056 1057 (void) new_state; 1058 ctx->_NeedEyeCoords = GL_FALSE; 1059 1060 if (ctx->_ForceEyeCoords || 1061 (ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD) || 1062 ctx->Point._Attenuated || 1063 ctx->Light._NeedEyeCoords) 1064 ctx->_NeedEyeCoords = GL_TRUE; 1065 1066 if (ctx->Light.Enabled && 1067 !_math_matrix_is_length_preserving(ctx->ModelviewMatrixStack.Top)) 1068 ctx->_NeedEyeCoords = GL_TRUE; 1069 1070 /* Check if the truth-value interpretations of the bitfields have 1071 * changed: 1072 */ 1073 if (oldneedeyecoords != ctx->_NeedEyeCoords) { 1074 /* Recalculate all state that depends on _NeedEyeCoords. 1075 */ 1076 update_modelview_scale(ctx); 1077 compute_light_positions( ctx ); 1078 1079 if (ctx->Driver.LightingSpaceChange) 1080 ctx->Driver.LightingSpaceChange( ctx ); 1081 } 1082 else { 1083 GLuint new_state2 = ctx->NewState; 1084 1085 /* Recalculate that same state only if it has been invalidated 1086 * by other statechanges. 1087 */ 1088 if (new_state2 & _NEW_MODELVIEW) 1089 update_modelview_scale(ctx); 1090 1091 if (new_state2 & (_NEW_LIGHT|_NEW_MODELVIEW)) 1092 compute_light_positions( ctx ); 1093 } 1094 } 1095 1096 1097 /** 1098 * Drivers may need this if the hardware tnl unit doesn't support the 1099 * light-in-modelspace optimization. It's also useful for debugging. 1100 */ 1101 void 1102 _mesa_allow_light_in_model( struct gl_context *ctx, GLboolean flag ) 1103 { 1104 ctx->_ForceEyeCoords = !flag; 1105 ctx->NewState |= _NEW_POINT; /* one of the bits from 1106 * _MESA_NEW_NEED_EYE_COORDS. 1107 */ 1108 } 1109 1110 1111 1112 /**********************************************************************/ 1113 /***** Initialization *****/ 1114 /**********************************************************************/ 1115 1116 /** 1117 * Initialize the n-th light data structure. 1118 * 1119 * \param l pointer to the gl_light structure to be initialized. 1120 * \param n number of the light. 1121 * \note The defaults for light 0 are different than the other lights. 1122 */ 1123 static void 1124 init_light( struct gl_light *l, GLuint n ) 1125 { 1126 ASSIGN_4V( l->Ambient, 0.0, 0.0, 0.0, 1.0 ); 1127 if (n==0) { 1128 ASSIGN_4V( l->Diffuse, 1.0, 1.0, 1.0, 1.0 ); 1129 ASSIGN_4V( l->Specular, 1.0, 1.0, 1.0, 1.0 ); 1130 } 1131 else { 1132 ASSIGN_4V( l->Diffuse, 0.0, 0.0, 0.0, 1.0 ); 1133 ASSIGN_4V( l->Specular, 0.0, 0.0, 0.0, 1.0 ); 1134 } 1135 ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 ); 1136 ASSIGN_3V( l->SpotDirection, 0.0, 0.0, -1.0 ); 1137 l->SpotExponent = 0.0; 1138 l->SpotCutoff = 180.0; 1139 l->_CosCutoff = 0.0; /* KW: -ve values not admitted */ 1140 l->ConstantAttenuation = 1.0; 1141 l->LinearAttenuation = 0.0; 1142 l->QuadraticAttenuation = 0.0; 1143 l->Enabled = GL_FALSE; 1144 } 1145 1146 1147 /** 1148 * Initialize the light model data structure. 1149 * 1150 * \param lm pointer to the gl_lightmodel structure to be initialized. 1151 */ 1152 static void 1153 init_lightmodel( struct gl_lightmodel *lm ) 1154 { 1155 ASSIGN_4V( lm->Ambient, 0.2F, 0.2F, 0.2F, 1.0F ); 1156 lm->LocalViewer = GL_FALSE; 1157 lm->TwoSide = GL_FALSE; 1158 lm->ColorControl = GL_SINGLE_COLOR; 1159 } 1160 1161 1162 /** 1163 * Initialize the material data structure. 1164 * 1165 * \param m pointer to the gl_material structure to be initialized. 1166 */ 1167 static void 1168 init_material( struct gl_material *m ) 1169 { 1170 ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_AMBIENT], 0.2F, 0.2F, 0.2F, 1.0F ); 1171 ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_DIFFUSE], 0.8F, 0.8F, 0.8F, 1.0F ); 1172 ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_SPECULAR], 0.0F, 0.0F, 0.0F, 1.0F ); 1173 ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_EMISSION], 0.0F, 0.0F, 0.0F, 1.0F ); 1174 ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_SHININESS], 0.0F, 0.0F, 0.0F, 0.0F ); 1175 ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_INDEXES], 0.0F, 1.0F, 1.0F, 0.0F ); 1176 1177 ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_AMBIENT], 0.2F, 0.2F, 0.2F, 1.0F ); 1178 ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_DIFFUSE], 0.8F, 0.8F, 0.8F, 1.0F ); 1179 ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_SPECULAR], 0.0F, 0.0F, 0.0F, 1.0F ); 1180 ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_EMISSION], 0.0F, 0.0F, 0.0F, 1.0F ); 1181 ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_SHININESS], 0.0F, 0.0F, 0.0F, 0.0F ); 1182 ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_INDEXES], 0.0F, 1.0F, 1.0F, 0.0F ); 1183 } 1184 1185 1186 /** 1187 * Initialize all lighting state for the given context. 1188 */ 1189 void 1190 _mesa_init_lighting( struct gl_context *ctx ) 1191 { 1192 GLuint i; 1193 1194 /* Lighting group */ 1195 ctx->Light._EnabledLights = 0; 1196 for (i = 0; i < MAX_LIGHTS; i++) { 1197 init_light( &ctx->Light.Light[i], i ); 1198 } 1199 1200 init_lightmodel( &ctx->Light.Model ); 1201 init_material( &ctx->Light.Material ); 1202 ctx->Light.ShadeModel = GL_SMOOTH; 1203 ctx->Light.ProvokingVertex = GL_LAST_VERTEX_CONVENTION_EXT; 1204 ctx->Light.Enabled = GL_FALSE; 1205 ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK; 1206 ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE; 1207 ctx->Light._ColorMaterialBitmask = _mesa_material_bitmask( ctx, 1208 GL_FRONT_AND_BACK, 1209 GL_AMBIENT_AND_DIFFUSE, ~0, 1210 NULL ); 1211 1212 ctx->Light.ColorMaterialEnabled = GL_FALSE; 1213 ctx->Light.ClampVertexColor = ctx->API == API_OPENGL_COMPAT; 1214 ctx->Light._ClampVertexColor = ctx->API == API_OPENGL_COMPAT; 1215 1216 /* Miscellaneous */ 1217 ctx->Light._NeedEyeCoords = GL_FALSE; 1218 ctx->_NeedEyeCoords = GL_FALSE; 1219 ctx->_ForceEyeCoords = GL_FALSE; 1220 ctx->_ModelViewInvScale = 1.0; 1221 ctx->_ModelViewInvScaleEyespace = 1.0; 1222 } 1223
