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 "ImageHelper.h"
#include "OwnedPtr.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 reset ();

    private:
        Ogre::Real mHeight;
        Ogre::Real mCloudCover;

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

        Ogre::Real mCloudBlendPos;
        int mCurrentTextureIndex;

        Ogre::Real mCloudBlendTime;

        std::vector<String> mNoiseTextureNames;

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

        Ogre::GpuProgramParametersSharedPtr getVpParams();
        Ogre::GpuProgramParametersSharedPtr getFpParams();

        // Set various internal parameters:
        void setCloudMassOffset(const Ogre::Vector2 &cloudMassOffset);
        void setCloudDetailOffset(const Ogre::Vector2 &cloudDetailOffset);
        void setSunDirection(const Ogre::Vector3 &sunDirection);
        void setSunLightColour(const Ogre::ColourValue &sunLightColour);
        void setSunSphereColour(const Ogre::ColourValue &sunSphereColour);
        void setFogColour(const Ogre::ColourValue &fogColour);

    private:
        Ogre::SceneManager *mSceneMgr;

        // Note: objects are destroyed in reverse order of declaration.
        // This means that objects must be ordered by dependency.
        OwnedMaterialPtr mMaterial;     
        OwnedMeshPtr mMesh;
        SceneNodePtr mNode;
        EntityPtr 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; }

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

        Ogre::Real getHeight() const;

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

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

        void setCloudCover (const Ogre::Real cloudCover);

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

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

        void disableCloudCoverLookup ();

        void setCloudBlendTime (const Ogre::Real value);

        Ogre::Real getCloudBlendTime () const;

        void setCloudBlendPos (const Ogre::Real value);

        Ogre::Real getCloudBlendPos () const;

    private:
        Ogre::Real mCloudUVFactor;
        Ogre::Real mHeightRedFactor;

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

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

    private:
        Ogre::Real mNearFadeDist;
        Ogre::Real mFarFadeDist;

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

    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

---