VClouds.h

Go to the documentation of this file.

/*
--------------------------------------------------------------------------------
This source file is part of SkyX.
Visit http://www.paradise-studios.net/products/skyx/

Copyright (C) 2009-2012 Xavier Verguín González <xavyiy@gmail.com>

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 _SkyX_VClouds_VClouds_H_
#define _SkyX_VClouds_VClouds_H_

#include <vector>

#include "Prerequisites.h"

#include "VClouds/DataManager.h"
#include "VClouds/GeometryManager.h"
#include "VClouds/LightningManager.h"

namespace SkyX { namespace VClouds {

  class DllExport VClouds
  {
  public:
    struct RenderQueueGroups
    {
      inline RenderQueueGroups(const Ogre::uint8& vc, const Ogre::uint8& vcl)
        : vclouds(vc), vcloudsLightnings(vcl)
      {
      }

      Ogre::uint8 vclouds;
      Ogre::uint8 vcloudsLightnings;
    };

    struct GeometrySettings
    {
      Ogre::Vector2 Height;
      Ogre::Radian Alpha, Beta;
      float Radius;
      int NumberOfBlocks;
      int Na, Nb, Nc;

      GeometrySettings()
        : Height(Ogre::Vector2(10, 50))
        , Alpha(Ogre::Degree(12)), Beta(Ogre::Degree(40))
        , Radius(100)
        , NumberOfBlocks(12)
        , Na(10), Nb(8), Nc(6)
      {
      }

      GeometrySettings(const Ogre::Vector2& _Height, const float& _Radius,
          const Ogre::Radian& _Alpha = Ogre::Degree(12),
          const Ogre::Radian& _Beta = Ogre::Degree(40),
          const int& _NumberOfBlocks = 12, const int& _Na = 10,
          const int& _Nb = 8, const int& _Nc = 6)
        : Height(_Height)
        , Alpha(_Alpha), Beta(_Beta)
        , Radius(_Radius)
        , NumberOfBlocks(_NumberOfBlocks)
        , Na(_Na), Nb(_Nb), Nc(_Nc)
      {
      }
    };

    struct CameraData
    {
    public:
      inline CameraData()
        : camera(0)
        , lastPosition(Ogre::Vector3(0, 0, 0))
        , cameraOffset(Ogre::Vector2(0, 0))
        , geometryDisplacement(Ogre::Vector3(0, 0, 0))
      {
      }

      explicit inline CameraData(Ogre::Camera* c)
        : camera(c)
        , lastPosition(c->getDerivedPosition())
        , cameraOffset(Ogre::Vector2(0, 0))
        , geometryDisplacement(Ogre::Vector3(0, 0, 0))
      {
      }

      Ogre::Camera* camera;
      Ogre::Vector3 lastPosition;
      Ogre::Vector2 cameraOffset;
      Ogre::Vector3 geometryDisplacement;
    };

    VClouds(Ogre::SceneManager *sm);

    ~VClouds();

    void create();

    void create(const GeometrySettings& gs);

    void create(const Ogre::Vector2& Height, const float& Radius);

    void remove();

        void update(const Ogre::Real& timeSinceLastFrame);

        void notifyCameraRender(Ogre::Camera* c,
                                const Ogre::Real& timeSinceLastCameraFrame);

    void registerCamera(Ogre::Camera* c);

    void unregisterCamera(Ogre::Camera* c);

    inline const bool& isCreated() const
    {
      return mCreated;
    }

    inline void setGeometrySettings(const GeometrySettings& gs)
    {
      mGeometrySettings = gs;
    }

    inline const GeometrySettings& getGeometrySettings() const
    {
      return mGeometrySettings;
    }

    inline void setDistanceFallingParams(
        const Ogre::Vector2& DistanceFallingParams)
    {
      mDistanceFallingParams = DistanceFallingParams;
    }

    inline const Ogre::Vector2& getDistanceFallingParams() const
    {
      return mDistanceFallingParams;
    }

    void setRenderQueueGroups(const RenderQueueGroups& rqg);

    inline const RenderQueueGroups& getRenderQueueGroups() const
    {
      return mRenderQueueGroups;
    }

    inline void setWindDirection(const Ogre::Radian& WindDirection)
    {
      mWindDirection = WindDirection;
    }

    inline const Ogre::Radian& getWindDirection() const
    {
      return mWindDirection;
    }

    inline const Ogre::Vector2 getWindDirectionV2() const
    {
      return Ogre::Vector2(Ogre::Math::Cos(mWindDirection),
                           Ogre::Math::Sin(mWindDirection));
    }

    inline void setWindSpeed(const float& WindSpeed)
    {
      mWindSpeed = WindSpeed;
    }

    inline const float& getWindSpeed() const
    {
      return mWindSpeed;
    }

    inline void setSunDirection(const Ogre::Vector3& SunDirection)
    {
      mSunDirection = SunDirection;
    }

    inline const Ogre::Vector3& getSunDirection() const
    {
      return mSunDirection;
    }

    void setSunColor(const Ogre::Vector3& SunColor);

    inline const Ogre::Vector3& getSunColor() const
    {
      return mSunColor;
    }

    void setAmbientColor(const Ogre::Vector3& AmbientColor);

    inline const Ogre::Vector3& getAmbientColor() const
    {
      return mAmbientColor;
    }

    void setLightResponse(const Ogre::Vector4& LightResponse);

    inline const Ogre::Vector4& getLightResponse() const
    {
      return mLightResponse;
    }

    void setAmbientFactors(const Ogre::Vector4& AmbientFactors);

    inline const Ogre::Vector4& getAmbientFactors() const
    {
      return mAmbientFactors;
    }

    inline void setGlobalOpacity(const Ogre::Real& GlobalOpacity)
    {
      mGlobalOpacity = GlobalOpacity;
    }

    inline const Ogre::Real& getGlobalOpacity() const
    {
      return mGlobalOpacity;
    }

    inline void setCloudFieldScale(const Ogre::Real& CloudFieldScale)
    {
      mCloudFieldScale = CloudFieldScale;
    }

    inline const Ogre::Real& getCloudFieldScale() const
    {
      return mCloudFieldScale;
    }

    inline void setNoiseScale(const Ogre::Real& NoiseScale)
    {
      mNoiseScale = NoiseScale;
    }

    inline const Ogre::Real& getNoiseScale() const
    {
      return mNoiseScale;
    }

    void setWheater(const float& Humidity, const float& AverageCloudsSize,
        const bool& DelayedResponse);

    inline const Ogre::Vector2& getWheater() const
    {
      return mWheater;
    }

    void setVisible(const bool& visible);

    void setEnabled(bool _enabled);

    inline const bool& isVisible() const
    {
      return mVisible;
    }

    inline Ogre::SceneManager* getSceneManager()
    {
      return mSceneManager;
    }

    inline Ogre::Camera* getCamera()
    {
            return mCamera;
    }

    inline DataManager* getDataManager()
    {
      return mDataManager;
    }

    inline GeometryManager* getGeometryManager()
    {
      return mGeometryManager;
    }

    inline LightningManager* getLightningManager()
    {
      return mLightningManager;
    }

    inline std::vector<CameraData>& _getCamerasData()
    {
      return mCamerasData;
    }

  private:
    Ogre::SceneManager *mSceneManager;

    Ogre::Camera* mCamera;

    bool mCreated;

    GeometrySettings mGeometrySettings;

    Ogre::Vector2 mDistanceFallingParams;

    RenderQueueGroups mRenderQueueGroups;

    Ogre::Radian mWindDirection;
    float mWindSpeed;

    Ogre::Vector2 mWheater;
    bool mDelayedResponse;

    Ogre::Vector3 mSunDirection;

    Ogre::Vector3 mSunColor;
    Ogre::Vector3 mAmbientColor;

    Ogre::Vector4 mLightResponse;
    Ogre::Vector4 mAmbientFactors;

    float mGlobalOpacity;

    float mCloudFieldScale;
    float mNoiseScale;

    bool mVisible;

    DataManager *mDataManager;
    GeometryManager *mGeometryManager;
    LightningManager *mLightningManager;

    std::vector<CameraData> mCamerasData;

    Ogre::MaterialPtr mVolCloudsMaterial;

    Ogre::MaterialPtr mVolCloudsLightningMaterial;
  };
}}

#endif