Ignore:
Timestamp:
09/04/06 08:56:26 (18 years ago)
Author:
mattausch
Message:
 
Location:
GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include
Files:
5 edited
1 moved

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreBvHierarchy.h

    r1319 r1320  
    1111#define _OgreBvHierarchy_H__ 
    1212 
    13 #define KDNODE_CAST(a) (static_cast<KdTree::Node>(a)) 
    14 #define KDBRANCH_CAST(a) (static_cast<KdTree::Branch>(a)) 
    15 #define KDLEAF_CAST(a) (static_cast<KdTree::Leaf>(a)) 
    16 #define KDNODEPTR_CAST(a) (static_cast<KdTree::Node *>(a)) 
    17 #define KDBRANCHPTR_CAST(a) (static_cast<KdTree::Branch *>(a)) 
    18 #define KDLEAFPTR_CAST(a) (static_cast<KdTree::Leaf *>(a)) 
    19  
    20 #define KDTREE_LOGNAME "KdTreeBuild.log" 
     13#define BVHNODE_CAST(a) (static_cast<BvHierarchy::Node>(a)) 
     14#define BVHBRANCH_CAST(a) (static_cast<BvHierarchy::Branch>(a)) 
     15#define BVHLEAF_CAST(a) (static_cast<BvHierarchy::Leaf>(a)) 
     16#define BVHNODEPTR_CAST(a) (static_cast<BvHierarchy::Node *>(a)) 
     17#define BVHBRANCHPTR_CAST(a) (static_cast<BvHierarchy::Branch *>(a)) 
     18#define BVHLEAFPTR_CAST(a) (static_cast<BvHierarchy::Leaf *>(a)) 
     19 
     20#define BvHierarchy_LOGNAME "BvHierarchyBuild.log" 
    2121 
    2222#include <OgreAxisAlignedBox.h> 
    … …  
    3131#include "OgreBvHierarchyCamera.h" 
    3232#include "HierarchyInterface.h" 
    33  
     33#include "OgreKdTree.h" 
    3434 
    3535namespace Ogre 
    3636{ 
    3737        class BvHierarchyCamera; 
    38         class BvRenderable; 
    39         struct SplitInfo; 
    40  
    41         class PlaneEvent 
     38        class BvhRenderable; 
     39        struct BvhSplitInfo; 
     40         
     41        class BvhPlaneEvent 
    4242        { 
    4343        public: 
    … …  
    6363                }; 
    6464 
    65                 PlaneEvent(): mRenderable(0), mPosition(Vector3()), mDimension(PED_X), mType(PET_ON) 
     65                BvhPlaneEvent(): mRenderable(0), mPosition(Vector3()), mDimension(PED_X), mType(PET_ON) 
    6666                { }; 
    6767 
    68                 PlaneEvent(BvRenderable *rend, const Vector3& pos, PlaneEvent::Dimension dim, PlaneEvent::Type type): 
     68                BvhPlaneEvent(BvhRenderable *rend, const Vector3& pos, BvhPlaneEvent::Dimension dim, BvhPlaneEvent::Type type): 
    6969                        mRenderable(rend), mPosition(pos), mDimension(dim), mType(type)  
    7070                { }; 
    7171 
    72                 ~PlaneEvent() {}; 
     72                ~BvhPlaneEvent() {}; 
    7373 
    7474                // the less operator for plane events 
    7575                // first sort by position, then by dimension and finally by type 
    76                 bool operator < (const PlaneEvent& e) const 
     76                bool operator < (const BvhPlaneEvent& e) const 
    7777                { 
    7878                        if(mPosition[mDimension] < e.mPosition[e.mDimension]) 
    … …  
    100100 
    101101                // the equals operator for tree events 
    102                 bool operator == (const PlaneEvent& e) const 
     102                bool operator == (const BvhPlaneEvent& e) const 
    103103                { 
    104104                        return  (mPosition[mDimension] == e.mPosition[e.mDimension]) && 
    … …  
    107107                }; 
    108108 
    109                 bool equalsType(const PlaneEvent& e, PlaneEvent::Type t) 
     109                bool equalsType(const BvhPlaneEvent& e, BvhPlaneEvent::Type t) 
    110110                { 
    111111                        return  (mPosition[mDimension] == e.mPosition[e.mDimension]) && 
    … …  
    114114                }; 
    115115 
    116                 void classify(const PlaneEvent& e, PlaneEvent::Side side); 
    117  
    118                 PlaneEvent clip(AxisAlignedBox& box, PlaneEvent::Dimension dim); 
     116                void classify(const BvhPlaneEvent& e, BvhPlaneEvent::Side side); 
     117 
     118                BvhPlaneEvent clip(AxisAlignedBox& box, BvhPlaneEvent::Dimension dim); 
    119119 
    120120                Plane * getSplitPlane() const 
    … …  
    125125                } 
    126126 
    127                 BvRenderable * getRenderable() const //?? 
     127                BvhRenderable * getRenderable() const //?? 
    128128                { 
    129129                        return mRenderable; 
    130130                }; 
    131131 
    132                 PlaneEvent::Dimension getDimension() const //?? 
     132                BvhPlaneEvent::Dimension getDimension() const //?? 
    133133                { 
    134134                        return mDimension; 
    … …  
    139139        protected: 
    140140                // event info 
    141                 BvRenderable *                  mRenderable; 
     141                BvhRenderable *                 mRenderable; 
    142142                Vector3                                 mPosition; 
    143                 PlaneEvent::Dimension   mDimension; 
    144                 PlaneEvent::Type                mType; 
     143                BvhPlaneEvent::Dimension        mDimension; 
     144                BvhPlaneEvent::Type             mType; 
    145145 
    146146                // ------------------------------------------------------------------------------// 
    … …  
    149149                // TODO discuss if these functions really belong here, OO & SE - wise 
    150150                // pros: convenient, don't have to pass internal data to the outside 
    151                 // cons: SplitInfo ...  
     151                // cons: BvhSplitInfo ...  
    152152        public: 
    153153                // compute "global" surface area heuristic (SAH) for the plane represented by this event 
    154154                // use only with priority queue build method 
    155                 void pqSAH(Real globalSA, Real parentSA, int nLeft, int nPlane, int nRight, AxisAlignedBox& parentBox, SplitInfo& split); 
     155                void pqSAH(Real globalSA, Real parentSA, int nLeft, int nPlane, int nRight, AxisAlignedBox& parentBox, BvhSplitInfo& split); 
    156156                static Real pqSplitCost(Real p, Real pl, Real pr, int nLeft, int nRight, Real mu); 
    157157 
    158158                // compute the surface area heuristic (SAH) for the plane represented by this event 
    159                 void SAH(const AxisAlignedBox& parent, int nLeft, int nPlane, int nRight, SplitInfo& split); 
     159                void SAH(const AxisAlignedBox& parent, int nLeft, int nPlane, int nRight, BvhSplitInfo& split); 
    160160                // the variables determining the cost of a branch traversal (KT) and a leaf intersection (KI) 
    161161                static Real KT; 
    … …  
    171171 
    172172        // Holds all the important information on a split 
    173         struct SplitInfo 
     173        struct BvhSplitInfo 
    174174        { 
    175175                AxisAlignedBox bleft; 
    … …  
    178178                int nright; 
    179179                Real cost; 
    180                 PlaneEvent::Side side; 
    181                 PlaneEvent event; 
     180                BvhPlaneEvent::Side side; 
     181                BvhPlaneEvent event; 
    182182 
    183183                // DEBUG 
    … …  
    185185        }; 
    186186 
    187         typedef std::list<PlaneEvent> PlaneEventList; 
    188         typedef std::list<BvRenderable *> BvRenderableList; 
     187        typedef std::list<BvhRenderable *> BvhRenderableList; 
     188        typedef std::list<BvhPlaneEvent> BvhPlaneEventList; 
    189189         
    190         class KdTree 
     190        class BvHierarchy 
    191191        { 
    192192        protected: 
    … …  
    197197                { 
    198198                public: 
    199                         Node(KdTree * owner, int level, AxisAlignedBox& aabb, Branch * parent): 
     199                        Node(BvHierarchy * owner, int level, AxisAlignedBox& aabb, Branch * parent): 
    200200                        mOwner(owner), 
    201201                        mLevel(level), 
    … …  
    217217 
    218218                        // Gets this node's parent (NULL if this is the root). 
    219                         KdTree::Node *getParent(void) const { return mParent; }; 
     219                        BvHierarchy::Node *getParent(void) const { return mParent; }; 
    220220 
    221221                        // Gets the nodes left & right child nodes, or NULL if not present or node is leaf 
    222                         virtual KdTree::Node *getLeftChild(void) const = 0; 
    223                         virtual KdTree::Node *getRightChild(void) const = 0; 
     222                        virtual BvHierarchy::Node *getLeftChild(void) const = 0; 
     223                        virtual BvHierarchy::Node *getRightChild(void) const = 0; 
    224224 
    225225                        // add contained objects to render queue 
    … …  
    242242 
    243243                                if (mOwner->getHiLiteLevel() == mLevel) 
    244                                         mWBB->setMaterial("KdTree/BoxHiLite"); 
     244                                        mWBB->setMaterial("BvHierarchy/BoxHiLite"); 
    245245                                else 
    246246                                        mWBB->setMaterial("BaseWhiteNoLighting"); 
    … …  
    275275                        */ 
    276276                        void setLastRendered(unsigned int frameid) { mLastRendered = frameid; }; 
    277                         /** Returns real extent of the kdtree, i.e., the merged extent of the bounding boxes.  
     277                        /** Returns real extent of the BvHierarchy, i.e., the merged extent of the bounding boxes.  
    278278                        */ 
    279279                        AxisAlignedBox _getWorldAABB(void) const { return mAABB; }; 
    280                         /** Updates bound of the real aabb of kdtree 
     280                        /** Updates bound of the real aabb of BvHierarchy 
    281281                        */ 
    282282                        virtual void _updateBounds(bool recurse = true) = 0; 
    … …  
    288288                        AxisAlignedBox mWorldAABB; 
    289289                protected: 
    290                         KdTree * mOwner; 
     290                        BvHierarchy * mOwner; 
    291291                        Branch * mParent; 
    292292                        int mLevel; 
    … …  
    303303                { 
    304304                public: 
    305                         Branch(KdTree * owner, int level, AxisAlignedBox& aabb, Branch * parent,  
    306                                 Plane * splitplane, PlaneEvent::Side side): 
     305                        Branch(BvHierarchy * owner, int level, AxisAlignedBox& aabb, Branch * parent,  
     306                                Plane * splitplane, BvhPlaneEvent::Side side): 
    307307                        Node(owner, level, aabb, parent),  
    308308                        mSplitPlane(splitplane),  
    … …  
    335335 
    336336                        // a branch should have at least one child 
    337                         virtual KdTree::Node * getLeftChild() const { return mLeft; }; 
    338                         virtual KdTree::Node * getRightChild() const { return mRight; }; 
     337                        virtual BvHierarchy::Node * getLeftChild() const { return mLeft; }; 
     338                        virtual BvHierarchy::Node * getRightChild() const { return mRight; }; 
    339339 
    340340                        virtual void queueVisibleObjects(unsigned long currentFrame,  
    … …  
    379379                        Node * mRight; 
    380380                        Plane  * mSplitPlane; 
    381                         PlaneEvent::Side mPlaneSide; 
     381                        BvhPlaneEvent::Side mPlaneSide; 
    382382                protected: 
    383383                        std::set<Leaf *> mLeaves; 
    … …  
    387387                { 
    388388                public: 
    389                         Leaf(KdTree * owner, int level, AxisAlignedBox& aabb, Branch * parent): 
     389                        Leaf(BvHierarchy * owner, int level, AxisAlignedBox& aabb, Branch * parent): 
    390390                        Node(owner, level, aabb, parent)  
    391391                        {}; 
    … …  
    397397 
    398398                        // a leaf is empty when it does not posses renderables 
    399                         virtual bool isEmpty() const { return mBvRenderables.empty(); } 
     399                        virtual bool isEmpty() const { return mBvhRenderables.empty(); } 
    400400 
    401401                        // a leaf has geometry when it has renderables 
    402                         virtual bool hasGeometry() const { return !mBvRenderables.empty(); } 
     402                        virtual bool hasGeometry() const { return !mBvhRenderables.empty(); } 
    403403 
    404404                        // a leaf adds itself to the leaf set 
    … …  
    406406 
    407407                        // a leaf never has children  
    408                         virtual KdTree::Node * getLeftChild() const { return 0; }; 
    409                         virtual KdTree::Node * getRightChild() const { return 0; }; 
     408                        virtual BvHierarchy::Node * getLeftChild() const { return 0; }; 
     409                        virtual BvHierarchy::Node * getRightChild() const { return 0; }; 
    410410 
    411411                        virtual void queueVisibleObjects(unsigned long currentFrame,  
    … …  
    417417                        virtual void _updateBounds(bool recurse = true); 
    418418 
    419                         virtual void remove(BvRenderable * rend) 
    420                         { 
    421                                 mBvRenderables.remove(rend); 
    422                                 //mBvRenderables.erase(find(mBvRenderables.begin(), mBvRenderables.end(), rend)); 
     419                        virtual void remove(BvhRenderable * rend) 
     420                        { 
     421                                mBvhRenderables.remove(rend); 
     422                                //mBvhRenderables.erase(find(mBvhRenderables.begin(), mBvhRenderables.end(), rend)); 
    423423                        }; 
    424424 
    425                         virtual void insert(BvRenderable * rend) 
    426                         { 
    427                                 mBvRenderables.push_back(rend); 
     425                        virtual void insert(BvhRenderable * rend) 
     426                        { 
     427                                mBvhRenderables.push_back(rend); 
    428428                        }; 
    429429 
    430                         BvRenderableList mBvRenderables; 
    431                 }; 
    432  
    433                 struct SplitCandidate 
    434                 { 
    435                         SplitCandidate(PlaneEventList * e, int n, AxisAlignedBox& a, 
    436                                 KdTree::Branch * p, Real c, Real d, SplitInfo * b, PlaneEvent::Side s): 
     430                        BvhRenderableList mBvhRenderables; 
     431                }; 
     432 
     433                struct BvhSubdivisionCandidate 
     434                { 
     435                        BvhSubdivisionCandidate(BvhPlaneEventList * e, int n, AxisAlignedBox& a, 
     436                                BvHierarchy::Branch * p, Real c, Real d, BvhSplitInfo * b, BvhPlaneEvent::Side s): 
    437437                        events(e), nObjects(n), aabb(a), parent(p), cost(c), decrease(d), best(b), side(s) 
    438438                        { }; 
    439439 
    440                         bool operator < (const SplitCandidate& rhs) const 
     440                        bool operator < (const BvhSubdivisionCandidate& rhs) const 
    441441                        { 
    442442                                return decrease < rhs.decrease; 
    443443                        }; 
    444444 
    445                         void operator = (const SplitCandidate& rhs) 
     445                        void operator = (const BvhSubdivisionCandidate& rhs) 
    446446                        { 
    447447                                decrease = rhs.decrease; 
    … …  
    461461                        Real cost; 
    462462                        int nObjects; 
    463                         PlaneEvent::Side side; 
     463                        BvhPlaneEvent::Side side; 
    464464                        AxisAlignedBox aabb; 
    465                         PlaneEventList * events; 
    466                         KdTree::Branch * parent; 
    467                         SplitInfo * best; 
    468                 }; 
    469  
    470                 // typedef std::stack<SplitCandidate> SplitCandidatePQ; 
    471                 typedef std::priority_queue<SplitCandidate> SplitCandidatePQ; 
     465                        BvhPlaneEventList *events; 
     466                        BvHierarchy::Branch * parent; 
     467                        BvhSplitInfo * best; 
     468                }; 
     469 
     470                // typedef std::stack<BvhSubdivisionCandidate> SplitCandidatePQ; 
     471                typedef std::priority_queue<BvhSubdivisionCandidate> SplitCandidatePQ; 
    472472 
    473473                // nodestack for the stack-based rendering function 
    474                 typedef std::stack<KdTree::Node *> NodeStack; 
     474                typedef std::stack<BvHierarchy::Node *> NodeStack; 
    475475        public: 
    476                 friend class KdTreeHierarchyInterface; 
    477  
    478                 typedef KdTree::Node * NodePtr; 
    479                 typedef KdTree::Branch * BranchPtr; 
    480                 typedef KdTree::Leaf * LeafPtr; 
     476                friend class BvHierarchyInterface; 
     477 
     478                typedef BvHierarchy::Node * NodePtr; 
     479                typedef BvHierarchy::Branch * BranchPtr; 
     480                typedef BvHierarchy::Leaf * LeafPtr; 
    481481 
    482482                typedef std::list<NodePtr> NodeList; 
    … …  
    513513                enum RenderMethod 
    514514                { 
    515                         KDRM_INTERNAL, 
    516                         KDRM_GTP_VFC, 
    517                         KDRM_GTP_SWC, 
    518                         KDRM_GTP_CHC, 
     515                        BVHRM_INTERNAL, 
     516                        BVHRM_GTP_VFC, 
     517                        BVHRM_GTP_SWC, 
     518                        BVHRM_GTP_CHC, 
    519519                        // invalid modes, just for convenience 
    520                         KDRM_SIZE, 
    521                         KDRM_NOTSET 
     520                        BVHRM_SIZE, 
     521                        BVHRM_NOTSET 
    522522                }; 
    523523 
    524524                enum BuildMethod 
    525525                { 
    526                         KDBM_RECURSIVE, 
    527                         KDBM_PRIORITYQUEUE, 
     526                        BVHBM_RECURSIVE, 
     527                        BVHBM_PRIORITYQUEUE, 
    528528                        // invalid modes, just for convenience 
    529                         KDBM_SIZE, 
    530                         KDBM_NOTSET 
     529                        BVHBM_SIZE, 
     530                        BVHBM_NOTSET 
    531531                }; 
    532532 
    … …  
    534534                const static int HILITE_OFF  = -1; 
    535535                 
    536                 KdTree(int maxdepth, BuildMethod bm); 
    537                 KdTree(int maxdepth, BuildMethod bm, int hilite, bool allboxes, bool shownodes); 
    538                 virtual ~KdTree(); 
     536                BvHierarchy(int maxdepth, BuildMethod bm); 
     537                BvHierarchy(int maxdepth, BuildMethod bm, int hilite, bool allboxes, bool shownodes); 
     538                virtual ~BvHierarchy(); 
    539539 
    540540                // DEBUG 
    … …  
    546546                inline int  getHiLiteLevel(void) { return mHiLiteLevel; }; 
    547547 
    548                 // toggles displaying the kdtree boxes 
     548                // toggles displaying the BvHierarchy boxes 
    549549                inline void setShowAllBoxes(bool show) { mShowAllBoxes = show; }; 
    550550                inline bool getShowAllBoxes(void) { return mShowAllBoxes; }; 
    … …  
    559559                bool getEnhancedVis(void); 
    560560 
    561                 NodePtr getRoot(void) const { return mKdRoot; }; 
    562  
    563                 // insert a new scene node into an existing kd-tree 
    564                 void insert(BvRenderable * rend); 
     561                NodePtr getRoot(void) const { return mBvhRoot; }; 
     562 
     563                // insert a new scene node into an existing bvhierarchy 
     564                void insert(BvhRenderable * rend); 
    565565                // remove a scene node from the tree 
    566                 void remove(BvRenderable * rend); 
     566                void remove(BvhRenderable * rend); 
    567567                // function to initialize a kd-tree based on the contents of the scene 
    568                 void build(BvRenderable * sceneRoot); 
     568                void build(BvhRenderable * sceneRoot); 
    569569 
    570570                // test visibility of objects and add to render queue 
    571571                void queueVisibleObjects(BvHierarchyCamera* cam, RenderQueue* queue, bool onlyShadowCasters,  
    572                         bool showBoxes, KdTree::NodeList& visibleNodes); 
     572                        bool showBoxes, BvHierarchy::NodeList& visibleNodes); 
    573573 
    574574                // find visible nodes & place in list 
    575575                //void findVisibleNodes(NodeList& visibleNodes, Camera * cam); 
    576576 
    577                 /** Recurses the kdtree, adding any nodes intersecting with the  
     577                /** Recurses the BvHierarchy, adding any nodes intersecting with the  
    578578                box/sphere/volume/ray into the given list. 
    579579                It ignores the exclude scene node. 
    … …  
    588588                const TreeStats& getTreeStats(void) const { return mTreeStats; } 
    589589                const FrameStats& getFramesStats(void) const { return mFrameStats; } 
    590                 AxisAlignedBox getBox(void) { if (mKdRoot) return mKdRoot->mAABB; else return AxisAlignedBox(); } 
     590                AxisAlignedBox getBox(void) { if (mBvhRoot) return mBvhRoot->mAABB; else return AxisAlignedBox(); } 
    591591                void setBuildMethod(BuildMethod bm) { mBuildMethod = bm; } 
    592592        protected: 
    … …  
    594594                void init(); 
    595595                // recursive insert funciton 
    596                 void recInsert(KdTree::Node * node, BvRenderable * rend); 
     596                void recInsert(BvHierarchy::Node * node, BvhRenderable * rend); 
    597597                // helper functions for insert 
    598                 void recInsertNew(KdTree::Branch * parent, PlaneEvent::Side side, BvRenderable * rend); 
    599                 void splitBox(const KdTree::Branch& parent, AxisAlignedBox& left, AxisAlignedBox& right); 
    600                 void rebuildSubtree(KdTree::Node * node, BvRenderable * rend); 
     598                void recInsertNew(BvHierarchy::Branch * parent, BvhPlaneEvent::Side side, BvhRenderable * rend); 
     599                void splitBox(const BvHierarchy::Branch& parent, AxisAlignedBox& left, AxisAlignedBox& right); 
     600                void rebuildSubtree(BvHierarchy::Node * node, BvhRenderable * rend); 
    601601                // build scene from a list of nodes rather than a hierarchy 
    602                 KdTree::Node * buildFromList(BvRenderableList& nodelist, KdTree::Branch * parent, AxisAlignedBox& aabb); 
    603                 void addRendToList(KdTree::Node * node, BvRenderableList& nodelist); 
     602                BvHierarchy::Node * buildFromList(BvhRenderableList& nodelist, BvHierarchy::Branch * parent, AxisAlignedBox& aabb); 
     603                void addRendToList(BvHierarchy::Node * node, BvhRenderableList& nodelist); 
    604604 
    605605                // recursively delete empty nodes 
    606                 void recDelete(KdTree::Node * node); 
     606                void recDelete(BvHierarchy::Node * node); 
    607607 
    608608                // find the best plane for node division 
    609                 SplitInfo * pqFindPlane(PlaneEventList * events, int nObjects, AxisAlignedBox& aabb, Real globalSA); 
     609                BvhSplitInfo * pqFindPlane(BvhPlaneEventList * events, int nObjects, AxisAlignedBox& aabb, Real globalSA); 
    610610 
    611611                // priority queue based build function 
    612                 KdTree::Node * pqBuild(PlaneEventList& events, int nObjects, AxisAlignedBox& aabb, KdTree::Branch * parent); 
     612                BvHierarchy::Node * pqBuild(BvhPlaneEventList& events, int nObjects, AxisAlignedBox& aabb, BvHierarchy::Branch * parent); 
    613613                // recursive build function 
    614                 KdTree::Node * recBuild(PlaneEventList& events, int nObjects, AxisAlignedBox& aabb, KdTree::Branch * parent); 
     614                BvHierarchy::Node * recBuild(BvhPlaneEventList& events, int nObjects, AxisAlignedBox& aabb, BvHierarchy::Branch * parent); 
    615615 
    616616                // recursive rendering function 
    617                 void recQueueVisibleObjects(KdTree::Node * node, unsigned long currentFrame, BvHierarchyCamera* cam, 
     617                void recQueueVisibleObjects(BvHierarchy::Node * node, unsigned long currentFrame, BvHierarchyCamera* cam, 
    618618                        RenderQueue* queue, bool onlyShadowCasters, bool showBoxes,  
    619                         KdTree::NodeList& visibleNodes, bool fullVis = false); 
     619                        BvHierarchy::NodeList& visibleNodes, bool fullVis = false); 
    620620 
    621621                // recursively find visible nodes 
    622                 //void recFindVisibleNodes(KdTree::Node * node, NodeList& visibleNodes, Camera * cam); 
    623  
    624                 /** Recurses the kdtree, adding any nodes intersecting with the  
     622                //void recFindVisibleNodes(BvHierarchy::Node * node, NodeList& visibleNodes, Camera * cam); 
     623 
     624                /** Recurses the BvHierarchy, adding any nodes intersecting with the  
    625625                box/sphere/volume/ray into the given list. 
    626626                It ignores the exclude scene node. 
    … …  
    631631                void recFindNodesIn(const Ray &ray, std::list<SceneNode *> &list, SceneNode *exclude, Node * node, bool full = false); 
    632632 
    633                 // the root node of the kdtree 
    634                 KdTree::Node * mKdRoot; 
     633                // the root node of the BvHierarchy 
     634                BvHierarchy::Node * mBvhRoot; 
    635635                // Maximum depth of the tree 
    636636                int mMaxDepth; 
    … …  
    649649 
    650650                /** Visualization flags **/ 
    651                 // show/highlight selected level in kdtree 
     651                // show/highlight selected level in BvHierarchy 
    652652                int mHiLiteLevel; 
    653653                // show whole kd-tree 
    … …  
    662662 
    663663                // DEBUG 
    664                 void KdTree::dump(KdTree::Node * node); 
    665                 Real KdTree::calcCost(KdTree::Node * node, Real vs); 
    666         }; // class KdTree 
     664                void BvHierarchy::dump(BvHierarchy::Node * node); 
     665                Real BvHierarchy::calcCost(BvHierarchy::Node * node, Real vs); 
     666        }; // class BvHierarchy 
    667667 
    668668} // namespace Ogre 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreBvHierarchyCamera.h

    r1319 r1320  
    1313#include <OgreCamera.h> 
    1414 
    15 #define KDCAMPTR_CAST(cam) (static_cast<BvHierarchyCamera *>(cam)) 
     15#define BVHCAMPTR_CAST(cam) (static_cast<BvHierarchyCamera *>(cam)) 
    1616 
    1717namespace Ogre 
    … …  
    2323        enum NodeVisibility 
    2424        { 
    25                 KDNV_NONE, 
    26                 KDNV_PART, 
    27                 KDNV_FULL 
     25                BVHNV_NONE, 
     26                BVHNV_PART, 
     27                BVHNV_FULL 
    2828        }; 
    2929 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreBvHierarchyInterface.h

    r1319 r1320  
    1616{ 
    1717 
    18 class KdTreeSceneManager; 
     18class BvHierarchySceneManager; 
    1919 
    20 class KdTreeHierarchyInterface : public PlatformHierarchyInterface 
     20class BvHierarchyInterface : public PlatformHierarchyInterface 
    2121{ 
    2222public: 
    23         KdTreeHierarchyInterface(KdTreeSceneManager *sm, RenderSystem *rsys); 
     23        BvHierarchyInterface(BvHierarchySceneManager *sm, RenderSystem *rsys); 
    2424 
    25         virtual ~KdTreeHierarchyInterface() {}; 
     25        virtual ~BvHierarchyInterface() {}; 
    2626 
    2727        /** Returns true if current node is leaf of the hierarchy.  

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreBvHierarchySceneManager.h

    r1319 r1320  
    88*/ 
    99 
    10 #ifndef _KdTreeSceneManager_H__ 
    11 #define _KdTreeSceneManager_H__ 
     10#ifndef _BvHierarchySceneManager_H__ 
     11#define _BvHierarchySceneManager_H__ 
    1212 
    1313#include <OgreSceneManager.h> 
    … …  
    1919#include "OgreBvHierarchyInterface.h" 
    2020 
    21 #define KDTREE_MAX_DEPTH 12 
     21#define BvHierarchy_MAX_DEPTH 12 
    2222 
    2323namespace Ogre 
    2424{ 
    2525 
    26 class KdTreeSceneNode; 
    27  
    28 class KdTreeSceneManager : public SceneManager 
     26class BvHierarchySceneNode; 
     27 
     28class BvHierarchySceneManager : public SceneManager 
    2929{ 
    3030public: 
    31         KdTreeSceneManager(const String& name, GtpVisibility::VisibilityManager *vm); 
    32         ~KdTreeSceneManager(void); 
     31        BvHierarchySceneManager(const String& name, GtpVisibility::VisibilityManager *vm); 
     32        ~BvHierarchySceneManager(void); 
    3333 
    3434        virtual const String& getTypeName(void) const; 
    3535 
    36         //typedef std::list<KdTreeSceneNode *> NodeList; 
     36        //typedef std::list<BvHierarchySceneNode *> NodeList; 
    3737        //typedef std::list<WireBoundingBox *> BoxList; 
    3838 
    3939        /************************************************************************/ 
    40         /* Functions overridden form SceneManager for KdTree                    */ 
     40        /* Functions overridden form SceneManager for BvHierarchy                    */ 
    4141        /************************************************************************/ 
    4242 
    … …  
    4545        virtual Camera* createCamera(const String& name); 
    4646 
    47         /** Override from SceneManager to create SceneNodes as instance of KdTreeSceneNode 
     47        /** Override from SceneManager to create SceneNodes as instance of BvHierarchySceneNode 
    4848        */ 
    4949        virtual SceneNode* createSceneNode(void); 
    50         /** Override from SceneManager to create SceneNodes as instance of KdTreeSceneNode 
     50        /** Override from SceneManager to create SceneNodes as instance of BvHierarchySceneNode 
    5151        */ 
    5252        virtual SceneNode* createSceneNode(const String& name); 
    … …  
    6262        bool getOptionKeys(StringVector &refKeys); 
    6363 
    64         /** Overide from scene manager to destroy kdtree properly (before the scene graph is destroyed) 
     64        /** Overide from scene manager to destroy BvHierarchy properly (before the scene graph is destroyed) 
    6565        */ 
    6666        virtual void clearScene(); 
    … …  
    110110 
    111111        /************************************************************************/ 
    112         /* Functions which are specific to the KdTree                           */ 
     112        /* Functions which are specific to the BvHierarchy                           */ 
    113113        /************************************************************************/ 
    114114         
    115         /** Update the KdTree with the node (more or less disabled now) 
    116         */ 
    117         virtual void _updateNode(KdTreeSceneNode *node); // TODO:  
    118  
    119         /** Show or hide the bounding boxes of KdTree nodes - obsolete, use options 
     115        /** Update the BvHierarchy with the node (more or less disabled now) 
     116        */ 
     117        virtual void _updateNode(BvHierarchySceneNode *node); // TODO:  
     118 
     119        /** Show or hide the bounding boxes of BvHierarchy nodes - obsolete, use options 
    120120        */ 
    121121        virtual void setShowBoxes(bool showboxes); 
    … …  
    124124        virtual bool getShowBoxes(void) const; 
    125125 
    126         /** Recurses the kdtree, adding any nodes intersecting with the  
     126        /** Recurses the BvHierarchy, adding any nodes intersecting with the  
    127127        box/sphere/volume/ray into the given list. 
    128128        It ignores the exclude scene node. 
    … …  
    162162        /** Render a list of scenenodes 
    163163        */ 
    164         //virtual void _renderNodes(const BvRenderableList& nodelist, Camera * cam, 
     164        //virtual void _renderNodes(const BvhRenderableList& nodelist, Camera * cam, 
    165165        //      bool onlyShadowCasters, int leavePassesInQueue); 
    166         virtual void _renderNode(KdTree::NodePtr node, Camera * cam, 
     166        virtual void _renderNode(BvHierarchy::NodePtr node, Camera * cam, 
    167167                bool onlyShadowCasters, int leavePassesInQueue); 
    168168 
    … …  
    181181        /** Returns hierarchy interface. 
    182182        */ 
    183         KdTreeHierarchyInterface *GetHierarchyInterface(); 
     183        BvHierarchyInterface *GetHierarchyInterface(); 
    184184 
    185185protected: 
    … …  
    223223 
    224224        // the hierarchy interface for CHC 
    225         KdTreeHierarchyInterface *mHierarchyInterface; 
     225        BvHierarchyInterface *mHierarchyInterface; 
    226226 
    227227        // if hierarchical culling is currently in use 
    … …  
    273273 
    274274        // remember visited scene nodes for viz 
    275         KdTree::NodeList mVisibleNodes; 
     275        BvHierarchy::NodeList mVisibleNodes; 
    276276 
    277277        /************************************************************************/ 
    278278        /* Kd-Tree specific options & members                                   */ 
    279279        /************************************************************************/ 
    280         // maximum depth of the kdtree 
     280        // maximum depth of the BvHierarchy 
    281281        int mMaxDepth; 
    282282 
    283         // the kdtree which holds the scene 
    284         KdTree *mBvHierarchy; 
    285  
    286         // if bounding boxes of kdtree nodes are shown 
     283        // the BvHierarchy which holds the scene 
     284        BvHierarchy *mBvHierarchy; 
     285 
     286        // if bounding boxes of BvHierarchy nodes are shown 
    287287        bool mShowBoxes; 
    288288        // bounding boxes of kd nodes will be highlighted on this level of the kd tree 
    … …  
    290290        // if all bounding boxes shall be displayed, not only the highlighted level 
    291291        bool mShowAllBoxes; 
    292         // visualize kdtree nodes or bounding boxes of objects in nodes 
     292        // visualize BvHierarchy nodes or bounding boxes of objects in nodes 
    293293        bool mShowNodes; 
    294294 
    … …  
    297297 
    298298        // the method/algorithm used when rendering the scene 
    299         KdTree::RenderMethod mRenderMethod; 
     299        BvHierarchy::RenderMethod mRenderMethod; 
    300300 
    301301        // the method of building the tree 
    302         KdTree::BuildMethod mBuildMethod; 
     302        BvHierarchy::BuildMethod mBuildMethod; 
    303303 
    304304        /************************************************************************/ 
    … …  
    327327 
    328328 
    329 /// Factory for KdTreeSceneManager 
    330 class BvHierarchySceneManagerFactory : public SceneManagerFactory 
     329/// Factory for BvHierarchySceneManager 
     330class BvHierarchySceneManagerFactory: public SceneManagerFactory 
    331331{ 
    332332protected: 
    … …  
    337337        { 
    338338                visManager = vm; 
    339         }; 
     339        } 
    340340        ~BvHierarchySceneManagerFactory(void) {}; 
    341341        /// Factory type name 
    … …  
    347347} // namespace Ogre 
    348348 
    349 #endif // _KdTreeSceneManager_H__ 
     349#endif // _BvHierarchySceneManager_H__ 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreBvHierarchySceneNode.h

    r1319 r1320  
    1212 
    1313#include <OgreSceneNode.h> 
    14 #include "OgreBvRenderable.h" 
     14#include "OgreBvhRenderable.h" 
    1515 
    1616namespace Ogre 
    1717{ 
    1818 
    19         class KdTreeSceneNode : public SceneNode, public BvRenderable 
     19        class BvHierarchySceneNode : public SceneNode, public BvhRenderable 
    2020        { 
    2121        public: 
    22                 KdTreeSceneNode(SceneManager *creator): 
     22                BvHierarchySceneNode(SceneManager *creator): 
    2323                  SceneNode(creator) {}; 
    2424 
    25                 KdTreeSceneNode(SceneManager *creator, const String& name): 
     25                BvHierarchySceneNode(SceneManager *creator, const String& name): 
    2626                  SceneNode(creator, name) {}; 
    2727 
    28                 ~KdTreeSceneNode() {}; 
     28                ~BvHierarchySceneNode() {}; 
    2929 
    3030                // gather info for kd-tree creation 
    31                 virtual void computeScene(PlaneEventList& events, AxisAlignedBox& aabb, int& nObjects, bool includeChildren = true); 
     31                virtual void computeScene(BvhPlaneEventList& events, AxisAlignedBox& aabb, int& nObjects, bool includeChildren = true); 
    3232 
    3333                // add all contained objects to render queue 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreBvhRenderable.h

    r1319 r1320  
    88*/ 
    99 
    10 #ifndef _OgreBvRenderable_H__ 
    11 #define _OgreBvRenderable_H__ 
     10#ifndef _OgreBvhRenderable_H__ 
     11#define _OgreBvhRenderable_H__ 
    1212 
    1313#include "OgreBvHierarchy.h" 
    … …  
    1818        // interface which must be implemented by all objects which desire to be 
    1919        // placed in the kd-tree 
    20         class BvRenderable 
     20        class BvhRenderable 
    2121        { 
    2222        public: 
    23                 BvRenderable():mSide(PlaneEvent::PES_BOTH), mClassified(false), mLastQueued(0), mBvHierarchy(0) {}; 
    24                 virtual ~BvRenderable() 
     23                BvhRenderable():mSide(BvhPlaneEvent::PES_BOTH), mClassified(false), mLastQueued(0), mBvHierarchy(0) {}; 
     24                virtual ~BvhRenderable() 
    2525                { 
    2626                        if (mBvHierarchy) 
    … …  
    2929 
    3030                // gather the information required for the creation of the kd-tree 
    31                 virtual void computeScene(PlaneEventList& events, AxisAlignedBox& aabb, int& nObjects, bool includeChildren = true) = 0; 
     31                virtual void computeScene(BvhPlaneEventList& events, AxisAlignedBox& aabb, int& nObjects, bool includeChildren = true) = 0; 
    3232 
    3333                // put all objects this element holds in the renedering queue 
    … …  
    5050                }; 
    5151 
    52                 inline PlaneEvent::Side getSide() 
     52                inline BvhPlaneEvent::Side getSide() 
    5353                { 
    5454                        return mSide; 
    5555                }; 
    56                 inline void setSide(PlaneEvent::Side s) 
     56                inline void setSide(BvhPlaneEvent::Side s) 
    5757                { 
    5858                        mSide = s; 
    … …  
    6565                }; 
    6666                // the following functions should work in O(log N) 
    67                 inline bool isAttached(KdTree::LeafPtr leaf) 
     67                inline bool isAttached(BvHierarchy::LeafPtr leaf) 
    6868                { 
    6969                        return mLeaves.find(leaf) != mLeaves.end(); 
    7070                }; 
    71                 inline bool attachTo(KdTree::LeafPtr leaf, KdTree * kdTree) 
     71                inline bool attachTo(BvHierarchy::LeafPtr leaf, BvHierarchy * BvHierarchy) 
    7272                { 
    73                         if (mBvHierarchy == 0 || mBvHierarchy == kdTree) 
    74                                 mBvHierarchy = kdTree; 
     73                        if (mBvHierarchy == 0 || mBvHierarchy == BvHierarchy) 
     74                                mBvHierarchy = BvHierarchy; 
    7575                        else 
    7676                                return false; 
    7777 
    78                         KdTree::LeafSet::_Pairib p = mLeaves.insert(leaf); 
     78                        BvHierarchy::LeafSet::_Pairib p = mLeaves.insert(leaf); 
    7979                        return p.second; 
    8080                }; 
    81                 inline bool detachFrom(KdTree::LeafPtr leaf) 
     81                inline bool detachFrom(BvHierarchy::LeafPtr leaf) 
    8282                { 
    8383                        bool success = (mLeaves.erase(leaf) == 1); 
    … …  
    102102                }; 
    103103 
    104                 KdTree::LeafSet& getLeaves() 
     104                BvHierarchy::LeafSet& getLeaves() 
    105105                { 
    106106                        return mLeaves; 
    … …  
    113113                Camera * mLastCam; 
    114114                 
    115                 // kdtree to which this renderable is attached 
    116                 KdTree * mBvHierarchy; 
    117                 // kdtree leaves which overlap this renderable 
    118                 KdTree::LeafSet mLeaves; 
     115                // BvHierarchy to which this renderable is attached 
     116                BvHierarchy * mBvHierarchy; 
     117                // BvHierarchy leaves which overlap this renderable 
     118                BvHierarchy::LeafSet mLeaves; 
    119119 
    120120                // Flag for the SAH determining the "cheaper" side of the split plane 
    121                 PlaneEvent::Side mSide; 
     121                BvhPlaneEvent::Side mSide; 
    122122                // Flag for the SAH which marks if this renderable was already placed in the list after a split 
    123123                bool mClassified; 
    124         }; // class BvRenderable 
     124        }; // class BvhRenderable 
    125125 
    126126} // namespace Ogre 
    127127 
    128 #endif // _OgreBvRenderable_H__ 
     128#endif // _OgreBvhRenderable_H__ 
Note: See TracChangeset for help on using the changeset viewer.