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

Copyright (c) 2000-2014 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 {
    /** \addtogroup Core
    *  @{
    */
    /** \addtogroup Effects
    *  @{
    */
    /** Chain of compositor effects applying to one viewport.
    */
    class _OgreExport CompositorChain : public RenderTargetListener, public Viewport::Listener, public CompositorInstAlloc
    {
    public:
        CompositorChain(Viewport *vp);
        /** Another gcc warning here, which is no problem because RenderTargetListener is never used
            to delete an object.
        */
        virtual ~CompositorChain();
        
        /// Data types
        typedef vector<CompositorInstance*>::type Instances;
        typedef VectorIterator<Instances> InstanceIterator;
        
        /// Identifier for "last" compositor in chain.
        static const size_t LAST = (size_t)-1;
        /// Identifier for best technique.
        static const size_t BEST = 0;
        
        /** Apply a compositor. Initially, the filter is enabled.
        @param filter
            Filter to apply.
        @param addPosition
            Position in filter chain to insert this filter at; defaults to the end (last applied filter).
        @param scheme
            Scheme to use (blank means default).
        */
        CompositorInstance* addCompositor(CompositorPtr filter, size_t addPosition=LAST, const String& scheme = StringUtil::BLANK);

        /** Remove a compositor.
        @param position
            Position in filter chain of filter to remove; defaults to the end (last applied filter)
        */
        void removeCompositor(size_t position=LAST);
        
        /** Get the number of compositors.
        */
        size_t getNumCompositors();
        
        /** Remove all compositors.
        */
        void removeAllCompositors();
        
        /** Get compositor instance by position.
        */
        CompositorInstance *getCompositor(size_t index);

        /** Get compositor instance by name. Returns null if not found.
        */
        CompositorInstance *getCompositor(const String& name);

        /** Get the original scene compositor instance for this chain (internal use). 
        */
        CompositorInstance* _getOriginalSceneCompositor(void) { return mOriginalScene; }

        /** Get an iterator over the compositor instances. The first compositor in this list is applied first, the last one is applied last.
        */
        InstanceIterator getCompositors();
    
        /** Enable or disable a compositor, by position. Disabling a compositor stops it from rendering
            but does not free any resources. This can be more efficient than using removeCompositor and 
            addCompositor in cases the filter is switched on and off a lot.
        @param position
            Position in filter chain of filter
        */
        void setCompositorEnabled(size_t position, bool state);

        /** @see RenderTargetListener::preRenderTargetUpdate */
        virtual void preRenderTargetUpdate(const RenderTargetEvent& evt);
        /** @see RenderTargetListener::postRenderTargetUpdate */
        virtual void postRenderTargetUpdate(const RenderTargetEvent& evt);
        /** @see RenderTargetListener::preViewportUpdate */
        virtual void preViewportUpdate(const RenderTargetViewportEvent& evt);
        /** @see RenderTargetListener::postViewportUpdate */
        virtual void postViewportUpdate(const RenderTargetViewportEvent& evt);

        /** @see Viewport::Listener::viewportCameraChanged */
        virtual void viewportCameraChanged(Viewport* viewport);
        /** @see Viewport::Listener::viewportDimensionsChanged */
        virtual void viewportDimensionsChanged(Viewport* viewport);
        /** @see Viewport::Listener::viewportDestroyed */
        virtual void viewportDestroyed(Viewport* viewport);

        /** Mark state as dirty, and to be recompiled next frame.
        */
        void _markDirty();
        
        /** Get viewport that is the target of this chain
        */
        Viewport *getViewport();

        /** Remove a compositor by pointer. This is internally used by CompositionTechnique to
            "weak" remove any instanced of a deleted technique.
        */
        void _removeInstance(CompositorInstance *i);

        /** Internal method for registering a queued operation for deletion later **/
        void _queuedOperation(CompositorInstance::RenderSystemOperation* op);

        /** Compile this Composition chain into a series of RenderTarget operations.
        */
        void _compile();

        /** Get the previous instance in this chain to the one specified. 
        */
        CompositorInstance* getPreviousInstance(CompositorInstance* curr, bool activeOnly = true);
        /** Get the next instance in this chain to the one specified. 
        */
        CompositorInstance* getNextInstance(CompositorInstance* curr, bool activeOnly = true);

    protected:
        /// Viewport affected by this CompositorChain
        Viewport *mViewport;
        
        /** Plainly renders the scene; implicit first compositor in the chain.
        */
        CompositorInstance *mOriginalScene;
        
        /// Postfilter instances in this chain
        Instances mInstances;
        
        /// State needs recompile
        bool mDirty;
        /// Any compositors enabled?
        bool mAnyCompositorsEnabled;

        String mOriginalSceneScheme;

        /// Compiled state (updated with _compile)
        CompositorInstance::CompiledState mCompiledState;
        CompositorInstance::TargetOperation mOutputOperation;
        /// Render System operations queued by last compile, these are created by this
        /// instance thus managed and deleted by it. The list is cleared with 
        /// clearCompilationState()
        typedef vector<CompositorInstance::RenderSystemOperation*>::type RenderSystemOperations;
        RenderSystemOperations mRenderSystemOperations;

        /** Clear compiled state */
        void clearCompiledState();
        
        /** Prepare a viewport, the camera and the scene for a rendering operation
        */
        void preTargetOperation(CompositorInstance::TargetOperation &op, Viewport *vp, Camera *cam);
        
        /** Restore a viewport, the camera and the scene after a rendering operation
        */
        void postTargetOperation(CompositorInstance::TargetOperation &op, Viewport *vp, Camera *cam);

        void createOriginalScene();
        void destroyOriginalScene();

        /// destroy internal resources
        void destroyResources(void);

        /** Render queue listener used to set up rendering events. */
        class _OgreExport RQListener: public RenderQueueListener
        {
        public:
            RQListener() : mOperation(0), mSceneManager(0), mRenderSystem(0), mViewport(0) {}

            /** @copydoc RenderQueueListener::renderQueueStarted
            */
            virtual void renderQueueStarted(uint8 queueGroupId, const String& invocation, bool& skipThisInvocation);
            /** @copydoc RenderQueueListener::renderQueueEnded
            */
            virtual void renderQueueEnded(uint8 queueGroupId, const String& invocation, bool& repeatThisInvocation);

            /** Set current operation and target. */
            void setOperation(CompositorInstance::TargetOperation *op,SceneManager *sm,RenderSystem *rs);

            /** Notify current destination viewport. */
            void notifyViewport(Viewport* vp) { mViewport = vp; }

            /** Flush remaining render system operations. */
            void flushUpTo(uint8 id);
        private:
            CompositorInstance::TargetOperation *mOperation;
            SceneManager *mSceneManager;
            RenderSystem *mRenderSystem;
            Viewport* mViewport;
            CompositorInstance::RenderSystemOpPairs::iterator currentOp, lastOp;
        };
        RQListener mOurListener;
        /// Old viewport settings
        unsigned int mOldClearEveryFrameBuffers;
        /// Store old scene visibility mask
        uint32 mOldVisibilityMask;
        /// Store old find visible objects
        bool mOldFindVisibleObjects;
        /// Store old camera LOD bias
        float mOldLodBias;
        /// Store old viewport material scheme
        String mOldMaterialScheme;
        /// Store old shadows enabled flag
        bool mOldShadowsEnabled;

    };
    /** @} */
    /** @} */
} // namespace Ogre

#include "OgreHeaderSuffix.h"

#endif // __CompositorChain_H__
