source: GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreBihRenderable.h @ 2390

/*
-----------------------------------------------------------------------------
This source file is part of the GameTools Project
http://www.gametools.org

Author: Martin Szydlowski
-----------------------------------------------------------------------------
*/

#ifndef _OgreBihRenderable_H__
#define _OgreBihRenderable_H__

#include "OgreBiHierarchy.h"

namespace Ogre
{

        // interface which must be implemented by all objects which desire to be
        // placed in the kd-tree
        class BihRenderable
        {
        public:
                BihRenderable():mSide(BihPlaneEvent::PES_BOTH), mClassified(false), mLastQueued(0), mBiHierarchy(0) 
                { 
                        setDecided(0,false); setDecided(1,false); setDecided(2,false); 
            };
                virtual ~BihRenderable()
                {
                        if (mBiHierarchy)
                                mBiHierarchy->remove(this);
                }

                // gather the information required for the creation of the kd-tree
                virtual void computeScene(BihPlaneEventList& events, AxisAlignedBox& aabb, int& nObjects, bool includeChildren = true) = 0;

                // put all objects this element holds in the renedering queue
                virtual void queueObjects(Camera* cam, RenderQueue* queue, bool onlyShadowCasters) = 0;

                // place all entities in geometry queue (for CHC)
                virtual void getGeometryList(GeometryVector *geometryList) = 0;

                // return a bounding box enclosing all objects
                virtual AxisAlignedBox getBoundingBox() const = 0;

                // TODO: reconsider getters/setters !!!
                inline bool isClassified()
                {
                        return mClassified;
                };
                inline void setClassified(bool q)
                {
                        mClassified = q;
                };

                inline  isDecided(int w)
                {
                        return mDecided[w];
                };
                inline void setDecided(int w,bool b)
                {
                        mDecided[w] = b;
                };

                inline BihPlaneEvent::Side getSide()
                {
                        return mSide;
                };
                inline void setSide(BihPlaneEvent::Side s)
                {
                        mSide = s;
                };

                inline void setActualSide(int d,BihPlaneEvent::Side s)
                {
                        mActualSide[d] = s;
                };

                inline void FinalizeSide(int d)
                {
                        mFinalSide[d]=mActualSide[d];
                };

                inline BihPlaneEvent::Side GetFinalSide(int d)
                {
                        return mFinalSide[d];
                };

                // funcions for attachment/detachment of renderables to/from the kd-tree
                inline bool isAttached()
                {
                        return mLeaves.size() != 0;
                };
                // the following functions should work in O(log N)
                inline bool isAttached(BiHierarchy::LeafPtr leaf)
                {
                        return mLeaves.find(leaf) != mLeaves.end();
                };
                inline bool attachTo(BiHierarchy::LeafPtr leaf, BiHierarchy * BiHierarchy)
                {
                        if (mBiHierarchy == 0 || mBiHierarchy == BiHierarchy)
                                mBiHierarchy = BiHierarchy;
                        else
                                return false;

                        BiHierarchy::LeafSet::_Pairib p = mLeaves.insert(leaf);
                        return p.second;
                };
                inline bool detachFrom(BiHierarchy::LeafPtr leaf)
                {
                        bool success = (mLeaves.erase(leaf) == 1);
                        if (mLeaves.size() == 0)
                                mBiHierarchy = 0;

                        return success;
                };

                inline bool isQueued(unsigned long currentFrame, Camera * currentCam)
                {
                        if (mLastQueued == currentFrame && mLastCam == currentCam)
                        {
                                return true;
                        }
                        else
                        {
                                mLastQueued = currentFrame;
                                mLastCam = currentCam;
                                return false;
                        }
                };

                BiHierarchy::LeafSet& getLeaves()
                {
                        return mLeaves;
                };

        protected:
                // number of the frame in which this renderable was last queued for rendering
                unsigned long mLastQueued;
                // the camera for which this renderable was last queued for rendering
                Camera * mLastCam;
                
                // BiHierarchy to which this renderable is attached
                BiHierarchy * mBiHierarchy;
                // BiHierarchy leaves which overlap this renderable
                BiHierarchy::LeafSet mLeaves;

                // Flag for the SAH determining the "cheaper" side of the split plane
                BihPlaneEvent::Side mSide;
                BihPlaneEvent::Side mFinalSide[3];
                BihPlaneEvent::Side mActualSide[3];
                // Flag for the SAH which marks if this renderable was already placed in the list after a split
                bool mClassified;

                bool mDecided[3];
        }; // class BihRenderable

} // namespace Ogre

#endif // _OgreBihRenderable_H__