OgreRenderQueueSortingGrouping.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 __RenderQueueSortingGrouping_H__
#define __RenderQueueSortingGrouping_H__

// Precompiler options
#include "OgrePrerequisites.h"
#include "OgreIteratorWrappers.h"
#include "OgreMaterial.h"
#include "OgreTechnique.h"
#include "OgrePass.h"
#include "OgreRadixSort.h"

namespace Ogre {

    struct RenderablePass
    {
        Renderable* renderable;
        Pass* pass;

        RenderablePass(Renderable* rend, Pass* p) :renderable(rend), pass(p) {}
    };


    class _OgreExport QueuedRenderableVisitor
    {
    public:
        QueuedRenderableVisitor() {}
        virtual ~QueuedRenderableVisitor() {}
        
        virtual void visit(const RenderablePass* rp) = 0;

        /* When visiting a collection grouped by pass, this is
            called when the grouping pass changes.
        @remarks
            If this method is called, the RenderablePass visit 
            method will not be called for this collection. The 
            Renderable visit method will be called for each item
            underneath the pass grouping level.
        @returns True to continue, false to skip the Renderables underneath
        */
        virtual bool visit(const Pass* p) = 0;
        virtual void visit(const Renderable* r) = 0;
        
        
    };

    class _OgreExport QueuedRenderableCollection
    {
    public:
        enum OrganisationMode
        {
            OM_PASS_GROUP = 1,
            OM_SORT_DESCENDING = 2,
            OM_SORT_ASCENDING = 6
        };

    protected:
        struct PassGroupLess
        {
            bool _OgreExport operator()(const Pass* a, const Pass* b) const
            {
                // Sort by passHash, which is pass, then texture unit changes
                uint32 hasha = a->getHash();
                uint32 hashb = b->getHash();
                if (hasha == hashb)
                {
                    // Must differentTransparentQueueItemLessiate by pointer incase 2 passes end up with the same hash
                    return a < b;
                }
                else
                {
                    return hasha < hashb;
                }
            }
        };
        struct DepthSortDescendingLess
        {
            const Camera* camera;

            DepthSortDescendingLess(const Camera* cam)
                : camera(cam)
            {
            }

            bool _OgreExport operator()(const RenderablePass& a, const RenderablePass& b) const
            {
                if (a.renderable == b.renderable)
                {
                    // Same renderable, sort by pass hash
                    return a.pass->getHash() < b.pass->getHash();
                }
                else
                {
                    // Different renderables, sort by depth
                    Real adepth = a.renderable->getSquaredViewDepth(camera);
                    Real bdepth = b.renderable->getSquaredViewDepth(camera);
                    if (adepth == bdepth)
                    {
                        // Must return deterministic result, doesn't matter what
                        return a.pass < b.pass;
                    }
                    else
                    {
                        // Sort DESCENDING by depth (ie far objects first)
                        return (adepth > bdepth);
                    }
                }

            }
        };

        typedef std::vector<RenderablePass> RenderablePassList;
        typedef std::vector<Renderable*> RenderableList;
        typedef std::map<Pass*, RenderableList*, PassGroupLess> PassGroupRenderableMap;

        struct RadixSortFunctorPass
        {
            uint32 operator()(const RenderablePass& p) const
            {
                return p.pass->getHash();
            }
        };

        static RadixSort<RenderablePassList, RenderablePass, uint32> msRadixSorter1;

        struct RadixSortFunctorDistance
        {
            const Camera* camera;

            RadixSortFunctorDistance(const Camera* cam)
                : camera(cam)
            {
            }

            float operator()(const RenderablePass& p) const
            {
                // Sort DESCENDING by depth (ie far objects first), use negative distance
                // here because radix sorter always dealing with accessing sort
                return static_cast<float>(- p.renderable->getSquaredViewDepth(camera));
            }
        };

        static RadixSort<RenderablePassList, RenderablePass, float> msRadixSorter2;

        uint8 mOrganisationMode;

        PassGroupRenderableMap mGrouped;
        RenderablePassList mSortedDescending;

        void acceptVisitorGrouped(QueuedRenderableVisitor* visitor) const;
        void acceptVisitorDescending(QueuedRenderableVisitor* visitor) const;
        void acceptVisitorAscending(QueuedRenderableVisitor* visitor) const;

    public:
        QueuedRenderableCollection();
        ~QueuedRenderableCollection();

        void clear(void);

        void removePassGroup(Pass* p);
        
        void resetOrganisationModes(void) 
        { 
            mOrganisationMode = 0; 
        }
        
        void addOrganisationMode(OrganisationMode om) 
        { 
            mOrganisationMode |= om; 
        }

        void addRenderable(Pass* pass, Renderable* rend);
        
        void sort(const Camera* cam);

        void acceptVisitor(QueuedRenderableVisitor* visitor, OrganisationMode om) const;
        
    };

    class _OgreExport RenderPriorityGroup
    {
    protected:

        RenderQueueGroup* mParent;
        bool mSplitPassesByLightingType;
        bool mSplitNoShadowPasses;
        bool mShadowCastersNotReceivers;
        QueuedRenderableCollection mSolidsBasic;
        QueuedRenderableCollection mSolidsDiffuseSpecular;
        QueuedRenderableCollection mSolidsDecal;
        QueuedRenderableCollection mSolidsNoShadowReceive;
        QueuedRenderableCollection mTransparents;

        void removePassEntry(Pass* p);

        void addSolidRenderable(Technique* pTech, Renderable* rend, bool toNoShadowMap);
        void addSolidRenderableSplitByLightType(Technique* pTech, Renderable* rend);
        void addTransparentRenderable(Technique* pTech, Renderable* rend);

    public:
        RenderPriorityGroup(RenderQueueGroup* parent, 
            bool splitPassesByLightingType,
            bool splitNoShadowPasses, 
            bool shadowCastersNotReceivers); 
           
        ~RenderPriorityGroup() { }

        const QueuedRenderableCollection& getSolidsBasic(void) const
        { return mSolidsBasic; }
        const QueuedRenderableCollection& getSolidsDiffuseSpecular(void) const
        { return mSolidsDiffuseSpecular; }
        const QueuedRenderableCollection& getSolidsDecal(void) const
        { return mSolidsDecal; }
        const QueuedRenderableCollection& getSolidsNoShadowReceive(void) const
        { return mSolidsNoShadowReceive; }
        const QueuedRenderableCollection& getTransparents(void) const
        { return mTransparents; }


        void resetOrganisationModes(void);
        
        void addOrganisationMode(QueuedRenderableCollection::OrganisationMode om); 

        void defaultOrganisationMode(void); 

        void addRenderable(Renderable* pRend, Technique* pTech);

        void sort(const Camera* cam);

        void clear(void);

        void setSplitPassesByLightingType(bool split)
        {
            mSplitPassesByLightingType = split;
        }

        void setSplitNoShadowPasses(bool split)
        {
            mSplitNoShadowPasses = split;
        }

        void setShadowCastersCannotBeReceivers(bool ind)
        {
            mShadowCastersNotReceivers = ind;
        }



    };


    class _OgreExport RenderQueueGroup
    {
    public:
        typedef std::map<ushort, RenderPriorityGroup*, std::less<ushort> > PriorityMap;
        typedef MapIterator<PriorityMap> PriorityMapIterator;
    protected:
        RenderQueue* mParent;
        bool mSplitPassesByLightingType;
        bool mSplitNoShadowPasses;
        bool mShadowCastersNotReceivers;
        PriorityMap mPriorityGroups;
        bool mShadowsEnabled;


    public:
        RenderQueueGroup(RenderQueue* parent,
            bool splitPassesByLightingType,
            bool splitNoShadowPasses,
            bool shadowCastersNotReceivers) 
            : mParent(parent)
            , mSplitPassesByLightingType(splitPassesByLightingType)
            , mSplitNoShadowPasses(splitNoShadowPasses)
            , mShadowCastersNotReceivers(shadowCastersNotReceivers)
            , mShadowsEnabled(true)
        {
        }

        ~RenderQueueGroup() {
            // destroy contents now
            PriorityMap::iterator i;
            for (i = mPriorityGroups.begin(); i != mPriorityGroups.end(); ++i)
            {
                delete i->second;
            }
        }

        PriorityMapIterator getIterator(void)
        {
            return PriorityMapIterator(mPriorityGroups.begin(), mPriorityGroups.end());
        }

        void addRenderable(Renderable* pRend, Technique* pTech, ushort priority)
        {
            // Check if priority group is there
            PriorityMap::iterator i = mPriorityGroups.find(priority);
            RenderPriorityGroup* pPriorityGrp;
            if (i == mPriorityGroups.end())
            {
                // Missing, create
                pPriorityGrp = new RenderPriorityGroup(this, 
                    mSplitPassesByLightingType,
                    mSplitNoShadowPasses, 
                    mShadowCastersNotReceivers);
                mPriorityGroups.insert(PriorityMap::value_type(priority, pPriorityGrp));
            }
            else
            {
                pPriorityGrp = i->second;
            }

            // Add
            pPriorityGrp->addRenderable(pRend, pTech);

        }

        void clear(bool destroy = false)
        {
            PriorityMap::iterator i, iend;
            iend = mPriorityGroups.end();
            for (i = mPriorityGroups.begin(); i != iend; ++i)
            {
                if (destroy)
                    delete i->second;
                else
                    i->second->clear();
            }

            if (destroy)
                mPriorityGroups.clear();

        }

        void setShadowsEnabled(bool enabled) { mShadowsEnabled = enabled; }

        bool getShadowsEnabled(void) const { return mShadowsEnabled; }

        void setSplitPassesByLightingType(bool split)
        {
            mSplitPassesByLightingType = split;
            PriorityMap::iterator i, iend;
            iend = mPriorityGroups.end();
            for (i = mPriorityGroups.begin(); i != iend; ++i)
            {
                i->second->setSplitPassesByLightingType(split);
            }
        }
        void setSplitNoShadowPasses(bool split)
        {
            mSplitNoShadowPasses = split;
            PriorityMap::iterator i, iend;
            iend = mPriorityGroups.end();
            for (i = mPriorityGroups.begin(); i != iend; ++i)
            {
                i->second->setSplitNoShadowPasses(split);
            }
        }
        void setShadowCastersCannotBeReceivers(bool ind)
        {
            mShadowCastersNotReceivers = ind;
            PriorityMap::iterator i, iend;
            iend = mPriorityGroups.end();
            for (i = mPriorityGroups.begin(); i != iend; ++i)
            {
                i->second->setShadowCastersCannotBeReceivers(ind);
            }
        }
        void resetOrganisationModes(void)
        {
            PriorityMap::iterator i, iend;
            iend = mPriorityGroups.end();
            for (i = mPriorityGroups.begin(); i != iend; ++i)
            {
                i->second->resetOrganisationModes();
            }
        }
        
        void addOrganisationMode(QueuedRenderableCollection::OrganisationMode om)
        {
            PriorityMap::iterator i, iend;
            iend = mPriorityGroups.end();
            for (i = mPriorityGroups.begin(); i != iend; ++i)
            {
                i->second->addOrganisationMode(om);
            }
        }

        void defaultOrganisationMode(void)
        {
            PriorityMap::iterator i, iend;
            iend = mPriorityGroups.end();
            for (i = mPriorityGroups.begin(); i != iend; ++i)
            {
                i->second->defaultOrganisationMode();
            }
        }

    };



}

#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:48 2006