SO3Sky.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/SO3Sky.h"
#include "SO3SceneGraph/SO3Environment.h"
#include "SO3SceneGraph/SO3SkyAstronomicalModel.h"
#include "SO3Renderer/SO3ViewPort.h"
#include "SO3SceneGraph/SO3Sun.h"
#include "SO3SceneGraph/SO3Moon.h"
 
namespace SO3
{
 
SSky::SSky(SEnvironment* parent, const std::string& skyName) : SEnvironmentComponent(parent, skyName)
{
  // Init member pointers
  parentScene = parent->GetScene();
  skyxManager = 0;
 
  // Store default params
  cloudsAnimationSpeed = 1.0f;
  cloudsCeilingHeight = 100.0f;
  cachedMoonTextureName = "SkyX_Moon.png";
  skyxOptions.RayleighMultiplier = 0.003075f;
  skyxOptions.MieMultiplier = 0.00125f;
  skyxOptions.InnerRadius = 5.92f;
  skyxOptions.OuterRadius = 6.3311f;
  skyxOptions.SunIntensity = 15;
  skyLightingMode = SO3_SKY_LDR;
  skyLightningEnable = false;
 
  // Create our custom moon & sun positions provider
  astronomicalModel = new SSkyAstronomicalModel(this);
 
  // Create sky subcomponents
 
  const Ogre::RenderSystemCapabilities* caps = Ogre::Root::getSingleton().getRenderSystem()->getCapabilities();
  if (caps && caps->hasCapability(Ogre::RSC_TEXTURE_3D))
    volumetricClouds = new CloudVolumetric(this);
  else
    volumetricClouds = 0;
 
  layeredClouds = new CloudLayered(this);
}
 
SSky::SSky() : SEnvironmentComponent(0, "")
{
  // Forbiden (private)
}
 
SSky::~SSky()
{
  // Call the "SComponent::Clean" parent class function, must be done here cause it call some SSky virtual functions.
  Cleanup();
 
  // Delete skyx
  SO3_SAFE_DELETE(skyxManager);
 
  // Delete Sky object.
  SO3_SAFE_DELETE(layeredClouds);
  SO3_SAFE_DELETE(volumetricClouds);
  SO3_SAFE_DELETE(astronomicalModel);
}
 
void SSky::SetEnableImpl(const bool& enableComponent)
{
  if(enableComponent)
  {
    if(!skyxManager)
    {
      // Create Skyx object
      skyxManager = new SkyX::SkyX(parentScene->GetOgreScenePointer(), astronomicalModel);
 
      // Initialise
      // skyxManager->getMeshManager()->setUnderHorizonParams();
      skyxManager->setTimeMultiplier(parentEnvironment->GetTimeSpeedFactor() / SO3_SKY_DEFAULT_TIME_MULTIPLIER);
      skyxManager->create();
      skyxManager->getMeshManager()->getEntity()->setVisibilityFlags(SO3_VISIBILITY_FLAG_INVISIBLE_ENVIRONMENT|SO3_VISIBILITY_MASK_VISIBLE_WATER_RTT);
 
      // Re-apply all parameters
      skyxManager->getAtmosphereManager()->setOptions(skyxOptions);
      SetHDREnable(skyLightingMode == SO3_SKY_HDR);
 
      // To avoid sky clipping
      skyxManager->getMeshManager()->setRadiusMultiplier(0.80f);
 
      //TODO add as SKY parameter
      skyxManager->getMoonManager()->setMoonSize(0.120f);
 
      // Register all the viewports
      SEnvironmentComponent::ViewportList viewportList = GetRegisteredViewports();
      SEnvironmentComponent::ViewportList::iterator iViewport = viewportList.begin();
      while(iViewport != viewportList.end())
      {
        bool hasStereo = (*iViewport)->IsStereoViewportRegistered();
        if (hasStereo)
          (*iViewport)->UnregisterStereoViewport();
      
        RegisterViewportImpl(*iViewport);
 
        if (hasStereo)
          (*iViewport)->RegisterStereoViewport();
 
        iViewport++;
      }
 
      if (volumetricClouds)
        volumetricClouds->SetEnableImpl(volumetricClouds->GetEnabled());
 
      layeredClouds->SetEnableImpl(layeredClouds->GetEnabled());
    }
  }
  else
  {
    if(skyxManager)
    {
      // Unregister all the viewports
      SEnvironmentComponent::ViewportList viewportList = GetRegisteredViewports();
      SEnvironmentComponent::ViewportList::iterator iViewport = viewportList.begin();
      while(iViewport != viewportList.end())
      {
        bool hasStereo = (*iViewport)->IsStereoViewportRegistered();
        if (hasStereo)
          (*iViewport)->UnregisterStereoViewport();
        
        UnregisterViewportImpl(*iViewport);
 
        if (hasStereo)
          (*iViewport)->RegisterStereoViewport();
 
        iViewport++;
      }
 
      if (volumetricClouds)
        volumetricClouds->SetEnableImpl(false);
 
      layeredClouds->SetEnableImpl(false);
 
      // Delete skyx
      skyxManager->remove();
      SO3_SAFE_DELETE(skyxManager);
    }
  }
}
 
void SSky::RegisterViewportImpl(SViewPort* viewport)
{
  if(skyxManager)
  {
    Ogre::Viewport* ogreViewport = viewport->GetOgreViewPortPointer();
    ogreViewport->getTarget()->removeListener(skyxManager);
    ogreViewport->getTarget()->addListener(skyxManager);
    parentEnvironment->_NotifyEnvironmentComponentRegisterRenderTarget(ogreViewport);
  }
}
 
void SSky::UnregisterViewportImpl(SViewPort* viewport)
{
  if(skyxManager)
  {
    Ogre::Viewport* ogreViewport = viewport->GetOgreViewPortPointer();
    if (volumetricClouds)
      volumetricClouds->UnregisterCamera(ogreViewport->getCamera());
 
    ogreViewport->getTarget()->removeListener(skyxManager);
    parentEnvironment->_NotifyEnvironmentComponentUnRegisterRenderTarget(ogreViewport);
  }
}
 
void SSky::AddViewport(Ogre::Viewport* viewport)
{
  if(skyxManager)
  {
    viewport->getTarget()->removeListener(skyxManager);
    viewport->getTarget()->addListener(skyxManager);
    parentEnvironment->_NotifyEnvironmentComponentRegisterRenderTarget(viewport);
  }
}
 
void SSky::RemoveViewport(Ogre::Viewport* viewport)
{
  if(skyxManager)
  {
    if (volumetricClouds)
      volumetricClouds->UnregisterCamera(viewport->getCamera());
 
    viewport->getTarget()->removeListener(skyxManager);
    parentEnvironment->_NotifyEnvironmentComponentUnRegisterRenderTarget(viewport);
  }
}
 
void SSky::UnregisterCameraImpl(Ogre::Camera* cam)
{
  if(skyxManager && volumetricClouds)
  {
    volumetricClouds->UnregisterCamera(cam);
  }
}
 
SkyX::SkyX* SSky::GetSkyX()
{
  return skyxManager;
}
 
void SSky::UpdateCamera(SViewPort* viewport)
{
}
 
void SSky::Update(const Ogre::Real& updateTime)
{
  if(skyxManager)
  {
    // Update layer clouds
    layeredClouds->Update(updateTime);
 
    // Update layer clouds
    if (volumetricClouds)
      volumetricClouds->Update(updateTime);
 
    std::string moonNewTextureName = parentEnvironment->GetMoon()->GetTextureName();
    if(cachedMoonTextureName != moonNewTextureName)
    {
      try
      {
        Ogre::MaterialPtr moonMaterial = static_cast<Ogre::MaterialPtr> (Ogre::MaterialManager::getSingleton().getByName(skyxManager->getGPUManager()->getMoonMaterialName()));
        if(moonMaterial)
        {
          Ogre::Material::Techniques techList = moonMaterial->getSupportedTechniques();
          if(techList.size() > 0)
          {
            Ogre::Technique* ogreTechnique = techList[0];
            Ogre::Pass* ogrePass = ogreTechnique->getPasses()[0];
            if(ogrePass != 0)
            {
              Ogre::TextureUnitState* ogreTextureUnit = ogrePass->getTextureUnitState(0);
              if(ogreTextureUnit != 0)
              {
                ogreTextureUnit->setTextureName(moonNewTextureName);
                cachedMoonTextureName = moonNewTextureName;
              }
            }
          }
        }
      }
      catch(const Ogre::Exception&)
      {
        // Do nothing
      }
    }
 
    // Pause the sky rendering?
    if(parentEnvironment->GetPaused())
      skyxManager->setTimeMultiplier(0.0f);
    else
    {
      // Big Hack!!!
      float speed = parentEnvironment->GetTimeSpeedFactor();
      if((speed > -1) && (speed < 1))
      {
        // Not true, but avoid the layered cloud animation to stop. The stars rotation will be un-noticiable.
        skyxManager->setTimeMultiplier(1.0f / SO3_SKY_DEFAULT_TIME_MULTIPLIER);
      }
      else
      {
        skyxManager->setTimeMultiplier(parentEnvironment->GetTimeSpeedFactor() / SO3_SKY_DEFAULT_TIME_MULTIPLIER);
      }
    }
 
    // Update skyx
    skyxManager->update(updateTime);
  }
}
 
SSky::SkyComponent* SSky::GetComponent(const SSky::SkyComponentType& componentType)
{
  SSky::SkyComponent* component = 0;
  switch(componentType)
  {
  case SSky::SO3_SKY_COMPONENT_LAYERER_CLOUD:
    component = layeredClouds;
    break;
  case SSky::SO3_SKY_COMPONENT_VOLUMETRIC_CLOUD:
    component = volumetricClouds;
    break;
  default:
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Invalid sky component type requested!", "SSky::GetComponent");
    break;
  }
  return component;
}
 
SSky::CloudVolumetric* SSky::GetCloudVolumetric()
{
  return volumetricClouds;
}
 
SSky::CloudLayered* SSky::GetCloudLayered()
{
  return layeredClouds;
}
 
float SSky::GetAnimationSpeed()
{
  return cloudsAnimationSpeed;
}
 
void SSky::SetAnimationSpeed(const float& animationSpeed)
{
  cloudsAnimationSpeed = animationSpeed;
}
 
float SSky::GetCloudCeiling()
{
  return cloudsCeilingHeight;
}
 
void SSky::SetCloudCeiling(const float& newCloudCeiling)
{
  float oldCloudCeiling = cloudsCeilingHeight;
  std::vector<int> layerIndexes = layeredClouds->GetLayerIndexes();
  std::vector<int>::iterator iLayerIndexes = layerIndexes.begin();
  while(iLayerIndexes != layerIndexes.end())
  {
    float layerHeightAboveCeiling = layeredClouds->GetHeightFromCloudCeiling(*iLayerIndexes);
    cloudsCeilingHeight = newCloudCeiling;
    layeredClouds->SetHeightFromCloudCeiling((*iLayerIndexes), layerHeightAboveCeiling);
    cloudsCeilingHeight = oldCloudCeiling;
    iLayerIndexes++;
  }
  cloudsCeilingHeight = newCloudCeiling;
}
 
bool SSky::GetHDREnable()
{
  return (skyLightingMode == SO3_SKY_HDR);
}
 
void SSky::SetHDREnable(const bool& enable)
{
  if(enable)
  {
    skyLightingMode = SO3_SKY_HDR;
    if(skyxManager)
      skyxManager->setLightingMode(SkyX::SkyX::LM_HDR);
  }
  else
  {
    skyLightingMode = SO3_SKY_LDR;
    if(skyxManager)
      skyxManager->setLightingMode(SkyX::SkyX::LM_LDR);
  }
}
 
bool SSky::GetLightningEnable()
{
  return skyLightningEnable;
}
 
void SSky::SetLightningEnable(const bool& enable)
{
  if (skyxManager && volumetricClouds && GetComponent(SSky::SO3_SKY_COMPONENT_VOLUMETRIC_CLOUD)->GetEnabled())
  {
    SkyX::VCloudsManager* skyxVolumetricCloudsManager = skyxManager->getVCloudsManager();
    SkyX::VClouds::VClouds* skyxVolumetricClouds = skyxVolumetricCloudsManager->getVClouds();
 
    skyxVolumetricClouds->getLightningManager()->setEnabled(enable);
    skyxVolumetricClouds->getLightningManager()->setAverageLightningApparitionTime(0.5f);
    skyxVolumetricClouds->getLightningManager()->setLightningColor(Ogre::Vector3(1,0.976,0.92));
    skyxVolumetricClouds->getLightningManager()->setLightningTimeMultiplier(2);
  }
 
  skyLightningEnable = enable;
}
 
void SSky::AddLightning(const Ogre::Vector3 from, const Ogre::Vector3 dir, const Ogre::Real length)
{
  if (skyxManager && volumetricClouds && GetComponent(SSky::SO3_SKY_COMPONENT_VOLUMETRIC_CLOUD)->GetEnabled() && skyLightningEnable)
  {
    SkyX::VCloudsManager* skyxVolumetricCloudsManager = skyxManager->getVCloudsManager();
    SkyX::VClouds::VClouds* skyxVolumetricClouds = skyxVolumetricCloudsManager->getVClouds();
 
    skyxVolumetricClouds->getLightningManager()->addLightning(from, dir, length);
  }
}
 
 
/**********************************/
/* Base cloud class.              */
/* Do not use directly, must be   */
/* derivated.                     */
/**********************************/
SSky::SkyComponent::SkyComponent(SSky* parentSkyInstance, const SSky::SkyComponentType& component) : componentType(component)
{
  parentSky = parentSkyInstance;
  skyComponentEnable = false;
}
 
SSky::SkyComponent::SkyComponent() : componentType(SSky::SO3_SKY_COMPONENT_NONE)
{
  // Forbiden constructor (private)
}
 
SSky::SkyComponent::~SkyComponent()
{
  parentSky = 0;
}
 
bool SSky::SkyComponent::GetEnabled()
{
  return skyComponentEnable;
}
 
void SSky::SkyComponent::SetEnableImpl(const bool& enableComponent)
{
}
 
void SSky::SkyComponent::UnregisterCamera(Ogre::Camera* cam)
{
}
 
void SSky::SkyComponent::SetEnabled(const bool& enable)
{
  SetEnableImpl(enable);
  skyComponentEnable = enable;
}
 
SSky::SkyComponentType SSky::SkyComponent::GetType()
{
  return componentType;
}
 
/**********************************/
/*       Basic layer cloud        */
/**********************************/
SSky::CloudLayered::CloudLayered(SSky* parentSkyInstance) : SSky::SkyComponent(parentSkyInstance, SSky::SO3_SKY_COMPONENT_LAYERER_CLOUD)
{
}
 
SSky::CloudLayered::CloudLayered() : SSky::SkyComponent(0, SSky::SO3_SKY_COMPONENT_NONE)
{
  // Forbiden constructor (private)
}
 
SSky::CloudLayered::~CloudLayered()
{
  RemoveAllLayers();
}
 
void SSky::CloudLayered::SetEnableImpl(const bool& enableComponent)
{
  SkyX::SkyX* skyxManager = parentSky->GetSkyX();
  if(skyxManager)
  {
    if(enableComponent)
    {
      CloudLayerOptionsMap::iterator iCloudLayerOptionsMap = cloudLayerOptionsMap.begin();
      while(iCloudLayerOptionsMap != cloudLayerOptionsMap.end())
      {
        // Apply layer options.
        ApplyLayerOptions(iCloudLayerOptionsMap->first);
        iCloudLayerOptionsMap++;
      }
    }
    else
    {
      // Remove any remaining CloudLayer instances.
      skyxManager->getCloudsManager()->removeAll();
 
      cloudLayerMap.clear();
    }
  }
}
 
void SSky::CloudLayered::Update(const Ogre::Real& updateTime)
{
  if(GetEnabled())
  {
    CloudLayerOptionsMap::iterator iCloudLayerOptionsMap = cloudLayerOptionsMap.begin();
    while(iCloudLayerOptionsMap!=cloudLayerOptionsMap.end())
    {
      SkyX::CloudLayer::Options* skyxCloudLayerOptions = iCloudLayerOptionsMap->second;
      skyxCloudLayerOptions->WindDirection = Ogre::Vector2(parentSky->GetEnvironment()->GetWindDirection().x, -parentSky->GetEnvironment()->GetWindDirection().y);
 
      // Auto-updated params
      float environmentHumidity = parentSky->GetEnvironment()->GetHumidity();
      skyxCloudLayerOptions->DetailAttenuation = 2.0f - (0.020f * environmentHumidity);
 
      // Do not animate while environment is paused
      if(parentSky->GetEnvironment()->GetPaused())
        skyxCloudLayerOptions->TimeMultiplier = 0.0f;
      else
      {
        float speed = parentSky->GetEnvironment()->GetTimeSpeedFactor();
        if((speed > -1) && (speed < 1))
        {
          if(speed < 0)
            skyxCloudLayerOptions->TimeMultiplier = -SO3_SKY_DEFAULT_TIME_MULTIPLIER * parentSky->GetEnvironment()->GetWindSpeed() * 0.1f;
          else
            skyxCloudLayerOptions->TimeMultiplier = SO3_SKY_DEFAULT_TIME_MULTIPLIER * parentSky->GetEnvironment()->GetWindSpeed() * 0.1f;
        }
        else
        {
          if(speed < 0)
            skyxCloudLayerOptions->TimeMultiplier = -SO3_SKY_DEFAULT_TIME_MULTIPLIER / speed * parentSky->GetEnvironment()->GetWindSpeed() * 0.1f;
          else
            skyxCloudLayerOptions->TimeMultiplier = SO3_SKY_DEFAULT_TIME_MULTIPLIER / speed * parentSky->GetEnvironment()->GetWindSpeed() * 0.1f;
        }
      }
 
      // Apply layer options.
      ApplyLayerOptions(iCloudLayerOptionsMap->first);
      iCloudLayerOptionsMap++;
    }
  }
}
 
unsigned int SSky::CloudLayered::AddLayer(const Ogre::Real& heightFromCloudCeiling, const Ogre::Real& scale, const Ogre::Real& distanceAttenuation, const Ogre::Real& detailAttenuation, const Ogre::Real& heightVolume, const Ogre::Real& volumetricDisplacement)
{
  // Find the lower index
  unsigned int lowerIndex = 1;
  if(!cloudLayerOptionsMap.empty())
  {
    bool lowerIndexFound = false;
    while(!lowerIndexFound)
    {
      if(cloudLayerOptionsMap.find(lowerIndex) != cloudLayerOptionsMap.end())
        lowerIndex++;
      else
        lowerIndexFound = true;
    }
  }
 
  // Initialise layer options
  SkyX::CloudLayer::Options* skyxCloudLayerOptions = new SkyX::CloudLayer::Options();
  skyxCloudLayerOptions->Height = parentSky->GetCloudCeiling() + heightFromCloudCeiling;
  skyxCloudLayerOptions->Scale = scale;
  skyxCloudLayerOptions->DistanceAttenuation = distanceAttenuation;
  skyxCloudLayerOptions->DetailAttenuation = detailAttenuation;
        skyxCloudLayerOptions->HeightVolume = heightVolume;
        skyxCloudLayerOptions->VolumetricDisplacement = volumetricDisplacement;
  skyxCloudLayerOptions->WindDirection = Ogre::Vector2(parentSky->GetEnvironment()->GetWindDirection().x, -parentSky->GetEnvironment()->GetWindDirection().y);
  float speed = parentSky->GetEnvironment()->GetTimeSpeedFactor();
  if((speed > -1) && (speed < 1))
  {
    if(speed < 0)
      skyxCloudLayerOptions->TimeMultiplier = -SO3_SKY_DEFAULT_TIME_MULTIPLIER * parentSky->GetEnvironment()->GetWindSpeed() * 0.1f;
    else
      skyxCloudLayerOptions->TimeMultiplier = SO3_SKY_DEFAULT_TIME_MULTIPLIER * parentSky->GetEnvironment()->GetWindSpeed() * 0.1f;
  }
  else
  {
    if(speed < 0)
      skyxCloudLayerOptions->TimeMultiplier = -SO3_SKY_DEFAULT_TIME_MULTIPLIER / speed * parentSky->GetEnvironment()->GetWindSpeed() * 0.1f;
    else
      skyxCloudLayerOptions->TimeMultiplier = SO3_SKY_DEFAULT_TIME_MULTIPLIER / speed * parentSky->GetEnvironment()->GetWindSpeed() * 0.1f;
  }
 
  cloudLayerOptionsMap.insert(CloudLayerOptionsMap::value_type(lowerIndex, skyxCloudLayerOptions));
  ApplyLayerOptions(lowerIndex);
 
  // Return the index of this layer
  return lowerIndex;
}
 
void SSky::CloudLayered::ApplyLayerOptions(const unsigned int& index)
{
  SkyX::SkyX* skyxManager = parentSky->GetSkyX();
  if(skyxManager != 0)
  {
    CloudLayerOptionsMap::iterator iLayerOptions = cloudLayerOptionsMap.find(index);
    CloudLayerMap::iterator iLayer = cloudLayerMap.find(index);
    if(iLayer == cloudLayerMap.end())
    {
      // The layer does not exist in skyx, so create it
      SkyX::CloudLayer* skyxCloudLayer = skyxManager->getCloudsManager()->add(*(iLayerOptions->second));
 
      // Store the layer index
      cloudLayerMap.insert(CloudLayerMap::value_type(index, skyxCloudLayer));
    }
    else
    {
      // Apply option on the existing layer.
      iLayer->second->setOptions(*(iLayerOptions->second));
    }
  }
  else
  {
    // Remove any remaining CloudLayer instances.
    cloudLayerMap.clear();
  }
}
 
void SSky::CloudLayered::RemoveLayer(const unsigned int& index)
{
  CloudLayerOptionsMap::iterator iSearchedLayerOptions = cloudLayerOptionsMap.find(index);
  if(iSearchedLayerOptions == cloudLayerOptionsMap.end())
    OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Cannot remove cloud layer, there's no layer associated with this index!", "SSky::CloudLayered::RemoveLayer");
 
  // Destroy from skyx cloud manager
  SkyX::SkyX* skyxManager = parentSky->GetSkyX();
  CloudLayerMap::iterator iSearchedLayer = cloudLayerMap.find(index);
  if(iSearchedLayer != cloudLayerMap.end())
  {
    if(skyxManager)
      skyxManager->getCloudsManager()->remove(iSearchedLayer->second);
 
    // Erase even if not present in skyx, because it means that we have an invalid pointer stored.
    cloudLayerMap.erase(iSearchedLayer);
  }
 
  // Remove from the list
  cloudLayerOptionsMap.erase(iSearchedLayerOptions);
}
 
void SSky::CloudLayered::RemoveAllLayers()
{
  SkyX::SkyX* skyxManager = parentSky->GetSkyX();
  if(skyxManager)
    skyxManager->getCloudsManager()->removeAll();
 
  cloudLayerMap.clear();
  cloudLayerOptionsMap.clear();
}
 
std::vector<int> SSky::CloudLayered::GetLayerIndexes()
{
  std::vector<int> layerIndexes;
  CloudLayerOptionsMap::iterator iLayerOptions = cloudLayerOptionsMap.begin();
  while(iLayerOptions != cloudLayerOptionsMap.end())
  {
    layerIndexes.push_back(iLayerOptions->first);
    iLayerOptions++;
  }
  return layerIndexes;
}
 
SkyX::CloudLayer::Options* SSky::CloudLayered::GetLayerOptions(const unsigned int& index)
{
  CloudLayerOptionsMap::iterator iSearchedLayerOption = cloudLayerOptionsMap.find(index);
  if(iSearchedLayerOption == cloudLayerOptionsMap.end())
    OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Cannot find cloud layer, there's no layer associated with this index!", "SSky::CloudLayered::GetLayerOptions");
 
  return iSearchedLayerOption->second;
}
 
void SSky::CloudLayered::SetParameters(const unsigned int& index, const float& heightFromCloudCeiling, const float& scale, const float& attenuationDistance, const float& attenuationDetail, const float& heightVolume, const float& volumetricDisplacement)
{
  SkyX::CloudLayer::Options* skyxCloudLayerOptions = GetLayerOptions(index);
  skyxCloudLayerOptions->Height = parentSky->GetCloudCeiling() + heightFromCloudCeiling;
  skyxCloudLayerOptions->Scale = scale;
  skyxCloudLayerOptions->DistanceAttenuation = attenuationDistance;
  skyxCloudLayerOptions->DetailAttenuation = attenuationDetail;
  skyxCloudLayerOptions->HeightVolume = heightVolume;
  skyxCloudLayerOptions->VolumetricDisplacement = volumetricDisplacement;
  ApplyLayerOptions(index);
}
 
Ogre::Real SSky::CloudLayered::GetHeightFromCloudCeiling(const unsigned int& index)
{
  return (parentSky->GetCloudCeiling() - GetLayerOptions(index)->Height);
}
 
void SSky::CloudLayered::SetHeightFromCloudCeiling(const unsigned int& index, const Ogre::Real& newHeightFromCloudCeiling)
{
  GetLayerOptions(index)->Height = parentSky->GetCloudCeiling() + newHeightFromCloudCeiling;
  ApplyLayerOptions(index);
}
 
Ogre::Real SSky::CloudLayered::GetScale(const unsigned int& index)
{
  return GetLayerOptions(index)->Scale;
}
 
void SSky::CloudLayered::SetScale(const unsigned int& index, const Ogre::Real& newScale)
{
  GetLayerOptions(index)->Scale = newScale;
  ApplyLayerOptions(index);
}
 
Ogre::Real SSky::CloudLayered::GetAttenuationDistance(const unsigned int& index)
{
  return GetLayerOptions(index)->DistanceAttenuation;
}
 
void SSky::CloudLayered::SetAttenuationDistance(const unsigned int& index, const Ogre::Real& newAttenuationDistance)
{
  GetLayerOptions(index)->DistanceAttenuation = newAttenuationDistance;
  ApplyLayerOptions(index);
}
 
Ogre::Real SSky::CloudLayered::GetAttenuationDetail(const unsigned int& index)
{
  return GetLayerOptions(index)->DetailAttenuation;
}
 
void SSky::CloudLayered::SetAttenuationDetail(const unsigned int& index, const Ogre::Real& newAttenuationDetail)
{
  GetLayerOptions(index)->DetailAttenuation = newAttenuationDetail;
  ApplyLayerOptions(index);
}
 
Ogre::Real SSky::CloudLayered::GetHeightVolume(const unsigned int& index)
{
  return GetLayerOptions(index)->HeightVolume;
}
 
void SSky::CloudLayered::SetHeightVolume(const unsigned int& index, const Ogre::Real& newHeightVolume)
{
  GetLayerOptions(index)->HeightVolume = newHeightVolume;
  ApplyLayerOptions(index);
}
 
Ogre::Real SSky::CloudLayered::GetVolumetricDisplacement(const unsigned int& index)
{
  return GetLayerOptions(index)->VolumetricDisplacement;
}
 
void SSky::CloudLayered::SetVolumetricDisplacement(const unsigned int& index, const Ogre::Real& newVolumetricDisplacement)
{
  GetLayerOptions(index)->VolumetricDisplacement = newVolumetricDisplacement;
  ApplyLayerOptions(index);
}
 
/**********************************/
/*   Advanced volumetric cloud    */
/**********************************/
SSky::CloudVolumetric::CloudVolumetric(SSky* parentSkyInstance) : SSky::SkyComponent(parentSkyInstance, SSky::SO3_SKY_COMPONENT_VOLUMETRIC_CLOUD)
{
}
 
SSky::CloudVolumetric::CloudVolumetric() : SSky::SkyComponent(0, SSky::SO3_SKY_COMPONENT_NONE)
{
  // Forbiden constructor (private)
}
 
SSky::CloudVolumetric::~CloudVolumetric()
{
  SkyX::SkyX* skyxManager = parentSky->GetSkyX();
  if(skyxManager)
  {
    skyxManager->getVCloudsManager()->remove();
  }
}
 
void SSky::CloudVolumetric::UnregisterCamera(Ogre::Camera* cam)
{
  SkyX::SkyX* skyxManager = parentSky->GetSkyX();
  if(skyxManager)
  {
    // Init some useful ptr
    SkyX::VCloudsManager* skyxVolumetricCloudsManager = skyxManager->getVCloudsManager();
    SkyX::VClouds::VClouds* skyxVolumetricClouds = skyxVolumetricCloudsManager->getVClouds();
    skyxVolumetricClouds->unregisterCamera(cam);
  }
}
 
void SSky::CloudVolumetric::SetEnableImpl(const bool& enableComponent)
{
  SkyX::SkyX* skyxManager = parentSky->GetSkyX();
  if(skyxManager)
  {
    // Init some useful ptr
    SkyX::VCloudsManager* skyxVolumetricCloudsManager = skyxManager->getVCloudsManager();
    SkyX::VClouds::VClouds* skyxVolumetricClouds = skyxVolumetricCloudsManager->getVClouds();
 
    if(enableComponent)
    {
      skyxVolumetricCloudsManager->setAutoupdate(false);
 
      // Should we create or destroy the 3D clouds?
      if(!skyxVolumetricCloudsManager->isCreated())
      {
        // Set height params before calling create!
        cachedHumidity = parentSky->GetEnvironment()->GetHumidity();
        cachedCloudCeiling = parentSky->GetCloudCeiling();
 
        // Change default sun gradient, no need to change ambient gradient.
        CheckSunColourGradient(true);
 
        // Initialise wind speed
        cachedWindDirection = parentSky->GetEnvironment()->GetWindDirection();
        cachedWindSpeed = parentSky->GetEnvironment()->GetWindSpeed();
        if(parentSky->GetEnvironment()->GetTimeSpeedFactor() < 0)
          cachedWindSpeed = -cachedWindSpeed;
 
        // Stop clouds animations if wind direction vector is setted to (0;0).
        if(cachedWindDirection.squaredLength() == 0.0f)
          skyxVolumetricCloudsManager->setWindSpeed(0.0f);
        else
          skyxVolumetricCloudsManager->setWindSpeed(parentSky->GetAnimationSpeed() * cachedWindSpeed * 0.5f * (cachedCloudCeiling / 7.5f));
 
        // Initialise wind direction. ATan2 instead of ATan to avoid division by zero.
        skyxVolumetricClouds->setWindDirection(Ogre::Math::ATan2(cachedWindDirection.x, -cachedWindDirection.y));
 
        // Create & apply our options. Radius is computed from default values
        float radius = 100.0f * cachedCloudCeiling / 7.5f;
        skyxVolumetricCloudsManager->create(radius);
 
        // Update humidity
        skyxVolumetricClouds->setWheater(cachedHumidity / 100.0f, std::min(1.0f, cachedHumidity / 75.0f), false);
 
        // Lightning
        skyxVolumetricClouds->getLightningManager()->setEnabled(parentSky->GetLightningEnable());
              skyxVolumetricClouds->getLightningManager()->setAverageLightningApparitionTime(0.5f);
              skyxVolumetricClouds->getLightningManager()->setLightningColor(Ogre::Vector3(1,0.976,0.92));
              skyxVolumetricClouds->getLightningManager()->setLightningTimeMultiplier(2);
 
        skyxVolumetricCloudsManager->getVClouds()->getDataManager()->setUpdateTime(5.0f);
      }
    }
    else if((skyxVolumetricCloudsManager->isCreated()) && (!enableComponent))
    {
      // Destroy
      skyxManager->getVCloudsManager()->remove();
    }
  }
}
 
void SSky::CloudVolumetric::Update(const Ogre::Real& updateTime)
{
  SkyX::SkyX* skyxManager = parentSky->GetSkyX();
  if(skyxManager)
  {
    // Init some useful ptr
    SkyX::VCloudsManager* skyxVolumetricCloudsManager = skyxManager->getVCloudsManager();
    SkyX::VClouds::VClouds* skyxVolumetricClouds = skyxVolumetricCloudsManager->getVClouds();
 
    // Should we update params?
    if(skyxVolumetricCloudsManager->isCreated())
    {
      // Update wind speed? !Cloud ceiling scale the geometry, so adapt the speed with the geometry size!
      float newCloudCeiling = parentSky->GetCloudCeiling();
      Ogre::Vector2 newWindDirection = parentSky->GetEnvironment()->GetWindDirection();
      float newWindSpeed = parentSky->GetEnvironment()->GetWindSpeed();
      if(parentSky->GetEnvironment()->GetTimeSpeedFactor() < 0)
        newWindSpeed = -newWindSpeed;
 
      // Stop clouds animations if wind direction vector is setted to (0;0).
      if((cachedWindSpeed != newWindSpeed) || (cachedCloudCeiling != newCloudCeiling) || (cachedWindDirection != newWindDirection))
      {
        if(newWindDirection.squaredLength() == 0.0f)
          skyxVolumetricCloudsManager->setWindSpeed(0.0f);
        else
          skyxVolumetricCloudsManager->setWindSpeed(parentSky->GetAnimationSpeed() * newWindSpeed * 0.5f * (newCloudCeiling / 7.5f));
      }
 
      // Update wind direction? ATan2 instead of ATan to avoid division by zero.
      if(cachedWindDirection != newWindDirection)
        skyxVolumetricClouds->setWindDirection(Ogre::Math::ATan2(newWindDirection.x, -newWindDirection.y));
 
      // Updtate humidity
      float newHumidity = parentSky->GetEnvironment()->GetHumidity();
      if(cachedHumidity != newHumidity)
        skyxVolumetricClouds->setWheater(newHumidity / 100.0f, std::min(1.0f, newHumidity / 75.0f), true);
 
      // Update sun / moon color
      CheckSunColourGradient();
 
      // Update cloud height?
      if(cachedCloudCeiling != newCloudCeiling)
      {
        // Destroy and re-create clouds, ugly, but skyx works this way for now...
        float radius = 100.0f * newCloudCeiling / 7.5f;
        skyxVolumetricCloudsManager->remove();
        skyxVolumetricCloudsManager->create(radius);
      }
 
      cachedHumidity = newHumidity;
      cachedCloudCeiling = newCloudCeiling;
      cachedWindSpeed = newWindSpeed;
      cachedWindDirection = newWindDirection;
    }
  }
}
 
void SSky::CloudVolumetric::CheckSunColourGradient(const bool& force)
{
  float moonLightTreshold = 0.4125f;
  SSun* sun = parentSky->GetEnvironment()->GetSun();
  SMoon* moon = parentSky->GetEnvironment()->GetMoon();
 
  Ogre::ColourValue newSunColour = sun->GetLightColour();
  Ogre::ColourValue newMoonColour = moon->GetLightColour();
  if((newSunColour != cachedSunLightColour) || (newMoonColour != cachedMoonLightColour) || force)
  {
    sunGradient.clear();
    Ogre::ColourValue lightSourceColour = sun->GetLightColour((0.9f - moonLightTreshold) / (1.0f - moonLightTreshold));
    sunGradient.addCFrame(SkyX::ColorGradient::ColorFrame(Ogre::Vector3(lightSourceColour.r, lightSourceColour.g, lightSourceColour.b), 1.0f));
    lightSourceColour = sun->GetLightColour((0.75f - moonLightTreshold) / (1.0f - moonLightTreshold));
    sunGradient.addCFrame(SkyX::ColorGradient::ColorFrame(Ogre::Vector3(lightSourceColour.r, lightSourceColour.g, lightSourceColour.b), 0.75f));
    lightSourceColour = sun->GetLightColour((0.5625f - moonLightTreshold) / (1.0f - moonLightTreshold));
    sunGradient.addCFrame(SkyX::ColorGradient::ColorFrame(Ogre::Vector3(lightSourceColour.r, lightSourceColour.g, lightSourceColour.b), 0.5625f));
    lightSourceColour = sun->GetLightColour((0.5f - moonLightTreshold) / (1.0f - moonLightTreshold));
    sunGradient.addCFrame(SkyX::ColorGradient::ColorFrame(Ogre::Vector3(lightSourceColour.r, lightSourceColour.g, lightSourceColour.b), 0.5f));
    lightSourceColour = sun->GetLightColour((0.4725f - moonLightTreshold) / (1.0f - moonLightTreshold));
    sunGradient.addCFrame(SkyX::ColorGradient::ColorFrame(Ogre::Vector3(lightSourceColour.r, lightSourceColour.g, lightSourceColour.b), 0.4725f));
    lightSourceColour = sun->GetLightColour((0.45f - moonLightTreshold) / (1.0f - moonLightTreshold));
    sunGradient.addCFrame(SkyX::ColorGradient::ColorFrame(Ogre::Vector3(lightSourceColour.r, lightSourceColour.g, lightSourceColour.b), 0.45f));
    sunGradient.addCFrame(SkyX::ColorGradient::ColorFrame(Ogre::Vector3(0.0, 0.0, 0.0), 0.4125f)); // Sun-Moon threshold
    lightSourceColour = moon->GetLightColour((0.45f - moonLightTreshold) / (1.0f - moonLightTreshold));
    sunGradient.addCFrame(SkyX::ColorGradient::ColorFrame(Ogre::Vector3(lightSourceColour.r, lightSourceColour.g, lightSourceColour.b), 0.25f));
    lightSourceColour = moon->GetLightColour((0.75f - moonLightTreshold) / (1.0f - moonLightTreshold));
    sunGradient.addCFrame(SkyX::ColorGradient::ColorFrame(Ogre::Vector3(lightSourceColour.r, lightSourceColour.g, lightSourceColour.b), 0.0f));
 
    SkyX::SkyX* skyxManager = parentSky->GetSkyX();
    if(skyxManager)
      skyxManager->getVCloudsManager()->setSunGradient(sunGradient);
 
    cachedSunLightColour = newSunColour;
    cachedMoonLightColour = newMoonColour;
  }
}
 
}