SO3Sky.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#ifndef __SO3SKY_H__
#define __SO3SKY_H__
 
#include "SCOLBasic/SO3Prerequisites.h"
#include "SO3EnvironmentComponent.h"
#include "SCOLBasic/SO3DataScol.h"
#include "SkyX.h"
 
namespace SO3
{
 
#define SO3_SKY_DEFAULT_TIME_MULTIPLIER 10000.0f
 
class _SO3_Export SSky : public SEnvironmentComponent,
                         public Ogre::RenderTargetListener
{
public:
  enum SkyComponentType
  {
    SO3_SKY_COMPONENT_NONE,
    SO3_SKY_COMPONENT_LAYERER_CLOUD,
    SO3_SKY_COMPONENT_VOLUMETRIC_CLOUD
  };
 
        enum SkyLightingMode
        {
                SO3_SKY_LDR = 0, 
                SO3_SKY_HDR = 1  
        };
 
  class SkyComponent
  {
  public:
  protected:
    SSky* parentSky;
  private:
    bool skyComponentEnable;
    const SkyComponentType componentType;
 
  public:
    SkyComponent(SSky* parentSkyInstance, const SkyComponentType& component);
 
    virtual ~SkyComponent();
 
    bool GetEnabled();
 
    void SetEnabled(const bool& enable);
 
    virtual void SetEnableImpl(const bool& enableComponent);
 
    virtual void UnregisterCamera(Ogre::Camera* cam);
 
    SkyComponentType GetType();
 
    virtual void Update(const Ogre::Real& updateTime)=0;
  protected:
  private:
    SkyComponent();
  };
 
  class CloudLayered : public SkyComponent
  {
  public:
  protected:
  private:
    typedef std::map<unsigned int, SkyX::CloudLayer::Options*> CloudLayerOptionsMap;
    CloudLayerOptionsMap cloudLayerOptionsMap;
    typedef std::map<unsigned int, SkyX::CloudLayer*> CloudLayerMap;
    CloudLayerMap cloudLayerMap;
  
  public:
    CloudLayered(SSky* parentSkyInstance);
 
    ~CloudLayered();
 
    virtual void Update(const Ogre::Real& updateTime);
 
    unsigned int AddLayer(const Ogre::Real& heightFromCloudCeiling=0.0f, const Ogre::Real& scale=0.001f, const Ogre::Real& distanceAttenuation=0.05f, const Ogre::Real& detailAttenuation=1.0f, const Ogre::Real& heightVolume=0.25f, const Ogre::Real& volumetricDisplacement=0.01f);
 
    void RemoveLayer(const unsigned int& index);
 
    void RemoveAllLayers();
 
    std::vector<int> GetLayerIndexes();
 
    void SetParameters(const unsigned int& index, const float& heightFromCloudCeiling, const float& scale, const float& attenuationDistance, const float& attenuationDetail, const float& heightVolume, const float& volumetricDisplacement);
 
    Ogre::Real GetHeightFromCloudCeiling(const unsigned int& index);
 
    void SetHeightFromCloudCeiling(const unsigned int& index, const Ogre::Real& newHeightFromCloudCeiling);
 
    Ogre::Real GetScale(const unsigned int& index);
 
    void SetScale(const unsigned int& index, const Ogre::Real& newScale);
 
    Ogre::Real GetAttenuationDistance(const unsigned int& index);
 
    void SetAttenuationDistance(const unsigned int& index, const Ogre::Real& newAttenuationDistance);
 
    Ogre::Real GetAttenuationDetail(const unsigned int& index);
 
    void SetAttenuationDetail(const unsigned int& index, const Ogre::Real& newAttenuationDetail);
 
    Ogre::Real GetHeightVolume(const unsigned int& index);
 
    void SetHeightVolume(const unsigned int& index, const Ogre::Real& newHeightVolume);
 
    Ogre::Real GetVolumetricDisplacement(const unsigned int& index);
 
    void SetVolumetricDisplacement(const unsigned int& index, const Ogre::Real& newVolumetricDisplacement);
 
    virtual void SetEnableImpl(const bool& enableComponent);
  protected:
  private:
    CloudLayered();
 
    SkyX::CloudLayer::Options* GetLayerOptions(const unsigned int& index);
 
    void ApplyLayerOptions(const unsigned int& index);
  };
 
  class CloudVolumetric : public SkyComponent
  {
  public:
  protected:
  private:
    float cachedHumidity;
    SkyX::ColorGradient sunGradient;
    Ogre::ColourValue cachedMoonLightColour;
    Ogre::ColourValue cachedSunLightColour;
    float cachedCloudCeiling;
    float cachedWindSpeed;
    Ogre::Vector2 cachedWindDirection;
  
  public:
    CloudVolumetric(SSky* parentSkyInstance);
 
    ~CloudVolumetric();
 
    virtual void Update(const Ogre::Real& updateTime);
 
    virtual void UnregisterCamera(Ogre::Camera* cam);
 
    virtual void SetEnableImpl(const bool& enableComponent);
  protected:
  private:
    CloudVolumetric();
 
    void CheckSunColourGradient(const bool& force = false);
  };
protected:
private:
  SScene* parentScene;
  SkyX::SkyX* skyxManager;
  SkyX::AtmosphereManager::Options skyxOptions;
  SSkyAstronomicalModel* astronomicalModel;
  CloudVolumetric* volumetricClouds;
  CloudLayered* layeredClouds;
  float cloudsAnimationSpeed;
  float cloudsCeilingHeight;
  std::string cachedMoonTextureName;
  SkyLightingMode skyLightingMode;
  bool skyLightningEnable;
 
public:
  SSky(SEnvironment* parent, const std::string& skyName);
 
  ~SSky();
 
  SkyX::SkyX* GetSkyX();
 
  SSky::CloudVolumetric* GetCloudVolumetric();
  
  SkyComponent* GetComponent(const SkyComponentType& componentType);
 
  SSky::CloudLayered* GetCloudLayered();
 
  virtual void Update(const Ogre::Real& updateTime);
 
  virtual void UpdateCamera(SViewPort* viewport);
 
  float GetAnimationSpeed();
 
  void SetAnimationSpeed(const float& animationSpeed);
 
  float GetCloudCeiling();
 
  void SetCloudCeiling(const float& newCloudCeiling);
 
  bool GetHDREnable();
 
  void SetHDREnable(const bool& enable);
 
  bool GetLightningEnable();
 
  void SetLightningEnable(const bool& enable);
 
  void AddLightning(const Ogre::Vector3 from, const Ogre::Vector3 dir, const Ogre::Real length);
 
  void AddViewport(Ogre::Viewport* viewport);
 
  void RemoveViewport(Ogre::Viewport* viewport);
protected:
  virtual void SetEnableImpl(const bool& enableComponent);
  
  virtual void RegisterViewportImpl(SViewPort* viewport);
 
  virtual void UnregisterViewportImpl(SViewPort* viewport);
 
  virtual void UnregisterCameraImpl(Ogre::Camera* cam);
private:
  SSky();
};
 
}
 
#endif