LightNode.hh

/*===========================================================================*\
*                                                                            *
*                              OpenFlipper                                   *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
*                                                                            *
\*===========================================================================*/
 
 
 
 
 
 
//=============================================================================
//
//  CLASS LightNode
//
//=============================================================================
 
#ifndef ACG_LIGHT_NODE_HH
#define ACG_LIGHT_NODE_HH
 
 
//== INCLUDES =================================================================
 
#include <ACG/Scenegraph/BaseNode.hh>
#include <OpenFlipper/common/ObjectTypeDLLDefines.hh>
#include <OpenFlipper/BasePlugin/PluginFunctions.hh>
#include <ACG/GL/gl.hh>
#include <ACG/GL/GLPrimitives.hh>
#include <OpenFlipper/common/GlobalOptions.hh>
#include <string>
#include <vector>
 
 
//== NAMESPACES ===============================================================
 
namespace ACG {
namespace SceneGraph {
 
 
//== CLASS DEFINITION =========================================================
 
class OBJECTTYPEDLLEXPORT LightSource
{
  // Declare Node as friend for direct access to memberss
  friend class LightNode;
 
public:
 
  LightSource();
 
  void position( Vec3d _pos);
 
  Vec3d position() const;
 
  bool directional() const;
 
  Vec3d direction() const;
 
  void direction( Vec3d _pos);
 
  void enable();
 
  void disable();
 
  bool enabled() const;
 
  void spotDirection(Vec3d _pos);
 
  Vec3d spotDirection( ) const;
 
  void ambientColor(  Vec4f _color);
 
  Vec4f ambientColor() const;
 
  void diffuseColor(  Vec4f _color);
 
  Vec4f diffuseColor() const;
 
  void specularColor(  Vec4f _color);
 
  Vec4f specularColor() const;
 
  void setColor(const Vec4f& _ambient, const Vec4f& _diffuse, const Vec4f& _specular);
 
  void fixedPosition( bool _state);
 
  bool fixedPosition() const;
 
  void spotExponent(float _exponent);
 
  float spotExponent() const;
 
  void spotCutoff(float _cutoff);
 
  float spotCutoff() const;
 
  void constantAttenuation(float _constantAttenuation);
 
  float constantAttenuation() const;
 
  void linearAttenuation(float _linearAttenuation);
 
  float linearAttenuation() const;
 
  void quadraticAttenuation(float _quadraticAttenuation);
 
  float quadraticAttenuation() const;
 
  void brightness(const float _brightness);
 
  float brightness() const;
 
  float radius() const { return radius_; }
 
  void radius(const float _radius) { radius_ = _radius; }
 
protected:
 
  Vec4f position_;
  Vec4f realPosition_;
 
  bool enabled_;
  bool fixedPosition_;
  Vec4f ambientColor_;
  Vec4f diffuseColor_;
  Vec4f specularColor_;
 
  Vec3d spotDirection_;
  Vec3d realSpotDirection_;
 
  // Only if in fixed mode
  Vec4f initialPosition_;
  Vec3d initialSpotDirection_;
  bool initialPositionInit_;
 
  float spotExponent_;
  float spotCutoff_;
  float constantAttenuation_;
  float linearAttenuation_;
  float quadraticAttenuation_;
 
  float brightness_;
 
  float radius_;
};
 
 
class OBJECTTYPEDLLEXPORT LightNode : public BaseNode
{
 
public:
 
  LightNode( BaseNode*           _parent = 0,
                   const std::string&  _name = "<LightNode>");
 
  virtual ~LightNode();
 
  void setLightSource(LightSource _light ) { light_ = _light; };
 
  void getLightSource(LightSource* _light) const;
 
  void getLightSourceViewSpace(LightSource* _light) const;
 
 
  ACG_CLASSNAME(LightNode);
 
  void boundingBox(ACG::Vec3d& /* _bbMin */, ACG::Vec3d& /*_bbMax*/ ) override;
 
  void enter(GLState& _state, const DrawModes::DrawMode& _drawmode) override;
 
  void leave(GLState& _state, const DrawModes::DrawMode& _drawmode) override;
 
  void draw(GLState& _state, const DrawModes::DrawMode& _drawMode) override;
 
  void pick(GLState& _state, PickTarget _target) override;
 
  bool visualize() { return visualize_; }
 
  void visualize(bool _visualize) { visualize_ = _visualize; }
 
 
  void getRenderObjects(IRenderer* _renderer, GLState&  _state , const DrawModes::DrawMode&  _drawMode , const Material* _mat) override;
 
 
private:
 
  void setParameters(GLState&  _state, GLenum _index, LightSource& _light);
 
  void getParameters(GLState&  _state, GLenum _index, LightSource& _light);
 
private:
 
  LightSource light_;
 
  LightSource transformedLight_;
 
  LightSource lightSave_;
 
  bool visualize_;
 
  GLenum lightId_;
 
  ACG::GLCone* cone_;
  ACG::GLSphere* sphere_;
};
 
class OBJECTTYPEDLLEXPORT LightSourceHandle {
  public:
    LightSourceHandle() {
      GLint maxLights;
 
      // Get max number of lights
      if (OpenFlipper::Options::gui() && !OpenFlipper::Options::coreProfile())
        glGetIntegerv(GL_MAX_LIGHTS, &maxLights);
      else
        maxLights = 50;
 
      for(int i = 0; i < maxLights; ++i) {
        lights_.insert(std::pair<GLenum, LightNode*>(GL_LIGHT0 + i, (LightNode*)0 ));
      }
    };
 
    GLenum getLight(LightNode* _node) {
      GLenum light = GL_INVALID_ENUM;
      for(std::map<GLenum, LightNode*>::iterator it = lights_.begin();
          it != lights_.end(); ++it) {
 
        if(it->second == 0) {
          lights_[it->first] = _node;
          light = it->first;
          break;
        }
      }
      return light;
    };
 
    void removeLight(LightNode* _node) {
      for(std::map<GLenum, LightNode*>::iterator it = lights_.begin();
          it != lights_.end(); ++it) {
 
        if(it->second == _node) {
          lights_[it->first] = 0;
          break;
        }
      }
    };
 
  private:
    std::map<GLenum, LightNode*> lights_;
};
 
//=============================================================================
} // namespace SceneGraph
} // namespace ACG
//=============================================================================
#endif // ACG_LIGHT_NODE_HH defined
//=============================================================================