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

#include "CaelumPrerequisites.h"
#include "UniversalClock.h"
#include "ImageStarfield.h"
#include "PointStarfield.h"
#include "SkyLight.h"
#include "Sun.h"
#include "Moon.h"
#include "CloudSystem.h"
#include "SkyDome.h"
#include "DepthComposer.h"
#include "PrecipitationController.h"
#include "GroundFog.h"
#include "PrivatePtr.h"

namespace Caelum
{
    class CAELUM_EXPORT CaelumSystem:
            public Ogre::FrameListener,
            public Ogre::RenderTargetListener
    {
    private:
        Ogre::Root *mOgreRoot;

        Ogre::SceneManager *mSceneMgr;

        PrivateSceneNodePtr mCaelumCameraNode;

        PrivateSceneNodePtr mCaelumGroundNode;

        bool mCleanup;

        bool mAutoMoveCameraNode;

        bool mAutoNotifyCameraChanged;

        bool mAutoAttachViewportsToComponents;

        bool mAutoViewportBackground;

        Ogre::FogMode mManageSceneFogMode;

        Ogre::Real    mManageSceneFogFromDistance, mManageSceneFogToDistance;

        Real mGlobalFogDensityMultiplier;
        Ogre::ColourValue mGlobalFogColourMultiplier;

        Real mSceneFogDensityMultiplier;
        Ogre::ColourValue mSceneFogColourMultiplier;

        Real mGroundFogDensityMultiplier;
        Ogre::ColourValue mGroundFogColourMultiplier;

        bool mManageAmbientLight;

        Ogre::ColourValue mMinimumAmbientLight;

        bool mEnsureSingleLightSource;

        bool mEnsureSingleShadowSource;

        std::auto_ptr<Ogre::Image> mSkyGradientsImage;

        std::auto_ptr<Ogre::Image> mSunColoursImage;

        Ogre::Degree mObserverLatitude;
        Ogre::Degree mObserverLongitude;

        static const Ogre::Vector3 makeDirection (
                Ogre::Degree azimuth, Ogre::Degree altitude);
        
        // References to sub-components
        std::auto_ptr<UniversalClock> mUniversalClock;
        std::auto_ptr<SkyDome> mSkyDome;
        std::auto_ptr<BaseSkyLight> mSun;
        std::auto_ptr<Moon> mMoon;
        std::auto_ptr<ImageStarfield> mImageStarfield;
        std::auto_ptr<PointStarfield> mPointStarfield;
        std::auto_ptr<GroundFog> mGroundFog;
        std::auto_ptr<CloudSystem> mCloudSystem;
        std::auto_ptr<PrecipitationController> mPrecipitationController;
        std::auto_ptr<DepthComposer> mDepthComposer;

    public:
        typedef std::set<Ogre::Viewport*> AttachedViewportSet;

    private:
        AttachedViewportSet mAttachedViewports;

    public:
        enum CaelumComponent
        {
            CAELUM_COMPONENT_SKY_DOME           = 1 << 1,
            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,
            CAELUM_COMPONENT_PRECIPITATION      = 1 << 8,
            CAELUM_COMPONENT_SCREEN_SPACE_FOG   = 1 << 9,

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

            // Groups
            CAELUM_COMPONENTS_NONE              = 0,
            CAELUM_COMPONENTS_DEFAULT           = 0
                    | CAELUM_COMPONENT_SKY_DOME
                    | CAELUM_COMPONENT_MOON
                    | CAELUM_COMPONENT_SUN
                    | CAELUM_COMPONENT_POINT_STARFIELD
                    | CAELUM_COMPONENT_CLOUDS,
            CAELUM_COMPONENTS_ALL               = 0
                    | CAELUM_COMPONENTS_DEFAULT
                    | CAELUM_COMPONENT_PRECIPITATION 
                    | CAELUM_COMPONENT_SCREEN_SPACE_FOG
                    | CAELUM_COMPONENT_GROUND_FOG,
        };

        static const String DEFAULT_SKY_GRADIENTS_IMAGE;
        static const String DEFAULT_SUN_COLOURS_IMAGE;
    
        CaelumSystem (
                Ogre::Root *root, 
                Ogre::SceneManager *sceneMgr,
                CaelumComponent componentsToCreate);

        void clear ();

        void autoConfigure (
                CaelumComponent componentsToCreate);

        ~CaelumSystem ();

        void shutdown (bool cleanup);

        void updateSubcomponents (Real timeSinceLastFrame);

        void notifyCameraChanged(Ogre::Camera* cam);

        inline Ogre::SceneManager* getSceneMgr() const { return mSceneMgr; }

        inline Ogre::SceneNode* getCaelumCameraNode(void) const { return mCaelumCameraNode.get(); }

        inline Ogre::SceneNode* getCaelumGroundNode(void) const { return mCaelumGroundNode.get(); }

        inline void setAutoNotifyCameraChanged(bool value) { mAutoNotifyCameraChanged = value; }
        inline bool getAutoNotifyCameraChanged() const { return mAutoNotifyCameraChanged; }

        inline void setAutoAttachViewportsToComponents(bool value) { mAutoAttachViewportsToComponents = value; }
        inline bool getAutoAttachViewportsToComponents() const { return mAutoAttachViewportsToComponents; }

        inline void setAutoMoveCameraNode(bool value) { mAutoMoveCameraNode = value; }
        inline bool getAutoMoveCameraNode() { return mAutoMoveCameraNode; }

        inline void setAutoViewportBackground(bool value) { mAutoViewportBackground = value; }
        inline bool getAutoViewportBackground() const { return mAutoViewportBackground; }

        inline const Ogre::Degree getObserverLongitude () const { return mObserverLongitude; }

        inline void setObserverLongitude (Ogre::Degree value) { mObserverLongitude = value; }

        inline const Ogre::Degree getObserverLatitude () const { return mObserverLatitude; }

        inline void setObserverLatitude (Ogre::Degree value) { mObserverLatitude = value; }

        inline LongReal getJulianDay () const { return mUniversalClock->getJulianDay (); }
        inline void setJulianDay (LongReal value) { mUniversalClock->setJulianDay (value); }
        inline Real getTimeScale () const { return mUniversalClock->getTimeScale (); }
        inline void setTimeScale (Real value) { mUniversalClock->setTimeScale (value); }

    public:
        void attachViewport (Ogre::Viewport* rt);

        void detachViewport (Ogre::Viewport* rt);

        bool isViewportAttached (Ogre::Viewport* vp) const;

        void detachAllViewports ();

        const AttachedViewportSet& _getAttachedViewportSet () { return mAttachedViewports; }

    protected:
        // Do the work behind attach/detach viewport.
        void attachViewportImpl (Ogre::Viewport* rt);
        void detachViewportImpl (Ogre::Viewport* rt);
        
    public:
        inline UniversalClock *getUniversalClock () const { return mUniversalClock.get(); }

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

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

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

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

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

        inline GroundFog* getGroundFog () { return mGroundFog.get (); }
        void setGroundFog (GroundFog *obj);

        inline CloudSystem* getCloudSystem () { return mCloudSystem.get (); }
        void setCloudSystem (CloudSystem *obj);

        inline PrecipitationController* getPrecipitationController () { return mPrecipitationController.get (); }
        void setPrecipitationController (PrecipitationController *obj);
 
        inline DepthComposer* getDepthComposer () { return mDepthComposer.get (); }
        void setDepthComposer (DepthComposer *obj);
 
        void setManageSceneFog (Ogre::FogMode f);
        void disableFogMangement();

        Ogre::FogMode getManageSceneFog () const;

        void setManageSceneFogStart (Ogre::Real from);
        void setManageSceneFogEnd (Ogre::Real to);
        Ogre::Real getManageSceneFogStart() const;
        Ogre::Real getManageSceneFogEnd() const;

        void setSceneFogDensityMultiplier (Real value);

        Real getSceneFogDensityMultiplier () const;

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

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

        void setGroundFogDensityMultiplier (Real value);

        Real getGroundFogDensityMultiplier () const;

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

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

        void setGlobalFogDensityMultiplier (Real value);

        Real getGlobalFogDensityMultiplier () const;

        inline void setGlobalFogColourMultiplier (const Ogre::ColourValue& value) { mGlobalFogColourMultiplier = value; }

        inline const Ogre::ColourValue getGlobalFogColourMultiplier () const { return mGlobalFogColourMultiplier; }

        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; }

        Ogre::ColourValue getFogColour (Real time, const Ogre::Vector3 &sunDir);

        Real getFogDensity (Real time, const Ogre::Vector3 &sunDir);

        Ogre::ColourValue getSunSphereColour (Real time, const Ogre::Vector3 &sunDir);

        Ogre::ColourValue getSunLightColour (Real time, const Ogre::Vector3 &sunDir);

        Ogre::ColourValue getMoonBodyColour (const Ogre::Vector3 &moonDir);

        Ogre::ColourValue getMoonLightColour (const Ogre::Vector3 &moonDir);

        void setSkyGradientsImage (const Ogre::String &filename = DEFAULT_SKY_GRADIENTS_IMAGE);

        void setSunColoursImage (const Ogre::String &filename = DEFAULT_SUN_COLOURS_IMAGE);

        const Ogre::Vector3 getSunDirection (LongReal jday);

        const Ogre::Vector3 getMoonDirection (LongReal jday);

        const Ogre::Real getMoonPhase (LongReal jday);

        const Ogre::Vector3 getEclipticNorthPoleDirection (LongReal jday);
        
    private:
        virtual bool frameStarted (const Ogre::FrameEvent &e);

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

        void destroySubcomponents (bool everything);

    public:
        void forceSubcomponentQueryFlags (uint mask);

        void forceSubcomponentVisibilityFlags (uint mask);
    };
}

#endif // CAELUM__CAELUM_SYSTEM_H