RttManager.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_RttManager_H_
#define _Hydrax_RttManager_H_
 
#include "Prerequisites.h"
 
#include "Enums.h"
#include "Help.h"
 
 
 
namespace Hydrax
{
    class Hydrax;
 
    class RttManager
    {
    public:
        enum RttType
        {
            RTT_REFLECTION       = 0,
            RTT_REFRACTION       = 1,
            RTT_DEPTH            = 2,
            RTT_DEPTH_REFLECTION = 3,
            RTT_DEPTH_AIP        = 4,
            RTT_GPU_NORMAL_MAP   = 5
        };
 
        enum BitsPerChannel
        {
            BPC_8  = 8,
            BPC_16 = 16,
            BPC_32 = 32
        };
 
        enum NumberOfChannels
        {
            NOC_1 = 1,
            NOC_2 = 2,
            NOC_3 = 3,
            NOC_4 = 4
        };
 
        struct RttOptions
        {
            Ogre::String Name;
            Size Size_;
            NumberOfChannels NumberOfChannels_;
            BitsPerChannel BitsPerChannel_;
        };
 
        class RttListener
        {
        public:
            virtual void preRenderTargetUpdate(const RttType& Rtt){};
 
            virtual void postRenderTargetUpdate(const RttType& Rtt){};
        };
 
        RttManager(Hydrax *h);
 
        ~RttManager();
 
        void initialize(const RttType& Rtt);
 
        void remove(const RttType& Rtt);
 
        void removeAll();
 
        inline const Ogre::String& getRttName(RttType Rtt) const
        {
            return mRttOptions[static_cast<int>(Rtt)].Name;
        }
 
        inline Ogre::TexturePtr getTexture(RttType Rtt)
        {
            return mTextures[static_cast<int>(Rtt)];
        }
 
        inline Ogre::SceneNode* getPlanesSceneNode()
        {
            return mPlanesSceneNode;
        }
 
        inline Ogre::MovablePlane* getPlane(RttType Rtt)
        {
            return mPlanes[static_cast<int>(Rtt)];
        }
 
        inline const Size& getTextureSize(const RttType& Rtt) const
        {
            return mRttOptions[static_cast<int>(Rtt)].Size_;
        }
 
        void setTextureSize(const RttType& Rtt, const Size& S);
 
        void setTexturesSize(const Size& S);
 
        const Ogre::PixelFormat getPixelFormat(const RttType& Rtt) const;
 
        inline void setNumberOfChannels(const RttType& Rtt, const NumberOfChannels& NOC)
        {
            mRttOptions[Rtt].NumberOfChannels_ = NOC;
 
            if (!getTexture(Rtt).isNull())
            {
                initialize(Rtt);
            }
        }
 
        inline const NumberOfChannels& getNumberOfChannels(const RttType& Rtt) const
        {
            return mRttOptions[Rtt].NumberOfChannels_;
        }
 
        inline void setBitsPerChannel(const RttType& Rtt, const BitsPerChannel& BPC)
        {
            mRttOptions[Rtt].BitsPerChannel_ = BPC;
 
            if (!getTexture(Rtt).isNull())
            {
                initialize(Rtt);
            }
        }
 
        inline const BitsPerChannel& getBitsPerChannel(const RttType& Rtt) const
        {
            return mRttOptions[Rtt].BitsPerChannel_;
        }
 
        inline const RttOptions& getRttOptions(const RttType& Rtt) const
        {
            return mRttOptions[Rtt];
        }
 
        void setReflectionDisplacementError(const Ogre::Real& ReflectionDisplacementError)
        {
            mReflectionDisplacementError = ReflectionDisplacementError;
        }
 
        inline const Ogre::Real& getReflectionDisplacementError() const
        {
            return mReflectionDisplacementError;
        }
 
        inline void setDisableReflectionCustomNearCliplPlaneRenderQueues(const std::vector<Ogre::RenderQueueGroupID>& DisableReflectionCustomNearClipPlaneRenderQueues)
        {
            mDisableReflectionCustomNearClipPlaneRenderQueues = DisableReflectionCustomNearClipPlaneRenderQueues;
        }
 
        inline const std::vector<Ogre::RenderQueueGroupID>& getDisableReflectionCustomNearClipPlaneRenderQueues()
        {
            return mDisableReflectionCustomNearClipPlaneRenderQueues;
        }
 
        inline void addRttListener(RttListener *l)
        {
            mRttListeners.push_back(l);
        }
 
        void removeRttListener(RttListener *l, const bool& releaseMemory = true);
 
        void removeAllRttListeners(const bool& releaseMemory = true);
 
    private:
        class CRefractionListener : public Ogre::RenderTargetListener
        {
        public:
            RttManager* mRttManager;
 
            Ogre::Real mCameraPlaneDiff;
 
            void preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt) override;
            void postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt) override;
        };
 
        class CReflectionListener : public Ogre::RenderTargetListener
        {
        public:
            class CReflectionQueueListener : public Ogre::RenderQueueListener
            {
            public:
                void renderQueueStarted(Ogre::uint8 queueGroupId, const Ogre::String &invocation, bool &skipThisInvocation) override;
                void renderQueueEnded(Ogre::uint8 queueGroupId, const Ogre::String &invocation, bool &skipThisInvocation) override;
 
                RttManager* mRttManager;
                bool mActive;
            };
 
            CReflectionQueueListener mCReflectionQueueListener;
 
            RttManager* mRttManager;
 
            Ogre::Real mCameraPlaneDiff;
 
            void preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt) override;
            void postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt) override;
        };
 
        class CDepthListener : public Ogre::RenderTargetListener
        {
        public:
            RttManager* mRttManager;
 
            std::queue<std::string> mMaterials;
 
            Ogre::Real mCameraPlaneDiff;
 
            void preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt) override;
            void postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt) override;
        };
 
        class CDepthReflectionListener : public Ogre::RenderTargetListener
        {
        public:
            RttManager* mRttManager;
 
            std::queue<std::string> mMaterials;
 
            Ogre::Real mCameraPlaneDiff;
 
            void preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt) override;
            void postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt) override;
        };
 
        class CGPUNormalMapListener : public Ogre::RenderTargetListener
        {
        public:
            RttManager* mRttManager;
 
            Ogre::String mOldMaterialName;
 
            void preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt) override;
            void postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt) override;
        };
 
 
        void _initializeRtt(const RttType& Rtt,                        const Ogre::Vector3& RttPlaneNormal,
                            const Ogre::ColourValue& BackgroundColour, const bool& RenderSky,
                            Ogre::RenderTargetListener* RTListener,    const Ogre::String& MaterialScheme = "",
                            const bool& ShadowsEnabled = true);
 
        inline const bool _isRenderQueueInList(const std::vector<Ogre::RenderQueueGroupID>& l, const Ogre::RenderQueueGroupID& rq)
        {
            for (std::vector<Ogre::RenderQueueGroupID>::const_iterator i = l.begin(); i != l.end(); i++)
            {
                if ((*i) == rq)
                {
                    return true;
                }
            }
 
            return false;
        }
 
        void _invokeRttListeners(const RttType& Rtt, const bool& pre);
 
        Hydrax *mHydrax;
 
        Ogre::SceneNode *mPlanesSceneNode;
        Ogre::MovablePlane *mPlanes[6];
 
        Ogre::TexturePtr mTextures[6];
        RttOptions mRttOptions[6];
 
        CReflectionListener      mReflectionListener;
        CRefractionListener      mRefractionListener;
        CDepthListener           mDepthListener;
        CDepthReflectionListener mDepthReflectionListener;
        CGPUNormalMapListener    mGPUNormalMapListener;
 
        std::vector<Ogre::RenderQueueGroupID> mDisableReflectionCustomNearClipPlaneRenderQueues;
        std::vector<RttListener*> mRttListeners;
 
        Ogre::Real mReflectionDisplacementError;
    };
};
 
 
#endif