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

#include "SO3Scene.h"
#include "SO3Sky.h"
#include "SO3Environment.h"
#include "SO3SkyAstronomicalModel.h"
#include "../SO3Renderer/SO3Viewport.h"
#include "SO3Moon.h"

namespace SO3
{

SSky::SSky(SEnvironment* parent, std::string skyName) : SEnvironmentComponent(parent, skyName)
{
  parentScene = parent->GetScene();
  cloudsAnimationSpeed = 1.0f;
  cloudsCeilingHeight = 100.0f;
  cachedMoonTextureName = "SkyX_Moon.png";

  // Create our custom moon & sun positions provider
  astronomicalModel = new SSkyAstronomicalModel(this);

  // Create Skyx object
  skyxManager = new SkyX::SkyX(parentScene->GetOgreScenePointer(), SO3_INTERNAL_SKYX_RESOURCE_GROUP, astronomicalModel);
  skyxManager->getMeshManager()->setSkydomeFadingParameters(false); // No smooth fading
  skyxManager->setTimeMultiplier(1.0f/3600.0f);
  skyxOptions = skyxManager->getAtmosphereManager()->getOptions();

  /*DEBUG*/
  skyxOptions.RayleighMultiplier = 0.003075f;
  skyxOptions.MieMultiplier = 0.00125f;
  skyxOptions.InnerRadius = 9.92f;
  skyxOptions.OuterRadius = 10.3311f;
  skyxManager->getAtmosphereManager()->setOptions(skyxOptions);
  
  // Create sky subcomponents
  volumetricClouds = new CloudVolumetric(this);
  layeredClouds = new CloudLayered(this);
}

SSky::SSky() : SEnvironmentComponent(0, "")
{
  // Forbiden (private)
}

SSky::~SSky()
{
  if(skyxManager)
  {
    SAFE_DELETE(layeredClouds);
    SAFE_DELETE(volumetricClouds);
    SAFE_DELETE(skyxManager);
    SAFE_DELETE(astronomicalModel); // Destroy after destroying skyx
  }
}

void SSky::RegisterViewport(SViewPort* viewport)
{
  skyxManager->registerViewport(viewport->GetOgreViewPortPointer());
}

SkyX::SkyX* SSky::GetSkyX()
{
  return skyxManager;
}

void SSky::Update(Ogre::Real 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.isNull())
      {
        Ogre::Technique* ogreTechnique = moonMaterial->getBestTechnique();
        if(ogreTechnique != 0)
        {
          Ogre::Pass* ogrePass = ogreTechnique->getPass(0);
          if(ogrePass != 0)
          {
            Ogre::TextureUnitState* ogreTextureUnit = ogrePass->getTextureUnitState(0);
            if(ogreTextureUnit != 0)
            {
              ogreTextureUnit->setTextureName(moonNewTextureName);
              cachedMoonTextureName = moonNewTextureName;
            }
          }
        }
      }
    }
    catch(const Ogre::Exception&)
    {
      // Do nothing
    }
  }

  skyxManager->update(updateTime);
}

SSky::SkyComponent* SSky::GetComponent(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(float animationSpeed)
{
  cloudsAnimationSpeed = animationSpeed;
}

float SSky::GetCloudCeiling()
{
  return cloudsCeilingHeight;
}

void SSky::SetCloudCeiling(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 (skyxManager->getLightingMode() == SkyX::SkyX::LM_HDR);
}

void SSky::SetHDREnable(bool enable)
{
  if(enable)
    skyxManager->setLightingMode(SkyX::SkyX::LM_HDR);
  else
    skyxManager->setLightingMode(SkyX::SkyX::LM_LDR);
}

/**********************************/
/* Base cloud class.              */
/* Do not use directly, must be   */
/* derivated.                     */
/**********************************/
SSky::SkyComponent::SkyComponent(SSky* parentSkyInstance, SSky::SkyComponentType component) : componentType(component)
{
  parentSky = parentSkyInstance;
  skyxManager = parentSkyInstance->GetSkyX();
  skyComponentEnable = true;
}

SSky::SkyComponent::SkyComponent() : componentType(SSky::SO3_SKY_COMPONENT_NONE)
{
  // Forbiden constructor (private)
}

SSky::SkyComponent::~SkyComponent()
{
  skyxManager = 0;
  parentSky = 0;
}

bool SSky::SkyComponent::GetEnabled()
{
  return skyComponentEnable;
}

void SSky::SkyComponent::SetEnabled(bool 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::Update(Ogre::Real updateTime)
{
  CloudLayerMap::iterator iCloudLayerMap = cloudLayerMap.begin();
  while(iCloudLayerMap!=cloudLayerMap.end())
  {
    SkyX::CloudLayer::Options skyxCloudLayerOptions = iCloudLayerMap->second->getOptions();
    // TODO skyxCloudLayerOptions.Height = parentSky->GetCloudCeiling() + heightFromCloudCeiling;
    skyxCloudLayerOptions.WindDirection = parentSky->GetEnvironment()->GetWindDirection();
    skyxCloudLayerOptions.TimeMultiplier = parentSky->GetAnimationSpeed();
    iCloudLayerMap->second->setOptions(skyxCloudLayerOptions);
  }
}

unsigned int SSky::CloudLayered::AddLayer(Ogre::Real heightFromCloudCeiling, Ogre::Real scale, Ogre::Real distanceAttenuation, Ogre::Real detailAttenuation, Ogre::Real normalMultiplier, Ogre::Real heightVolume, Ogre::Real volumetricDisplacement)
{
  // Find the lower index
  unsigned int lowerIndex = 1;
  if(!cloudLayerMap.empty())
    lowerIndex = cloudLayerMap.upper_bound(0)->first + 1;

  // Initialise layer options
  SkyX::CloudLayer::Options skyxCloudLayerOptions;
  skyxCloudLayerOptions.Height = parentSky->GetCloudCeiling() + heightFromCloudCeiling;
  skyxCloudLayerOptions.Scale = scale;
  skyxCloudLayerOptions.DistanceAttenuation = distanceAttenuation;
  skyxCloudLayerOptions.DetailAttenuation = detailAttenuation;
        skyxCloudLayerOptions.NormalMultiplier = normalMultiplier;
        skyxCloudLayerOptions.HeightVolume = heightVolume;
        skyxCloudLayerOptions.VolumetricDisplacement = volumetricDisplacement;
  skyxCloudLayerOptions.WindDirection = parentSky->GetEnvironment()->GetWindDirection();
  skyxCloudLayerOptions.TimeMultiplier = parentSky->GetAnimationSpeed();

  // Generate layer
  SkyX::CloudLayer* skyxCloudLayer = skyxManager->getCloudsManager()->add(skyxCloudLayerOptions);
    
  // Store the layer index
  cloudLayerMap.insert(CloudLayerMap::value_type(lowerIndex, skyxCloudLayer));

  // Return the index of this layer
  return lowerIndex;
}

void SSky::CloudLayered::RemoveLayer(unsigned int index)
{
  CloudLayerMap::iterator iSearchedLayer = cloudLayerMap.find(index);
  if(iSearchedLayer == cloudLayerMap.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
  skyxManager->getCloudsManager()->remove(iSearchedLayer->second);

  // Remove from the list
  cloudLayerMap.erase(iSearchedLayer);
}

void SSky::CloudLayered::RemoveAllLayers()
{
  skyxManager->getCloudsManager()->removeAll();
  cloudLayerMap.clear();
}

std::vector<int> SSky::CloudLayered::GetLayerIndexes()
{
  std::vector<int> layerIndexes;
  CloudLayerMap::iterator iLayers = cloudLayerMap.begin();
  while(iLayers != cloudLayerMap.end())
  {
    layerIndexes.push_back(iLayers->first);
    iLayers++;
  }
  return layerIndexes;
}

SkyX::CloudLayer* SSky::CloudLayered::GetLayer(unsigned int index)
{
  CloudLayerMap::iterator iSearchedLayer = cloudLayerMap.find(index);
  if(iSearchedLayer == cloudLayerMap.end())
    OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Cannot find cloud layer, there's no layer associated with this index!", "SSky::CloudLayered::GetLayer");
  
  return iSearchedLayer->second;
}

void SSky::CloudLayered::SetParameters(unsigned int index, float heightFromCloudCeiling, float scale, float attenuationDistance, float attenuationDetail, float normalMultiplier, float heightVolume, float volumetricDisplacement)
{
  SkyX::CloudLayer* skyxCloudLayer = GetLayer(index);
  SkyX::CloudLayer::Options skyxCloudLayerOptions = skyxCloudLayer->getOptions();
  skyxCloudLayerOptions.Height = parentSky->GetCloudCeiling() + heightFromCloudCeiling;
  skyxCloudLayerOptions.Scale = scale;
  skyxCloudLayerOptions.DistanceAttenuation = attenuationDistance;
  skyxCloudLayerOptions.DetailAttenuation = attenuationDetail;
  skyxCloudLayerOptions.NormalMultiplier = normalMultiplier;
  skyxCloudLayerOptions.HeightVolume = heightVolume;
  skyxCloudLayerOptions.VolumetricDisplacement = volumetricDisplacement;
  skyxCloudLayer->setOptions(skyxCloudLayerOptions);
}

Ogre::Real SSky::CloudLayered::GetHeightFromCloudCeiling(unsigned int index)
{
  return (parentSky->GetCloudCeiling() - GetLayer(index)->getOptions().Height);
}

void SSky::CloudLayered::SetHeightFromCloudCeiling(unsigned int index, Ogre::Real newHeightFromCloudCeiling)
{
  SkyX::CloudLayer* skyxCloudLayer = GetLayer(index);
  SkyX::CloudLayer::Options skyxCloudLayerOptions = skyxCloudLayer->getOptions();
  skyxCloudLayerOptions.Height = parentSky->GetCloudCeiling() + newHeightFromCloudCeiling;
  skyxCloudLayer->setOptions(skyxCloudLayerOptions);
}

Ogre::Real SSky::CloudLayered::GetScale(unsigned int index)
{
  return GetLayer(index)->getOptions().Scale;
}

void SSky::CloudLayered::SetScale(unsigned int index, Ogre::Real newScale)
{
  SkyX::CloudLayer* skyxCloudLayer = GetLayer(index);
  SkyX::CloudLayer::Options skyxCloudLayerOptions = skyxCloudLayer->getOptions();
  skyxCloudLayerOptions.Scale = newScale;
  skyxCloudLayer->setOptions(skyxCloudLayerOptions);
}


Ogre::Real SSky::CloudLayered::GetAttenuationDistance(unsigned int index)
{
  return GetLayer(index)->getOptions().DistanceAttenuation;
}

void SSky::CloudLayered::SetAttenuationDistance(unsigned int index, Ogre::Real newAttenuationDistance)
{
  SkyX::CloudLayer* skyxCloudLayer = GetLayer(index);
  SkyX::CloudLayer::Options skyxCloudLayerOptions = skyxCloudLayer->getOptions();
  skyxCloudLayerOptions.DistanceAttenuation = newAttenuationDistance;
  skyxCloudLayer->setOptions(skyxCloudLayerOptions);
}

Ogre::Real SSky::CloudLayered::GetAttenuationDetail(unsigned int index)
{
  return GetLayer(index)->getOptions().DetailAttenuation;
}

void SSky::CloudLayered::SetAttenuationDetail(unsigned int index, Ogre::Real newAttenuationDetail)
{
  SkyX::CloudLayer* skyxCloudLayer = GetLayer(index);
  SkyX::CloudLayer::Options skyxCloudLayerOptions = skyxCloudLayer->getOptions();
  skyxCloudLayerOptions.DetailAttenuation = newAttenuationDetail;
  skyxCloudLayer->setOptions(skyxCloudLayerOptions);
}

Ogre::Real SSky::CloudLayered::GetNormalMultiplier(unsigned int index)
{
  return GetLayer(index)->getOptions().NormalMultiplier;
}

void SSky::CloudLayered::SetNormalMultiplier(unsigned int index, Ogre::Real newNormalMultiplier)
{
  SkyX::CloudLayer* skyxCloudLayer = GetLayer(index);
  SkyX::CloudLayer::Options skyxCloudLayerOptions = skyxCloudLayer->getOptions();
  skyxCloudLayerOptions.NormalMultiplier = newNormalMultiplier;
  skyxCloudLayer->setOptions(skyxCloudLayerOptions);
}

Ogre::Real SSky::CloudLayered::GetHeightVolume(unsigned int index)
{
  return GetLayer(index)->getOptions().HeightVolume;
}

void SSky::CloudLayered::SetHeightVolume(unsigned int index, Ogre::Real newHeightVolume)
{
  SkyX::CloudLayer* skyxCloudLayer = GetLayer(index);
  SkyX::CloudLayer::Options skyxCloudLayerOptions = skyxCloudLayer->getOptions();
  skyxCloudLayerOptions.HeightVolume = newHeightVolume;
  skyxCloudLayer->setOptions(skyxCloudLayerOptions);
}

Ogre::Real SSky::CloudLayered::GetVolumetricDisplacement(unsigned int index)
{
  return GetLayer(index)->getOptions().VolumetricDisplacement;
}

void SSky::CloudLayered::SetVolumetricDisplacement(unsigned int index, Ogre::Real newVolumetricDisplacement)
{
  SkyX::CloudLayer* skyxCloudLayer = GetLayer(index);
  SkyX::CloudLayer::Options skyxCloudLayerOptions = skyxCloudLayer->getOptions();
  skyxCloudLayerOptions.VolumetricDisplacement = newVolumetricDisplacement;
  skyxCloudLayer->setOptions(skyxCloudLayerOptions);
}

/**********************************/
/*   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)
}

void SSky::CloudVolumetric::Update(Ogre::Real updateTime)
{
  // TODO
}

}

---