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*/ );

  void enter(GLState& _state, const DrawModes::DrawMode& _drawmode);

  void leave(GLState& _state, const DrawModes::DrawMode& _drawmode);

  void draw(GLState& _state, const DrawModes::DrawMode& _drawMode);

  void pick(GLState& _state, PickTarget _target);

  bool visualize() { return visualize_; }

  void visualize(bool _visualize) { visualize_ = _visualize; }


  void getRenderObjects(IRenderer* _renderer, GLState&  _state , const DrawModes::DrawMode&  _drawMode , const Material* _mat);


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
//=============================================================================