OgreCompositorInstance.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-2005 The OGRE Team
Also see acknowledgements in Readme.html

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 __CompositorInstance_H__
#define __CompositorInstance_H__

#include "OgrePrerequisites.h"
#include "OgreMaterial.h"
#include "OgreTexture.h"
#include "OgreRenderQueue.h"
namespace Ogre {
    const size_t RENDER_QUEUE_COUNT = RENDER_QUEUE_OVERLAY+1;       
            
    class _OgreExport CompositorInstance
    {
    public:
        CompositorInstance(Compositor *filter, CompositionTechnique *technique, CompositorChain *chain);
        virtual ~CompositorInstance();
        class _OgreExport Listener
        {
        public:
            virtual ~Listener();

            virtual void notifyMaterialSetup(uint32 pass_id, MaterialPtr &mat);

            virtual void notifyMaterialRender(uint32 pass_id, MaterialPtr &mat);
        };
        class RenderSystemOperation
        {
        public:
            virtual ~RenderSystemOperation();
            virtual void execute(SceneManager *sm, RenderSystem *rs) = 0;
        };
        typedef std::map<int, MaterialPtr> QuadMaterialMap;
        typedef std::pair<int, RenderSystemOperation*> RenderSystemOpPair;
        typedef std::vector<RenderSystemOpPair> RenderSystemOpPairs;
        class TargetOperation
        {
        public:
            TargetOperation()
            { 
            }
            TargetOperation(RenderTarget *target):
                target(target), currentQueueGroupID(0), visibilityMask(0xFFFFFFFF),
                lodBias(1.0f),
                onlyInitial(false), hasBeenRendered(false), findVisibleObjects(false)
            { 
            }
            RenderTarget *target;

            int currentQueueGroupID;

            RenderSystemOpPairs renderSystemOperations;

            uint32 visibilityMask;
            
            float lodBias;
            
            typedef std::bitset<RENDER_QUEUE_COUNT> RenderQueueBitSet;

            RenderQueueBitSet renderQueues;
            
            bool onlyInitial;
            bool hasBeenRendered;
            bool findVisibleObjects;
            String materialScheme;
        };
        typedef std::vector<TargetOperation> CompiledState;
        
        void setEnabled(bool value);
        
        bool getEnabled();

        virtual void _prepareForCompilation();
        
        virtual void _compileTargetOperations(CompiledState &compiledState);
        
        virtual void _compileOutputOperation(TargetOperation &finalState);
        
        Compositor *getCompositor();
        
        CompositionTechnique *getTechnique();

        CompositorChain *getChain();

        void addListener(Listener *l);

        void removeListener(Listener *l);

        void _fireNotifyMaterialSetup(uint32 pass_id, MaterialPtr &mat);

        void _fireNotifyMaterialRender(uint32 pass_id, MaterialPtr &mat);
    private:
        Compositor *mCompositor;
        CompositionTechnique *mTechnique;
        CompositorChain *mChain;
        bool mEnabled;
        typedef std::map<String,TexturePtr> LocalTextureMap;
        LocalTextureMap mLocalTextures;

        typedef std::vector<RenderSystemOperation*> RenderSystemOperations;
        RenderSystemOperations mRenderSystemOperations;

        typedef std::vector<Listener*> Listeners;
        Listeners mListeners;
        
        CompositorInstance *mPreviousInstance;
        
        virtual void collectPasses(TargetOperation &finalState, CompositionTargetPass *target);
        
        MaterialPtr createLocalMaterial();
        
        void createResources();
        
        void freeResources();

        void clearCompilationState();
        
        RenderTarget *getTargetForTex(const String &name);
        
        const String &getSourceForTex(const String &name);

        void queueRenderSystemOp(TargetOperation &finalState, RenderSystemOperation *op);
        
        friend class CompositorChain;
    };
}

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:39 2006