SO3Water.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#ifndef __SO3WATER_H__
#define __SO3WATER_H__
 
#include "SO3EnvironmentComponent.h"
#include "SCOLBasic/SO3DataScol.h"
#include "SO3Utils/SO3ColourGradient.h"
#include "Hydrax.h"
#include "Modules/ProjectedGrid/HydraxProjectedGrid.h"
#include "Modules/RadialGrid/HydraxRadialGrid.h"
#include "Modules/SimpleGrid/HydraxSimpleGrid.h"
#include "Noise/Perlin/HydraxPerlin.h"
#include "Noise/FFT/HydraxFFT.h"
#include "Noise/Real/HydraxReal.h"
 
namespace SO3
{
 
class _SO3_Export SWater : public SEnvironmentComponent,
                           public Hydrax::RttManager::RttListener,
                           public Ogre::RenderTargetListener
{
public:
  enum WaterGeometryType
  {
    SO3_WATER_GEOM_INFINITE_PLANE,  //<! Infinite plane surface
    SO3_WATER_GEOM_FINITE_PLANE,    //<! Sized plane surface
    SO3_WATER_GEOM_RADIAL           //<! Radial surface (circle)
  };
 
  enum WaterComponentType
  {
    SO3_WATER_COMPONENT_NONE,
    SO3_WATER_COMPONENT_SUN,
    SO3_WATER_COMPONENT_FOAM,
    SO3_WATER_COMPONENT_DEPTH,
    SO3_WATER_COMPONENT_SMOOTH,
    SO3_WATER_COMPONENT_CAUSTICS,
    SO3_WATER_COMPONENT_UNDERWATER,
    SO3_WATER_COMPONENT_UNDERWATER_REFLECTIONS,
    SO3_WATER_COMPONENT_GODRAYS
  };
 
  class WaterComponent
  {
  public:
  protected:
    SWater* parentWater;
    const Hydrax::HydraxComponent hydraxComponentType;
    const SWater::WaterComponentType componentType;
  private:
    bool waterComponentEnable;
 
  public:
    WaterComponent(SWater* parentWaterInstance, const SWater::WaterComponentType& component, const Hydrax::HydraxComponent& hydraxComponent);
 
    virtual ~WaterComponent();
 
    bool GetEnabled();
 
    void SetEnabled(const bool& enable);
    
    void ApplyEnable();
 
    SWater::WaterComponentType GetType();
 
    virtual void Update(const Ogre::Real& updateTime)=0;
  protected:
    virtual void ApplyParameters()=0;
  private:
    WaterComponent();
  };
 
  class WaterComponentSun : public WaterComponent
  {
  public:
  protected:
  private:
    Ogre::Plane horizonPlane;
    Ogre::Vector3 sunPosition;
    float sunStrength;
    float sunArea;
    Ogre::ColourValue sunColor;
  
  public:
    WaterComponentSun(SWater* parentWaterInstance);
 
    void SetParameters(const Ogre::Vector3& position, const float& strength, const float& area, const Ogre::ColourValue& color);
 
    Ogre::Vector3 GetPosition();
    
    void SetPosition(const Ogre::Vector3& position);
    
    float GetStrength();
 
    void SetStrength(const float& strength);
 
    float GetArea();
 
    void SetArea(const float& area);
 
    Ogre::ColourValue GetColor();
 
    void SetColor(const Ogre::ColourValue& color);
 
    virtual void Update(const Ogre::Real& updateTime);
  protected:
    virtual void ApplyParameters();
  private:
    WaterComponentSun();
  };
 
  class WaterComponentFoam : public WaterComponent
  {
  public:
  protected:
  private:
    float foamMaxDistance;
    float foamScale;
    float foamStart;
    float foamTransparency;
  
  public:
    WaterComponentFoam(SWater* parentWaterInstance);
 
    void SetParameters(const float& maxDistance, const float& scale, const float& start, const float& transparency);
 
    float GetMaxDistance();
 
    void SetMaxDistance(const float& maxDistance);
 
    float GetScale();
 
    void SetScale(const float& scale);
 
    float GetStart();
 
    void SetStart(const float& start);
 
    float GetTransparency();
 
    void SetTransparency(const float& transparency);
 
    virtual void Update(const Ogre::Real& updateTime);
  protected:
    virtual void ApplyParameters();
  private:
    WaterComponentFoam();
  };
 
  class WaterComponentDepth : public WaterComponent
  {
  public:
  protected:
  private:
    float depthLimitation;
    float distanceLimitation;
  
  public:
    WaterComponentDepth(SWater* parentWaterInstance);
 
    void SetParameters(const float& depthLimit, const float& distanceLimit);
 
    float GetDepthLimit();
 
    void SetDepthLimit(const float& depthLimit);
 
    void SetDistanceLimit(const float& distanceLimit);
 
    float GetDistanceLimit();
 
    virtual void Update(const Ogre::Real& updateTime);
  protected:
    virtual void ApplyParameters();
  private:
    WaterComponentDepth();
  };
 
  class WaterComponentSmooth : public WaterComponent
  {
  public:
  protected:
  private:
    float smoothPower;
  
  public:
    WaterComponentSmooth(SWater* parentWaterInstance);
 
    float GetPower();
 
    void SetPower(const float& power);
 
    virtual void Update(const Ogre::Real& updateTime);
  protected:
    virtual void ApplyParameters();
  private:
    WaterComponentSmooth();
  };
 
  class WaterComponentCaustics : public WaterComponent
  {
  public:
  protected:
  private:
    float causticsScale;
    float causticsPower;
    float causticsEnd;
  
  public:
    WaterComponentCaustics(SWater* parentWaterInstance);
 
    void SetParameters(const float& scale, const float& power, const float& end);
 
    float GetScale();
 
    void SetScale(const float& scale);
 
    float GetPower();
 
    void SetPower(const float& power);
 
    float GetEnd();
 
    void SetEnd(const float& end);
 
    virtual void Update(const Ogre::Real& updateTime);
  protected:
    virtual void ApplyParameters();
  private:
    WaterComponentCaustics();
  };
 
  class WaterComponentUnderwater : public WaterComponent
  {
  public:
  protected:
  private:
  
  public:
    WaterComponentUnderwater(SWater* parentWaterInstance);
 
    virtual void Update(const Ogre::Real& updateTime);
  protected:
    virtual void ApplyParameters();
  private:
    WaterComponentUnderwater();
  };
 
  class WaterComponentUnderwaterReflections : public WaterComponent
  {
  public:
  protected:
  private:
  
  public:
    WaterComponentUnderwaterReflections(SWater* parentWaterInstance);
 
    virtual void Update(const Ogre::Real& updateTime);
  protected:
    virtual void ApplyParameters();
  private:
    WaterComponentUnderwaterReflections();
  };
 
  class WaterComponentGodRays : public WaterComponent
  {
  public:
  protected:
  private:
    Ogre::Vector3 godRaysExposure;
    float godRaysIntensity;
    float godRaysSpeed;
    int godRaysNumberOfRays;
    float godRaysRaysSize;
    bool godRaysRaysIntersections;
  
  public:
    WaterComponentGodRays(SWater* parentWaterInstance);
 
    void SetParameters(const Ogre::Vector3& exposure, const float& intensity, const float& speed, const int& numberOfRays, const float& raysSize, const bool& raysIntersections);
 
    Ogre::Vector3       GetExposure();
 
    void SetExposure(const Ogre::Vector3& exposure);
 
    float GetIntensity();
 
    void SetIntensity(const float& intensity);
 
    float GetSpeed();
 
    void SetSpeed(const float& speed);
 
    int GetNumberOfRays();
 
    void SetNumberOfRays(const int& numberOfRays);
 
    float GetRaysSize();
 
    void SetRaysSize(const float& raysSize);
 
    bool GetRaysIntersectionEnable();
 
    void SetRaysIntersectionEnable(const bool& raysIntersections);
 
    virtual void Update(const Ogre::Real& updateTime);
 
  protected:
    virtual void ApplyParameters();
  private:
    WaterComponentGodRays();
  };
protected:
private:
  SScene* parentScene;
  WaterComponentSun* sunComponent;
  WaterComponentFoam* foamComponent;
  WaterComponentDepth* depthComponent;
  WaterComponentSmooth* smoothComponent;
  WaterComponentCaustics* causticsComponent;
  WaterComponentUnderwater* underwaterComponent;
  WaterComponentUnderwaterReflections* underwaterReflectionsComponent;
  WaterComponentGodRays* godRaysComponent;
  WaterGeometryType actualGeometryType;
  Hydrax::Hydrax* hydraxManager;
  Hydrax::Module::Module* hydraxGeometry;
  Hydrax::Module::ProjectedGrid::Options progGridOptions;
 
  Hydrax::Noise::Noise* hydraxNoise;
  Hydrax::Noise::Perlin::Options perlinNoiseOptions;
  Hydrax::Noise::FFT::Options fftNoiseOptions;
  SViewPort* renderingViewport;
  Ogre::ColourValue baseColour;
  SColourGradient waterColourGradient;
  int finitePlaneWaterSizeX;
  int finitePlaneWaterSizeY;
  Ogre::Real radialWaterRadius;
  Ogre::Vector3 waterPlanePosition;
  float wavesAnimationSpeed;
  Ogre::Vector2 cachedWindDirection;
  bool IslastUnderWater;
 
public:
  SWater(SEnvironment* parent, const std::string& waterName);
    
  SWater(SEnvironment* parent, const std::string& waterName, const int& planeSizeX, const int& planeSizeY);
 
  SWater(SEnvironment* parent, const std::string& waterName, const float& waterRadius);
 
  ~SWater();
 
  Hydrax::Hydrax* GetHydrax();
  
  WaterGeometryType GetGeometryType();
  
  void SetGeometryTypeInfinitePlane();
 
  float GetInfinitePlaneStrength();
 
  void SetInfinitePlaneStrength(const float& value);
 
  float GetInfinitePlaneElevation();
 
  void SetInfinitePlaneElevation(const float& value);
 
  float GetInfinitePlaneComplexity();
 
  void SetInfinitePlaneComplexity(const float& value);
 
  float GetInfinitePlaneChoppyStrength();
 
  void SetInfinitePlaneChoppyStrength(const float& value);
 
  void SetGeometryTypeFinitePlane(const int& planeSizeX, const int& planeSizeY);
  
  void SetGeometryTypeRadialPlane(const float& waterRadius);
 
  WaterComponent* GetComponent(const SWater::WaterComponentType& componentType);
 
  WaterComponentSun* GetSun();
 
  WaterComponentFoam* GetFoam();
 
  WaterComponentDepth* GetDepth();
 
  WaterComponentSmooth* GetSmooth();
 
  WaterComponentCaustics* GetCaustics();
 
  WaterComponentUnderwater* GetUnderwater();
 
  WaterComponentUnderwaterReflections* GetUnderwaterReflections();
 
  WaterComponentGodRays* GetGodRays();
 
  Ogre::Vector3 GetPosition();
 
  void SetPosition(const Ogre::Vector3& newSeaLevel);
 
  Ogre::ColourValue GetColor();
 
  void SetColor(const Ogre::ColourValue& color);
 
  virtual void Update(const Ogre::Real& updateTime);
 
  float GetAnimationSpeed();
 
  void SetAnimationSpeed(const float& animationSpeed);
 
  Hydrax::Noise::Perlin::Options GetPerlinOptions();
 
  void SetPerlinOptions(const Hydrax::Noise::Perlin::Options& newOptions);
 
  Hydrax::Noise::FFT::Options GetFFTOptions();
 
  void SetFFTOptions(const Hydrax::Noise::FFT::Options& newOptions);
 
        void ApplyHydraxComponentTypes();
 
        virtual void preRenderTargetUpdate(const Hydrax::RttManager::RttType& Rtt);
 
        virtual void postRenderTargetUpdate(const Hydrax::RttManager::RttType& Rtt);
 
  virtual void preViewportUpdate(const Ogre::RenderTargetViewportEvent& evt);
 
  virtual void UpdateCamera(SViewPort* viewport);
 
  void AddViewport(Ogre::Viewport* viewport);
 
  void RemoveViewport(Ogre::Viewport* viewport);
 
protected:
  virtual void SetEnableImpl(const bool& enableComponent);
 
  virtual void RegisterViewportImpl(SViewPort* viewport);
 
  virtual void UnregisterViewportImpl(SViewPort* viewport);
 
private:
  SWater();
 
  void CommonConstructorsSequence(const WaterGeometryType& selectedWaterGeometryType);
 
  bool Initialize();
 
  void CreateInfinitePlaneGeometry();
 
  void CreateFinitePlaneGeometry(const int& planeSizeX, const int& planeSizeY);
 
  /*
  */
  void CreateRadialPlaneGeometry(const float& waterRadius);
 
  Hydrax::Noise::Noise* CreatePerlinNoise();
 
  Hydrax::Noise::Noise* CreateFftNoise();
 
  Hydrax::Noise::Noise* CreateRealNoise();
 
  void RefreshWaterColourGradient();
};
 
}
 
#endif