Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/graphics/light.cc @ 10598

Last change on this file since 10598 was 10114, checked in by patrick, 18 years ago

merged network back to trunk

File size: 9.6 KB
Line 
1
2
3/*
4   orxonox - the future of 3D-vertical-scrollers
5
6   Copyright (C) 2004 orx
7
8   This program is free software; you can redistribute it and/or modify
9   it under the terms of the GNU General Public License as published by
10   the Free Software Foundation; either version 2, or (at your option)
11   any later version.
12
13   ### File Specific:
14   main-programmer: Benjamin Grauer
15   co-programmer: ...
16*/
17
18#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_GRAPHICS
19
20#include "light.h"
21
22#include "glincl.h"
23#include "vector.h"
24#include "util/loading/load_param_xml.h"
25#include "util/loading/factory.h"
26#include "debug.h"
27
28ObjectListDefinition(Light);
29CREATE_FACTORY(Light);
30
31//! Definition of the Lights and their Names
32int lightsV[] =
33  {
34    GL_LIGHT0,
35    GL_LIGHT1,
36    GL_LIGHT2,
37    GL_LIGHT3,
38    GL_LIGHT4,
39    GL_LIGHT5,
40    GL_LIGHT6,
41    GL_LIGHT7
42  };
43
44/**
45 * @param root The XML-element to load the Light from
46
47  @todo what to do, if no Light-Slots are open anymore ???
48 */
49Light::Light(const TiXmlElement* root)
50{
51  PRINTF(4)("initializing Light number %d.\n", this->lightNumber);
52
53  this->registerObject(this, Light::_objectList);
54
55  this->lightNumber = LightManager::getInstance()->registerLight(this);
56
57  char tmpName[10];
58  sprintf(tmpName, "Light[%d]", this->lightNumber);
59  this->setName(tmpName);
60
61  // enable The light
62  glEnable(lightsV[this->lightNumber]); // postSpawn
63
64  // set values (defaults)
65  this->setDiffuseColor(1.0, 1.0, 1.0);
66  this->setSpecularColor(1.0, 1.0, 1.0);
67
68  if (root != NULL)
69    this->loadParams(root);
70}
71
72/**
73 *  destroys a Light
74*/
75Light::~Light()
76{
77  glDisable(lightsV[this->lightNumber]);
78
79  LightManager::getInstance()->unregisterLight(this);
80}
81
82/**
83 * @param root The XML-element to load the Light from
84 */
85void Light::loadParams(const TiXmlElement* root)
86{
87  PNode::loadParams(root);
88
89  LoadParam(root, "diffuse-color", this, Light, setDiffuseColor)
90  .describe("sets the diffuse color of the Light (red [0-1], green [0-1], blue [0-1])");
91
92  LoadParam(root, "specular-color", this, Light, setSpecularColor)
93  .describe("sets the specular color of the Light (red [0-1], green [0-1], blue [0-1])");
94
95  LoadParam(root, "attenuation", this, Light, setAttenuation)
96  .describe("sets the Attenuation of the LightSource (constant Factor, linear Factor, quadratic Factor).");
97
98  LoadParam(root, "spot-direction", this, Light, setSpotDirection)
99  .describe("sets the Direction of the Spot");
100
101  LoadParam(root, "spot-cutoff", this, Light, setSpotCutoff)
102  .describe("the cuttoff of the Spotlight");
103}
104
105/**
106 *  sets an emitting Diffuse color of this Light
107 * @param r red
108 * @param g green
109 * @param b blue
110*/
111void Light::setDiffuseColor(GLfloat r, GLfloat g, GLfloat b)
112{
113  this->diffuseColor[0] = r;
114  this->diffuseColor[1] = g;
115  this->diffuseColor[2] = b;
116  this->diffuseColor[3] = 1.0;
117
118  glLightfv (lightsV[this->lightNumber], GL_DIFFUSE, this->diffuseColor);
119}
120
121/**
122 *  sets an emitting Specular color of this Light
123 * @param r red
124 * @param g green
125 * @param b blue
126*/
127void Light::setSpecularColor(GLfloat r, GLfloat g, GLfloat b)
128{
129  this->specularColor[0] = r;
130  this->specularColor[1] = g;
131  this->specularColor[2] = b;
132  this->specularColor[3] = 1.0;
133
134  glLightfv (lightsV[this->lightNumber], GL_SPECULAR, this->specularColor);
135}
136
137
138/**
139 *  Sets the AttenuationType of this Light Source
140 * @param constantAttenuation The Constant Attenuation of the Light
141 * @param linearAttenuation The Linear Attenuation of the Light
142 * @param quadraticAttenuation The Quadratic Attenuation of the Light
143*/
144void Light::setAttenuation(float constantAttenuation, float linearAttenuation, float quadraticAttenuation)
145{
146  this->constantAttenuation  = constantAttenuation;
147  this->linearAttenuation    = linearAttenuation;
148  this->quadraticAttenuation = quadraticAttenuation;
149
150  glLightf(lightsV[this->lightNumber], GL_CONSTANT_ATTENUATION,  constantAttenuation);
151  glLightf(lightsV[this->lightNumber], GL_LINEAR_ATTENUATION,    linearAttenuation);
152  glLightf(lightsV[this->lightNumber], GL_QUADRATIC_ATTENUATION, quadraticAttenuation);
153}
154
155
156/**
157 *  stets the direction of the Spot Light.
158 * @param direction The direction of the Spot Light.
159*/
160void Light::setSpotDirection(const Vector& direction)
161{
162  this->spotDirection[0] = direction.x;
163  this->spotDirection[1] = direction.y;
164  this->spotDirection[2] = direction.z;
165
166  glLightfv(lightsV[this->lightNumber], GL_SPOT_DIRECTION, this->spotDirection);
167}
168
169
170/**
171 *  sets the cutoff angle of the Light.
172 * @param cutoff The cutoff angle.
173*/
174void Light::setSpotCutoff(GLfloat cutoff)
175{
176  this->spotCutoff = cutoff;
177  glLightf(lightsV[this->lightNumber], GL_SPOT_CUTOFF, cutoff);
178}
179
180/**
181 *  draws this Light. Being a World-entity the possibility to do this lies at hand.
182*/
183void Light::draw() const
184{
185  float pos[4] = {this->getAbsCoor().x, this->getAbsCoor().y, this->getAbsCoor().z, 1.0};
186  PRINTF(4)("Drawing The Lights new Position at %f %f %f\n", pos[0], pos[1], pos[2]);
187  glLightfv(lightsV[this->lightNumber], GL_POSITION, pos);
188}
189
190
191/**
192 *  Prints out some nice formated debug information about the Light
193*/
194void Light::debug() const
195{
196  PRINT(0)(":: %d ::  -- reference %p\n", this->lightNumber, this);
197  PRINT(0)(" GL-state: ");
198  GLboolean param;
199  glGetBooleanv(lightsV[this->lightNumber], &param);
200  if (param)
201    PRINT(0)("ON\n");
202  else
203    PRINT(0)("OFF\n");
204
205  PRINT(0)(" DiffuseColor:  %f/%f/%f\n", this->diffuseColor[0], this->diffuseColor[1], this->diffuseColor[2]);
206  PRINT(0)(" SpecularColor: %f/%f/%f\n", this->specularColor[0], this->specularColor[1], this->specularColor[2]);
207  PRINT(0)(" Attenuation: constant=%f linear=%f quadratic=%f\n", this->constantAttenuation, this->linearAttenuation, this->quadraticAttenuation);
208}
209
210
211/******************
212** LIGHT-MANAGER **
213******************/
214ObjectListDefinition(LightManager);
215/**
216 *  standard constructor for a Light
217*/
218LightManager::LightManager ()
219{
220  this->registerObject(this, LightManager::_objectList);
221
222  glEnable (GL_LIGHTING);
223  glEnable ( GL_COLOR_MATERIAL ) ;
224  glColorMaterial ( GL_FRONT, GL_DIFFUSE ) ;
225
226  this->setAmbientColor(.3, .3, .3);
227  this->lights = new Light*[NUMBEROFLIGHTS];
228  for (int i = 0; i < NUMBEROFLIGHTS; i++)
229    lights[i] = NULL;
230  this->currentLight = NULL;
231}
232
233/**
234 *  standard deconstructor
235
236   first disables Lighting
237
238   then deletes the rest of the allocated memory
239   and in the end sets the singleton Reference to zero.
240*/
241LightManager::~LightManager ()
242{
243  glDisable(GL_COLOR_MATERIAL);
244  glDisable(GL_LIGHTING);
245  this->setAmbientColor(.0,.0,.0);
246
247  for (int i = 0; i < NUMBEROFLIGHTS; i++)
248    if (this->lights[i] != NULL)
249      delete lights[i];
250  delete[] lights;
251  LightManager::singletonRef = NULL;
252}
253
254/**
255 *  singleton-Reference to the Light-class
256*/
257LightManager* LightManager::singletonRef = NULL;
258
259/**
260* @param root the XML-element to load the LightManager's settings from
261 */
262void LightManager::loadParams(const TiXmlElement* root)
263{
264  LoadParamXML(root, "Lights", this, LightManager, loadLights)
265  .describe("an XML-Element to load lights from.");
266
267  LoadParam(root, "ambient-color", this, LightManager, setAmbientColor)
268  .describe("sets the ambient Color of the Environmental Light");
269}
270
271/**
272* @param root The XML-element to load Lights from
273 */
274void LightManager::loadLights(const TiXmlElement* root)
275{
276  const TiXmlElement* element = root->FirstChildElement();
277
278  while (element != NULL)
279  {
280    Factory::fabricate(element);
281
282    element = element->NextSiblingElement();
283  }
284}
285
286// set Attributes
287/**
288 *  sets the ambient Color of the Scene
289 * @param r red
290 * @param g green
291 * @param b blue
292*/
293void LightManager::setAmbientColor(GLfloat r, GLfloat g, GLfloat b)
294{
295  this->ambientColor[0] = r;
296  this->ambientColor[1] = g;
297  this->ambientColor[2] = b;
298  this->ambientColor[3] = 1.0;
299
300  glLightfv (GL_LIGHT0, GL_AMBIENT, this->ambientColor);
301}
302
303/**
304* @param light the Light to register to the LightManager
305
306  This is done explicitely by the constructor of a Light
307*/
308int LightManager::registerLight(Light* light)
309{
310  for (int i = 0; i < NUMBEROFLIGHTS; i++)
311    if (!this->lights[i])
312    {
313      this->lights[i]=light;
314      return i;
315    }
316  PRINTF(1)("no more light slots availiable. All %d already taken\n", NUMBEROFLIGHTS);
317  return -1;
318}
319
320/**
321* @param light The light to unregister from the LightManager
322
323  This is done every time a Light is destroyed explicitely by the Light-destructor
324 */
325void LightManager::unregisterLight(Light* light)
326{
327  for (int i = 0; i < NUMBEROFLIGHTS; i++)
328  {
329    if (this->lights[i] == light)
330    {
331      this->lights[i] = NULL;
332      return;
333    }
334  }
335  PRINTF(2)("Light %p could not be unloaded (this should not heappen\n)");
336  return;
337}
338
339
340Light* LightManager::getLight(int lightNumber) const
341{
342  if( lightNumber < NUMBEROFLIGHTS)
343    return this->lights[lightNumber];
344
345  return NULL;
346}
347
348/**
349 *  draws all the Lights in their appropriate position
350 */
351void LightManager::draw() const
352{
353  PRINTF(4)("Drawing the Lights\n");
354  for (int i = 0; i < NUMBEROFLIGHTS; i++)
355    if (this->lights[i] != NULL)
356      lights[i]->draw();
357}
358
359/**
360 *  outputs debug information about the Class and its lights
361*/
362void LightManager::debug() const
363{
364  PRINT(0)("=================================\n");
365  PRINT(0)("= DEBUG INFORMATION CLASS LIGHT =\n");
366  PRINT(0)("=================================\n");
367  PRINT(0)("Reference: %p\n", LightManager::singletonRef);
368  if (this->currentLight)
369    PRINT(0)("current Light Nr: %d\n", this->currentLight->getLightNumber());
370  PRINT(0)("Ambient Color: %f:%f:%f\n", this->ambientColor[0], this->ambientColor[0], this->ambientColor[0]);
371  PRINT(0)("=== Lights ===\n");
372  for (int i = 0; i < NUMBEROFLIGHTS; i++)
373    if (this->lights[i])
374    {
375      this->lights[i]->debug();
376    }
377  PRINT(0)("-----------------------------LM-\n");
378}
Note: See TracBrowser for help on using the repository browser.