main/include/CaelumSystem.h

/*
This file is part of Caelum.
See http://www.ogre3d.org/wiki/index.php/Caelum 

Copyright (c) 2006-2008 Caelum team. See Contributors.txt for details.

Caelum 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 3 of the License, or
(at your option) any later version.

Caelum 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 Caelum. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef CAELUMSYSTEM_H
#define CAELUMSYSTEM_H

#include "CaelumPrerequisites.h"

#include "UniversalClock.h"
#include "SkyColourModel.h"
#include "SkyDome.h"
#include "ImageStarfield.h"
#include "LayeredClouds.h"
#include "SolarSystemModel.h"
#include "GroundFog.h"
#include "Sun.h"
#include "Moon.h"

namespace caelum {

class CAELUM_EXPORT CaelumSystem : public Ogre::FrameListener, public Ogre::RenderTargetListener {
// Attributes -----------------------------------------------------------------
    private:
        Ogre::Root *mOgreRoot;

        Ogre::SceneManager *mSceneMgr;

        Ogre::SceneNode *mCaelumRootNode;

        bool mCleanup;

        bool mManageResourceGroup;

        UniversalClock *mUniversalClock;

        bool mManageSceneFog;

        double mGlobalFogDensityMultiplier;

        double mSceneFogDensityMultiplier;

        Ogre::ColourValue mSceneFogColourMultiplier;

        double mGroundFogDensityMultiplier;

        Ogre::ColourValue mGroundFogColourMultiplier;

        bool mManageAmbientLight;

        Ogre::ColourValue mMinimumAmbientLight;

        bool mEnsureSingleLightSource;

        bool mEnsureSingleShadowSource;
        
        // References to sub-components
        std::auto_ptr<SkyColourModel> mSkyColourModel;
        std::auto_ptr<SkyDome> mSkyDome;
        std::auto_ptr<SolarSystemModel> mSolarSystemModel;
        std::auto_ptr<BaseSkyLight> mSun;
        std::auto_ptr<Moon> mMoon;
        std::auto_ptr<ImageStarfield> mImageStarfield;
        std::auto_ptr<PointStarfield> mPointStarfield;
        std::auto_ptr<LayeredClouds> mClouds;
        std::auto_ptr<GroundFog> mGroundFog;

// Methods --------------------------------------------------------------------
    public:
        enum CaelumComponent
        {
            CAELUM_COMPONENT_SKY_COLOUR_MODEL   = 1 << 0,
            CAELUM_COMPONENT_SKY_DOME           = 1 << 1,
            CAELUM_COMPONENT_SOLAR_SYSTEM_MODEL = 1 << 2,
            CAELUM_COMPONENT_MOON               = 1 << 3,
            CAELUM_COMPONENT_SUN                = 1 << 4,
            CAELUM_COMPONENT_IMAGE_STARFIELD    = 1 << 5,
            CAELUM_COMPONENT_POINT_STARFIELD    = 1 << 6,
            CAELUM_COMPONENT_CLOUDS             = 1 << 7,

            // These have nasty dependencies on materials.
            CAELUM_COMPONENT_GROUND_FOG         = 1 << (16 + 0),

            // Groups
            CAELUM_COMPONENTS_NONE              = 0,
            CAELUM_COMPONENTS_DEFAULT           = 0
                    | CAELUM_COMPONENT_SKY_COLOUR_MODEL
                    | CAELUM_COMPONENT_SKY_DOME
                    | CAELUM_COMPONENT_SOLAR_SYSTEM_MODEL
                    | CAELUM_COMPONENT_MOON
                    | CAELUM_COMPONENT_SUN
                    | CAELUM_COMPONENT_POINT_STARFIELD
                    | CAELUM_COMPONENT_CLOUDS,
            CAELUM_COMPONENTS_ALL               =
                    CAELUM_COMPONENTS_DEFAULT | CAELUM_COMPONENT_GROUND_FOG,
        };
    
        CaelumSystem (
                Ogre::Root *root, 
                Ogre::SceneManager *sceneMgr, 
                CaelumComponent componentsToCreate = CAELUM_COMPONENTS_DEFAULT, 
                bool manageResGroup = true, 
                const Ogre::String &resGroupName = RESOURCE_GROUP_NAME
        );

        ~CaelumSystem ();

        void shutdown (bool cleanup);
        
        UniversalClock *getUniversalClock () const;
        
        Ogre::SceneNode* getRootNode(void) const { return mCaelumRootNode; }

        void updateSubcomponents (double timeSinceLastFrame);

        inline SkyDome* getSkyDome () const { return mSkyDome.get (); }
        inline void setSkyDome (SkyDome *obj) { mSkyDome.reset (obj); }

        inline BaseSkyLight* getSun () const { return mSun.get (); }
        inline void setSun (BaseSkyLight* obj) { mSun.reset (obj); }

        BaseSkyLight* getMoon () const { return mMoon.get (); }
        inline void setMoon (Moon* obj) { mMoon.reset (obj); }

        inline ImageStarfield* getImageStarfield () const { return mImageStarfield.get (); }
        inline void setImageStarfield (ImageStarfield* obj) { mImageStarfield.reset (obj); }

        inline PointStarfield* getPointStarfield () const { return mPointStarfield.get (); }
        inline void setPointStarfield (PointStarfield* obj) { mPointStarfield.reset (obj); }

        inline LayeredClouds* getClouds () const { return mClouds.get (); }
        inline void setClouds (LayeredClouds* obj) { mClouds.reset (obj); }

        inline void setSkyColourModel (SkyColourModel *model) {
            mSkyColourModel.reset(model);
        }

        inline SkyColourModel* getSkyColourModel () const {
            return mSkyColourModel.get();
        }

        inline void setSolarSystemModel (SolarSystemModel *model) {
            mSolarSystemModel.reset(model);
        }

        inline SolarSystemModel* getSolarSystemModel () const {
            return mSolarSystemModel.get();
        }

        inline void setGroundFog (GroundFog *model) {
            mGroundFog.reset(model);
        }

        inline GroundFog* getGroundFog () const {
            return mGroundFog.get();
        }

        void setManageSceneFog (bool value);

        bool getManageSceneFog () const;

        void setSceneFogDensityMultiplier (double value);

        double getSceneFogDensityMultiplier () const;

        inline void setSceneFogColourMultiplier (const Ogre::ColourValue& value) { mSceneFogColourMultiplier = value; }

        inline Ogre::ColourValue getSceneFogColourMultiplier () const { return mSceneFogColourMultiplier; }

        void setGroundFogDensityMultiplier (double value);

        double getGroundFogDensityMultiplier () const;

        inline void setGroundFogColourMultiplier (const Ogre::ColourValue& value) { mGroundFogColourMultiplier = value; }

        inline Ogre::ColourValue getGroundFogColourMultiplier () const { return mGroundFogColourMultiplier; }

        void setGlobalFogDensityMultiplier (double value);

        double getGlobalFogDensityMultiplier () const;

        inline void setManageAmbientLight (bool value) { mManageAmbientLight = value; }

        inline bool getManageAmbientLight () const { return mManageAmbientLight; }

        inline void setMinimumAmbientLight (const Ogre::ColourValue &value) { mMinimumAmbientLight = value; }

        inline const Ogre::ColourValue getMinimumAmbientLight () const { return mMinimumAmbientLight; }

        inline void setEnsureSingleLightSource (bool value) { mEnsureSingleLightSource = value; }

        inline bool getEnsureSingleLightSource () const { return mEnsureSingleLightSource; }

        inline void setEnsureSingleShadowSource (bool value) { mEnsureSingleShadowSource = value; }

        inline bool getEnsureSingleShadowSource () const { return mEnsureSingleShadowSource; }

    protected:
        virtual bool frameStarted (const Ogre::FrameEvent &e);

        virtual void preViewportUpdate (const Ogre::RenderTargetViewportEvent &e);

    private:
        void destroySubcomponents();
};
} // namespace caelum

#endif //CAELUMSYSTEM_H

---