main/include/FlatCloudLayer.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__FLAT_CLOUD_LAYER_H
#define CAELUM__FLAT_CLOUD_LAYER_H

#include "CaelumPrerequisites.h"
#include "InternalUtilities.h"
#include "PrivatePtr.h"
#include "FastGpuParamRef.h"

namespace Caelum
{
    class CAELUM_EXPORT FlatCloudLayer
    {
    public:
        FlatCloudLayer(
                Ogre::SceneManager *sceneMgr,
                Ogre::SceneNode *cloudRoot);

        ~FlatCloudLayer();

        void update (
                Ogre::Real timePassed,
                const Ogre::Vector3 &sunDirection,
                const Ogre::ColourValue &sunLightColour,
                const Ogre::ColourValue &fogColour,
                const Ogre::ColourValue &sunSphereColour);

        void advanceAnimation (Ogre::Real timePassed);

        void reset ();

    private:
        Ogre::Vector2 mCloudSpeed;
        Ogre::Vector2 mCloudMassOffset;
        Ogre::Vector2 mCloudDetailOffset;

        // Set texture offsets.
        // Animated every frame.
        void setCloudMassOffset(const Ogre::Vector2 &cloudMassOffset);
        void setCloudDetailOffset(const Ogre::Vector2 &cloudDetailOffset);

    public:
        void setCloudSpeed (const Ogre::Vector2 &cloudSpeed);

        const Ogre::Vector2 getCloudSpeed () const { return mCloudSpeed; }

    private:
        Ogre::Vector3 mSunDirection; 
        Ogre::ColourValue mSunLightColour; 
        Ogre::ColourValue mSunSphereColour; 
        Ogre::ColourValue mFogColour; 

    public:
        void setSunDirection(const Ogre::Vector3 &sunDirection);
        void setSunLightColour(const Ogre::ColourValue &sunLightColour);
        void setSunSphereColour(const Ogre::ColourValue &sunSphereColour);
        void setFogColour(const Ogre::ColourValue &fogColour);
        const Ogre::Vector3 getSunDirection () const; 
        const Ogre::ColourValue getSunLightColour () const; 
        const Ogre::ColourValue getSunSphereColour () const; 
        const Ogre::ColourValue getFogColour () const; 

    private:
        Ogre::SceneManager *mSceneMgr;

        // Note: objects are destroyed in reverse order of declaration.
        // This means that objects must be ordered by dependency.

        PrivateMaterialPtr mMaterial;       

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

            Ogre::GpuProgramParametersSharedPtr vpParams;
            Ogre::GpuProgramParametersSharedPtr fpParams;

            FastGpuParamRef cloudCoverageThreshold;
            FastGpuParamRef cloudMassOffset;
            FastGpuParamRef cloudDetailOffset;
            FastGpuParamRef cloudMassBlend;
            FastGpuParamRef vpSunDirection;
            FastGpuParamRef fpSunDirection;
            FastGpuParamRef sunLightColour;
            FastGpuParamRef sunSphereColour;
            FastGpuParamRef fogColour;
            FastGpuParamRef layerHeight;
            FastGpuParamRef cloudUVFactor;
            FastGpuParamRef heightRedFactor;
            FastGpuParamRef nearFadeDist;
            FastGpuParamRef farFadeDist;
            FastGpuParamRef fadeDistMeasurementVector;
        } mParams;

    private:
        PrivateMeshPtr mMesh;
        PrivateSceneNodePtr mNode;
        PrivateEntityPtr mEntity;

        // Mesh parameters.
        bool mMeshDirty;
        Real mMeshWidth, mMeshHeight;
        int mMeshWidthSegments, mMeshHeightSegments;

    public:
        void _ensureGeometry();

        void _invalidateGeometry();

        void setMeshParameters (
                Real meshWidth, Real meshHeight,
                int meshWidthSegments, int meshHeightSegments);

        inline void setMeshWidth (Real value) { mMeshWidth = value; _invalidateGeometry (); }
        inline void setMeshHeight (Real value) { mMeshHeight = value; _invalidateGeometry (); }
        inline void setMeshWidthSegments (int value) { mMeshWidthSegments = value; _invalidateGeometry (); }
        inline void setMeshHeightSegments (int value) { mMeshHeightSegments = value; _invalidateGeometry (); }
        inline Real getMeshWidth () const { return mMeshWidth; }
        inline Real getMeshHeight () const { return mMeshHeight; }
        inline int getMeshWidthSegments () const { return mMeshWidthSegments; }
        inline int getMeshHeightSegments () const { return mMeshHeightSegments; }

    private:
        std::auto_ptr<Ogre::Image> mCloudCoverLookup;

        Ogre::String mCloudCoverLookupFileName;

        Ogre::Real mCloudCover;

    public:
        void setCloudCover (const Ogre::Real cloudCover);

        inline Ogre::Real getCloudCover () const { return mCloudCover; }

        void setCloudCoverLookup (const Ogre::String& fileName);

        const Ogre::String getCloudCoverLookupFileName () const;

        void disableCloudCoverLookup ();

    private:
        Ogre::Real mCloudCoverVisibilityThreshold;

    protected:
        void _updateVisibilityThreshold ();

    public:
        Ogre::Real getCloudCoverVisibilityThreshold () const { return mCloudCoverVisibilityThreshold; }

        void setCloudCoverVisibilityThreshold (const Ogre::Real value);

    private:
        Ogre::Real mHeight;

    public:
        void setHeight(Ogre::Real height);

        Ogre::Real getHeight() const;

    private:
        Ogre::Real mCloudBlendPos;

        int mCurrentTextureIndex;

        Ogre::Real mCloudBlendTime;

        std::vector<String> mNoiseTextureNames;

    public:
        void setCloudBlendTime (const Ogre::Real value);

        Ogre::Real getCloudBlendTime () const;

        void setCloudBlendPos (const Ogre::Real value);

        Ogre::Real getCloudBlendPos () const;

    private:
        Ogre::Real mCloudUVFactor;

    public:
        void setCloudUVFactor (const Ogre::Real value);
        inline Ogre::Real getCloudUVFactor () const { return mCloudUVFactor; }

    private:
        Ogre::Real mHeightRedFactor;

    public:
        void setHeightRedFactor (const Ogre::Real value);
        Ogre::Real getHeightRedFactor () const { return mHeightRedFactor; }

    private:
        Ogre::Real mNearFadeDist;
        Ogre::Real mFarFadeDist;
        Ogre::Vector3 mFadeDistMeasurementVector;

    public:
        void setFadeDistances (Ogre::Real nearValue, Ogre::Real farValue);

        void setNearFadeDist (const Ogre::Real value);
        Ogre::Real getNearFadeDist () const { return mNearFadeDist; }

        void setFarFadeDist (const Ogre::Real value);
        Ogre::Real getFarFadeDist () const { return mFarFadeDist; }

        void setFadeDistMeasurementVector (const Ogre::Vector3& value);
        const Ogre::Vector3 getFadeDistMeasurementVector () const { return mFadeDistMeasurementVector; }

    public:
        void setQueryFlags (uint flags) { mEntity->setQueryFlags (flags); }
        uint getQueryFlags () const { return mEntity->getQueryFlags (); }
        void setVisibilityFlags (uint flags) { mEntity->setVisibilityFlags (flags); }
        uint getVisibilityFlags () const { return mEntity->getVisibilityFlags (); }
    };
}

#endif // CAELUM__FLAT_CLOUD_LAYER_H

---