DecalsManager.h

Go to the documentation of this file.

/*
--------------------------------------------------------------------------------
This source file is part of Hydrax.
Visit ---
 
Copyright (C) 2008 Xavier Vergu�n Gonz�lez <xavierverguin@hotmail.com>
                                           <xavyiy@gmail.com>
 
This program 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 2 of the License, or (at your option) any later
version.
 
This program 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
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
--------------------------------------------------------------------------------
*/
 
#ifndef _Hydrax_DecalsManager_H_
#define _Hydrax_DecalsManager_H_
 
#include "Prerequisites.h"
 
 
 
namespace Hydrax
{
    class Hydrax;
 
    class Decal
    {
    public:
        Decal(Hydrax *h, const Ogre::String &TextureName, const int& Id);
 
        ~Decal();
 
        void registerPass(Ogre::Pass* _Pass);
 
        void unregister();
 
        inline const Ogre::String& getTextureName() const
        {
            return mTextureName;
        }
        inline const Ogre::String& getTextureName() const {…}
 
        inline const int& getId() const
        {
            return mId;
        }
        inline const int& getId() const {…}
 
        inline Ogre::Frustum* getProjector()
        {
            return mProjector;
        }
        inline Ogre::Frustum* getProjector() {…}
 
        inline Ogre::SceneNode* getSceneNode()
        {
            return mSceneNode;
        }
        inline Ogre::SceneNode* getSceneNode() {…}
 
        inline Ogre::Pass *getRegisteredPass()
        {
            return mRegisteredPass;
        }
        inline Ogre::Pass *getRegisteredPass() {…}
 
        inline const Ogre::Vector2& getPosition() const
        {
            return mPosition;
        }
        inline const Ogre::Vector2& getPosition() const {…}
 
        inline const Ogre::Vector2& getSize() const
        {
            return mSize;
        }
        inline const Ogre::Vector2& getSize() const {…}
 
        inline const Ogre::Radian& getOrientation() const
        {
            return mOrientation;
        }
        inline const Ogre::Radian& getOrientation() const {…}
 
        inline const Ogre::Real& getTransparency() const
        {
            return mTransparency;
        }
        inline const Ogre::Real& getTransparency() const {…}
 
        inline const bool& isVisible() const
        {
            return mVisible;
        }
        inline const bool& isVisible() const {…}
 
        void setPosition(const Ogre::Vector2& Position);
 
        void setSize(const Ogre::Vector2& Size);
 
        void setOrientation(const Ogre::Radian& Orientation);
 
        void setTransparency(const Ogre::Real& Transparency);
 
        void setVisible(const bool& Visible);
 
    private:
        Ogre::String mTextureName;
        int mId;
        Ogre::Frustum *mProjector;
        Ogre::SceneNode *mSceneNode;
        Ogre::Pass *mRegisteredPass;
 
        Ogre::Vector2 mPosition;
        Ogre::Vector2 mSize;
        Ogre::Radian mOrientation;
        Ogre::Real mTransparency;
        bool mVisible;
 
        Hydrax *mHydrax;
    };
    class Decal {…};
 
    class DecalsManager
    {
    public:
        DecalsManager(Hydrax *h);
 
        ~DecalsManager();
 
        void update();
 
        Decal* add(const Ogre::String& TextureName);
 
        Decal* get(const int& Id);
 
        void remove(const int& Id);
 
        void removeAll();
 
        void registerAll();
 
        inline std::vector<Decal*> getDecals()
        {
            return mDecals;
        }
        inline std::vector<Decal*> getDecals() {…}
 
        inline const Ogre::Real _getWaterStrength() const
        {
            return mWaterStrength;
        }
        inline const Ogre::Real _getWaterStrength() const {…}
 
        inline void _setWaterStrength(const Ogre::Real &WaterStrength)
        {
            mWaterStrength = WaterStrength;
        }
        inline void _setWaterStrength(const Ogre::Real &WaterStrength) {…}
 
        inline void _forceToUpdate()
        {
            mForceToUpdate = true;
        }
        inline void _forceToUpdate() {…}
 
    private:
        std::vector<Decal*> mDecals;
        std::vector<Decal*>::iterator DecalIt;
        int mNextId;
 
        Ogre::Real mWaterStrength;
 
        Ogre::Vector3 mLastPosition;
        Ogre::Quaternion mLastOrientation;
        bool mLastUnderwater;
        bool mForceToUpdate;
 
        Hydrax *mHydrax;
    };
    class DecalsManager {…};
};
 
 
#endif