OgreCompositorChain.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2013 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef __CompositorChain_H__
#define __CompositorChain_H__

#include "OgrePrerequisites.h"
#include "OgreRenderTargetListener.h"
#include "OgreRenderQueueListener.h"
#include "OgreCompositorInstance.h"
#include "OgreCompositor.h"
#include "OgreViewport.h"
#include "OgreHeaderPrefix.h"

namespace Ogre {
    class _OgreExport CompositorChain : public RenderTargetListener, public Viewport::Listener, public CompositorInstAlloc
    {
    public:
        CompositorChain(Viewport *vp);
        virtual ~CompositorChain();
        
        typedef vector<CompositorInstance*>::type Instances;
        typedef VectorIterator<Instances> InstanceIterator;
        
        static const size_t LAST = (size_t)-1;
        static const size_t BEST = 0;
        
        CompositorInstance* addCompositor(CompositorPtr filter, size_t addPosition=LAST, const String& scheme = StringUtil::BLANK);

        void removeCompositor(size_t position=LAST);
        
        size_t getNumCompositors();
        
        void removeAllCompositors();
        
        CompositorInstance *getCompositor(size_t index);

        CompositorInstance *getCompositor(const String& name);

        CompositorInstance* _getOriginalSceneCompositor(void) { return mOriginalScene; }

        InstanceIterator getCompositors();
    
        void setCompositorEnabled(size_t position, bool state);

        virtual void preRenderTargetUpdate(const RenderTargetEvent& evt);
        virtual void postRenderTargetUpdate(const RenderTargetEvent& evt);
        virtual void preViewportUpdate(const RenderTargetViewportEvent& evt);
        virtual void postViewportUpdate(const RenderTargetViewportEvent& evt);

        virtual void viewportCameraChanged(Viewport* viewport);
        virtual void viewportDimensionsChanged(Viewport* viewport);
        virtual void viewportDestroyed(Viewport* viewport);

        void _markDirty();
        
        Viewport *getViewport();

        void _removeInstance(CompositorInstance *i);

        void _queuedOperation(CompositorInstance::RenderSystemOperation* op);

        void _compile();

        CompositorInstance* getPreviousInstance(CompositorInstance* curr, bool activeOnly = true);
        CompositorInstance* getNextInstance(CompositorInstance* curr, bool activeOnly = true);

    protected:
        Viewport *mViewport;
        
        CompositorInstance *mOriginalScene;
        
        Instances mInstances;
        
        bool mDirty;
        bool mAnyCompositorsEnabled;

        String mOriginalSceneScheme;

        CompositorInstance::CompiledState mCompiledState;
        CompositorInstance::TargetOperation mOutputOperation;
        typedef vector<CompositorInstance::RenderSystemOperation*>::type RenderSystemOperations;
        RenderSystemOperations mRenderSystemOperations;

        void clearCompiledState();
        
        void preTargetOperation(CompositorInstance::TargetOperation &op, Viewport *vp, Camera *cam);
        
        void postTargetOperation(CompositorInstance::TargetOperation &op, Viewport *vp, Camera *cam);

        void createOriginalScene();
        void destroyOriginalScene();

        void destroyResources(void);

        class _OgreExport RQListener: public RenderQueueListener
        {
        public:
            RQListener() : mOperation(0), mSceneManager(0), mRenderSystem(0), mViewport(0) {}

            virtual void renderQueueStarted(uint8 queueGroupId, const String& invocation, bool& skipThisInvocation);
            virtual void renderQueueEnded(uint8 queueGroupId, const String& invocation, bool& repeatThisInvocation);

            void setOperation(CompositorInstance::TargetOperation *op,SceneManager *sm,RenderSystem *rs);

            void notifyViewport(Viewport* vp) { mViewport = vp; }

            void flushUpTo(uint8 id);
        private:
            CompositorInstance::TargetOperation *mOperation;
            SceneManager *mSceneManager;
            RenderSystem *mRenderSystem;
            Viewport* mViewport;
            CompositorInstance::RenderSystemOpPairs::iterator currentOp, lastOp;
        };
        RQListener mOurListener;
        unsigned int mOldClearEveryFrameBuffers;
        uint32 mOldVisibilityMask;
        bool mOldFindVisibleObjects;
        float mOldLodBias;
        String mOldMaterialScheme;
        bool mOldShadowsEnabled;

    };
} // namespace Ogre

#include "OgreHeaderSuffix.h"

#endif // __CompositorChain_H__