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

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt

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

#ifndef __SO3SKY_H__
#define __SO3SKY_H__

#include "../SCOLBasic/SO3Std.h"
#include "SO3EnvironmentComponent.h"
#include "../SCOLBasic/SO3DataScol.h"
#include "SkyX/SkyX.h"

namespace SO3
{

class _SO3_Export SSky : public SEnvironmentComponent
{
public:
  enum SkyComponentType
  {
    SO3_SKY_COMPONENT_NONE,
    SO3_SKY_COMPONENT_LAYERER_CLOUD,
    SO3_SKY_COMPONENT_VOLUMETRIC_CLOUD
  };

  class SkyComponent
  {
  public:
  protected:
    SSky* parentSky;
    SkyX::SkyX* skyxManager;
  private:
    bool skyComponentEnable;
    const SkyComponentType componentType;

  public:
    SkyComponent(SSky* parentSkyInstance, SkyComponentType component);

    ~SkyComponent();

    bool GetEnabled();

    void SetEnabled(bool enable);

    SkyComponentType GetType();

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

  class CloudLayered : public SkyComponent
  {
  public:
  protected:
  private:
    typedef std::map<unsigned int, SkyX::CloudLayer*> CloudLayerMap;
    CloudLayerMap cloudLayerMap;
  
  public:
    CloudLayered(SSky* parentSkyInstance);

    ~CloudLayered();

    virtual void Update(Ogre::Real updateTime);

    unsigned int AddLayer(Ogre::Real heightFromCloudCeiling=0.0f, Ogre::Real scale=0.001f, Ogre::Real distanceAttenuation=0.05f, Ogre::Real detailAttenuation=1.0f, Ogre::Real normalMultiplier=2.0f, Ogre::Real heightVolume=0.25f, Ogre::Real volumetricDisplacement=0.01f);

    void RemoveLayer(unsigned int index);

    void RemoveAllLayers();

    std::vector<int> GetLayerIndexes();

    void SetParameters(unsigned int index, float heightFromCloudCeiling, float scale, float attenuationDistance, float attenuationDetail, float normalMultiplier, float heightVolume, float volumetricDisplacement);

    Ogre::Real GetHeightFromCloudCeiling(unsigned int index);

    void SetHeightFromCloudCeiling(unsigned int index, Ogre::Real newHeightFromCloudCeiling);

    Ogre::Real GetScale(unsigned int index);

    void SetScale(unsigned int index, Ogre::Real newScale);

    Ogre::Real GetAttenuationDistance(unsigned int index);

    void SetAttenuationDistance(unsigned int index, Ogre::Real newAttenuationDistance);

    Ogre::Real GetAttenuationDetail(unsigned int index);

    void SetAttenuationDetail(unsigned int index, Ogre::Real newAttenuationDetail);

    Ogre::Real GetNormalMultiplier(unsigned int index);

    void SetNormalMultiplier(unsigned int index, Ogre::Real newNormalMultiplier);

    Ogre::Real GetHeightVolume(unsigned int index);

    void SetHeightVolume(unsigned int index, Ogre::Real newHeightVolume);

    Ogre::Real GetVolumetricDisplacement(unsigned int index);

    void SetVolumetricDisplacement(unsigned int index, Ogre::Real newVolumetricDisplacement);
  protected:
  private:
    CloudLayered();

    SkyX::CloudLayer* GetLayer(unsigned int index);
  };

  class CloudVolumetric : public SkyComponent
  {
  public:
  protected:
  private:
  
  public:
    CloudVolumetric(SSky* parentSkyInstance);

    virtual void Update(Ogre::Real updateTime);
  protected:
  private:
    CloudVolumetric();
  };
protected:
private:
  SScene* parentScene;
  SkyX::SkyX* skyxManager;
  SkyX::AtmosphereManager::Options skyxOptions;
  SSkyAstronomicalModel* astronomicalModel;
  CloudVolumetric* volumetricClouds;
  CloudLayered* layeredClouds;
  float cloudsAnimationSpeed;
  float cloudsCeilingHeight;
  std::string cachedMoonTextureName;

public:
  SSky(SEnvironment* parent, std::string skyName);

  ~SSky();

  void RegisterViewport(SViewPort* viewport);

  SkyX::SkyX* GetSkyX();

  SSky::CloudVolumetric* GetCloudVolumetric();
  
  SkyComponent* GetComponent(SkyComponentType componentType);

  SSky::CloudLayered* GetCloudLayered();

  virtual void Update(Ogre::Real updateTime);

  float GetAnimationSpeed();

  void SetAnimationSpeed(float animationSpeed);

  float GetCloudCeiling();

  void SetCloudCeiling(float newCloudCeiling);

  bool GetHDREnable();

  void SetHDREnable(bool enable);
protected:
private:
  SSky();
};

}

#endif

---