SO3Engine/SO3SceneGraph/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) 2010 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

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

#ifndef __SO3WATER_H__
#define __SO3WATER_H__

#include "SO3EnvironmentComponent.h"
#include "../SCOLBasic/SO3DataScol.h"
#include "../SO3Utils/SO3ColourGradient.h"
#include "Hydrax/Hydrax.h"
#include "Hydrax/Modules/ProjectedGrid/HydraxProjectedGrid.h"
#include "Hydrax/Modules/RadialGrid/HydraxRadialGrid.h"
#include "Hydrax/Modules/SimpleGrid/HydraxSimpleGrid.h"
#include "Hydrax/Noise/Perlin/HydraxPerlin.h"
#include "Hydrax/Noise/FFT/HydraxFFT.h"

namespace SO3
{

class _SO3_Export SWater : public SEnvironmentComponent,
                           public Hydrax::RttManager::RttListener
{
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_GODRAYS
  };

  class WaterComponent
  {
  public:
  protected:
    Hydrax::Hydrax* hydraxManager;
    SWater* parentWater;
    const Hydrax::HydraxComponent hydraxComponentType;
    const SWater::WaterComponentType componentType;
  private:
    bool waterComponentEnable;

  public:
    WaterComponent(SWater* parentWaterInstance, SWater::WaterComponentType component, Hydrax::HydraxComponent hydraxComponent);

    ~WaterComponent();

    bool GetEnabled();

    void SetEnabled(bool enable);

    SWater::WaterComponentType GetType();

    virtual void Update(Ogre::Real updateTime)=0;
  protected:
  private:
    WaterComponent();
  };

  class WaterComponentSun : public WaterComponent
  {
  public:
  protected:
  private:
    Ogre::Plane horizonPlane;
  
  public:
    WaterComponentSun(SWater* parentWaterInstance);

    void SetParameters(Ogre::Vector3 position, float strength, float area, Ogre::Vector3 color);

    Ogre::Vector3 GetPosition();
    
    void SetPosition(Ogre::Vector3 position);
    
    float GetStrength();

    void SetStrength(float strength);

    float GetArea();

    void SetArea(float area);

    Ogre::ColourValue GetColor();

    void SetColor(Ogre::ColourValue color);

    virtual void Update(Ogre::Real updateTime);
  protected:
  private:
    WaterComponentSun();
  };

  class WaterComponentFoam : public WaterComponent
  {
  public:
  protected:
  private:
  
  public:
    WaterComponentFoam(SWater* parentWaterInstance);

    void SetParameters(float maxDistance, float scale, float start, float transparency);

    float GetMaxDistance();

    void SetMaxDistance(float maxDistance);

    float GetScale();

    void SetScale(float scale);

    float GetStart();

    void SetStart(float start);

    float GetTransparency();

    void SetTransparency(float transparency);

    virtual void Update(Ogre::Real updateTime);
  protected:
  private:
    WaterComponentFoam();
  };

  class WaterComponentDepth : public WaterComponent
  {
  public:
  protected:
  private:
  
  public:
    WaterComponentDepth(SWater* parentWaterInstance);

    void SetParameters(float depthLimit, float distortionLimit);

    float GetDepthLimit();

    void SetDepthLimit(float depthLimit);

    void SetDistortionLimit(float distortionLimit);

    float GetDistortionLimit();

    virtual void Update(Ogre::Real updateTime);
  protected:
  private:
    WaterComponentDepth();
  };

  class WaterComponentSmooth : public WaterComponent
  {
  public:
  protected:
  private:
  
  public:
    WaterComponentSmooth(SWater* parentWaterInstance);

    float GetPower();

    void SetPower(float smoothPower);

    virtual void Update(Ogre::Real updateTime);
  protected:
  private:
    WaterComponentSmooth();
  };

  class WaterComponentCaustics : public WaterComponent
  {
  public:
  protected:
  private:
  
  public:
    WaterComponentCaustics(SWater* parentWaterInstance);

    void SetParameters(float scale, float power, float end);

    float GetScale();

    void SetScale(float scale);

    float GetPower();

    void SetPower(float power);

    float GetEnd();

    void SetEnd(float end);

    virtual void Update(Ogre::Real updateTime);
  protected:
  private:
    WaterComponentCaustics();
  };

  class WaterComponentUnderwater : public WaterComponent
  {
  public:
  protected:
  private:
  
  public:
    WaterComponentUnderwater(SWater* parentWaterInstance);

    virtual void Update(Ogre::Real updateTime);
  protected:
  private:
    WaterComponentUnderwater();
  };

  class WaterComponentGodRays : public WaterComponent
  {
  public:
  protected:
  private:
  
  public:
    WaterComponentGodRays(SWater* parentWaterInstance);

    void SetParameters(Ogre::Vector3 exposure, float intensity, float speed, int numberOfRays, float raysSize, bool raysIntersections);

    Ogre::Vector3       GetExposure();

    void SetExposure(Ogre::Vector3 exposure);

    float GetIntensity();

    void SetIntensity(float intensity);

    float GetSpeed();

    void SetSpeed(float speed);

    int GetNumberOfRays();

    void SetNumberOfRays(int numberOfRays);

    float GetRaysSize();

    void SetRaysSize(float raysSize);

    bool GetRaysIntersectionEnable();

    void SetRaysIntersectionEnable(bool raysIntersections);

    virtual void Update(Ogre::Real updateTime);
  protected:
  private:
    WaterComponentGodRays();
  };
protected:
private:
  SScene* parentScene;
  WaterComponentSun* sunComponent;
  WaterComponentFoam* foamComponent;
  WaterComponentDepth* depthComponent;
  WaterComponentSmooth* smoothComponent;
  WaterComponentCaustics* causticsComponent;
  WaterComponentUnderwater* underwaterComponent;
  WaterComponentGodRays* godRaysComponent;
  WaterGeometryType actualGeometryType;
  Hydrax::Hydrax* hydraxManager;
  Hydrax::Module::Module* hydraxGeometry;
  Hydrax::Noise::Noise* hydraxNoise;
  Hydrax::Noise::Perlin::Options perlinNoiseOptions;
  Hydrax::Noise::FFT::Options fftNoiseOptions;
  SViewPort* renderingViewport;
  SCamera* renderingCamera;
  Ogre::ColourValue baseColour;
  SColourGradient waterColourGradient;

public:
  SWater(SEnvironment* parent, std::string waterName, SViewPort* targetViewport, SCamera* targetCamera);
    
  SWater(SEnvironment* parent, std::string waterName, SViewPort* targetViewport, SCamera* targetCamera, int planeSizeX, int planeSizeY);

  SWater(SEnvironment* parent, std::string waterName, SViewPort* targetViewport, SCamera* targetCamera, float waterRadius);

  ~SWater();

  Hydrax::Hydrax* GetHydrax();
  
  WaterGeometryType GetGeometryType();
  
  void SetGeometryTypeInfinitePlane();

  void SetGeometryTypeFinitePlane(int planeSizeX, int planeSizeY);
  
  void SetGeometryTypeRadialPlane(float waterRadius);

  WaterComponent* GetComponent(SWater::WaterComponentType componentType);

  WaterComponentSun* GetSun();

  WaterComponentFoam* GetFoam();

  WaterComponentDepth* GetDepth();

  WaterComponentSmooth* GetSmooth();

  WaterComponentCaustics* GetCaustics();

  WaterComponentUnderwater* GetUnderwater();

  WaterComponentGodRays* GetGodRays();

  void SetWindSpeed(float newWindSpeed);

  void SetWindDirection(Ogre::Vector3 newWindDirection);

  const Ogre::Vector3& GetPosition() const;

  void SetPosition(const Ogre::Vector3& newSeaLevel);

  Ogre::ColourValue GetColor();

  void SetColor(Ogre::ColourValue color);

  virtual void Update(Ogre::Real updateTime);

  float GetAnimationSpeed();

  void SetAnimationSpeed(float animationSpeed);

        virtual void preRenderTargetUpdate(const Hydrax::RttManager::RttType& Rtt);

        virtual void postRenderTargetUpdate(const Hydrax::RttManager::RttType& Rtt);
protected:
private:
  SWater();

  void CommonConstructorsSequence(SViewPort* targetViewport, SCamera* targetCamera);

  void Initialise();

  void CreateInfinitePlaneGeometry();

  void CreateFinitePlaneGeometry(int planeSizeX, int planeSizeY);

  /*
  */
  void CreateRadialPlaneGeometry(float waterRadius);

  Hydrax::Noise::Noise* CreatePerlinNoise();

  Hydrax::Noise::Noise* CreateFftNoise();

  void RefreshWaterColourGradient();
};

}

#endif

---