SkyX.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_SkyX_H_
#define _SkyX_SkyX_H_
 
#include "Prerequisites.h"
 
#include "MeshManager.h"
#include "AtmosphereManager.h"
#include "GPUManager.h"
#include "MoonManager.h"
#include "CloudsManager.h"
#include "ColorGradient.h"
#include "Controller.h"
#include "BasicController.h"
#include "VCloudsManager.h"
#include "VClouds/VClouds.h"
#include "VClouds/GeometryManager.h"
#include "VClouds/GeometryBlock.h"
#include "VClouds/FastFakeRandom.h"
#include "VClouds/Ellipsoid.h"
#include "VClouds/DataManager.h"
#include "SCfgFileManager.h"
 
namespace SkyX
{
    class SkyX : public Ogre::FrameListener, public Ogre::RenderTargetListener
    {
    public:
        struct RenderQueueGroups
        {
            inline RenderQueueGroups(const Ogre::uint8& s, const Ogre::uint8& vc, const Ogre::uint8& vclu, const Ogre::uint8& vclo)
                : skydome(s), vclouds(vc), vcloudsLightningsUnder(vclu), vcloudsLightningsOver(vclo)
            {
            }
 
            Ogre::uint8 skydome;
            Ogre::uint8 vclouds;
            Ogre::uint8 vcloudsLightningsUnder;
            Ogre::uint8 vcloudsLightningsOver;
        };
 
        enum LightingMode
        {
            LM_LDR = 0,
            LM_HDR = 1
        };
 
        SkyX(Ogre::SceneManager* sm, Controller* c);
 
        ~SkyX();
 
        void create();
 
        void remove();
 
        void update(const Ogre::Real &timeSinceLastFrame);
 
        void notifyCameraRender(Ogre::Camera* c);
 
        inline const bool isCreated() const
        {
            return mCreated;
        }
 
        void setVisible(const bool& visible);
 
        inline const bool& isVisible() const
        {
            return mVisible;
        }
 
        inline void setTimeMultiplier(const Ogre::Real& TimeMultiplier)
        {
            mTimeMultiplier = TimeMultiplier;
            mVCloudsManager->_updateWindSpeedConfig();
        }
 
        inline const Ogre::Real& getTimeMultiplier() const
        {
            return mTimeMultiplier;
        }
 
        inline MeshManager* getMeshManager()
        {
            return mMeshManager;
        }
 
        inline AtmosphereManager* getAtmosphereManager()
        {
            return mAtmosphereManager;
        }
 
        inline GPUManager* getGPUManager()
        {
            return mGPUManager;
        }
 
        inline MoonManager* getMoonManager()
        {
            return mMoonManager;
        }
 
        inline CloudsManager* getCloudsManager()
        {
            return mCloudsManager;
        }
 
        inline VCloudsManager* getVCloudsManager()
        {
            return mVCloudsManager;
        }
 
        inline void setController(Controller* c)
        {
            if (mController->getDeleteBySkyX())
            {
                delete mController;
            }
 
            mController = c;
        }
 
        inline Controller* getController() const
        {
            return mController;
        }
 
        void setRenderQueueGroups(const RenderQueueGroups& rqg);
 
        inline const RenderQueueGroups& getRenderQueueGroups() const
        {
            return mRenderQueueGroups;
        }
 
        void setLightingMode(const LightingMode& lm);
 
        inline const LightingMode& getLightingMode() const
        {
            return mLightingMode;
        }
 
        void setStarfieldEnabled(const bool& Enabled);
 
        inline const bool& isStarfieldEnabled() const
        {
            return mStarfield;
        }
 
        inline void setInfiniteCameraFarClipDistance(const Ogre::Real& d)
        {
            mInfiniteCameraFarClipDistance = d;
        }
 
        inline const Ogre::Real& getInfiniteCameraFarClipDistance() const
        {
            return mInfiniteCameraFarClipDistance;
        }
 
        inline Ogre::SceneManager* getSceneManager()
        {
            return mSceneManager;
        }
 
        inline Ogre::Camera* getCamera()
        {
            return mCamera;
        }
 
        bool frameStarted(const Ogre::FrameEvent& evt);
 
        void preViewportUpdate(const Ogre::RenderTargetViewportEvent& evt);
 
        inline const Ogre::Real& _getTimeOffset() const
        {
            return mTimeOffset;
        }
 
        inline CfgFileManager* getCfgFileManager()
        {
            return mCfgFileManager;
        }
 
        inline const bool loadCfg(const Ogre::String &File) const
        {
            return mCfgFileManager->load(File);
        }
 
    private:
        bool mCreated;
 
        MeshManager* mMeshManager;
        AtmosphereManager* mAtmosphereManager;
        GPUManager* mGPUManager;
        MoonManager* mMoonManager;
        CloudsManager* mCloudsManager;
        VCloudsManager* mVCloudsManager;
 
        Controller* mController;
 
        RenderQueueGroups mRenderQueueGroups;
 
        Ogre::SceneManager *mSceneManager;
        Ogre::Camera* mCamera;
 
        Ogre::Vector3 mLastCameraPosition;
        Ogre::Real mLastCameraFarClipDistance;
        Ogre::Real mInfiniteCameraFarClipDistance;
 
        bool mVisible;
 
        LightingMode mLightingMode;
        bool mStarfield;
 
        Ogre::Real mTimeMultiplier;
        Ogre::Real mTimeOffset;
 
        CfgFileManager *mCfgFileManager;
    };
}
 
#endif