Developer Documentation

LightNode.cc
1 /*===========================================================================*\
2 * *
3 * OpenFlipper *
4 * Copyright (c) 2001-2015, RWTH-Aachen University *
5 * Department of Computer Graphics and Multimedia *
6 * All rights reserved. *
7 * www.openflipper.org *
8 * *
9 *---------------------------------------------------------------------------*
10 * This file is part of OpenFlipper. *
11 *---------------------------------------------------------------------------*
12 * *
13 * Redistribution and use in source and binary forms, with or without *
14 * modification, are permitted provided that the following conditions *
15 * are met: *
16 * *
17 * 1. Redistributions of source code must retain the above copyright notice, *
18 * this list of conditions and the following disclaimer. *
19 * *
20 * 2. Redistributions in binary form must reproduce the above copyright *
21 * notice, this list of conditions and the following disclaimer in the *
22 * documentation and/or other materials provided with the distribution. *
23 * *
24 * 3. Neither the name of the copyright holder nor the names of its *
25 * contributors may be used to endorse or promote products derived from *
26 * this software without specific prior written permission. *
27 * *
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS *
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
30 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
31 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
32 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, *
33 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, *
34 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR *
35 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
36 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING *
37 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
38 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
39 * *
40 \*===========================================================================*/
41
42
43
44
45
46
47 //=============================================================================
48 //
49 // CLASS LightNode - IMPLEMENTATION
50 //
51 //=============================================================================
52
53
54 //== INCLUDES =================================================================
55
56
57 #include "LightNode.hh"
58 #include <ACG/GL/IRenderer.hh>
59
60 #ifndef M_PI
61 #define M_PI 3.14159265358979323846
62 #endif
63
64 //== NAMESPACES ===============================================================
65
66 namespace ACG {
67 namespace SceneGraph {
68
69 //== IMPLEMENTATION ==========================================================
70
71 static LightSourceHandle* lightSourceHandle = 0;
72
73 //default Constructor
74 LightSource::LightSource()
75 {
76 // set OpenGL defaults
77 enabled_ = false;
78 fixedPosition_ = false;
79
80 ambientColor_ = Vec4f(0.1f,0.1f,0.1f,1.f);
81 diffuseColor_ = Vec4f(1.f,1.f,1.f,1.f);
82 specularColor_ = Vec4f(1.f,1.f,1.f,1.f);
83
84 position_ = Vec4f(0.f,0.f,1.f,0.f);
85 realPosition_ = Vec4f(0.f,0.f,1.f,0.f);
86
87 spotDirection_ = Vec3d(0.0,0.0,-1.0);
88 realSpotDirection_ = Vec3d(0.0,0.0,-1.0);
89
90 // Holds initial light source position
91 // converted to camera coordinates
92 initialPosition_ = Vec4f(0.f, 0.f, 0.f, 0.f);
93 initialSpotDirection_ = Vec3d(0.0, 0.0, -1.0);
94 initialPositionInit_ = false;
95
96 spotExponent_ = 0;
97 spotCutoff_ = 180;
98
99 constantAttenuation_ = 1;
100 linearAttenuation_ = 0;
101 quadraticAttenuation_ = 0;
102
103 brightness_ = 1.0f;
104
105 radius_ = 0.1f;
106 }
107
108 void LightSource::position( Vec3d _pos){
109 // Set homogeneous coordinte to 1.0 to get a positional light source
110 position_ = Vec4d( _pos[0],_pos[1],_pos[2],1.0);
111 }
112
113 Vec3d LightSource::position() const {
114 return Vec3d( position_[0], position_[1], position_[2]);
115 }
116
117 void LightSource::direction( Vec3d _pos) {
118 // Set homogeneous coordinate of position to 0.0 to tell OpenGL
119 // that this is a directional light source
120 position_ = Vec4d( _pos[0],_pos[1],_pos[2],0.0);
121 }
122
123 Vec3d LightSource::direction() const {
124 return Vec3d(position_[0], position_[1], position_[2]);
125 }
126
127 bool LightSource::directional() const {
128 return ( position_[3] == 0.0 );
129 }
130
131 void LightSource::enable()
132 { enabled_ = true; }
133
134 void LightSource::disable()
135 { enabled_ = false; }
136
137 bool LightSource::enabled() const {
138 return enabled_;
139 }
140
141 void LightSource::spotDirection( Vec3d _pos)
142 { spotDirection_ = _pos; }
143
144 Vec3d LightSource::spotDirection( ) const {
145 return Vec3d(spotDirection_[0],spotDirection_[1],spotDirection_[2]);
146 }
147
148 void LightSource::ambientColor( Vec4f _color)
149 { ambientColor_ = _color; }
150
151 Vec4f LightSource::ambientColor() const
152 { return ambientColor_; }
153
154 void LightSource::diffuseColor( Vec4f _color)
155 { diffuseColor_ = _color; }
156
157 Vec4f LightSource::diffuseColor() const
158 { return diffuseColor_; }
159
160 void LightSource::specularColor( Vec4f _color)
161 { specularColor_ = _color; }
162
163 Vec4f LightSource::specularColor() const
164 { return specularColor_; }
165
166 void LightSource::setColor(const Vec4f& _ambient, const Vec4f& _diffuse, const Vec4f& _specular) {
167 ambientColor_ = _ambient;
168 diffuseColor_ = _diffuse;
169 specularColor_ = _specular;
170 }
171
172 void LightSource::fixedPosition( bool _state)
173 { fixedPosition_ = _state; }
174
175 bool LightSource::fixedPosition() const {
176 return fixedPosition_;
177 }
178
179 void LightSource::spotExponent(float _exponent) {
180 spotExponent_ = _exponent;
181 }
182
183 float LightSource::spotExponent() const {
184 return spotExponent_;
185 }
186
187 void LightSource::spotCutoff(float _cutoff) {
188 spotCutoff_ = _cutoff;
189 }
190
191 float LightSource::spotCutoff() const {
192 return spotCutoff_;
193 }
194
195 void LightSource::constantAttenuation(float _constantAttenuation) {
196 constantAttenuation_ = _constantAttenuation;
197 }
198
199 float LightSource::constantAttenuation() const {
200 return constantAttenuation_;
201 }
202
203 void LightSource::linearAttenuation(float _linearAttenuation) {
204 linearAttenuation_ = _linearAttenuation;
205 }
206
207 float LightSource::linearAttenuation() const {
208 return linearAttenuation_;
209 }
210
211 void LightSource::quadraticAttenuation(float _quadraticAttenuation) {
212 quadraticAttenuation_ = _quadraticAttenuation;
213 }
214
215 float LightSource::quadraticAttenuation() const {
216 return quadraticAttenuation_;
217 }
218
219 void LightSource::brightness(float _brightness) {
220 brightness_ = _brightness;
221 }
222
223 float LightSource::brightness() const {
224 return brightness_;
225 }
226
227 LightNode::LightNode( BaseNode* _parent,
228 const std::string& _name)
229 : BaseNode(_parent, _name),
230 visualize_(false),
231 lightId_(GL_INVALID_ENUM) {
232
233 if(lightSourceHandle == 0) {
234 lightSourceHandle = new LightSourceHandle();
235 }
236
237 sphere_ = new ACG::GLSphere(10, 10);
238 cone_ = new ACG::GLCone(10, 10, 1.0f, 1.0f, false, true);
239 }
240
241 //----------------------------------------------------------------------------
242
243 LightNode::~LightNode() {
244 if (sphere_)
245 delete sphere_;
246
247 if (cone_)
248 delete cone_;
249 }
250
251 //----------------------------------------------------------------------------
252
253 void LightNode::getLightSource(LightSource* _light) const
254 {
255 memcpy(_light, &light_, sizeof(LightSource));
256 }
257
258 //----------------------------------------------------------------------------
259
260 void LightNode::getLightSourceViewSpace( LightSource* _light ) const
261 {
262 memcpy(_light, &transformedLight_, sizeof(LightSource));
263 }
264
265 //----------------------------------------------------------------------------
266
267 void LightNode::boundingBox(ACG::Vec3d& _bbMin, ACG::Vec3d& _bbMax) {
268
269 if( visualize_ && !light_.directional() ) {
270 ACG::Vec3d r;
271 if(light_.fixedPosition())
272 r = ACG::Vec3d((double)light_.realPosition_[0],
273 (double)light_.realPosition_[1],
274 (double)light_.realPosition_[2]);
275 else
276 r = light_.position();
277 _bbMin.minimize( r - Vec3d(light_.radius()*3) );
278 _bbMax.maximize( r + Vec3d(light_.radius()*3) );
279 }
280 }
281
282 //----------------------------------------------------------------------------
283
284 void LightNode::draw(GLState& _state, const DrawModes::DrawMode& /*_drawMode*/) {
285
286 // Visualize light node
287 if(visualize_ && !light_.directional()) {
288
289 // Get initial camera coords of light if in fixed
290 // mode and if they haven't been computed yet
291 if(light_.fixedPosition_ && !light_.initialPositionInit_) {
292 light_.initialPosition_ = _state.modelview() * light_.position_;
293 light_.initialSpotDirection_ = _state.modelview().transform_vector(light_.spotDirection());
294 light_.initialPositionInit_ = true;
295 }
296
297 if(light_.fixedPosition_) {
298 light_.realPosition_ = _state.inverse_modelview() * light_.initialPosition_;
299 light_.realSpotDirection_ = _state.inverse_modelview().transform_vector(light_.initialSpotDirection_);
300 } else {
301 light_.realPosition_ = light_.position_;
302 light_.realSpotDirection_ = light_.spotDirection_;
303 }
304
305 ACG::Vec3f p = ACG::Vec3f(light_.realPosition_[0],
306 light_.realPosition_[1],
307 light_.realPosition_[2]);
308 ACG::Vec3d spotDir = light_.realSpotDirection_;
309
310 ACG::Vec4f ac = light_.ambientColor();
311 ACG::Vec4f dc = light_.diffuseColor();
312 ACG::Vec4f sc = light_.specularColor();
313
314 // Make light sources appear as bright as possible
315 float max = 0;
316 for(int i = 0; i < 3; ++i) {
317 if(ac[i] > max) max = ac[i];
318 }
319 ac += ACG::Vec4f(1.0f - max);
320 max = 0;
321 for(int i = 0; i < 3; ++i) {
322 if(dc[i] > max) max = dc[i];
323 }
324 dc += ACG::Vec4f(1.0f - max);
325 max = 0;
326 for(int i = 0; i < 3; ++i) {
327 if(sc[i] > max) max = sc[i];
328 }
329 sc += ACG::Vec4f(1.0f - max);
330
331 // Backup variables
332 GLboolean lighting_backup;
333
334 // Origin
335 _state.push_modelview_matrix();
336 // Transform to light origin and direction
337 _state.translate(p[0], p[1], p[2]);
338
339 // Set lighting
340 glGetBooleanv(GL_LIGHTING, &lighting_backup);
341 ACG::GLState::enable(GL_LIGHTING);
342
343 // Make light directional just for the drawing
344 // of itself
345 bool backup_directional = light_.directional();
346 ACG::Vec3d backup_position = light_.position();
347
348 // Get light id
349 lightId_ = lightSourceHandle->getLight(this);
350
351 // Return if we don't have a valid light source
352 if(lightId_ == GL_INVALID_ENUM) {
353
354 // Reset all stored attributes before returning
355 if(!lighting_backup) ACG::GLState::disable(GL_LIGHTING);
356
357 _state.pop_modelview_matrix();
358
359 return;
360 }
361
362 glLightf(lightId_, GL_SPOT_EXPONENT, 0.0f);
363 float pos[4];
364 pos [0] = backup_position[0];
365 pos [1] = backup_position[1];
366 pos [2] = backup_position[2];
367 pos [3] = 0.0f;
368
369 glLightfv(lightId_, GL_POSITION, pos);
370
371 // Set colors
372 float gl_ac[] = {ac[0], ac[1], ac[2], ac[3]};
373 glLightfv(lightId_, GL_AMBIENT, gl_ac);
374 float gl_dc[] = {dc[0], dc[1], dc[2], dc[3]};
375 glLightfv(lightId_, GL_DIFFUSE, gl_dc);
376 float gl_sc[] = {sc[0], sc[1], sc[2], sc[3]};
377 glLightfv(lightId_, GL_SPECULAR, gl_sc);
378
379 ACG::GLState::enable(lightId_);
380
381 sphere_->draw(_state, light_.radius());
382
383 // Visualize spot cone (or direction)
384 if(light_.spotCutoff() < 180.0f) {
385 // Note: if the cutoff angle is 180, the light source
386 // is a point light emitting light into all directions equally
387
388 // Rotate into light direction
389 ACG::Vec3d z = ACG::Vec3d(0.0f, 0.0f, 1.0f);
390 ACG::Vec3d spot = spotDir;
391 float angle = acos((z | spot)/(z.norm()*spot.norm()));
392 angle = angle*360/(2*M_PI);
393 ACG::Vec3d rA = z % spot;
394 _state.rotate(angle, rA[0], rA[1], rA[2]);
395
396 // Inverse normal orientation
397 cone_->setNormalOrientation(ACG::GLPrimitive::INSIDE);
398 cone_->setBottomRadius(light_.radius()/6.0f);
399 cone_->setTopRadius(light_.radius()/6.0f);
400 cone_->draw(_state, light_.radius()*2.0f);
401 _state.translate(0.0, 0.0, light_.radius()*2);
402 // Draw arrow tip
403 cone_->setBottomRadius(light_.radius()/2.0f);
404 cone_->setTopRadius(0.0f);
405 cone_->draw(_state, light_.radius());
406 }
407
408 // Free light id
409 lightSourceHandle->removeLight(this);
410
411 // Undo state changes
412
413 if(!backup_directional) {
414 light_.position(backup_position);
415 }
416
417 // Lighting
418 if(!lighting_backup) ACG::GLState::disable(GL_LIGHTING);
419
420 _state.pop_modelview_matrix();
421 }
422
423 }
424
425 void LightNode::pick(GLState& _state, PickTarget _target) {
426
427 GLenum prev_depth = _state.depthFunc();
428
429 if (_target == PICK_FACE ||
430 _target == PICK_ANYTHING) {
431
432 // Visualize light node
433 if(visualize_ && !light_.directional()) {
434
435 // Get initial camera coords of light if in fixed
436 // mode and if they haven't been computed yet
437 if(light_.fixedPosition_ && !light_.initialPositionInit_) {
438 light_.initialPosition_ = _state.modelview() * light_.position_;
439 light_.initialSpotDirection_ = _state.modelview().transform_vector(light_.spotDirection());
440 light_.initialPositionInit_ = true;
441 }
442
443 if(light_.fixedPosition_) {
444 light_.realPosition_ = _state.inverse_modelview() * light_.initialPosition_;
445 light_.realSpotDirection_ = _state.inverse_modelview().transform_vector(light_.initialSpotDirection_);
446 } else {
447 light_.realPosition_ = light_.position_;
448 light_.realSpotDirection_ = light_.spotDirection_;
449 }
450
451 // Enable depth test but store original status
452 glPushAttrib(GL_DEPTH_BUFFER_BIT);
453 ACG::GLState::enable(GL_DEPTH_TEST);
454 ACG::GLState::depthFunc(GL_LEQUAL);
455
456 _state.pick_set_maximum(1);
457 _state.pick_set_name(0);
458
459 ACG::Vec3f p = ACG::Vec3f(light_.realPosition_[0],
460 light_.realPosition_[1],
461 light_.realPosition_[2]);
462 ACG::Vec3d spotDir = light_.realSpotDirection_;
463
464 // Origin
465 _state.push_modelview_matrix();
466 // Transform to light origin and direction
467 _state.translate(p[0], p[1], p[2]);
468
469 sphere_->draw(_state, light_.radius());
470
471 // Visualize spot cone (or direction)
472 if(light_.spotCutoff() < 180.0f) {
473 // Note: if the cutoff angle is 180, the light source
474 // is a point light emitting light into all directions equally
475
476 // Rotate into light direction
477 ACG::Vec3d z = ACG::Vec3d(0.0f, 0.0f, 1.0f);
478 ACG::Vec3d spot = spotDir;
479 float angle = acos((z | spot)/(z.norm()*spot.norm()));
480 angle = angle*360/(2*M_PI);
481 ACG::Vec3d rA = z % spot;
482 _state.rotate(angle, rA[0], rA[1], rA[2]);
483
484 cone_->setNormalOrientation(ACG::GLPrimitive::OUTSIDE);
485 cone_->setBottomRadius(light_.radius()/6.0f);
486 cone_->setTopRadius(light_.radius()/6.0f);
487 cone_->draw(_state, light_.radius()*2.0f);
488 _state.translate(0.0, 0.0, light_.radius()*2);
489 // Draw arrow tip
490 cone_->setBottomRadius(light_.radius()/2.0f);
491 cone_->setTopRadius(0.0f);
492 cone_->draw(_state, light_.radius());
493 }
494
495 _state.pop_modelview_matrix();
496
497 ACG::GLState::depthFunc(prev_depth);
498 }
499 }
500 }
501
502 void LightNode::enter(GLState& _state, const DrawModes::DrawMode& /* _drawmode */ )
503 {
504 if(visualize_) return;
505
506 // Get initial camera coords of light if in fixed
507 // mode and if they haven't been computed yet
508 if(light_.fixedPosition_ && !light_.initialPositionInit_) {
509 light_.initialPosition_ = _state.modelview() * light_.position_;
510 light_.initialSpotDirection_ = _state.modelview().transform_vector(light_.spotDirection());
511 light_.initialPositionInit_ = true;
512 }
513
514 // Get light id
515 lightId_ = lightSourceHandle->getLight(this);
516
517 // Return if we don't have a valid light source
518 if(lightId_ == GL_INVALID_ENUM) return;
519
521 getParameters(_state, lightId_, lightSave_);
522
523 if(_state.compatibilityProfile())
524 {
525 // save old light
526 lightSave_.enabled_ = glIsEnabled(lightId_);
527 }
528
529 if(light_.enabled_ ) {
530 // correct Position for fixed Lights
531 if(light_.fixedPosition_) {
532 light_.realPosition_ = _state.inverse_modelview() * light_.initialPosition_;
533 light_.realSpotDirection_ = _state.inverse_modelview().transform_vector(light_.initialSpotDirection_);
534 //std::cerr << "New Light pos :" << _state.inverse_modelview().transform_vector(light_.position) << std::endl;
535 } else {
536 light_.realPosition_ = light_.position_;
537 light_.realSpotDirection_ = light_.spotDirection_;
538 //std::cerr << "New Light pos :" << light_.position << std::endl;
539 }
540
541 // transform to view space for shader pipeline
542 transformedLight_ = light_;
543 transformedLight_.position_ = _state.modelview() * light_.realPosition_;
544 transformedLight_.spotDirection_ = _state.modelview().transform_vector(light_.realSpotDirection_);
545
546 if (_state.compatibilityProfile()) {
547 ACG::GLState::enable(lightId_);
548 setParameters(_state, lightId_, light_);
549 }
550 } else {
551 if (_state.compatibilityProfile())
552 ACG::GLState::disable(lightId_);
553 }
554 }
555
556
557 //----------------------------------------------------------------------------
558
559
560 void LightNode::leave(GLState& _state , const DrawModes::DrawMode& /* _drawmode*/ )
561 {
562 if(visualize_) return;
563
564 // Return if we don't have a valid light source
565 if(lightId_ == GL_INVALID_ENUM) return;
566
567 if (_state.compatibilityProfile()) {
568 // restore old enabled light
569 if (lightSave_.enabled_) {
570 ACG::GLState::enable(lightId_);
571 setParameters(_state, lightId_, lightSave_);
572 }
573 else {
574 ACG::GLState::disable(lightId_);
575 }
576 }
577
578 // Free light id
579 lightSourceHandle->removeLight(this);
580 }
581
582 //----------------------------------------------------------------------------
583
584 void LightNode::setParameters(GLState& _state, GLenum _index, LightSource& _light)
585 {
586 if (_state.compatibilityProfile()) {
587
588 // Multiply colors by brightness
589 Vec4f& a = _light.ambientColor_;
590 GLfloat ambient[4] = { a[0] * _light.brightness_,
591 a[1] * _light.brightness_,
592 a[2] * _light.brightness_,
593 a[3] * _light.brightness_ };
594
595 Vec4f& d = _light.diffuseColor_;
596 GLfloat diffuse[4] = { d[0] * _light.brightness_,
597 d[1] * _light.brightness_,
598 d[2] * _light.brightness_,
599 d[3] * _light.brightness_ };
600
601 Vec4f& s = _light.specularColor_;
602 GLfloat specular[4] = { s[0] * _light.brightness_,
603 s[1] * _light.brightness_,
604 s[2] * _light.brightness_,
605 s[3] * _light.brightness_ };
606
607 Vec3d& sd = _light.realSpotDirection_;
608
609 bool directional = _light.directional();
610
611 Vec4f& p = _light.realPosition_;
612 GLfloat realPos[4] = { (float)p[0], (float)p[1], (float)p[2], (directional ? 0.0f : 1.0f) };
613
614 // set preferences of _light for GL_LIGHT#_index
615 glLightfv(_index, GL_AMBIENT, ambient);
616 glLightfv(_index, GL_DIFFUSE, diffuse);
617 glLightfv(_index, GL_SPECULAR, specular);
618
619 glLightfv(_index, GL_POSITION, realPos);
620
621 if (!directional) {
622 GLfloat dir[3] = { (float)sd[0], (float)sd[1], (float)sd[2] };
623 glLightfv(_index, GL_SPOT_DIRECTION, dir);
624 }
625
626 if (!directional) glLightf(_index, GL_SPOT_EXPONENT, _light.spotExponent_);
627 if (!directional) glLightf(_index, GL_SPOT_CUTOFF, _light.spotCutoff_);
628
629 glLightf(_index, GL_CONSTANT_ATTENUATION, _light.constantAttenuation_);
630 glLightf(_index, GL_LINEAR_ATTENUATION, _light.linearAttenuation_);
631 glLightf(_index, GL_QUADRATIC_ATTENUATION, _light.quadraticAttenuation_);
632 }
633 }
634
635 //----------------------------------------------------------------------------
636
637 void LightNode::getParameters(GLState& _state, GLenum _index, LightSource& _light)
638 {
639 if (_state.compatibilityProfile()) {
640 // get preferences of GL_LIGHT#_index and store them in _light
641 glGetLightfv(_index, GL_AMBIENT, (GLfloat *)_light.ambientColor_.data());
642 glGetLightfv(_index, GL_DIFFUSE, (GLfloat *)_light.diffuseColor_.data());
643 glGetLightfv(_index, GL_SPECULAR, (GLfloat *)_light.specularColor_.data());
644 glGetLightfv(_index, GL_POSITION, (GLfloat *)_light.position_.data());
645 glGetLightfv(_index, GL_SPOT_DIRECTION, (GLfloat *)_light.spotDirection_.data());
646
647 glGetLightfv(_index, GL_SPOT_EXPONENT, &_light.spotExponent_);
648 glGetLightfv(_index, GL_SPOT_CUTOFF, &_light.spotCutoff_);
649 glGetLightfv(_index, GL_CONSTANT_ATTENUATION, &_light.constantAttenuation_);
650 glGetLightfv(_index, GL_LINEAR_ATTENUATION, &_light.linearAttenuation_);
651 glGetLightfv(_index, GL_QUADRATIC_ATTENUATION, &_light.quadraticAttenuation_);
652 }
653 }
654
655
656 void LightNode::getRenderObjects( IRenderer* _renderer, GLState& _state , const DrawModes::DrawMode& _drawMode , const Material* _mat )
657 {
658
659 // fill IRenderer light struct with light data in view-space
660 IRenderer::LightData light;
661
662 if (transformedLight_.directional())
663 light.ltype = ACG::SG_LIGHT_DIRECTIONAL;
664 else if (transformedLight_.spotCutoff() > 179.5f)
665 light.ltype = ACG::SG_LIGHT_POINT;
666 else
667 light.ltype = ACG::SG_LIGHT_SPOT;
668
669 #define V4toV3(v) (ACG::Vec3f(v[0], v[1], v[2]))
670
671 light.diffuse = V4toV3(transformedLight_.diffuseColor());
672 light.ambient = V4toV3(transformedLight_.ambientColor());
673 light.specular = V4toV3(transformedLight_.specularColor());
674
675 light.pos = V4toV3(transformedLight_.position());
676 light.dir = V4toV3(transformedLight_.direction());
677
678 light.atten[0] = transformedLight_.constantAttenuation();
679 light.atten[1] = transformedLight_.linearAttenuation();
680 light.atten[2] = transformedLight_.quadraticAttenuation();
681
682 light.spotCutoffExponent[0] = transformedLight_.spotCutoff();
683 light.spotCutoffExponent[1] = transformedLight_.spotExponent();
684
685 _renderer->addLight(light);
686
687 }
688
689 //=============================================================================
690 } // namespace SceneGraph
691 } // namespace ACG
692 //=============================================================================
OpenMesh::VectorT::maximize
vector_type & maximize(const vector_type &_rhs)
maximize values: same as *this = max(*this, _rhs), but faster
Definition: Vector11T.hh:563
ACG
Namespace providing different geometric functions concerning angles.
Definition: BaseObjectData.hh:68
ACG::SceneGraph::LightSource::radius_
float radius_
Definition: LightNode.hh:245
ACG::GLCone
Definition: GLPrimitives.hh:169
ACG::GLState::inverse_modelview
const GLMatrixd & inverse_modelview() const
get inverse modelview matrix
Definition: GLState.hh:811
ACG::SceneGraph::LightNode::leave
void leave(GLState &_state, const DrawModes::DrawMode &_drawmode)
restores original Light Sources
Definition: LightNode.cc:560
ACG::SceneGraph::LightSource::specularColor
Vec4f specularColor() const
get Specular color for LightSource
Definition: LightNode.cc:163
ACG::SceneGraph::LightNode::light_
LightSource light_
store LightSources of this node
Definition: LightNode.hh:311
ACG::SceneGraph::PICK_ANYTHING
pick any of the prior targets (should be implemented for all nodes)
Definition: PickTarget.hh:84
ACG::SceneGraph::LightSource::directional
bool directional() const
Check if the light source is a directional light source.
Definition: LightNode.cc:127
OpenMesh::VectorT::norm
auto norm() const -> decltype(std::sqrt(std::declval< VectorT< S, DIM >>().sqrnorm()))
compute euclidean norm
Definition: Vector11T.hh:409
ACG::SceneGraph::LightSource::spotDirection
void spotDirection(Vec3d _pos)
Set spot direction.
Definition: LightNode.cc:141
ACG::GLState::push_modelview_matrix
void push_modelview_matrix()
push modelview matrix
Definition: GLState.cc:1010
ACG::Vec3f
VectorT< float, 3 > Vec3f
Definition: VectorT.hh:119
ACG::SceneGraph::LightSource::specularColor
void specularColor(Vec4f _color)
set Specular color for LightSource
Definition: LightNode.cc:160
ACG::GLState::depthFunc
const GLenum & depthFunc() const
get glDepthFunc() that is supposed to be active
Definition: GLState.cc:941
ACG::SceneGraph::ACG::GLState::enable
static void enable(GLenum _cap, bool _warnRemoved=true)
replaces glEnable, but supports locking
ACG::SceneGraph::LightNode::LightNode
LightNode(BaseNode *_parent=0, const std::string &_name="<LightNode>")
Default constructor. Applies all properties.
Definition: LightNode.cc:227
ACG::Vec4f
VectorT< float, 4 > Vec4f
Definition: VectorT.hh:138
ACG::SceneGraph::LightSource::enable
void enable()
enable LightSource
Definition: LightNode.cc:131
ACG::GLState::translate
void translate(double _x, double _y, double _z, MultiplyFrom _mult_from=MULT_FROM_RIGHT)
translate by (_x, _y, _z)
Definition: GLState.cc:533
ACG::IRenderer::addLight
virtual void addLight(const LightData &_light)
Callback for the scenegraph nodes, which send new lights to the renderer via this function...
Definition: IRenderer.cc:1184
ACG::SceneGraph::ACG::GLState::disable
static void disable(GLenum _cap, bool _warnRemoved=true)
replaces glDisable, but supports locking
ACG::SceneGraph::LightSource::position
Vec3d position() const
Get the position of the LightSource.
Definition: LightNode.cc:113
OpenMesh::VectorT::data
Scalar * data()
access to Scalar array
Definition: Vector11T.hh:195
ACG::SceneGraph::LightNode::getLightSourceViewSpace
void getLightSourceViewSpace(LightSource *_light) const
Definition: LightNode.cc:260
ACG::SceneGraph::LightNode::transformedLight_
LightSource transformedLight_
pretransformed light position and direction in view space
Definition: LightNode.hh:314
ACG::GLState
Definition: GLState.hh:213
ACG::SceneGraph::LightSource::fixedPosition
void fixedPosition(bool _state)
make LightSource fixed or moveable with ModelViewMatrix
Definition: LightNode.cc:172
ACG::SceneGraph::LightNode::getRenderObjects
void getRenderObjects(IRenderer *_renderer, GLState &_state, const DrawModes::DrawMode &_drawMode, const Material *_mat)
Add this light to shader render interface.
Definition: LightNode.cc:656
ACG::SceneGraph::LightNode::lightSave_
LightSource lightSave_
save old LightSources
Definition: LightNode.hh:317
ACG::SceneGraph::LightNode::pick
void pick(GLState &_state, PickTarget _target)
Picking.
Definition: LightNode.cc:425
ACG::SceneGraph::LightSource::spotDirection
Vec3d spotDirection() const
get spot direction
Definition: LightNode.cc:144
ACG::IRenderer::LightData
Definition: IRenderer.hh:104
ACG::Vec3d
VectorT< double, 3 > Vec3d
Definition: VectorT.hh:121
ACG::SceneGraph::LightSource::disable
void disable()
disable LightSource
Definition: LightNode.cc:134
ACG::SceneGraph::LightNode::getParameters
void getParameters(GLState &_state, GLenum _index, LightSource &_light)
get _light Options in OpenGL for GL_LIGHT::_index
Definition: LightNode.cc:637
ACG::SceneGraph::LightSource
Structure to hold options for one LightSource.
Definition: LightNode.hh:85
ACG::SceneGraph::LightNode::draw
void draw(GLState &_state, const DrawModes::DrawMode &_drawMode)
Draw light source node.
Definition: LightNode.cc:284
ACG::GLSphere
Definition: GLPrimitives.hh:139
ACG::SceneGraph::LightSource::enabled
bool enabled() const
Get light source status.
Definition: LightNode.cc:137
ACG::SceneGraph::DrawModes::DrawMode
Specifies a DrawMode.
Definition: DrawModes.hh:288
ACG::SceneGraph::LightNode::enter
void enter(GLState &_state, const DrawModes::DrawMode &_drawmode)
set current Light Sources
Definition: LightNode.cc:502
ACG::SceneGraph::Material
Definition: MaterialNode.hh:79
ACG::SceneGraph::LightNode::lightId_
GLenum lightId_
Internal light id.
Definition: LightNode.hh:323
ACG::SceneGraph::LightSource::diffuseColor
void diffuseColor(Vec4f _color)
set Diffuse color for LightSource
Definition: LightNode.cc:154
ACG::SceneGraph::LightSource::direction
Vec3d direction() const
Get direction of the light source.
Definition: LightNode.cc:123
ACG::SceneGraph::LightNode::visualize_
bool visualize_
Indicates whether light node should be visualized or not.
Definition: LightNode.hh:320
ACG::GLState::modelview
const GLMatrixd & modelview() const
get modelview matrix
Definition: GLState.hh:791
SceneGraph
Definition: QtPrincipalAxisDialog.hh:67
ACG::SceneGraph::LightSourceHandle
Definition: LightNode.hh:337
ACG::SceneGraph::PickTarget
PickTarget
What target to use for picking.
Definition: PickTarget.hh:73
OpenMesh::VectorT::minimize
vector_type & minimize(const vector_type &_rhs)
minimize values: same as *this = min(*this, _rhs), but faster
Definition: Vector11T.hh:535
ACG::GLState::rotate
void rotate(double _angle, double _x, double _y, double _z, MultiplyFrom _mult_from=MULT_FROM_RIGHT)
rotate around axis (_x, _y, _z) by _angle
Definition: GLState.cc:564
ACG::SceneGraph::BaseNode
Definition: BaseNode.hh:104
ACG::SceneGraph::LightSource::position
void position(Vec3d _pos)
Set position for LightSource.
Definition: LightNode.cc:108
ACG::GLState::pop_modelview_matrix
void pop_modelview_matrix()
pop modelview matrix
Definition: GLState.cc:1026
OpenMesh::VectorT
Definition: Vector11T.hh:83
ACG::SceneGraph::LightNode::~LightNode
virtual ~LightNode()
Destructor.
Definition: LightNode.cc:243
ACG::SceneGraph::PICK_FACE
picks faces (should be implemented for all nodes)
Definition: PickTarget.hh:78
ACG::SceneGraph::LightSource::diffuseColor
Vec4f diffuseColor() const
get Diffuse color for LightSource
Definition: LightNode.cc:157
ACG::IRenderer
Definition: IRenderer.hh:78
ACG::SceneGraph::LightNode::setParameters
void setParameters(GLState &_state, GLenum _index, LightSource &_light)
set _light Options in OpenGL for GL_LIGHT::_index
Definition: LightNode.cc:584
ACG::Vec4d
VectorT< double, 4 > Vec4d
Definition: VectorT.hh:140
ACG::SceneGraph::ACG::GLState::depthFunc
const GLenum & depthFunc() const
get glDepthFunc() that is supposed to be active
ACG::SceneGraph::LightSource::ambientColor
Vec4f ambientColor() const
get Ambient color for LightSource
Definition: LightNode.cc:151
ACG::Matrix4x4T::transform_vector
VectorT< T, 3 > transform_vector(const VectorT< T, 3 > &_v) const
transform vector (x&#39;,y&#39;,z&#39;,0) = A * (x,y,z,0)
Definition: Matrix4x4T_impl.hh:219
ACG::SceneGraph::LightNode::boundingBox
void boundingBox(ACG::Vec3d &, ACG::Vec3d &)
Get bounding box (for visualization purposes)
Definition: LightNode.cc:267
ACG::SceneGraph::LightSource::LightSource
LightSource()
Default Constructor.
Definition: LightNode.cc:74
ACG::SceneGraph::LightNode::getLightSource
void getLightSource(LightSource *_light) const
Get the light source parameters.
Definition: LightNode.cc:253
ACG::SceneGraph::LightSource::ambientColor
void ambientColor(Vec4f _color)
set Ambient color for LightSource
Definition: LightNode.cc:148
ACG::GLState::pick_set_maximum
bool pick_set_maximum(size_t _idx)
Set the maximal number of primitives/components of your object.
Definition: GLState.cc:1051
ACG::GLState::pick_set_name
void pick_set_name(size_t _idx)
sets the current name/color (like glLoadName(_idx))
Definition: GLState.cc:1061
ACG::SceneGraph::LightSource::radius
float radius() const
Get light source radius.
Definition: LightNode.hh:206