SO3Water.cpp

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
 
-----------------------------------------------------------------------------
*/
 
#include "SO3Renderer/SO3Root.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3SceneGraph/SO3Water.h"
#include "SO3Renderer/SO3ViewPort.h"
#include "SO3SceneGraph/SO3Camera.h"
#include "SO3SceneGraph/SO3Environment.h"
#include "SO3SceneGraph/SO3Sun.h"
 
namespace SO3
{
 
SWater::SWater(SEnvironment* parent, const std::string& waterName) : SEnvironmentComponent(parent, waterName)
{
  CommonConstructorsSequence(SO3_WATER_GEOM_INFINITE_PLANE);
}
 
SWater::SWater(SEnvironment* parent, const std::string& waterName, const int& planeSizeX, const int& planeSizeY) : SEnvironmentComponent(parent, waterName)
{
  CommonConstructorsSequence(SO3_WATER_GEOM_FINITE_PLANE);
  finitePlaneWaterSizeX = planeSizeX;
  finitePlaneWaterSizeY = planeSizeY;
}
 
SWater::SWater(SEnvironment* parent, const std::string& waterName, const float& waterRadius) : SEnvironmentComponent(parent, waterName)
{
  CommonConstructorsSequence(SO3_WATER_GEOM_RADIAL);
  radialWaterRadius = waterRadius;
}
 
SWater::SWater() : SEnvironmentComponent(0, "")
{
  // Forbiden (private)
}
 
void SWater::CommonConstructorsSequence(const WaterGeometryType& selectedWaterGeometryType)
{
  // Usefull pointers initialisation
  parentScene = parentEnvironment->GetScene();
  hydraxManager = 0;
  hydraxGeometry = 0;
  hydraxNoise = 0;
  renderingViewport = 0;
 
  IslastUnderWater = false;
 
  // Store geometry type for further usage
  actualGeometryType = selectedWaterGeometryType;
  finitePlaneWaterSizeX = 0;
  finitePlaneWaterSizeY = 0;
  radialWaterRadius = 0.0f;
 
  // Some member variable init
  waterPlanePosition = Ogre::Vector3::ZERO;
  wavesAnimationSpeed = 1.0f;
  cachedWindDirection = Ogre::Vector2::ZERO;
 
  // Configure water color
  baseColour = Ogre::ColourValue(0.025, .2, 0.35);
  RefreshWaterColourGradient();
 
  // Configure perlin noise
  perlinNoiseOptions.Octaves = 8;
        perlinNoiseOptions.Scale = 0.85f;
        perlinNoiseOptions.Falloff = 0.49f;
        perlinNoiseOptions.Animspeed = 1.4f;
        perlinNoiseOptions.Timemulti = 1.27f;
        perlinNoiseOptions.GPU_Strength = 0.20f;
        perlinNoiseOptions.GPU_LODParameters = Ogre::Vector3(0.5f, 50, 150000);
 
  // Configure fft noise
  fftNoiseOptions.Resolution = 128;
  fftNoiseOptions.PhysicalResolution = 32.0f;
  fftNoiseOptions.Scale = 0.25f;
  fftNoiseOptions.WindDirection = Ogre::Vector2(4,5);
  fftNoiseOptions.AnimationSpeed = .1;
  fftNoiseOptions.KwPower = 6.0f;
  fftNoiseOptions.Amplitude = 1.0f;
  fftNoiseOptions.GPU_Strength = .20f;
  fftNoiseOptions.GPU_LODParameters = Ogre::Vector3(0.5f, 50, 150000);
 
  // Create our components class instances (that do not enable the component!)
  godRaysComponent               = new WaterComponentGodRays(this);
  underwaterReflectionsComponent = new WaterComponentUnderwaterReflections(this);
  underwaterComponent            = new WaterComponentUnderwater(this);
  causticsComponent              = new WaterComponentCaustics(this);
  smoothComponent                = new WaterComponentSmooth(this);
  depthComponent                 = new WaterComponentDepth(this);
  foamComponent                  = new WaterComponentFoam(this);
  sunComponent                   = new WaterComponentSun(this);
 
  // Enabling all components by default
  sunComponent->SetEnabled(true);
  foamComponent->SetEnabled(true);
  depthComponent->SetEnabled(true);
  smoothComponent->SetEnabled(true);
  causticsComponent->SetEnabled(true);
  underwaterComponent->SetEnabled(true);
  underwaterReflectionsComponent->SetEnabled(true);
  godRaysComponent->SetEnabled(true);
 
  // Set up geometry options
  progGridOptions.Strength = 0.35f;
  progGridOptions.Elevation = 1.0f; // It's very important to set a little value here, cause max tesselation of the water plane is reached when the camera is at least to this height.
  progGridOptions.ChoppyStrength = 0.0375f;
  progGridOptions.Complexity = 256;
  progGridOptions.ForceRecalculateGeometry = false;
}
 
SWater::~SWater()
{
  Cleanup();
  SO3_SAFE_DELETE(sunComponent);
  SO3_SAFE_DELETE(foamComponent);
  SO3_SAFE_DELETE(depthComponent);
  SO3_SAFE_DELETE(smoothComponent);
  SO3_SAFE_DELETE(causticsComponent);
  SO3_SAFE_DELETE(underwaterComponent);
  SO3_SAFE_DELETE(underwaterReflectionsComponent);
  SO3_SAFE_DELETE(godRaysComponent);
  SO3_SAFE_DELETE(hydraxManager);
  SO3_SAFE_DELETE(hydraxGeometry);
  SO3_SAFE_DELETE(hydraxNoise);
  SO3_SAFE_DELETE(hydraxManager);
}
 
bool SWater::Initialize()
{
  // Create Hydrax object
  if (renderingViewport == 0)
    return false;
 
  Ogre::Viewport* ogreViewport = const_cast<Ogre::Viewport*> (renderingViewport->GetOgreViewPortPointer());
  hydraxManager = new Hydrax::Hydrax(parentScene->GetOgreScenePointer(), ogreViewport);
  hydraxManager->setRttVisibilityMask(SO3_VISIBILITY_MASK_VISIBLE_WATER_RTT);
 
  // For the moment, only perlin noise is supported by SO3 (random noise).
  hydraxNoise = CreatePerlinNoise();
  //(static_cast<Hydrax::Noise::Real*> (hydraxNoise))->addWave(parentEnvironment->GetWindDirection(), 0.01, parentEnvironment->GetWindSpeed(), 0.5);
 
  // Create geometry
  if(hydraxGeometry == 0)
  {
    switch(actualGeometryType)
    {
    case SO3_WATER_GEOM_INFINITE_PLANE:
      CreateInfinitePlaneGeometry();
      break;
    case SO3_WATER_GEOM_FINITE_PLANE:
      CreateFinitePlaneGeometry(finitePlaneWaterSizeX, finitePlaneWaterSizeY);
      break;
    case SO3_WATER_GEOM_RADIAL:
      CreateRadialPlaneGeometry(radialWaterRadius);
      break;
    }
  }
 
  // Load main options
  hydraxManager->setPlanesError(GetInfinitePlaneStrength() * 0.5 + 0.02f);
  hydraxManager->setUnderwaterCameraSwitchDelta(0.0f);
  hydraxManager->setGlobalTransparency(0.05f);
  hydraxManager->setFullReflectionDistance(99999997952.0);
 
  //hydraxManager->setShaderMode(Hydrax::MaterialManager::SM_CG);
 
  // Applying Hydrax parameters
  hydraxManager->setPosition(waterPlanePosition);
 
  // Applying components state (it also applies components parameters).
  sunComponent->ApplyEnable();
  foamComponent->ApplyEnable();
  depthComponent->ApplyEnable();
  smoothComponent->ApplyEnable();
  causticsComponent->ApplyEnable();
  underwaterComponent->ApplyEnable();
  underwaterReflectionsComponent->ApplyEnable();
  godRaysComponent->ApplyEnable();
 
        // Load rtt settings. Let Hydrax autodetect texture size as a default (window size is taken).
  // TODO, manage LOW/MEDIUM/HIGH parameters.
#ifdef ANDROID
  ScolWindowHandle awindow = (ScolWindowHandle)SCgetExtra("hscol");
  AConfiguration* config = AConfiguration_new();
  if (awindow)
  {
    int nwidth = (int)ANativeWindow_getWidth(awindow) / 2;
    int nheight = (int)ANativeWindow_getHeight(awindow) / 2;
 
    // portrait mode
    if (nheight > nwidth)
    {
      nwidth = (int)ANativeWindow_getHeight(awindow) / 2;
      nheight = (int)ANativeWindow_getWidth(awindow) / 2;
    }
 
    hydraxManager->getRttManager()->setTextureSize(Hydrax::RttManager::RTT_REFLECTION, Hydrax::Size(nwidth, nheight));
    hydraxManager->getRttManager()->setTextureSize(Hydrax::RttManager::RTT_REFRACTION, Hydrax::Size(nwidth, nheight));
    hydraxManager->getRttManager()->setTextureSize(Hydrax::RttManager::RTT_DEPTH, Hydrax::Size(nwidth, nheight));
    hydraxManager->getRttManager()->setTextureSize(Hydrax::RttManager::RTT_DEPTH_REFLECTION, Hydrax::Size(nwidth, nheight));
    hydraxManager->getRttManager()->setTextureSize(Hydrax::RttManager::RTT_GPU_NORMAL_MAP, Hydrax::Size(nwidth, nheight));
  }
#endif
 
  return true;
}
 
void SWater::SetEnableImpl(const bool& enableComponent)
{
  if(enableComponent)
  {
    if(hydraxManager)
      return;
 
    if(!Initialize())
      return;
 
    if(!hydraxManager->isCreated())
    {
      hydraxManager->create();
      if (hydraxManager->getMesh() && hydraxManager->getMesh()->getEntity())
        hydraxManager->getMesh()->getEntity()->setVisibilityFlags(SO3_VISIBILITY_FLAG_INVISIBLE_ENVIRONMENT);
 
      // Skyx/Hydrax synchro listener.
      hydraxManager->getRttManager()->addRttListener(this);
 
      // Add render target listener
      if(renderingViewport != 0)
      {
        bool hasStereo = renderingViewport->IsStereoViewportRegistered();
        if (hasStereo)
          renderingViewport->UnregisterStereoViewport();
 
        Ogre::Viewport* ogreViewport = renderingViewport->GetOgreViewPortPointer();
        ogreViewport->getTarget()->removeListener(this);
        ogreViewport->getTarget()->addListener(this);
        parentEnvironment->_NotifyEnvironmentComponentRegisterRenderTarget(ogreViewport);
 
        if (hasStereo)
          renderingViewport->RegisterStereoViewport();
      }
    }
  }
  else
  {
    if(hydraxManager == 0)
      return;
 
    if(hydraxManager->isCreated())
    {
      // Remove render target listener
      if(renderingViewport != 0)
      {
        bool hasStereo = renderingViewport->IsStereoViewportRegistered();
        if (hasStereo)
          renderingViewport->UnregisterStereoViewport();
 
        Ogre::Viewport* ogreViewport = renderingViewport->GetOgreViewPortPointer();
        if(ogreViewport != 0)
        {
          Ogre::RenderTarget* ogreRenderTarget = ogreViewport->getTarget();
          if(ogreRenderTarget)
            ogreRenderTarget->removeListener(this);
        }
        
        if (hasStereo)
          renderingViewport->RegisterStereoViewport();
      }
 
      hydraxManager->getRttManager()->removeRttListener(this, false);
    }
 
    // Delete Hydrax
    SO3_SAFE_DELETE(hydraxManager);
    hydraxGeometry = 0; // hydraxGeometry & hydraxNoise are deleted by hydraxManager->remove();
    hydraxNoise = 0;
  }
}
 
void SWater::AddViewport(Ogre::Viewport* viewport)
{
  if(hydraxManager)
    hydraxManager->registerViewport(viewport);
}
 
void SWater::RemoveViewport(Ogre::Viewport* viewport)
{
  if(hydraxManager)
    hydraxManager->unregisterViewport(viewport);
}
 
void SWater::RegisterViewportImpl(SViewPort* viewport)
{
  SetEnableImpl(false);
  renderingViewport = viewport;
  SetEnableImpl(GetEnable());
}
 
void SWater::UnregisterViewportImpl(SViewPort* viewport)
{
  if(hydraxManager)
  {
    if(viewport == renderingViewport)
    {
      // Stop rendering
      SetEnableImpl(false);
      renderingViewport = 0;
    }
  }
}
 
Hydrax::Hydrax* SWater::GetHydrax()
{
  return hydraxManager;
}
 
SWater::WaterComponent* SWater::GetComponent(const SWater::WaterComponentType& componentType)
{
  SWater::WaterComponent* component = 0;
  switch(componentType)
  {
  case SWater::SO3_WATER_COMPONENT_SUN:
    component = sunComponent;
    break;
  case SWater::SO3_WATER_COMPONENT_FOAM:
    component = foamComponent;
    break;
  case SWater::SO3_WATER_COMPONENT_DEPTH:
    component = depthComponent;
    break;
  case SWater::SO3_WATER_COMPONENT_SMOOTH:
    component = smoothComponent;
    break;
  case SWater::SO3_WATER_COMPONENT_CAUSTICS:
    component = causticsComponent;
    break;
  case SWater::SO3_WATER_COMPONENT_UNDERWATER:
    component = underwaterComponent;
    break;
  case SWater::SO3_WATER_COMPONENT_UNDERWATER_REFLECTIONS:
    component = underwaterReflectionsComponent;
    break;
  case SWater::SO3_WATER_COMPONENT_GODRAYS:
    component = godRaysComponent;
    break;
  default:
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Invalid water component type requested!", "SWater::GetComponent");
    break;
  }
  return component;
}
 
SWater::WaterComponentSun* SWater::GetSun()
{
  return sunComponent;
}
 
SWater::WaterComponentFoam* SWater::GetFoam()
{
  return foamComponent;
}
 
SWater::WaterComponentDepth* SWater::GetDepth()
{
  return depthComponent;
}
 
SWater::WaterComponentSmooth* SWater::GetSmooth()
{
  return smoothComponent;
}
 
SWater::WaterComponentCaustics* SWater::GetCaustics()
{
  return causticsComponent;
}
 
SWater::WaterComponentUnderwater* SWater::GetUnderwater()
{
  return underwaterComponent;
}
 
SWater::WaterComponentUnderwaterReflections* SWater::GetUnderwaterReflections()
{
  return underwaterReflectionsComponent;
}
 
SWater::WaterComponentGodRays* SWater::GetGodRays()
{
  return godRaysComponent;
}
 
Hydrax::Noise::Perlin::Options SWater::GetPerlinOptions()
{
  return perlinNoiseOptions;
}
 
void SWater::SetPerlinOptions(const Hydrax::Noise::Perlin::Options& newOptions)
{
  perlinNoiseOptions = newOptions;
  if(hydraxNoise)
    if(hydraxNoise->getName() == "Perlin")
      try
      {
        (static_cast<Hydrax::Noise::Perlin*> (hydraxNoise))->setOptions(perlinNoiseOptions);
      }
      catch(Ogre::Exception)
      {
      }
}
 
Hydrax::Noise::FFT::Options SWater::GetFFTOptions()
{
  return fftNoiseOptions;
}
 
void SWater::SetFFTOptions(const Hydrax::Noise::FFT::Options& newOptions)
{
  fftNoiseOptions = newOptions;
  if(hydraxNoise)
    if(hydraxNoise->getName() == "FFT")
      try
      {
        (static_cast<Hydrax::Noise::FFT*> (hydraxNoise))->setOptions(fftNoiseOptions);
      }
      catch(Ogre::Exception)
      {
      }
}
 
SWater::WaterGeometryType SWater::GetGeometryType()
{
  return actualGeometryType;
}
 
void SWater::SetGeometryTypeInfinitePlane()
{
  CreateInfinitePlaneGeometry();
}
 
float SWater::GetInfinitePlaneStrength()
{
  return progGridOptions.Strength;
}
 
void SWater::SetInfinitePlaneStrength(const float& value)
{
  progGridOptions.Strength = value;
 
  if((hydraxGeometry == 0) || (actualGeometryType != SO3_WATER_GEOM_INFINITE_PLANE))
    return;
 
  try
  {
    //update plane error
    hydraxManager->setPlanesError(value * 0.5 + 0.02f);
    static_cast<Hydrax::Module::ProjectedGrid*>(hydraxGeometry)->setOptions(progGridOptions);
  }
  catch(Ogre::Exception)
  {
  }
}
 
float SWater::GetInfinitePlaneElevation()
{
  return progGridOptions.Elevation;
}
 
void SWater::SetInfinitePlaneElevation(const float& value)
{
  progGridOptions.Elevation = value;
 
  if((hydraxGeometry == 0) || (actualGeometryType != SO3_WATER_GEOM_INFINITE_PLANE))
    return;
 
  try
  {
    static_cast<Hydrax::Module::ProjectedGrid*>(hydraxGeometry)->setOptions(progGridOptions);
  }
  catch(Ogre::Exception)
  {
  }
}
 
float SWater::GetInfinitePlaneComplexity()
{
  return progGridOptions.Complexity;
}
 
void SWater::SetInfinitePlaneComplexity(const float& value)
{
  progGridOptions.Complexity = value;
 
  if((hydraxGeometry == 0) || (actualGeometryType != SO3_WATER_GEOM_INFINITE_PLANE))
    return;
 
  try
  {
    static_cast<Hydrax::Module::ProjectedGrid*>(hydraxGeometry)->setOptions(progGridOptions);
  }
  catch(Ogre::Exception)
  {
  }
}
 
float SWater::GetInfinitePlaneChoppyStrength()
{
  return progGridOptions.ChoppyStrength;
}
 
void SWater::SetInfinitePlaneChoppyStrength(const float& value)
{
  progGridOptions.ChoppyStrength = value;
 
  if((hydraxGeometry == 0) || (actualGeometryType != SO3_WATER_GEOM_INFINITE_PLANE))
    return;
 
  try
  {
    static_cast<Hydrax::Module::ProjectedGrid*>(hydraxGeometry)->setOptions(progGridOptions);
  }
  catch(Ogre::Exception)
  {
  }
}
 
void SWater::SetGeometryTypeFinitePlane(const int& planeSizeX, const int& planeSizeY)
{
  CreateFinitePlaneGeometry(planeSizeX, planeSizeY);
}
 
void SWater::SetGeometryTypeRadialPlane(const float& waterRadius)
{
  CreateRadialPlaneGeometry(waterRadius);
}
 
void SWater::CreateInfinitePlaneGeometry()
{
  // Create geometry module
  Hydrax::Module::ProjectedGrid* newHydraxGeometry;
  newHydraxGeometry = new Hydrax::Module::ProjectedGrid(hydraxManager,
                                                        hydraxNoise,
                                                        Ogre::Plane(Ogre::Vector3(0,1,0), Ogre::Vector3(0,0,0)),
                                                        Hydrax::MaterialManager::NM_VERTEX,
                                                                                                                    progGridOptions);
 
  // Hydrax can handle the destruction of the existing geometry module.
  hydraxManager->setModule(newHydraxGeometry, true);
 
  // Updating internal data.
  hydraxGeometry = newHydraxGeometry;
  actualGeometryType = SO3_WATER_GEOM_INFINITE_PLANE;
}
 
void SWater::CreateFinitePlaneGeometry(const int& planeSizeX, const int& planeSizeY)
{
  // Set up geometry options
  Hydrax::Module::SimpleGrid::Options geometryOptions;
  geometryOptions.MeshSize = Hydrax::Size(planeSizeX, planeSizeY);
 
  // Create geometry module
  Hydrax::Module::SimpleGrid* newHydraxGeometry;
  newHydraxGeometry = new Hydrax::Module::SimpleGrid(hydraxManager,
                                                     hydraxNoise,
                                                     Hydrax::MaterialManager::NM_VERTEX,
                                                     geometryOptions);
 
  // Hydrax can handle the destruction of the existing geometry module.
  hydraxManager->setModule(newHydraxGeometry, true);
 
  // Updating internal data.
  hydraxGeometry = newHydraxGeometry;
  actualGeometryType = SO3_WATER_GEOM_FINITE_PLANE;
  finitePlaneWaterSizeX = planeSizeX;
  finitePlaneWaterSizeY = planeSizeY;
}
 
void SWater::CreateRadialPlaneGeometry(const float& waterRadius)
{
  // Set up geometry options
  Hydrax::Module::RadialGrid::Options geometryOptions;
  geometryOptions.Radius = waterRadius;
 
  // Create geometry module
  Hydrax::Module::RadialGrid* newHydraxGeometry;
  newHydraxGeometry = new Hydrax::Module::RadialGrid(hydraxManager,
                                                     hydraxNoise,
                                                     Hydrax::MaterialManager::NM_VERTEX,
                                                     geometryOptions);
 
  // Hydrax can handle the destruction of the existing geometry module.
  hydraxManager->setModule(newHydraxGeometry, true);
 
  // Updating internal data.
  hydraxGeometry = newHydraxGeometry;
  actualGeometryType = SO3_WATER_GEOM_RADIAL;
  radialWaterRadius = waterRadius;
}
 
void SWater::RefreshWaterColourGradient()
{
  // Alpha is not managed by Hydrax, which only use a Ogre::Vector3 for rgb values, so do not care about alpha that will be less than 1 after those multiplications.
  waterColourGradient.Clear();
  waterColourGradient.AddColourFrame(1.0,  baseColour);
  waterColourGradient.AddColourFrame(0.8,  baseColour * 0.75);
  waterColourGradient.AddColourFrame(0.6,  baseColour * 0.625);
  waterColourGradient.AddColourFrame(0.5,  baseColour * 0.5);
  waterColourGradient.AddColourFrame(0.0,  baseColour * 0.4);
}
void SWater::ApplyHydraxComponentTypes()
{
  // Hydrax remove not compatible components so we should use
  // the SWater configuration to be sure that the components are correctly added when needed
  if (hydraxManager)
  {
    Hydrax::HydraxComponent components = Hydrax::HYDRAX_COMPONENTS_NONE;
    if (godRaysComponent && godRaysComponent->GetEnabled())
      components = static_cast<Hydrax::HydraxComponent> (components|Hydrax::HYDRAX_COMPONENT_UNDERWATER_GODRAYS);
 
    if (underwaterReflectionsComponent && underwaterReflectionsComponent->GetEnabled())
      components = static_cast<Hydrax::HydraxComponent> (components|Hydrax::HYDRAX_COMPONENT_UNDERWATER_REFLECTIONS);
 
    if (underwaterComponent && underwaterComponent->GetEnabled())
      components = static_cast<Hydrax::HydraxComponent> (components|Hydrax::HYDRAX_COMPONENT_UNDERWATER);
 
    if (causticsComponent && causticsComponent->GetEnabled())
      components = static_cast<Hydrax::HydraxComponent> (components|Hydrax::HYDRAX_COMPONENT_CAUSTICS);
 
    if (smoothComponent && smoothComponent->GetEnabled())
      components = static_cast<Hydrax::HydraxComponent> (components|Hydrax::HYDRAX_COMPONENT_SMOOTH);
 
#if !defined(ANDROID) && !defined(APPLE_IOS) && !defined(RPI)
    if (depthComponent && depthComponent->GetEnabled())
      components = static_cast<Hydrax::HydraxComponent> (components|Hydrax::HYDRAX_COMPONENT_DEPTH);
#endif
 
    if (foamComponent && foamComponent->GetEnabled())
      components = static_cast<Hydrax::HydraxComponent> (components|Hydrax::HYDRAX_COMPONENT_FOAM);
 
    if (sunComponent && sunComponent->GetEnabled())
      components = static_cast<Hydrax::HydraxComponent> (components|Hydrax::HYDRAX_COMPONENT_SUN);
 
    hydraxManager->setComponents(components);
  }
}
 
/**********************************/
/* Base component class.          */
/* Do not use directly, must be   */
/* derivated.                     */
/**********************************/
SWater::WaterComponent::WaterComponent(SWater* parentWaterInstance, const SWater::WaterComponentType& component, const Hydrax::HydraxComponent& hydraxComponent) : componentType(component),
                                                                                                                                                                   hydraxComponentType(hydraxComponent)
{
  parentWater = parentWaterInstance;
  waterComponentEnable = false;
}
 
SWater::WaterComponent::WaterComponent() : componentType(SWater::SO3_WATER_COMPONENT_NONE),
                                           hydraxComponentType(Hydrax::HYDRAX_COMPONENTS_NONE)
{
  // Forbiden constructor (private).
  parentWater = 0;
  waterComponentEnable = false;
}
 
SWater::WaterComponent::~WaterComponent()
{
  SetEnabled(false);
  parentWater = 0;
}
 
bool SWater::WaterComponent::GetEnabled()
{
  return waterComponentEnable;
}
 
void SWater::WaterComponent::SetEnabled(const bool& enable)
{
  if(waterComponentEnable != enable)
  {
    waterComponentEnable = enable;
    ApplyEnable();
  }
}
 
void SWater::WaterComponent::ApplyEnable()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
  {
    // Apply components parameters too.
    if(waterComponentEnable)
      ApplyParameters();
 
    parentWater->ApplyHydraxComponentTypes();
  }
}
 
SWater::WaterComponentType SWater::WaterComponent::GetType()
{
  return componentType;
}
 
/**********************************/
/* Sun component functions        */
/**********************************/
SWater::WaterComponentSun::WaterComponentSun(SWater* parentWaterInstance) : SWater::WaterComponent(parentWaterInstance, SWater::SO3_WATER_COMPONENT_SUN, Hydrax::HYDRAX_COMPONENT_SUN)
{
  horizonPlane = Ogre::Plane(Ogre::Vector3::UNIT_Y, 0);
  SetParameters(Ogre::Vector3(0.0f, 10000.0f, 0.0f), 1.75f, 1500.0f, Ogre::ColourValue(1.0f, 0.9f, 0.6f));
}
 
SWater::WaterComponentSun::WaterComponentSun() : SWater::WaterComponent(0, SWater::SO3_WATER_COMPONENT_NONE, Hydrax::HYDRAX_COMPONENTS_NONE)
{
  // Forbiden constructor (private).
}
 
void SWater::WaterComponentSun::SetParameters(const Ogre::Vector3& position, const float& strength, const float& area, const Ogre::ColourValue& color)
{
  sunPosition = position;
        sunStrength = strength;
        sunArea = area;
        sunColor = color;
  ApplyParameters();
}
 
Ogre::Vector3 SWater::WaterComponentSun::GetPosition()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    sunPosition = hydraxManager->getSunPosition();
 
  return sunPosition;
}
 
void SWater::WaterComponentSun::SetPosition(const Ogre::Vector3& position)
{
  sunPosition = position;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    hydraxManager->setSunPosition(sunPosition);
}
 
float SWater::WaterComponentSun::GetStrength()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
          sunStrength = hydraxManager->getSunStrength();
 
  return sunStrength;
}
 
void SWater::WaterComponentSun::SetStrength(const float& strength)
{
  sunStrength = strength;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    hydraxManager->setSunStrength(sunStrength);
}
 
float SWater::WaterComponentSun::GetArea()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    sunArea = hydraxManager->getSunArea();
 
  return sunArea;
}
 
void SWater::WaterComponentSun::SetArea(const float& area)
{
  sunArea = area;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    hydraxManager->setSunArea(sunArea);
}
 
Ogre::ColourValue SWater::WaterComponentSun::GetColor()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
  {
    Ogre::Vector3 sunColourAsVector = hydraxManager->getSunColor();
    sunColor = Ogre::ColourValue(sunColourAsVector.x, sunColourAsVector.y, sunColourAsVector.z);
  }
 
  return sunColor;
}
 
void SWater::WaterComponentSun::SetColor(const Ogre::ColourValue& color)
{
  sunColor = color;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
  {
    Ogre::Vector3 sunColourAsVector(sunColor.r, sunColor.g, sunColor.b);
    hydraxManager->setSunColor(sunColourAsVector);
  }
}
 
void SWater::WaterComponentSun::Update(const Ogre::Real& updateTime)
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0 && hydraxManager->isCreated())
  {
    // Get the hydrax internal component state
    bool hydraxComponentState = hydraxManager->isComponent(hydraxComponentType);
 
    // Get sun light direction
    Ogre::Vector3 sunLightDirecton = parentWater->GetEnvironment()->GetSun()->GetLightDirection();
 
    // Get sun colour
    Ogre::Vector3 sunColourAsVector(0.0f, 0.0f, 0.0f);
    if(sunLightDirecton.y > -0.07)
    {
      // If the sun is above, get the sun light color, if below the horizon, set as black
      Ogre::ColourValue tmpSunColour = parentWater->GetEnvironment()->GetSun()->GetLightColour();
      sunColourAsVector = Ogre::Vector3(tmpSunColour.r, tmpSunColour.g, tmpSunColour.b);
    }
 
    if(hydraxComponentState == true)
    {
      // Update sun position
      hydraxManager->setSunPosition(sunLightDirecton * 10000.0f);
 
      // Update sun color
      hydraxManager->setSunColor(sunColourAsVector);
    }
  }
}
 
void SWater::WaterComponentSun::ApplyParameters()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
  {
    hydraxManager->setSunPosition(sunPosition);
          hydraxManager->setSunStrength(sunStrength);
          hydraxManager->setSunArea(sunArea);
    Ogre::Vector3 sunColourAsVector(sunColor.r, sunColor.g, sunColor.b);
          hydraxManager->setSunColor(sunColourAsVector);
  }
}
 
/**********************************/
/* Foam component functions       */
/**********************************/
SWater::WaterComponentFoam::WaterComponentFoam(SWater* parentWaterInstance) : SWater::WaterComponent(parentWaterInstance, SWater::SO3_WATER_COMPONENT_FOAM, Hydrax::HYDRAX_COMPONENT_FOAM)
{
  SetParameters(75000000.0f, 0.075f, 0.0f, 1.0f);
}
 
SWater::WaterComponentFoam::WaterComponentFoam() : SWater::WaterComponent(0, SWater::SO3_WATER_COMPONENT_NONE, Hydrax::HYDRAX_COMPONENTS_NONE)
{
  // Forbiden constructor (private).
}
 
void SWater::WaterComponentFoam::SetParameters(const float& maxDistance, const float& scale, const float& start, const float& transparency)
{
        foamMaxDistance = maxDistance;
        foamScale = scale;
        foamStart = start;
        foamTransparency = transparency;
  ApplyParameters();
}
 
float SWater::WaterComponentFoam::GetMaxDistance()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    foamMaxDistance = hydraxManager->getFoamMaxDistance();
 
  return foamMaxDistance;
}
 
void SWater::WaterComponentFoam::SetMaxDistance(const float& maxDistance)
{
  foamMaxDistance = maxDistance;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    hydraxManager->setFoamMaxDistance(foamMaxDistance);
}
 
float SWater::WaterComponentFoam::GetScale()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    foamScale = hydraxManager->getFoamScale();
 
  return foamScale;
}
 
void SWater::WaterComponentFoam::SetScale(const float& scale)
{
  foamScale = scale;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    hydraxManager->setFoamScale(foamScale);
}
 
float SWater::WaterComponentFoam::GetStart()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    foamStart = hydraxManager->getFoamStart();
 
  return foamStart;
}
 
void SWater::WaterComponentFoam::SetStart(const float& start)
{
  foamStart = start;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    hydraxManager->setFoamStart(foamStart);
}
 
float SWater::WaterComponentFoam::GetTransparency()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    foamTransparency = hydraxManager->getFoamTransparency();
 
  return foamTransparency;
}
 
void SWater::WaterComponentFoam::SetTransparency(const float& transparency)
{
  foamTransparency = transparency;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
          hydraxManager->setFoamTransparency(foamTransparency);
}
 
void SWater::WaterComponentFoam::Update(const Ogre::Real& updateTime)
{
}
 
void SWater::WaterComponentFoam::ApplyParameters()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
  {
          hydraxManager->setFoamMaxDistance(foamMaxDistance);
          hydraxManager->setFoamScale(foamScale);
          hydraxManager->setFoamStart(foamStart);
          hydraxManager->setFoamTransparency(foamTransparency);
  }
}
 
/**********************************/
/* Depth component functions      */
/**********************************/
SWater::WaterComponentDepth::WaterComponentDepth(SWater* parentWaterInstance) : SWater::WaterComponent(parentWaterInstance, SWater::SO3_WATER_COMPONENT_DEPTH, Hydrax::HYDRAX_COMPONENT_DEPTH)
{
  SetParameters(9.0f, 9.0f);
}
 
SWater::WaterComponentDepth::WaterComponentDepth() : SWater::WaterComponent(0, SWater::SO3_WATER_COMPONENT_NONE, Hydrax::HYDRAX_COMPONENTS_NONE)
{
  // Forbiden constructor (private).
}
 
void SWater::WaterComponentDepth::SetParameters(const float& depthLimit, const float& distanceLimit)
{
  depthLimitation = depthLimit;
  distanceLimitation = distanceLimit;
  ApplyParameters();
}
 
float SWater::WaterComponentDepth::GetDepthLimit()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    depthLimitation = hydraxManager->getDepthLimit();
 
  return depthLimitation;
}
 
void SWater::WaterComponentDepth::SetDepthLimit(const float& depthLimit)
{
  depthLimitation = depthLimit;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
          hydraxManager->setDepthLimit(depthLimitation);
}
 
float SWater::WaterComponentDepth::GetDistanceLimit()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    distanceLimitation = hydraxManager->getDistLimit();
 
  return distanceLimitation;
}
 
void SWater::WaterComponentDepth::SetDistanceLimit(const float& distanceLimit)
{
  distanceLimitation = distanceLimit;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    hydraxManager->setDistLimit(distanceLimitation);
}
 
void SWater::WaterComponentDepth::Update(const Ogre::Real& updateTime)
{
  // TODO Depth should vary a little depending day or night.
}
 
void SWater::WaterComponentDepth::ApplyParameters()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
  {
    hydraxManager->setDepthLimit(depthLimitation);
    hydraxManager->setDistLimit(distanceLimitation);
  }
 
  // Smooth transitions and caustics components need depth component, so force the reactivation of those components if needed.
  parentWater->GetSmooth()->ApplyEnable();
  parentWater->GetCaustics()->ApplyEnable();
}
 
/**********************************/
/* Smoothing component functions  */
/**********************************/
SWater::WaterComponentSmooth::WaterComponentSmooth(SWater* parentWaterInstance) : SWater::WaterComponent(parentWaterInstance, SWater::SO3_WATER_COMPONENT_SMOOTH, Hydrax::HYDRAX_COMPONENT_SMOOTH)
{
  SetPower(5.0f);
}
 
SWater::WaterComponentSmooth::WaterComponentSmooth() : SWater::WaterComponent(0, SWater::SO3_WATER_COMPONENT_NONE, Hydrax::HYDRAX_COMPONENTS_NONE)
{
  // Forbiden constructor (private).
}
 
float SWater::WaterComponentSmooth::GetPower()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    smoothPower = hydraxManager->getSmoothPower();
 
  return smoothPower;
}
 
void SWater::WaterComponentSmooth::SetPower(const float& power)
{
  smoothPower = power;
        ApplyParameters();
}
 
void SWater::WaterComponentSmooth::Update(const Ogre::Real& updateTime)
{
  // Nothing to do
}
 
void SWater::WaterComponentSmooth::ApplyParameters()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
        hydraxManager->setSmoothPower(smoothPower);
}
 
/**********************************/
/* Caustics component functions   */
/**********************************/
SWater::WaterComponentCaustics::WaterComponentCaustics(SWater* parentWaterInstance) : SWater::WaterComponent(parentWaterInstance, SWater::SO3_WATER_COMPONENT_CAUSTICS, Hydrax::HYDRAX_COMPONENT_CAUSTICS)
{
  SetParameters(2.35f, 5.0f, 0.55f);
}
 
SWater::WaterComponentCaustics::WaterComponentCaustics() : SWater::WaterComponent(0, SWater::SO3_WATER_COMPONENT_NONE, Hydrax::HYDRAX_COMPONENTS_NONE)
{
  // Forbiden constructor (private).
}
 
void SWater::WaterComponentCaustics::SetParameters(const float& scale, const float& power, const float& end)
{
        causticsScale = scale;
        causticsPower = power;
        causticsEnd = end;
  ApplyParameters();
}
 
float SWater::WaterComponentCaustics::GetScale()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    causticsScale = hydraxManager->getCausticsScale();
 
  return causticsScale;
}
 
void SWater::WaterComponentCaustics::SetScale(const float& scale)
{
  causticsScale = scale;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
          hydraxManager->setCausticsScale(causticsScale);
}
 
float SWater::WaterComponentCaustics::GetPower()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    causticsPower = hydraxManager->getCausticsPower();
 
  return causticsPower;
}
 
void SWater::WaterComponentCaustics::SetPower(const float& power)
{
  causticsPower = power;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    hydraxManager->setCausticsPower(causticsPower);
}
 
float SWater::WaterComponentCaustics::GetEnd()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    causticsEnd = hydraxManager->getCausticsEnd();
 
  return causticsEnd;
}
 
void SWater::WaterComponentCaustics::SetEnd(const float& end)
{
  causticsEnd = end;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
          hydraxManager->setCausticsEnd(causticsEnd);
}
 
void SWater::WaterComponentCaustics::Update(const Ogre::Real& updateTime)
{
  // TODO Darker caustics (lower intensity) at night.
}
 
void SWater::WaterComponentCaustics::ApplyParameters()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
  {
        hydraxManager->setCausticsScale(causticsScale);
          hydraxManager->setCausticsPower(causticsPower);
          hydraxManager->setCausticsEnd(causticsEnd);
  }
}
 
/**********************************/
/* Underwater component functions */
/**********************************/
SWater::WaterComponentUnderwater::WaterComponentUnderwater(SWater* parentWaterInstance) : SWater::WaterComponent(parentWaterInstance, SWater::SO3_WATER_COMPONENT_UNDERWATER, Hydrax::HYDRAX_COMPONENT_UNDERWATER)
{
}
 
SWater::WaterComponentUnderwater::WaterComponentUnderwater() : SWater::WaterComponent(0, SWater::SO3_WATER_COMPONENT_NONE, Hydrax::HYDRAX_COMPONENTS_NONE)
{
  // Forbiden constructor (private).
}
 
void SWater::WaterComponentUnderwater::Update(const Ogre::Real& updateTime)
{
  // Nothing to do.
}
 
void SWater::WaterComponentUnderwater::ApplyParameters()
{
  // Underwater reflections and god rays need underwater component, so force the reactivation of those components if needed.
  parentWater->GetUnderwaterReflections()->ApplyEnable();
  parentWater->GetGodRays()->ApplyEnable();
}
 
/**********************************************/
/* Underwater reflections component functions */
/**********************************************/
SWater::WaterComponentUnderwaterReflections::WaterComponentUnderwaterReflections(SWater* parentWaterInstance) : SWater::WaterComponent(parentWaterInstance, SWater::SO3_WATER_COMPONENT_UNDERWATER_REFLECTIONS, Hydrax::HYDRAX_COMPONENT_UNDERWATER_REFLECTIONS)
{
}
 
SWater::WaterComponentUnderwaterReflections::WaterComponentUnderwaterReflections() : SWater::WaterComponent(0, SWater::SO3_WATER_COMPONENT_NONE, Hydrax::HYDRAX_COMPONENTS_NONE)
{
  // Forbiden constructor (private).
}
 
void SWater::WaterComponentUnderwaterReflections::Update(const Ogre::Real& updateTime)
{
  // Nothing to do.
}
 
void SWater::WaterComponentUnderwaterReflections::ApplyParameters()
{
  // Nothing to do
}
 
/**********************************/
/* God rays component functions   */
/**********************************/
SWater::WaterComponentGodRays::WaterComponentGodRays(SWater* parentWaterInstance) : SWater::WaterComponent(parentWaterInstance, SWater::SO3_WATER_COMPONENT_GODRAYS, Hydrax::HYDRAX_COMPONENT_UNDERWATER_GODRAYS)
{
  // Init default params.
  SetParameters(Ogre::Vector3(0.76f, 12.46f, 12.29f), 0.015f, 1.0f, 100, 0.0254f, true);
}
 
SWater::WaterComponentGodRays::WaterComponentGodRays() : SWater::WaterComponent(0, SWater::SO3_WATER_COMPONENT_NONE, Hydrax::HYDRAX_COMPONENTS_NONE)
{
  // Forbiden constructor (private).
}
 
void SWater::WaterComponentGodRays::SetParameters(const Ogre::Vector3& exposure, const float& intensity, const float& speed, const int& numberOfRays, const float& raysSize, const bool& raysIntersections)
{
  godRaysExposure = exposure;
  godRaysIntensity = intensity;
  godRaysSpeed = speed;
  godRaysNumberOfRays = numberOfRays;
  godRaysRaysSize = raysSize;
  godRaysRaysIntersections = raysIntersections;
  ApplyParameters();
}
 
void SWater::WaterComponentGodRays::ApplyParameters()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
  {
          hydraxManager->setGodRaysExposure(godRaysExposure);
          hydraxManager->setGodRaysIntensity(godRaysIntensity);
          hydraxManager->getGodRaysManager()->setSimulationSpeed(godRaysSpeed);
          hydraxManager->getGodRaysManager()->setNumberOfRays(godRaysNumberOfRays);
          hydraxManager->getGodRaysManager()->setRaysSize(godRaysRaysSize);
          hydraxManager->getGodRaysManager()->setObjectIntersectionsEnabled(godRaysRaysIntersections);
  }
}
 
Ogre::Vector3   SWater::WaterComponentGodRays::GetExposure()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    godRaysExposure = hydraxManager->getGodRaysExposure();
 
  return godRaysExposure;
}
 
void SWater::WaterComponentGodRays::SetExposure(const Ogre::Vector3& exposure)
{
  godRaysExposure = exposure;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    hydraxManager->setGodRaysExposure(godRaysExposure);
}
 
float SWater::WaterComponentGodRays::GetIntensity()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    godRaysIntensity = hydraxManager->getGodRaysIntensity();
 
  return godRaysIntensity;
}
 
void SWater::WaterComponentGodRays::SetIntensity(const float& intensity)
{
  godRaysIntensity = intensity;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    hydraxManager->setGodRaysIntensity(godRaysIntensity);
}
 
float SWater::WaterComponentGodRays::GetSpeed()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    godRaysSpeed = hydraxManager->getGodRaysManager()->getSimulationSpeed();
 
  return godRaysSpeed;
}
 
void SWater::WaterComponentGodRays::SetSpeed(const float& speed)
{
  godRaysSpeed = speed;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    hydraxManager->getGodRaysManager()->setSimulationSpeed(godRaysSpeed);
}
 
int SWater::WaterComponentGodRays::GetNumberOfRays()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    godRaysNumberOfRays = hydraxManager->getGodRaysManager()->getNumberOfRays();
 
  return godRaysNumberOfRays;
}
 
void SWater::WaterComponentGodRays::SetNumberOfRays(const int& numberOfRays)
{
  godRaysNumberOfRays = numberOfRays;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    hydraxManager->getGodRaysManager()->setNumberOfRays(godRaysNumberOfRays);
}
 
float SWater::WaterComponentGodRays::GetRaysSize()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    godRaysRaysSize = hydraxManager->getGodRaysManager()->getRaysSize();
 
  return godRaysRaysSize;
}
 
void SWater::WaterComponentGodRays::SetRaysSize(const float& raysSize)
{
  godRaysRaysSize = raysSize;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    hydraxManager->getGodRaysManager()->setRaysSize(godRaysRaysSize);
}
 
bool SWater::WaterComponentGodRays::GetRaysIntersectionEnable()
{
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    godRaysRaysIntersections = hydraxManager->getGodRaysManager()->areObjectsIntersectionsEnabled();
 
  return godRaysRaysIntersections;
}
 
void SWater::WaterComponentGodRays::SetRaysIntersectionEnable(const bool& raysIntersections)
{
  godRaysRaysIntersections = raysIntersections;
  Hydrax::Hydrax* hydraxManager = parentWater->GetHydrax();
  if(hydraxManager != 0)
    hydraxManager->getGodRaysManager()->setObjectIntersectionsEnabled(godRaysRaysIntersections);
}
 
void SWater::WaterComponentGodRays::Update(const Ogre::Real& updateTime)
{
  // Nothing to do.
}
 
void SWater::UpdateCamera(SViewPort* viewport)
{
  if(viewport != renderingViewport)
    return;
 
  // Deactivate Hydrax if needed.
  SetEnableImpl(false);
 
  // Enable Hydrax if needeed
  SetEnableImpl(GetEnable());
}
 
void SWater::Update(const Ogre::Real& updateTime)
{
  // Update Hydrax
  if(hydraxManager != 0 && hydraxManager->isCreated())
  {
    // First, give the elapsed time to hydrax:
    hydraxManager->update(updateTime);
 
    // Update water color
    Ogre::ColourValue ogreColourValue = waterColourGradient.GetColour(std::max(parentEnvironment->GetSun()->GetLightDirection().y, 0.0f));
    hydraxManager->setWaterColor(Ogre::Vector3(ogreColourValue.r, ogreColourValue.g, ogreColourValue.b));
 
    // Pause the water rendering?
    if(parentEnvironment->GetPaused())
      hydraxManager->setTimeMultiplier(0.0f);
    else
      hydraxManager->setTimeMultiplier(wavesAnimationSpeed);
 
    // Change hydrax noise module if necessary
    float newWindSpeed = parentEnvironment->GetWindSpeed();
    /*if((newWindSpeed == 0.0f) && (hydraxNoise->getName() != "Perlin"))
    {
      // Old Hydrax noise module is automatically deleted.
      Hydrax::Noise::Noise* newHydraxNoise = CreatePerlinNoise();
      hydraxGeometry->setNoise(newHydraxNoise, hydraxManager->getGPUNormalMapManager());
      hydraxNoise = newHydraxNoise;
    }
    else
    {
      if((newWindSpeed > 0.0f) && (hydraxNoise->getName() != "FFT"))
      {
        Hydrax::Noise::Noise* newHydraxNoise = CreateFftNoise();
        hydraxGeometry->setNoise(newHydraxNoise, hydraxManager->getGPUNormalMapManager());
        hydraxNoise = newHydraxNoise;
      }
    }*/
 
    // TODO Change wave rendering
    /*if(newWindSpeed > 0.0f)
    {
      fftNoiseOptions.Amplitude = ?;
      fftNoiseOptions.AnimationSpeed = ?
      fftNoiseOptions.Amplitude  ? We 'may' use windDirection.y to modify amplitude...
    }*/
 
    // Apply noise options
    Ogre::Vector2 newWindDirection = parentEnvironment->GetWindDirection() * parentEnvironment->GetWindSpeed();
    if(cachedWindDirection != newWindDirection)
    {
      if(hydraxNoise->getName() == "REAL")
        (static_cast<Hydrax::Noise::Real*> (hydraxNoise))->modifyWave(0, parentEnvironment->GetWindDirection(), 0.01, 4.0, 0.5);
 
      fftNoiseOptions.WindDirection = newWindDirection;
      cachedWindDirection = newWindDirection;
 
      if(hydraxNoise->getName() == "FFT")
      {
        try
        {
          (static_cast<Hydrax::Noise::FFT*> (hydraxNoise))->setOptions(fftNoiseOptions);
        }
        catch(Ogre::Exception)
        {
        }
      }
    }
 
    // No wind direction
    //(static_cast<Hydrax::Noise::Perlin*> (hydraxNoise))->setOptions(perlinNoiseOptions);
 
    // Update all active water components. Order is important!!!
    if(sunComponent->GetEnabled())
      sunComponent->Update(updateTime);
 
    if(foamComponent->GetEnabled())
      foamComponent->Update(updateTime);
 
    if(depthComponent->GetEnabled())
      depthComponent->Update(updateTime);
 
    if(smoothComponent->GetEnabled())
      smoothComponent->Update(updateTime);
 
    if(causticsComponent->GetEnabled())
      causticsComponent->Update(updateTime);
 
    if(underwaterComponent->GetEnabled())
      underwaterComponent->Update(updateTime);
 
    if(godRaysComponent->GetEnabled())
      godRaysComponent->Update(updateTime);
  }
}
 
Ogre::Vector3 SWater::GetPosition()
{
  if(hydraxManager != 0)
    waterPlanePosition = hydraxManager->getPosition();
 
  return waterPlanePosition;
}
 
void SWater::SetPosition(const Ogre::Vector3& newSeaLevel)
{
  // avoid the projection grid bug with the same level
  if (waterPlanePosition != newSeaLevel)
  {
    waterPlanePosition = newSeaLevel;
    if(hydraxManager != 0)
      hydraxManager->setPosition(newSeaLevel);
  }
}
 
Ogre::ColourValue SWater::GetColor()
{
  return baseColour;
}
 
void SWater::SetColor(const Ogre::ColourValue& color)
{
  baseColour = color;
  RefreshWaterColourGradient();
}
 
float SWater::GetAnimationSpeed()
{
  if(hydraxManager)
    wavesAnimationSpeed = hydraxManager->getTimeMultiplier();
 
  return wavesAnimationSpeed;
}
 
void SWater::SetAnimationSpeed(const float& animationSpeed)
{
  wavesAnimationSpeed = animationSpeed;
  if(hydraxManager != 0)
    hydraxManager->setTimeMultiplier(wavesAnimationSpeed);
}
 
Hydrax::Noise::Noise* SWater::CreatePerlinNoise()
{
  return new Hydrax::Noise::Perlin(perlinNoiseOptions);
}
 
Hydrax::Noise::Noise* SWater::CreateFftNoise()
{
  return new Hydrax::Noise::FFT(fftNoiseOptions);
}
 
Hydrax::Noise::Noise* SWater::CreateRealNoise()
{
  return new Hydrax::Noise::Real();
}
 
void SWater::preRenderTargetUpdate(const Hydrax::RttManager::RttType& Rtt)
{
  SSky* sky = parentEnvironment->GetSky();
  if(sky)
  {
    SkyX::SkyX* skyxManager = sky->GetSkyX();
    if(skyxManager != 0)
    {
 
      switch (Rtt)
      {
              case Hydrax::RttManager::RTT_REFLECTION:
              {
                      // No stars in the reflection map
          skyxManager->setStarfieldEnabled(false);
              }
              break;
 
              case Hydrax::RttManager::RTT_REFRACTION:
              {
              }
              break;
 
              case Hydrax::RttManager::RTT_DEPTH:
        case Hydrax::RttManager::RTT_DEPTH_REFLECTION:
              {
                      // Hide SkyX components in depth maps
          if (hydraxManager && !hydraxManager->_isCurrentFrameUnderwater())
          {
                              skyxManager->getMeshManager()->getEntity()->setVisible(false);
                              skyxManager->getMoonManager()->getMoonBillboard()->setVisible(false);
          }
              }
              break;
      }
    }
  }
}
 
void SWater::postRenderTargetUpdate(const Hydrax::RttManager::RttType& Rtt)
{
  SSky* sky = parentEnvironment->GetSky();
  if(sky)
  {
    SkyX::SkyX* skyxManager = sky->GetSkyX();
    if(skyxManager != 0)
    {
            switch (Rtt)
            {
                    case Hydrax::RttManager::RTT_REFLECTION:
                    {
                            skyxManager->setStarfieldEnabled(true);
                    }
                    break;
 
                    case Hydrax::RttManager::RTT_REFRACTION:
                    {
                    }
                    break;
 
                    case Hydrax::RttManager::RTT_DEPTH:
        case Hydrax::RttManager::RTT_DEPTH_REFLECTION:
                    {
          if (hydraxManager && !hydraxManager->_isCurrentFrameUnderwater())
          {
                              skyxManager->getMeshManager()->getEntity()->setVisible(true);
                              skyxManager->getMoonManager()->getMoonBillboard()->setVisible(true);
          }
                    }
                    break;
            }
    }
  }
}
 
void SWater::preViewportUpdate(const Ogre::RenderTargetViewportEvent& evt)
{
}
 
}