PrecipitationController.h

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

Copyright (c) 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__PRECIPITATION_CONTROLLER_H
#define CAELUM__PRECIPITATION_CONTROLLER_H

#include "CaelumPrerequisites.h"
#include "FastGpuParamRef.h"

namespace Caelum
{
    struct PrecipitationPresetParams
    {
        Ogre::ColourValue Colour;
        Ogre::Real Speed;
        Ogre::String Name;
    };

    enum PrecipitationType
    {
        PRECTYPE_DRIZZLE        = 0,
        PRECTYPE_RAIN           = 1,
        PRECTYPE_SNOW           = 2,
        PRECTYPE_SNOWGRAINS     = 3,
        PRECTYPE_ICECRYSTALS    = 4,
        PRECTYPE_ICEPELLETS     = 5,
        PRECTYPE_HAIL           = 6,
        PRECTYPE_SMALLHAIL      = 7,

        PRECTYPE_CUSTOM         = 8,
    };

    class CAELUM_EXPORT PrecipitationController
    {
    private:
        friend class PrecipitationInstance;

        Ogre::SceneManager *mSceneMgr;
        Ogre::Vector3 mWindSpeed;
        Ogre::Real mIntensity;
        Ogre::Real mSpeed;
        Ogre::ColourValue mColour;
        PrecipitationType mPresetType;
        Ogre::String mTextureName;
        Ogre::Vector3 mCameraSpeedScale;
        Ogre::Vector3 mFallingDirection;

        Ogre::Real mAutoDisableThreshold;
        bool mHardDisableCompositor;

        Ogre::ColourValue mSceneColour;
        Real mInternalTime;

        // Only meant for the instance ctl in auto-camera-speed mode.
        Real mSecondsSinceLastFrame;
        inline Real getSecondsSinceLastFrame() { return mSecondsSinceLastFrame; }

    public:
        static const String COMPOSITOR_NAME;

        static const String MATERIAL_NAME;

        static bool isPresetType (PrecipitationType value);

        static const PrecipitationPresetParams& getPresetParams (PrecipitationType value);

        void setParams (const PrecipitationPresetParams& params);

        void setPresetType (PrecipitationType value);

        PrecipitationType getPresetType () const;

        // Texture name, part of a preset
        void setTextureName(const Ogre::String& textureName);
        const Ogre::String getTextureName() const;

        void setColour(const Ogre::ColourValue& color);
        const Ogre::ColourValue getColour() const;

        void setSpeed(Real value);
        Real getSpeed() const;

        void setIntensity(Real value);
        Real getIntensity() const;

        void setWindSpeed(const Ogre::Vector3 &value);
        const Ogre::Vector3 getWindSpeed() const;

        void setFallingDirection(const Ogre::Vector3 &value) { mFallingDirection = value; }
        const Ogre::Vector3 getFallingDirection() const { return mFallingDirection; }

        void setManualCameraSpeed(const Ogre::Vector3 &value);

        void setAutoCameraSpeed();

        inline void setAutoDisableThreshold (Real value) { mAutoDisableThreshold = value; }
        inline Real getAutoDisableThreshold () const { return mAutoDisableThreshold; }

        inline void setCameraSpeedScale (const Ogre::Vector3& value) {
            mCameraSpeedScale = value;
        }
        inline const Ogre::Vector3 getCameraSpeedScale () const {
            return mCameraSpeedScale;
        }

        inline void setCameraSpeedScale (Ogre::Real value) {
            setCameraSpeedScale(Ogre::Vector3::UNIT_SCALE * value);
        }

        void update(Real secondsSinceLastFrame, Ogre::ColourValue colour);

        PrecipitationController(
                Ogre::SceneManager *sceneMgr);
        ~PrecipitationController();

    public:
        typedef std::map<Ogre::Viewport*, PrecipitationInstance*> ViewportInstanceMap;
        ViewportInstanceMap mViewportInstanceMap;

    public:
        PrecipitationInstance* createViewportInstance(Ogre::Viewport* viewport);

        void destroyViewportInstance(Ogre::Viewport* viewport);

        PrecipitationInstance* getViewportInstance(Ogre::Viewport* viewport);

        void destroyAllViewportInstances();
    };

    class PrecipitationInstance: private Ogre::CompositorInstance::Listener
    {
    private:
        friend class PrecipitationController;

        PrecipitationController* mParent;
        Ogre::Viewport* mViewport;
        Ogre::CompositorInstance* mCompInst;
        Ogre::Camera* mLastCamera;
        Ogre::Vector3 mLastCameraPosition;
        Ogre::Vector3 mCameraSpeed;
        bool mAutoCameraSpeed;

        virtual void notifyMaterialSetup(uint pass_id, Ogre::MaterialPtr &mat);
        virtual void notifyMaterialRender(uint pass_id, Ogre::MaterialPtr &mat);

        void _updateMaterialParams(
                const Ogre::MaterialPtr& mat,
                const Ogre::Camera* cam,
                const Ogre::Vector3& camSpeed);

        // Add remove the compositors. Do nothing if already added/removed
        void createCompositor ();
        void destroyCompositor ();

        // Check if the compositor should be enabled
        bool shouldBeEnabled () const;

        void _update();

    public:
        inline Ogre::Viewport* getViewport() const { return mViewport; }
        inline PrecipitationController* getParent() const { return mParent; }
        inline Ogre::CompositorInstance* getCompositorInstance() const { return mCompInst; }

        bool getAutoCameraSpeed();

        void setAutoCameraSpeed();

        void setManualCameraSpeed(const Ogre::Vector3& value);

        const Ogre::Vector3 getCameraSpeed();

        PrecipitationInstance(PrecipitationController* parent, Ogre::Viewport* view);
        virtual ~PrecipitationInstance();

    private:
        struct Params {
            void setup(Ogre::GpuProgramParametersSharedPtr fpParams);

            Ogre::GpuProgramParametersSharedPtr fpParams;
            FastGpuParamRef precColor;
            FastGpuParamRef intensity;
            FastGpuParamRef dropSpeed;
            FastGpuParamRef corner1;
            FastGpuParamRef corner2;
            FastGpuParamRef corner3;
            FastGpuParamRef corner4;
            FastGpuParamRef deltaX;
            FastGpuParamRef deltaY;
        } mParams;

    };
}

#endif //CAELUM__PRECIPITATION_CONTROLLER_H