ReactOS 0.4.16-dev-1946-g52006dd
Functions
light.c File Reference
#include <assert.h>
#include <float.h>
#include <math.h>
#include <stdlib.h>
#include "context.h"
#include "light.h"
#include "dlist.h"
#include "macros.h"
#include "matrix.h"
#include "mmath.h"
#include "types.h"
#include "vb.h"
#include "xform.h"
Include dependency graph for light.c:

Go to the source code of this file.

Functions

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

Function Documentation

◆ gl_ColorMaterial()

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

Definition at line 485 of file light.c.

486{
487 if (INSIDE_BEGIN_END(ctx)) {
488 gl_error( ctx, GL_INVALID_OPERATION, "glColorMaterial" );
489 return;
490 }
491 switch (face) {
492 case GL_FRONT:
493 case GL_BACK:
494 case GL_FRONT_AND_BACK:
495 ctx->Light.ColorMaterialFace = face;
496 break;
497 default:
498 gl_error( ctx, GL_INVALID_ENUM, "glColorMaterial(face)" );
499 return;
500 }
501 switch (mode) {
502 case GL_EMISSION:
503 case GL_AMBIENT:
504 case GL_DIFFUSE:
505 case GL_SPECULAR:
506 case GL_AMBIENT_AND_DIFFUSE:
507 ctx->Light.ColorMaterialMode = mode;
508 break;
509 default:
510 gl_error( ctx, GL_INVALID_ENUM, "glColorMaterial(mode)" );
511 return;
512 }
513
514 ctx->Light.ColorMaterialBitmask = gl_material_bitmask( face, mode );
515}
face
WORD face[3]
Definition: mesh.c:4747
gl_error
void gl_error(GLcontext *ctx, GLenum error, const char *s)
Definition: context.c:1421
GL_DIFFUSE
#define GL_DIFFUSE
Definition: gl.h:325
GL_AMBIENT_AND_DIFFUSE
#define GL_AMBIENT_AND_DIFFUSE
Definition: gl.h:331
GL_FRONT_AND_BACK
#define GL_FRONT_AND_BACK
Definition: gl.h:336
GL_SPECULAR
#define GL_SPECULAR
Definition: gl.h:326
GL_INVALID_OPERATION
#define GL_INVALID_OPERATION
Definition: gl.h:696
GL_AMBIENT
#define GL_AMBIENT
Definition: gl.h:324
GL_BACK
#define GL_BACK
Definition: gl.h:271
GL_EMISSION
#define GL_EMISSION
Definition: gl.h:328
GL_FRONT
#define GL_FRONT
Definition: gl.h:270
GL_INVALID_ENUM
#define GL_INVALID_ENUM
Definition: gl.h:694
face
GLenum GLuint GLint GLenum face
Definition: glext.h:7025
mode
GLenum mode
Definition: glext.h:6217
INSIDE_BEGIN_END
#define INSIDE_BEGIN_END(CTX)
Definition: macros.h:135
gl_material_bitmask
GLuint gl_material_bitmask(GLenum face, GLenum pname)
Definition: light.c:362

Referenced by execute_list(), and init_exec_pointers().

◆ gl_compute_material_shine_table()

void gl_compute_material_shine_table ( struct gl_material *  m)

Definition at line 741 of file light.c.

742{
743 int i;
744
745 m->ShineTable[0] = 0.0F;
746 for (i=1;i<SHINE_TABLE_SIZE;i++) {
747#if 0
748 double x = pow( i/(double)(SHINE_TABLE_SIZE-1), exponent );
749 if (x<1.0e-10) {
750 m->ShineTable[i] = 0.0F;
751 }
752 else {
753 m->ShineTable[i] = x;
754 }
755#else
756 /* just invalidate the table */
757 m->ShineTable[i] = -1.0;
758#endif
759 }
760}
exponent
__int64 exponent
Definition: cvt.cpp:529
SHINE_TABLE_SIZE
#define SHINE_TABLE_SIZE
Definition: types.h:558
pow
double pow(double x, double y)
Definition: freeldr.c:178
x
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
m
const GLfloat * m
Definition: glext.h:10848
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248

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

◆ gl_compute_spot_exp_table()

void gl_compute_spot_exp_table ( struct gl_light *  l)

Definition at line 710 of file light.c.

711{
712 int i;
713 double exponent = l->SpotExponent;
714 double tmp;
715 int clamp = 0;
716
717 l->SpotExpTable[0][0] = 0.0;
718
719 for (i=EXP_TABLE_SIZE-1;i>0;i--) {
720 if (clamp == 0) {
721 tmp = pow(i/(double)(EXP_TABLE_SIZE-1), exponent);
722 if (tmp < FLT_MIN*100.0) {
723 tmp = 0.0;
724 clamp = 1;
725 }
726 }
727 l->SpotExpTable[i][0] = tmp;
728 }
729 for (i=0;i<EXP_TABLE_SIZE-1;i++) {
730 l->SpotExpTable[i][1] = l->SpotExpTable[i+1][0] - l->SpotExpTable[i][0];
731 }
732 l->SpotExpTable[EXP_TABLE_SIZE-1][1] = 0.0;
733}
l
r l[0]
Definition: byte_order.h:168
EXP_TABLE_SIZE
#define EXP_TABLE_SIZE
Definition: types.h:557
clamp
GLenum clamp
Definition: glext.h:6216
FLT_MIN
#define FLT_MIN
Definition: float.h:94

Referenced by gl_Lightfv(), and init_light().

◆ gl_GetLightfv()

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

Definition at line 211 of file light.c.

213{
214 GLint l = (GLint) (light - GL_LIGHT0);
215
216 if (l<0 || l>=MAX_LIGHTS) {
217 gl_error( ctx, GL_INVALID_ENUM, "glGetLightfv" );
218 return;
219 }
220
221 switch (pname) {
222 case GL_AMBIENT:
223 COPY_4V( params, ctx->Light.Light[l].Ambient );
224 break;
225 case GL_DIFFUSE:
226 COPY_4V( params, ctx->Light.Light[l].Diffuse );
227 break;
228 case GL_SPECULAR:
229 COPY_4V( params, ctx->Light.Light[l].Specular );
230 break;
231 case GL_POSITION:
232 COPY_4V( params, ctx->Light.Light[l].Position );
233 break;
234 case GL_SPOT_DIRECTION:
235 COPY_3V( params, ctx->Light.Light[l].Direction );
236 break;
237 case GL_SPOT_EXPONENT:
238 params[0] = ctx->Light.Light[l].SpotExponent;
239 break;
240 case GL_SPOT_CUTOFF:
241 params[0] = ctx->Light.Light[l].SpotCutoff;
242 break;
243 case GL_CONSTANT_ATTENUATION:
244 params[0] = ctx->Light.Light[l].ConstantAttenuation;
245 break;
246 case GL_LINEAR_ATTENUATION:
247 params[0] = ctx->Light.Light[l].LinearAttenuation;
248 break;
249 case GL_QUADRATIC_ATTENUATION:
250 params[0] = ctx->Light.Light[l].QuadraticAttenuation;
251 break;
252 default:
253 gl_error( ctx, GL_INVALID_ENUM, "glGetLightfv" );
254 break;
255 }
256}
MAX_LIGHTS
#define MAX_LIGHTS
Definition: config.h:84
GL_POSITION
#define GL_POSITION
Definition: gl.h:329
GL_SPOT_EXPONENT
#define GL_SPOT_EXPONENT
Definition: gl.h:319
GL_QUADRATIC_ATTENUATION
#define GL_QUADRATIC_ATTENUATION
Definition: gl.h:323
GL_LINEAR_ATTENUATION
#define GL_LINEAR_ATTENUATION
Definition: gl.h:322
GL_SPOT_DIRECTION
#define GL_SPOT_DIRECTION
Definition: gl.h:330
GLint
int GLint
Definition: gl.h:156
GL_CONSTANT_ATTENUATION
#define GL_CONSTANT_ATTENUATION
Definition: gl.h:321
GL_SPOT_CUTOFF
#define GL_SPOT_CUTOFF
Definition: gl.h:320
GL_LIGHT0
#define GL_LIGHT0
Definition: gl.h:311
pname
GLenum pname
Definition: glext.h:5645
params
GLenum const GLfloat * params
Definition: glext.h:5645
light
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum light
Definition: glfuncs.h:170
COPY_3V
#define COPY_3V(DST, SRC)
Definition: macros.h:98
COPY_4V
#define COPY_4V(DST, SRC)
Definition: macros.h:102

Referenced by init_dlist_pointers(), and init_exec_pointers().

◆ gl_GetLightiv()

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

Definition at line 260 of file light.c.

261{
262 GLint l = (GLint) (light - GL_LIGHT0);
263
264 if (l<0 || l>=MAX_LIGHTS) {
265 gl_error( ctx, GL_INVALID_ENUM, "glGetLightiv" );
266 return;
267 }
268
269 switch (pname) {
270 case GL_AMBIENT:
271 params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[0]);
272 params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[1]);
273 params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[2]);
274 params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[3]);
275 break;
276 case GL_DIFFUSE:
277 params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[0]);
278 params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[1]);
279 params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[2]);
280 params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[3]);
281 break;
282 case GL_SPECULAR:
283 params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[0]);
284 params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[1]);
285 params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[2]);
286 params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[3]);
287 break;
288 case GL_POSITION:
289 params[0] = ctx->Light.Light[l].Position[0];
290 params[1] = ctx->Light.Light[l].Position[1];
291 params[2] = ctx->Light.Light[l].Position[2];
292 params[3] = ctx->Light.Light[l].Position[3];
293 break;
294 case GL_SPOT_DIRECTION:
295 params[0] = ctx->Light.Light[l].Direction[0];
296 params[1] = ctx->Light.Light[l].Direction[1];
297 params[2] = ctx->Light.Light[l].Direction[2];
298 break;
299 case GL_SPOT_EXPONENT:
300 params[0] = ctx->Light.Light[l].SpotExponent;
301 break;
302 case GL_SPOT_CUTOFF:
303 params[0] = ctx->Light.Light[l].SpotCutoff;
304 break;
305 case GL_CONSTANT_ATTENUATION:
306 params[0] = ctx->Light.Light[l].ConstantAttenuation;
307 break;
308 case GL_LINEAR_ATTENUATION:
309 params[0] = ctx->Light.Light[l].LinearAttenuation;
310 break;
311 case GL_QUADRATIC_ATTENUATION:
312 params[0] = ctx->Light.Light[l].QuadraticAttenuation;
313 break;
314 default:
315 gl_error( ctx, GL_INVALID_ENUM, "glGetLightiv" );
316 break;
317 }
318}
FLOAT_TO_INT
#define FLOAT_TO_INT(X)
Definition: macros.h:222

Referenced by init_dlist_pointers(), and init_exec_pointers().

◆ gl_GetMaterialfv()

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

Definition at line 563 of file light.c.

565{
566 GLuint f;
567
568 if (INSIDE_BEGIN_END(ctx)) {
569 gl_error( ctx, GL_INVALID_OPERATION, "glGetMaterialfv" );
570 return;
571 }
572 if (face==GL_FRONT) {
573 f = 0;
574 }
575 else if (face==GL_BACK) {
576 f = 1;
577 }
578 else {
579 gl_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(face)" );
580 return;
581 }
582 switch (pname) {
583 case GL_AMBIENT:
584 COPY_4V( params, ctx->Light.Material[f].Ambient );
585 break;
586 case GL_DIFFUSE:
587 COPY_4V( params, ctx->Light.Material[f].Diffuse );
588 break;
589 case GL_SPECULAR:
590 COPY_4V( params, ctx->Light.Material[f].Specular );
591 break;
592 case GL_EMISSION:
593 COPY_4V( params, ctx->Light.Material[f].Emission );
594 break;
595 case GL_SHININESS:
596 *params = ctx->Light.Material[f].Shininess;
597 break;
598 case GL_COLOR_INDEXES:
599 params[0] = ctx->Light.Material[f].AmbientIndex;
600 params[1] = ctx->Light.Material[f].DiffuseIndex;
601 params[2] = ctx->Light.Material[f].SpecularIndex;
602 break;
603 default:
604 gl_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" );
605 }
606}
GL_SHININESS
#define GL_SHININESS
Definition: gl.h:327
GL_COLOR_INDEXES
#define GL_COLOR_INDEXES
Definition: gl.h:332
GLuint
unsigned int GLuint
Definition: gl.h:159
f
GLfloat f
Definition: glext.h:7540
f
#define f
Definition: ke_i.h:83

Referenced by init_dlist_pointers(), and init_exec_pointers().

◆ gl_GetMaterialiv()

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

Definition at line 610 of file light.c.

612{
613 GLuint f;
614
615 if (INSIDE_BEGIN_END(ctx)) {
616 gl_error( ctx, GL_INVALID_OPERATION, "glGetMaterialiv" );
617 return;
618 }
619 if (face==GL_FRONT) {
620 f = 0;
621 }
622 else if (face==GL_BACK) {
623 f = 1;
624 }
625 else {
626 gl_error( ctx, GL_INVALID_ENUM, "glGetMaterialiv(face)" );
627 return;
628 }
629 switch (pname) {
630 case GL_AMBIENT:
631 params[0] = FLOAT_TO_INT( ctx->Light.Material[f].Ambient[0] );
632 params[1] = FLOAT_TO_INT( ctx->Light.Material[f].Ambient[1] );
633 params[2] = FLOAT_TO_INT( ctx->Light.Material[f].Ambient[2] );
634 params[3] = FLOAT_TO_INT( ctx->Light.Material[f].Ambient[3] );
635 break;
636 case GL_DIFFUSE:
637 params[0] = FLOAT_TO_INT( ctx->Light.Material[f].Diffuse[0] );
638 params[1] = FLOAT_TO_INT( ctx->Light.Material[f].Diffuse[1] );
639 params[2] = FLOAT_TO_INT( ctx->Light.Material[f].Diffuse[2] );
640 params[3] = FLOAT_TO_INT( ctx->Light.Material[f].Diffuse[3] );
641 break;
642 case GL_SPECULAR:
643 params[0] = FLOAT_TO_INT( ctx->Light.Material[f].Specular[0] );
644 params[1] = FLOAT_TO_INT( ctx->Light.Material[f].Specular[1] );
645 params[2] = FLOAT_TO_INT( ctx->Light.Material[f].Specular[2] );
646 params[3] = FLOAT_TO_INT( ctx->Light.Material[f].Specular[3] );
647 break;
648 case GL_EMISSION:
649 params[0] = FLOAT_TO_INT( ctx->Light.Material[f].Emission[0] );
650 params[1] = FLOAT_TO_INT( ctx->Light.Material[f].Emission[1] );
651 params[2] = FLOAT_TO_INT( ctx->Light.Material[f].Emission[2] );
652 params[3] = FLOAT_TO_INT( ctx->Light.Material[f].Emission[3] );
653 break;
654 case GL_SHININESS:
655 *params = ROUNDF( ctx->Light.Material[f].Shininess );
656 break;
657 case GL_COLOR_INDEXES:
658 params[0] = ROUNDF( ctx->Light.Material[f].AmbientIndex );
659 params[1] = ROUNDF( ctx->Light.Material[f].DiffuseIndex );
660 params[2] = ROUNDF( ctx->Light.Material[f].SpecularIndex );
661 break;
662 default:
663 gl_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" );
664 }
665}
ROUNDF
#define ROUNDF(X)
Definition: macros.h:147

Referenced by init_dlist_pointers(), and init_exec_pointers().

◆ gl_Lightfv()

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

Definition at line 114 of file light.c.

117{
118 GLint l;
119
120 if (INSIDE_BEGIN_END(ctx)) {
121 gl_error( ctx, GL_INVALID_OPERATION, "glShadeModel" );
122 return;
123 }
124
125 l = (GLint) (light - GL_LIGHT0);
126
127 if (l<0 || l>=MAX_LIGHTS) {
128 gl_error( ctx, GL_INVALID_ENUM, "glLight" );
129 return;
130 }
131
132 switch (pname) {
133 case GL_AMBIENT:
134 COPY_4V( ctx->Light.Light[l].Ambient, params );
135 break;
136 case GL_DIFFUSE:
137 COPY_4V( ctx->Light.Light[l].Diffuse, params );
138 break;
139 case GL_SPECULAR:
140 COPY_4V( ctx->Light.Light[l].Specular, params );
141 break;
142 case GL_POSITION:
143 /* transform position by ModelView matrix */
144 TRANSFORM_POINT( ctx->Light.Light[l].Position, ctx->ModelViewMatrix,
145 params );
146 break;
147 case GL_SPOT_DIRECTION:
148 /* transform direction by inverse modelview */
149 {
150 GLfloat direction[4];
151 direction[0] = params[0];
152 direction[1] = params[1];
153 direction[2] = params[2];
154 direction[3] = 0.0;
155 if (ctx->NewModelViewMatrix) {
156 gl_analyze_modelview_matrix( ctx );
157 }
158 gl_transform_vector( ctx->Light.Light[l].Direction,
159 direction, ctx->ModelViewInv);
160 }
161 break;
162 case GL_SPOT_EXPONENT:
163 if (params[0]<0.0 || params[0]>128.0) {
164 gl_error( ctx, GL_INVALID_VALUE, "glLight" );
165 return;
166 }
167 if (ctx->Light.Light[l].SpotExponent != params[0]) {
168 ctx->Light.Light[l].SpotExponent = params[0];
169 gl_compute_spot_exp_table( &ctx->Light.Light[l] );
170 }
171 break;
172 case GL_SPOT_CUTOFF:
173 if ((params[0]<0.0 || params[0]>90.0) && params[0]!=180.0) {
174 gl_error( ctx, GL_INVALID_VALUE, "glLight" );
175 return;
176 }
177 ctx->Light.Light[l].SpotCutoff = params[0];
178 ctx->Light.Light[l].CosCutoff = cos(params[0]*DEG2RAD);
179 break;
180 case GL_CONSTANT_ATTENUATION:
181 if (params[0]<0.0) {
182 gl_error( ctx, GL_INVALID_VALUE, "glLight" );
183 return;
184 }
185 ctx->Light.Light[l].ConstantAttenuation = params[0];
186 break;
187 case GL_LINEAR_ATTENUATION:
188 if (params[0]<0.0) {
189 gl_error( ctx, GL_INVALID_VALUE, "glLight" );
190 return;
191 }
192 ctx->Light.Light[l].LinearAttenuation = params[0];
193 break;
194 case GL_QUADRATIC_ATTENUATION:
195 if (params[0]<0.0) {
196 gl_error( ctx, GL_INVALID_VALUE, "glLight" );
197 return;
198 }
199 ctx->Light.Light[l].QuadraticAttenuation = params[0];
200 break;
201 default:
202 gl_error( ctx, GL_INVALID_ENUM, "glLight" );
203 break;
204 }
205
206 ctx->NewState |= NEW_LIGHTING;
207}
cos
_STLP_DECLSPEC complex< float > _STLP_CALL cos(const complex< float > &)
Definition: complex_trig.cpp:92
DEG2RAD
#define DEG2RAD(degree)
Definition: precomp.h:76
gl_analyze_modelview_matrix
void gl_analyze_modelview_matrix(GLcontext *ctx)
Definition: matrix.c:420
NEW_LIGHTING
#define NEW_LIGHTING
Definition: types.h:1232
GL_INVALID_VALUE
#define GL_INVALID_VALUE
Definition: gl.h:695
GLfloat
float GLfloat
Definition: gl.h:161
direction
direction
Definition: netio.c:882
gl_compute_spot_exp_table
void gl_compute_spot_exp_table(struct gl_light *l)
Definition: light.c:710
gl_transform_vector
void gl_transform_vector(GLfloat u[4], const GLfloat v[4], const GLfloat m[16])
Definition: xform.c:248
TRANSFORM_POINT
#define TRANSFORM_POINT(Q, M, P)
Definition: xform.h:51

Referenced by execute_list(), and init_exec_pointers().

◆ gl_LightModelfv()

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

Definition at line 327 of file light.c.

328{
329 switch (pname) {
330 case GL_LIGHT_MODEL_AMBIENT:
331 COPY_4V( ctx->Light.Model.Ambient, params );
332 break;
333 case GL_LIGHT_MODEL_LOCAL_VIEWER:
334 if (params[0]==0.0)
335 ctx->Light.Model.LocalViewer = GL_FALSE;
336 else
337 ctx->Light.Model.LocalViewer = GL_TRUE;
338 break;
339 case GL_LIGHT_MODEL_TWO_SIDE:
340 if (params[0]==0.0)
341 ctx->Light.Model.TwoSide = GL_FALSE;
342 else
343 ctx->Light.Model.TwoSide = GL_TRUE;
344 break;
345 default:
346 gl_error( ctx, GL_INVALID_ENUM, "glLightModel" );
347 break;
348 }
349 ctx->NewState |= NEW_LIGHTING;
350}
GL_TRUE
#define GL_TRUE
Definition: gl.h:174
GL_LIGHT_MODEL_LOCAL_VIEWER
#define GL_LIGHT_MODEL_LOCAL_VIEWER
Definition: gl.h:334
GL_FALSE
#define GL_FALSE
Definition: gl.h:173
GL_LIGHT_MODEL_TWO_SIDE
#define GL_LIGHT_MODEL_TWO_SIDE
Definition: gl.h:333
GL_LIGHT_MODEL_AMBIENT
#define GL_LIGHT_MODEL_AMBIENT
Definition: gl.h:335

Referenced by execute_list(), and init_exec_pointers().

◆ gl_material_bitmask()

GLuint gl_material_bitmask ( GLenum  face,
GLenum  pname 
)

Definition at line 362 of file light.c.

363{
364 GLuint bitmask = 0;
365
366 /* Make a bitmask indicating what material attribute(s) we're updating */
367 switch (pname) {
368 case GL_EMISSION:
369 bitmask |= FRONT_EMISSION_BIT | BACK_EMISSION_BIT;
370 break;
371 case GL_AMBIENT:
372 bitmask |= FRONT_AMBIENT_BIT | BACK_AMBIENT_BIT;
373 break;
374 case GL_DIFFUSE:
375 bitmask |= FRONT_DIFFUSE_BIT | BACK_DIFFUSE_BIT;
376 break;
377 case GL_SPECULAR:
378 bitmask |= FRONT_SPECULAR_BIT | BACK_SPECULAR_BIT;
379 break;
380 case GL_SHININESS:
381 bitmask |= FRONT_SHININESS_BIT | BACK_SHININESS_BIT;
382 break;
383 case GL_AMBIENT_AND_DIFFUSE:
384 bitmask |= FRONT_AMBIENT_BIT | BACK_AMBIENT_BIT;
385 bitmask |= FRONT_DIFFUSE_BIT | BACK_DIFFUSE_BIT;
386 break;
387 case GL_COLOR_INDEXES:
388 bitmask |= FRONT_INDEXES_BIT | BACK_INDEXES_BIT;
389 break;
390 default:
391 gl_problem(NULL, "Bad param in gl_material_bitmask");
392 return 0;
393 }
394
395 ASSERT( face==GL_FRONT || face==GL_BACK || face==GL_FRONT_AND_BACK );
396
397 if (face==GL_FRONT) {
398 bitmask &= FRONT_MATERIAL_BITS;
399 }
400 else if (face==GL_BACK) {
401 bitmask &= BACK_MATERIAL_BITS;
402 }
403
404 return bitmask;
405}
NULL
#define NULL
Definition: types.h:112
gl_problem
void gl_problem(const GLcontext *ctx, const char *s)
Definition: context.c:1394
FRONT_SHININESS_BIT
#define FRONT_SHININESS_BIT
Definition: types.h:537
FRONT_SPECULAR_BIT
#define FRONT_SPECULAR_BIT
Definition: types.h:533
FRONT_INDEXES_BIT
#define FRONT_INDEXES_BIT
Definition: types.h:539
FRONT_DIFFUSE_BIT
#define FRONT_DIFFUSE_BIT
Definition: types.h:531
BACK_MATERIAL_BITS
#define BACK_MATERIAL_BITS
Definition: types.h:546
BACK_INDEXES_BIT
#define BACK_INDEXES_BIT
Definition: types.h:540
BACK_EMISSION_BIT
#define BACK_EMISSION_BIT
Definition: types.h:536
BACK_AMBIENT_BIT
#define BACK_AMBIENT_BIT
Definition: types.h:530
FRONT_MATERIAL_BITS
#define FRONT_MATERIAL_BITS
Definition: types.h:542
FRONT_AMBIENT_BIT
#define FRONT_AMBIENT_BIT
Definition: types.h:529
BACK_DIFFUSE_BIT
#define BACK_DIFFUSE_BIT
Definition: types.h:532
BACK_SPECULAR_BIT
#define BACK_SPECULAR_BIT
Definition: types.h:534
BACK_SHININESS_BIT
#define BACK_SHININESS_BIT
Definition: types.h:538
FRONT_EMISSION_BIT
#define FRONT_EMISSION_BIT
Definition: types.h:535
ASSERT
#define ASSERT(a)
Definition: mode.c:44

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

◆ gl_Materialfv()

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

Definition at line 523 of file light.c.

525{
526 GLuint bitmask;
527
528 /* error checking */
529 if (face!=GL_FRONT && face!=GL_BACK && face!=GL_FRONT_AND_BACK) {
530 gl_error( ctx, GL_INVALID_ENUM, "glMaterial(face)" );
531 return;
532 }
533 switch (pname) {
534 case GL_EMISSION:
535 case GL_AMBIENT:
536 case GL_DIFFUSE:
537 case GL_SPECULAR:
538 case GL_SHININESS:
539 case GL_AMBIENT_AND_DIFFUSE:
540 case GL_COLOR_INDEXES:
541 /* OK */
542 break;
543 default:
544 gl_error( ctx, GL_INVALID_ENUM, "glMaterial(pname)" );
545 return;
546 }
547
548 /* convert face and pname to a bitmask */
549 bitmask = gl_material_bitmask( face, pname );
550
551 if (ctx->Light.ColorMaterialEnabled) {
552 /* The material values specified by glColorMaterial() can't be */
553 /* updated by glMaterial() while GL_COLOR_MATERIAL is enabled! */
554 bitmask &= ~ctx->Light.ColorMaterialBitmask;
555 }
556
557 gl_set_material( ctx, bitmask, params );
558}
gl_set_material
void gl_set_material(GLcontext *ctx, GLuint bitmask, const GLfloat *params)
Definition: light.c:413

Referenced by execute_list(), and init_exec_pointers().

◆ gl_set_material()

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

Definition at line 413 of file light.c.

414{
415 struct gl_material *mat;
416
417 if (INSIDE_BEGIN_END(ctx)) {
418 struct vertex_buffer *VB = ctx->VB;
419 /* Save per-vertex material changes in the Vertex Buffer.
420 * The update_material function will eventually update the global
421 * ctx->Light.Material values.
422 */
423 mat = VB->Material[VB->Count];
424 VB->MaterialMask[VB->Count] |= bitmask;
425 VB->MonoMaterial = GL_FALSE;
426 }
427 else {
428 /* just update the global material property */
429 mat = ctx->Light.Material;
430 ctx->NewState |= NEW_LIGHTING;
431 }
432
433 if (bitmask & FRONT_AMBIENT_BIT) {
434 COPY_4V( mat[0].Ambient, params );
435 }
436 if (bitmask & BACK_AMBIENT_BIT) {
437 COPY_4V( mat[1].Ambient, params );
438 }
439 if (bitmask & FRONT_DIFFUSE_BIT) {
440 COPY_4V( mat[0].Diffuse, params );
441 }
442 if (bitmask & BACK_DIFFUSE_BIT) {
443 COPY_4V( mat[1].Diffuse, params );
444 }
445 if (bitmask & FRONT_SPECULAR_BIT) {
446 COPY_4V( mat[0].Specular, params );
447 }
448 if (bitmask & BACK_SPECULAR_BIT) {
449 COPY_4V( mat[1].Specular, params );
450 }
451 if (bitmask & FRONT_EMISSION_BIT) {
452 COPY_4V( mat[0].Emission, params );
453 }
454 if (bitmask & BACK_EMISSION_BIT) {
455 COPY_4V( mat[1].Emission, params );
456 }
457 if (bitmask & FRONT_SHININESS_BIT) {
458 GLfloat shininess = CLAMP( params[0], 0.0F, 128.0F );
459 if (mat[0].Shininess != shininess) {
460 mat[0].Shininess = shininess;
461 gl_compute_material_shine_table( &mat[0] );
462 }
463 }
464 if (bitmask & BACK_SHININESS_BIT) {
465 GLfloat shininess = CLAMP( params[0], 0.0F, 128.0F );
466 if (mat[1].Shininess != shininess) {
467 mat[1].Shininess = shininess;
468 gl_compute_material_shine_table( &mat[1] );
469 }
470 }
471 if (bitmask & FRONT_INDEXES_BIT) {
472 mat[0].AmbientIndex = params[0];
473 mat[0].DiffuseIndex = params[1];
474 mat[0].SpecularIndex = params[2];
475 }
476 if (bitmask & BACK_INDEXES_BIT) {
477 mat[1].AmbientIndex = params[0];
478 mat[1].DiffuseIndex = params[1];
479 mat[1].SpecularIndex = params[2];
480 }
481}
mat
static const MAT2 mat
Definition: font.c:66
gl_compute_material_shine_table
void gl_compute_material_shine_table(struct gl_material *m)
Definition: light.c:741
gl_material
Definition: types.h:596
vertex_buffer
Definition: vb.h:99
CLAMP
#define CLAMP(f, min, max)
Definition: tif_color.c:177
VB
struct vertex_buffer * VB
Definition: tritemp.h:139

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

◆ gl_ShadeModel()

void gl_ShadeModel ( GLcontext *  ctx,
GLenum  mode 
)

Definition at line 92 of file light.c.

93{
94 if (INSIDE_BEGIN_END(ctx)) {
95 gl_error( ctx, GL_INVALID_OPERATION, "glShadeModel" );
96 return;
97 }
98
99 switch (mode) {
100 case GL_FLAT:
101 case GL_SMOOTH:
102 if (ctx->Light.ShadeModel!=mode) {
103 ctx->Light.ShadeModel = mode;
104 ctx->NewState |= NEW_RASTER_OPS;
105 }
106 break;
107 default:
108 gl_error( ctx, GL_INVALID_ENUM, "glShadeModel" );
109 }
110}
NEW_RASTER_OPS
#define NEW_RASTER_OPS
Definition: types.h:1233
GL_SMOOTH
#define GL_SMOOTH
Definition: gl.h:339
GL_FLAT
#define GL_FLAT
Definition: gl.h:338

Referenced by execute_list(), and init_exec_pointers().

◆ gl_update_lighting()

void gl_update_lighting ( GLcontext *  ctx)

Definition at line 770 of file light.c.

771{
772 GLint i, side;
773 struct gl_light *prev_enabled, *light;
774
775 if (!ctx->Light.Enabled) {
776 /* If lighting is not enabled, we can skip all this. */
777 return;
778 }
779
780 /* Setup linked list of enabled light sources */
781 prev_enabled = NULL;
782 ctx->Light.FirstEnabled = NULL;
783 for (i=0;i<MAX_LIGHTS;i++) {
784 ctx->Light.Light[i].NextEnabled = NULL;
785 if (ctx->Light.Light[i].Enabled) {
786 if (prev_enabled) {
787 prev_enabled->NextEnabled = &ctx->Light.Light[i];
788 }
789 else {
790 ctx->Light.FirstEnabled = &ctx->Light.Light[i];
791 }
792 prev_enabled = &ctx->Light.Light[i];
793 }
794 }
795
796 /* base color = material_emission + global_ambient * material_ambient */
797 for (side=0; side<2; side++) {
798 ctx->Light.BaseColor[side][0] = ctx->Light.Material[side].Emission[0]
799 + ctx->Light.Model.Ambient[0] * ctx->Light.Material[side].Ambient[0];
800 ctx->Light.BaseColor[side][1] = ctx->Light.Material[side].Emission[1]
801 + ctx->Light.Model.Ambient[1] * ctx->Light.Material[side].Ambient[1];
802 ctx->Light.BaseColor[side][2] = ctx->Light.Material[side].Emission[2]
803 + ctx->Light.Model.Ambient[2] * ctx->Light.Material[side].Ambient[2];
804 ctx->Light.BaseColor[side][3]
805 = MIN2( ctx->Light.Material[side].Diffuse[3], 1.0F );
806 }
807
808
809 /* Precompute some lighting stuff */
810 for (light = ctx->Light.FirstEnabled; light; light = light->NextEnabled) {
811 for (side=0; side<2; side++) {
812 struct gl_material *mat = &ctx->Light.Material[side];
813 /* Add each light's ambient component to base color */
814 ctx->Light.BaseColor[side][0] += light->Ambient[0] * mat->Ambient[0];
815 ctx->Light.BaseColor[side][1] += light->Ambient[1] * mat->Ambient[1];
816 ctx->Light.BaseColor[side][2] += light->Ambient[2] * mat->Ambient[2];
817 /* compute product of light's ambient with front material ambient */
818 light->MatAmbient[side][0] = light->Ambient[0] * mat->Ambient[0];
819 light->MatAmbient[side][1] = light->Ambient[1] * mat->Ambient[1];
820 light->MatAmbient[side][2] = light->Ambient[2] * mat->Ambient[2];
821 /* compute product of light's diffuse with front material diffuse */
822 light->MatDiffuse[side][0] = light->Diffuse[0] * mat->Diffuse[0];
823 light->MatDiffuse[side][1] = light->Diffuse[1] * mat->Diffuse[1];
824 light->MatDiffuse[side][2] = light->Diffuse[2] * mat->Diffuse[2];
825 /* compute product of light's specular with front material specular */
826 light->MatSpecular[side][0] = light->Specular[0] * mat->Specular[0];
827 light->MatSpecular[side][1] = light->Specular[1] * mat->Specular[1];
828 light->MatSpecular[side][2] = light->Specular[2] * mat->Specular[2];
829
830 /* VP (VP) = Normalize( Position ) */
831 COPY_3V( light->VP_inf_norm, light->Position );
832 NORMALIZE_3FV( light->VP_inf_norm );
833
834 /* h_inf_norm = Normalize( V_to_P + <0,0,1> ) */
835 COPY_3V( light->h_inf_norm, light->VP_inf_norm );
836 light->h_inf_norm[2] += 1.0F;
837 NORMALIZE_3FV( light->h_inf_norm );
838
839 COPY_3V( light->NormDirection, light->Direction );
840 NORMALIZE_3FV( light->NormDirection );
841
842 /* Compute color index diffuse and specular light intensities */
843 light->dli = 0.30F * light->Diffuse[0]
844 + 0.59F * light->Diffuse[1]
845 + 0.11F * light->Diffuse[2];
846 light->sli = 0.30F * light->Specular[0]
847 + 0.59F * light->Specular[1]
848 + 0.11F * light->Specular[2];
849
850 } /* loop over materials */
851 } /* loop over lights */
852
853 /* Determine if the fast lighting function can be used */
854 ctx->Light.Fast = GL_TRUE;
855 if ( ctx->Light.BaseColor[0][0]<0.0F
856 || ctx->Light.BaseColor[0][1]<0.0F
857 || ctx->Light.BaseColor[0][2]<0.0F
858 || ctx->Light.BaseColor[0][3]<0.0F
859 || ctx->Light.BaseColor[1][0]<0.0F
860 || ctx->Light.BaseColor[1][1]<0.0F
861 || ctx->Light.BaseColor[1][2]<0.0F
862 || ctx->Light.BaseColor[1][3]<0.0F
863 || ctx->Light.Model.LocalViewer
864 || ctx->Light.ColorMaterialEnabled) {
865 ctx->Light.Fast = GL_FALSE;
866 }
867 else {
868 for (light=ctx->Light.FirstEnabled; light; light=light->NextEnabled) {
869 if ( light->Position[3]!=0.0F
870 || light->SpotCutoff!=180.0F
871 || light->MatDiffuse[0][0]<0.0F
872 || light->MatDiffuse[0][1]<0.0F
873 || light->MatDiffuse[0][2]<0.0F
874 || light->MatSpecular[0][0]<0.0F
875 || light->MatSpecular[0][1]<0.0F
876 || light->MatSpecular[0][2]<0.0F
877 || light->MatDiffuse[1][0]<0.0F
878 || light->MatDiffuse[1][1]<0.0F
879 || light->MatDiffuse[1][2]<0.0F
880 || light->MatSpecular[1][0]<0.0F
881 || light->MatSpecular[1][1]<0.0F
882 || light->MatSpecular[1][2]<0.0F) {
883 ctx->Light.Fast = GL_FALSE;
884 break;
885 }
886 }
887 }
888}
MIN2
#define MIN2(A, B)
Definition: macros.h:159
NORMALIZE_3FV
#define NORMALIZE_3FV(V)
Definition: mmath.h:68
gl_light
Definition: types.h:560
gl_light::NextEnabled
struct gl_light * NextEnabled
Definition: types.h:574

Referenced by gl_reset_vb(), and gl_update_state().