mesa: Remove the linked list of enabled lights
[mesa.git] / src / mesa / main / light.c
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 const GLbitfield bitmask = ctx->Light._ColorMaterialBitmask;
710 struct gl_material *mat = &ctx->Light.Material;
711 int i;
712
713 for (i = 0 ; i < MAT_ATTRIB_MAX ; i++)
714 if (bitmask & (1<<i))
715 COPY_4FV( mat->Attrib[i], color );
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 if (!_math_matrix_is_length_preserving(ctx->ModelviewMatrixStack.Top)) {
1036 const GLfloat *m = ctx->ModelviewMatrixStack.Top->inv;
1037 GLfloat f = m[2] * m[2] + m[6] * m[6] + m[10] * m[10];
1038 if (f < 1e-12f) f = 1.0f;
1039 if (ctx->_NeedEyeCoords)
1040 ctx->_ModelViewInvScale = 1.0f / sqrtf(f);
1041 else
1042 ctx->_ModelViewInvScale = sqrtf(f);
1043 }
1044 }
1045
1046
1047 /**
1048 * Bring up to date any state that relies on _NeedEyeCoords.
1049 */
1050 void
1051 _mesa_update_tnl_spaces( struct gl_context *ctx, GLuint new_state )
1052 {
1053 const GLuint oldneedeyecoords = ctx->_NeedEyeCoords;
1054
1055 (void) new_state;
1056 ctx->_NeedEyeCoords = GL_FALSE;
1057
1058 if (ctx->_ForceEyeCoords ||
1059 (ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD) ||
1060 ctx->Point._Attenuated ||
1061 ctx->Light._NeedEyeCoords)
1062 ctx->_NeedEyeCoords = GL_TRUE;
1063
1064 if (ctx->Light.Enabled &&
1065 !_math_matrix_is_length_preserving(ctx->ModelviewMatrixStack.Top))
1066 ctx->_NeedEyeCoords = GL_TRUE;
1067
1068 /* Check if the truth-value interpretations of the bitfields have
1069 * changed:
1070 */
1071 if (oldneedeyecoords != ctx->_NeedEyeCoords) {
1072 /* Recalculate all state that depends on _NeedEyeCoords.
1073 */
1074 update_modelview_scale(ctx);
1075 compute_light_positions( ctx );
1076
1077 if (ctx->Driver.LightingSpaceChange)
1078 ctx->Driver.LightingSpaceChange( ctx );
1079 }
1080 else {
1081 GLuint new_state2 = ctx->NewState;
1082
1083 /* Recalculate that same state only if it has been invalidated
1084 * by other statechanges.
1085 */
1086 if (new_state2 & _NEW_MODELVIEW)
1087 update_modelview_scale(ctx);
1088
1089 if (new_state2 & (_NEW_LIGHT|_NEW_MODELVIEW))
1090 compute_light_positions( ctx );
1091 }
1092 }
1093
1094
1095 /**
1096 * Drivers may need this if the hardware tnl unit doesn't support the
1097 * light-in-modelspace optimization. It's also useful for debugging.
1098 */
1099 void
1100 _mesa_allow_light_in_model( struct gl_context *ctx, GLboolean flag )
1101 {
1102 ctx->_ForceEyeCoords = !flag;
1103 ctx->NewState |= _NEW_POINT; /* one of the bits from
1104 * _MESA_NEW_NEED_EYE_COORDS.
1105 */
1106 }
1107
1108
1109
1110 /**********************************************************************/
1111 /***** Initialization *****/
1112 /**********************************************************************/
1113
1114 /**
1115 * Initialize the n-th light data structure.
1116 *
1117 * \param l pointer to the gl_light structure to be initialized.
1118 * \param n number of the light.
1119 * \note The defaults for light 0 are different than the other lights.
1120 */
1121 static void
1122 init_light( struct gl_light *l, GLuint n )
1123 {
1124 ASSIGN_4V( l->Ambient, 0.0, 0.0, 0.0, 1.0 );
1125 if (n==0) {
1126 ASSIGN_4V( l->Diffuse, 1.0, 1.0, 1.0, 1.0 );
1127 ASSIGN_4V( l->Specular, 1.0, 1.0, 1.0, 1.0 );
1128 }
1129 else {
1130 ASSIGN_4V( l->Diffuse, 0.0, 0.0, 0.0, 1.0 );
1131 ASSIGN_4V( l->Specular, 0.0, 0.0, 0.0, 1.0 );
1132 }
1133 ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 );
1134 ASSIGN_3V( l->SpotDirection, 0.0, 0.0, -1.0 );
1135 l->SpotExponent = 0.0;
1136 l->SpotCutoff = 180.0;
1137 l->_CosCutoff = 0.0; /* KW: -ve values not admitted */
1138 l->ConstantAttenuation = 1.0;
1139 l->LinearAttenuation = 0.0;
1140 l->QuadraticAttenuation = 0.0;
1141 l->Enabled = GL_FALSE;
1142 }
1143
1144
1145 /**
1146 * Initialize the light model data structure.
1147 *
1148 * \param lm pointer to the gl_lightmodel structure to be initialized.
1149 */
1150 static void
1151 init_lightmodel( struct gl_lightmodel *lm )
1152 {
1153 ASSIGN_4V( lm->Ambient, 0.2F, 0.2F, 0.2F, 1.0F );
1154 lm->LocalViewer = GL_FALSE;
1155 lm->TwoSide = GL_FALSE;
1156 lm->ColorControl = GL_SINGLE_COLOR;
1157 }
1158
1159
1160 /**
1161 * Initialize the material data structure.
1162 *
1163 * \param m pointer to the gl_material structure to be initialized.
1164 */
1165 static void
1166 init_material( struct gl_material *m )
1167 {
1168 ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_AMBIENT], 0.2F, 0.2F, 0.2F, 1.0F );
1169 ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_DIFFUSE], 0.8F, 0.8F, 0.8F, 1.0F );
1170 ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_SPECULAR], 0.0F, 0.0F, 0.0F, 1.0F );
1171 ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_EMISSION], 0.0F, 0.0F, 0.0F, 1.0F );
1172 ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_SHININESS], 0.0F, 0.0F, 0.0F, 0.0F );
1173 ASSIGN_4V( m->Attrib[MAT_ATTRIB_FRONT_INDEXES], 0.0F, 1.0F, 1.0F, 0.0F );
1174
1175 ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_AMBIENT], 0.2F, 0.2F, 0.2F, 1.0F );
1176 ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_DIFFUSE], 0.8F, 0.8F, 0.8F, 1.0F );
1177 ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_SPECULAR], 0.0F, 0.0F, 0.0F, 1.0F );
1178 ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_EMISSION], 0.0F, 0.0F, 0.0F, 1.0F );
1179 ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_SHININESS], 0.0F, 0.0F, 0.0F, 0.0F );
1180 ASSIGN_4V( m->Attrib[MAT_ATTRIB_BACK_INDEXES], 0.0F, 1.0F, 1.0F, 0.0F );
1181 }
1182
1183
1184 /**
1185 * Initialize all lighting state for the given context.
1186 */
1187 void
1188 _mesa_init_lighting( struct gl_context *ctx )
1189 {
1190 GLuint i;
1191
1192 /* Lighting group */
1193 ctx->Light._EnabledLights = 0;
1194 for (i = 0; i < MAX_LIGHTS; i++) {
1195 init_light( &ctx->Light.Light[i], i );
1196 }
1197
1198 init_lightmodel( &ctx->Light.Model );
1199 init_material( &ctx->Light.Material );
1200 ctx->Light.ShadeModel = GL_SMOOTH;
1201 ctx->Light.ProvokingVertex = GL_LAST_VERTEX_CONVENTION_EXT;
1202 ctx->Light.Enabled = GL_FALSE;
1203 ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK;
1204 ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE;
1205 ctx->Light._ColorMaterialBitmask = _mesa_material_bitmask( ctx,
1206 GL_FRONT_AND_BACK,
1207 GL_AMBIENT_AND_DIFFUSE, ~0,
1208 NULL );
1209
1210 ctx->Light.ColorMaterialEnabled = GL_FALSE;
1211 ctx->Light.ClampVertexColor = ctx->API == API_OPENGL_COMPAT;
1212 ctx->Light._ClampVertexColor = ctx->API == API_OPENGL_COMPAT;
1213
1214 /* Miscellaneous */
1215 ctx->Light._NeedEyeCoords = GL_FALSE;
1216 ctx->_NeedEyeCoords = GL_FALSE;
1217 ctx->_ForceEyeCoords = GL_FALSE;
1218 ctx->_ModelViewInvScale = 1.0;
1219 }