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