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 "Prerequisites.h"
 
#include "DataManager.h"
#include "GeometryManager.h"
#include "LightningManager.h"
 
namespace SkyX { namespace VClouds{
 
    class VClouds
    {
    public:
        struct RenderQueueGroups
        {
            inline RenderQueueGroups(const Ogre::uint8& vc, const Ogre::uint8& vclu, const Ogre::uint8& vclo)
                : vclouds(vc), vcloudsLightningsUnder(vclu), vcloudsLightningsOver(vclo)
            {
            }
 
            Ogre::uint8 vclouds;
            Ogre::uint8 vcloudsLightningsUnder;
            Ogre::uint8 vcloudsLightningsOver;
        };
 
        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))
            {
            }
 
            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);
 
        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:
        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;
 
        Ogre::SceneManager *mSceneManager;
        Ogre::Camera* mCamera;
 
        Ogre::MaterialPtr mVolCloudsMaterial;
        Ogre::MaterialPtr mVolCloudsLightningMaterial;
 
        std::vector<CameraData> mCamerasData;
    };
 
}}
 
#endif