stage.h

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: stage.h,v 1.19.16.1 2007/03/25 21:26:04 oliver Exp $

#ifndef BALL_VIEW_KERNEL_STAGE_H
#define BALL_VIEW_KERNEL_STAGE_H

#ifndef BALL_MATHS_VECTOR3_H
# include <BALL/MATHS/vector3.h>
#endif

#ifndef BALL_MATHS_QUATERNION_H
# include <BALL/MATHS/quaternion.h>
#endif

#ifndef BALL_MATHS_MATRIX44_H
# include <BALL/MATHS/matrix44.h>
#endif

#ifndef BALL_MATHS_ANGLE_H
# include <BALL/MATHS/angle.h>
#endif

#ifndef BALL_VIEW_DATATYPE_COLORRGBA_H
# include <BALL/VIEW/DATATYPE/colorRGBA.h>
#endif

#ifndef BALL_DATATYPE_LIST_H
# include <BALL/DATATYPE/list.h>
#endif

#ifndef  BALL_VIEW_KERNEL_REPRESENTATION_H
# include <BALL/VIEW/KERNEL/representation.h>
#endif

namespace BALL
{
  namespace VIEW
  {
    class BALL_VIEW_EXPORT LightSource
    {
      public:

      enum Types
      {

        AMBIENT = 0,

        POSITIONAL,

        DIRECTIONAL
      };


      LightSource();

      LightSource(const LightSource& light_source);

      virtual ~LightSource(){}



      const Vector3& getPosition() const
        { return position_;}

      void setPosition(const Vector3& position)
        { position_ = position; }

      const Vector3& getDirection() const
        { return direction_;}

      void setDirection(const Vector3& direction)
        { direction_ = direction;}
  
      const Vector3& getAttenuation() const
        { return attenuation_;}

      void setAttenuation(const Vector3& attenuation)
        { attenuation_ = attenuation;}


      const Angle& getAngle() const
        { return angle_;}

      void setAngle(const Angle& angle)
        { angle_ = angle;}
      
      float getIntensity() const
        { return intensity_;}

      void setIntensity(float intensity)
        { intensity_ = intensity;}
        
      const ColorRGBA& getColor() const
        { return color_;}

      void setColor(const ColorRGBA& color)
        { color_ = color;}
      
      Index getType() const
        { return type_;}

      void setType(Types type)
        { type_ = type;}

      void setRelativeToCamera(bool state)
        { relative_ = state;}

      bool isRelativeToCamera() const
        { return relative_;}

      LightSource& operator = (const LightSource& light);

      bool operator < (const LightSource& light) const;


      
      bool operator == (const LightSource& light_source) const;

      
      virtual void dump(std::ostream& s = std::cout, Size depth = 0) const;

      protected:

      //_ Position of the light source
      Vector3     position_;

      //_ Direction of the light cone
      Vector3     direction_;
      
      //_ Attenuation parameters of the light 
      Vector3     attenuation_;

      //_
      Vector3     r_position_;

      //_
      Vector3     r_direction_;

      //_ Angle of the light cone
      Angle       angle_;

      //_ Intensity of the light
      float       intensity_;

      //_ Color of the light
      ColorRGBA   color_;

      //_ Enumeration of types for further usage
      Index       type_;

      //_ Relative to camera
      bool        relative_;
    };
        

    class BALL_VIEW_EXPORT Camera
    {
      public:

      
      Camera();

      Camera(const Camera& camera);

      Camera(const Vector3& view_point, const Vector3& look_at, const Vector3& look_up_vector);

      virtual ~Camera(){}

      Camera& operator = (const Camera& camera);



      void moveRight(float translation)
        { view_point_ += right_vector_*translation; look_at_ += right_vector_*translation; }

      void moveUp(float translation)
        { view_point_ += look_up_vector_*translation; look_at_ += look_up_vector_*translation; }

      void moveForward(float translation)
      { 
        Vector3 normal_view_vector(view_vector_);
        normal_view_vector.normalize();
        view_point_ += normal_view_vector*translation; 
        look_at_ += normal_view_vector*translation; 
      }

      const Vector3& getViewPoint() const
        { return view_point_;}

      void setViewPoint(const Vector3& view_point) 
        { view_point_ = view_point; calculateVectors_();}

      const Vector3& getLookAtPosition() const
        { return look_at_;}

      void setLookAtPosition(const Vector3& look_at) 
        { look_at_ = look_at; calculateVectors_();}

      const Vector3& getLookUpVector() const
        { return look_up_vector_;}

      void setLookUpVector(const Vector3& look_up_vector) 
        { look_up_vector_ = look_up_vector; calculateVectors_();}

      float getDistance() const
        { return view_point_.getDistance(look_at_);}

      Vector3 getViewVector() const
        { return view_vector_;}

      Vector3 getRightVector() const
        { return right_vector_;}
      
      void translate(const Vector3& v) 
        { view_point_ += v; look_at_ += v; calculateVectors_();}

      void rotate(const Quaternion& q, const Vector3& origin);
      
      void rotate(const Matrix4x4& mat, const Vector3& origin);

      virtual void clear()
        { *this = Camera();}

      String toString() const;

      bool readFromString(const String& data);


      
      bool operator == (const Camera& camera) const;

      bool operator < (const Camera& camera) const;

  
      virtual void dump(std::ostream& s = std::cout, Size depth = 0) const;

      protected:

      //_
      void calculateVectors_();

      //_
      Vector3           view_point_;

      //_
      Vector3           look_at_;

      //_
      Vector3           look_up_vector_;

      /*_ The viewing vector.
          Stored only for better performance in the scene.
      */
      Vector3           view_vector_;
  
      /*_ The orthogonal vector to the viewing vector, which is showing to the right.
          Stored only for better performance in the scene.
      */
      Vector3           right_vector_;
    };

    class BALL_VIEW_EXPORT Stage
    {
      public:

      class RaytracingMaterial
      {
        public:
          ColorRGBA ambient_color;
          float     ambient_intensity;

          ColorRGBA specular_color;
          float     specular_intensity;

          ColorRGBA reflective_color;
          float     reflective_intensity;

          float     shininess;  
          float     transparency;
      };


      Stage();
      
      Stage(const Stage& stage);

      virtual ~Stage(){}

      virtual void clear();


      
      virtual const List<LightSource>& getLightSources() const
        { return light_sources_;}

      virtual void addLightSource(const LightSource& light_source);

      virtual void removeLightSource(const LightSource& light_source) ;

      void clearLightSources();
      
      virtual Camera& getCamera() 
        { return camera_;}

      virtual const Camera& getCamera() const
        { return camera_;}

      virtual void setCamera(const Camera& camera)
        { camera_ = camera;}

      virtual const ColorRGBA& getBackgroundColor() const
        { return background_color_;}

      virtual void setBackgroundColor(const ColorRGBA& color)
        { background_color_ = color;}
      
      virtual const ColorRGBA& getInfoColor() const
        { return info_color_;}

      virtual void setInfoColor(const ColorRGBA& color)
        { info_color_ = color;}

      void showCoordinateSystem(bool state)
        { show_coordinate_system_ = state;}

      bool coordinateSystemEnabled() const
        { return show_coordinate_system_;}

      void setEyeDistance(float value) 
        { eye_distance_ = value;}

      float getEyeDistance() const
        { return eye_distance_;}
        
      void setFocalDistance(float value) 
        { focal_distance_ = value;}

      float getFocalDistance() const
        { return focal_distance_;}

      void setSwapSideBySideStereo(bool state)
        { swap_side_by_side_stereo_ = state;}

      bool swapSideBySideStereo() const
        { return swap_side_by_side_stereo_;}

      float getFogIntensity() const
        { return fog_intensity_;}

      void setFogIntensity(float value)
        { fog_intensity_ = value;}
        
      float getSpecularIntensity() const
        { return specular_;}

      void setSpecularIntensity(float value)
        { specular_ = value;}
          
      float getDiffuseIntensity() const
        { return diffuse_;}

      void setDiffuseIntensity(float value)
        { diffuse_ = value;}
          
      float getAmbientIntensity() const
        { return ambient_;}

      void setAmbientIntensity(float value)
        { ambient_ = value;}
          
      float getShininess() const
        { return shininess_;}

      void setShininess(float value)
        { shininess_ = value;}
      

      
      bool operator == (const Stage& stage) const;

      Vector3 calculateRelativeCoordinates(Vector3 pos) const;

      Vector3 calculateAbsoluteCoordinates(Vector3 pos) const;

      
      virtual void dump(std::ostream& s = std::cout, Size depth = 0) const;

      RaytracingMaterial& getRTMaterial() { return rt_material_; }

      const RaytracingMaterial& getRTMaterial() const { return rt_material_; }

      protected:

      //_
      ColorRGBA           background_color_;

      //_
      ColorRGBA           info_color_;

      //_
      List<LightSource>   light_sources_;

      //_
      Camera              camera_;

      //_
      bool                show_coordinate_system_;

      //_
      float               fog_intensity_;

      //_
      float               eye_distance_;
      
      //_
      float               focal_distance_;

      //_
      bool                swap_side_by_side_stereo_;

      float               specular_;
      float               diffuse_;
      float               ambient_;
      float               shininess_;

      // the current default materials used for raytracing
      RaytracingMaterial  rt_material_;
    };

  } // namespace VIEW
} // namespace BALL

#endif // BALL_VIEW_KERNEL_STAGE_H

---