Changeset 1320 for GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE

Timestamp:

09/04/06 08:56:26 (18 years ago)

Author:

mattausch

Message:

 

Location:

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE

Files:

• include/OgreBvHierarchy.h (modified) (34 diffs)
• include/OgreBvHierarchyCamera.h (modified) (2 diffs)
• include/OgreBvHierarchyInterface.h (modified) (1 diff)
• include/OgreBvHierarchySceneManager.h (modified) (15 diffs)
• include/OgreBvHierarchySceneNode.h (modified) (1 diff)
• include/OgreBvhRenderable.h (moved) (moved from GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreBvRenderable.h) (7 diffs)
• src/OgreBvHierarchy.cpp (moved) (moved from GTP/trunk/Lib/Vis/OnlineCullingCHC/src/OgreBvHierarchy.cpp) (91 diffs)
• src/OgreBvHierarchyCamera.cpp (moved) (moved from GTP/trunk/Lib/Vis/OnlineCullingCHC/src/OgreBvHierarchyCamera.cpp) (3 diffs)
• src/OgreBvHierarchyInterface.cpp (moved) (moved from GTP/trunk/Lib/Vis/OnlineCullingCHC/src/OgreBvHierarchyInterface.cpp) (9 diffs)
• src/OgreBvHierarchySceneManager.cpp (moved) (moved from GTP/trunk/Lib/Vis/OnlineCullingCHC/src/OgreBvHierarchySceneManager.cpp) (55 diffs)
• src/OgreBvHierarchySceneNode.cpp (moved) (moved from GTP/trunk/Lib/Vis/OnlineCullingCHC/src/OgreBvHierarchySceneNode.cpp) (11 diffs)
• src/OgreKdTree.cpp (modified) (7 diffs)
• src/OgreVisibilitySceneManagerDll.cpp (modified) (5 diffs)
• src/Plugin_VisibilitySceneManager.vcproj (modified) (3 diffs)

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

@@ -11 +11 @@
 #define _OgreBvHierarchy_H__
 
-#define KDNODE_CAST(a) (static_cast<KdTree::Node>(a))
-#define KDBRANCH_CAST(a) (static_cast<KdTree::Branch>(a))
-#define KDLEAF_CAST(a) (static_cast<KdTree::Leaf>(a))
-#define KDNODEPTR_CAST(a) (static_cast<KdTree::Node *>(a))
-#define KDBRANCHPTR_CAST(a) (static_cast<KdTree::Branch *>(a))
-#define KDLEAFPTR_CAST(a) (static_cast<KdTree::Leaf *>(a))
-
-#define KDTREE_LOGNAME "KdTreeBuild.log"
+#define BVHNODE_CAST(a) (static_cast<BvHierarchy::Node>(a))
+#define BVHBRANCH_CAST(a) (static_cast<BvHierarchy::Branch>(a))
+#define BVHLEAF_CAST(a) (static_cast<BvHierarchy::Leaf>(a))
+#define BVHNODEPTR_CAST(a) (static_cast<BvHierarchy::Node *>(a))
+#define BVHBRANCHPTR_CAST(a) (static_cast<BvHierarchy::Branch *>(a))
+#define BVHLEAFPTR_CAST(a) (static_cast<BvHierarchy::Leaf *>(a))
+
+#define BvHierarchy_LOGNAME "BvHierarchyBuild.log"
 
 #include <OgreAxisAlignedBox.h>
@@ -31 +31 @@
 #include "OgreBvHierarchyCamera.h"
 #include "HierarchyInterface.h"
-
+#include "OgreKdTree.h"
 
 namespace Ogre
 {
         class BvHierarchyCamera;
-        class BvRenderable;
-        struct SplitInfo;
-
-        class PlaneEvent
+        class BvhRenderable;
+        struct BvhSplitInfo;
+        
+        class BvhPlaneEvent
         {
         public:
@@ -63 +63 @@
                 };
 
-                PlaneEvent(): mRenderable(0), mPosition(Vector3()), mDimension(PED_X), mType(PET_ON)
+                BvhPlaneEvent(): mRenderable(0), mPosition(Vector3()), mDimension(PED_X), mType(PET_ON)
                 { };
 
-                PlaneEvent(BvRenderable *rend, const Vector3& pos, PlaneEvent::Dimension dim, PlaneEvent::Type type):
+                BvhPlaneEvent(BvhRenderable *rend, const Vector3& pos, BvhPlaneEvent::Dimension dim, BvhPlaneEvent::Type type):
                         mRenderable(rend), mPosition(pos), mDimension(dim), mType(type) 
                 { };
 
-                ~PlaneEvent() {};
+                ~BvhPlaneEvent() {};
 
                 // the less operator for plane events
                 // first sort by position, then by dimension and finally by type
-                bool operator < (const PlaneEvent& e) const
+                bool operator < (const BvhPlaneEvent& e) const
                 {
                         if(mPosition[mDimension] < e.mPosition[e.mDimension])
@@ -100 +100 @@
 
                 // the equals operator for tree events
-                bool operator == (const PlaneEvent& e) const
+                bool operator == (const BvhPlaneEvent& e) const
                 {
                         return  (mPosition[mDimension] == e.mPosition[e.mDimension]) &&
@@ -107 +107 @@
                 };
 
-                bool equalsType(const PlaneEvent& e, PlaneEvent::Type t)
+                bool equalsType(const BvhPlaneEvent& e, BvhPlaneEvent::Type t)
                 {
                         return  (mPosition[mDimension] == e.mPosition[e.mDimension]) &&
@@ -114 +114 @@
                 };
 
-                void classify(const PlaneEvent& e, PlaneEvent::Side side);
-
-                PlaneEvent clip(AxisAlignedBox& box, PlaneEvent::Dimension dim);
+                void classify(const BvhPlaneEvent& e, BvhPlaneEvent::Side side);
+
+                BvhPlaneEvent clip(AxisAlignedBox& box, BvhPlaneEvent::Dimension dim);
 
                 Plane * getSplitPlane() const
@@ -125 +125 @@
                 }
 
-                BvRenderable * getRenderable() const //??
+                BvhRenderable * getRenderable() const //??
                 {
                         return mRenderable;
                 };
 
-                PlaneEvent::Dimension getDimension() const //??
+                BvhPlaneEvent::Dimension getDimension() const //??
                 {
                         return mDimension;
@@ -139 +139 @@
         protected:
                 // event info
-                BvRenderable *                  mRenderable;
+                BvhRenderable *                 mRenderable;
                 Vector3                                 mPosition;
-                PlaneEvent::Dimension   mDimension;
-                PlaneEvent::Type                mType;
+                BvhPlaneEvent::Dimension        mDimension;
+                BvhPlaneEvent::Type             mType;
 
                 // ------------------------------------------------------------------------------//
@@ -149 +149 @@
                 // TODO discuss if these functions really belong here, OO & SE - wise
                 // pros: convenient, don't have to pass internal data to the outside
-                // cons: SplitInfo ... 
+                // cons: BvhSplitInfo ... 
         public:
                 // compute "global" surface area heuristic (SAH) for the plane represented by this event
                 // use only with priority queue build method
-                void pqSAH(Real globalSA, Real parentSA, int nLeft, int nPlane, int nRight, AxisAlignedBox& parentBox, SplitInfo& split);
+                void pqSAH(Real globalSA, Real parentSA, int nLeft, int nPlane, int nRight, AxisAlignedBox& parentBox, BvhSplitInfo& split);
                 static Real pqSplitCost(Real p, Real pl, Real pr, int nLeft, int nRight, Real mu);
 
                 // compute the surface area heuristic (SAH) for the plane represented by this event
-                void SAH(const AxisAlignedBox& parent, int nLeft, int nPlane, int nRight, SplitInfo& split);
+                void SAH(const AxisAlignedBox& parent, int nLeft, int nPlane, int nRight, BvhSplitInfo& split);
                 // the variables determining the cost of a branch traversal (KT) and a leaf intersection (KI)
                 static Real KT;
@@ -171 +171 @@
 
         // Holds all the important information on a split
-        struct SplitInfo
+        struct BvhSplitInfo
         {
                 AxisAlignedBox bleft;
@@ -178 +178 @@
                 int nright;
                 Real cost;
-                PlaneEvent::Side side;
-                PlaneEvent event;
+                BvhPlaneEvent::Side side;
+                BvhPlaneEvent event;
 
                 // DEBUG
@@ -185 +185 @@
         };
 
-        typedef std::list<PlaneEvent> PlaneEventList;
-        typedef std::list<BvRenderable *> BvRenderableList;
+        typedef std::list<BvhRenderable *> BvhRenderableList;
+        typedef std::list<BvhPlaneEvent> BvhPlaneEventList;
         
-        class KdTree
+        class BvHierarchy
         {
         protected:
@@ -197 +197 @@
                 {
                 public:
-                        Node(KdTree * owner, int level, AxisAlignedBox& aabb, Branch * parent):
+                        Node(BvHierarchy * owner, int level, AxisAlignedBox& aabb, Branch * parent):
                         mOwner(owner),
                         mLevel(level),
@@ -217 +217 @@
 
                         // Gets this node's parent (NULL if this is the root).
-                        KdTree::Node *getParent(void) const { return mParent; };
+                        BvHierarchy::Node *getParent(void) const { return mParent; };
 
                         // Gets the nodes left & right child nodes, or NULL if not present or node is leaf
-                        virtual KdTree::Node *getLeftChild(void) const = 0;
-                        virtual KdTree::Node *getRightChild(void) const = 0;
+                        virtual BvHierarchy::Node *getLeftChild(void) const = 0;
+                        virtual BvHierarchy::Node *getRightChild(void) const = 0;
 
                         // add contained objects to render queue
@@ -242 +242 @@
 
                                 if (mOwner->getHiLiteLevel() == mLevel)
-                                        mWBB->setMaterial("KdTree/BoxHiLite");
+                                        mWBB->setMaterial("BvHierarchy/BoxHiLite");
                                 else
                                         mWBB->setMaterial("BaseWhiteNoLighting");
@@ -275 +275 @@
                         */
                         void setLastRendered(unsigned int frameid) { mLastRendered = frameid; };
-                        /** Returns real extent of the kdtree, i.e., the merged extent of the bounding boxes. 
+                        /** Returns real extent of the BvHierarchy, i.e., the merged extent of the bounding boxes. 
                         */
                         AxisAlignedBox _getWorldAABB(void) const { return mAABB; };
-                        /** Updates bound of the real aabb of kdtree
+                        /** Updates bound of the real aabb of BvHierarchy
                         */
                         virtual void _updateBounds(bool recurse = true) = 0;
@@ -288 +288 @@
                         AxisAlignedBox mWorldAABB;
                 protected:
-                        KdTree * mOwner;
+                        BvHierarchy * mOwner;
                         Branch * mParent;
                         int mLevel;
@@ -303 +303 @@
                 {
                 public:
-                        Branch(KdTree * owner, int level, AxisAlignedBox& aabb, Branch * parent, 
-                                Plane * splitplane, PlaneEvent::Side side):
+                        Branch(BvHierarchy * owner, int level, AxisAlignedBox& aabb, Branch * parent, 
+                                Plane * splitplane, BvhPlaneEvent::Side side):
                         Node(owner, level, aabb, parent), 
                         mSplitPlane(splitplane), 
@@ -335 +335 @@
 
                         // a branch should have at least one child
-                        virtual KdTree::Node * getLeftChild() const { return mLeft; };
-                        virtual KdTree::Node * getRightChild() const { return mRight; };
+                        virtual BvHierarchy::Node * getLeftChild() const { return mLeft; };
+                        virtual BvHierarchy::Node * getRightChild() const { return mRight; };
 
                         virtual void queueVisibleObjects(unsigned long currentFrame, 
@@ -379 +379 @@
                         Node * mRight;
                         Plane  * mSplitPlane;
-                        PlaneEvent::Side mPlaneSide;
+                        BvhPlaneEvent::Side mPlaneSide;
                 protected:
                         std::set<Leaf *> mLeaves;
@@ -387 +387 @@
                 {
                 public:
-                        Leaf(KdTree * owner, int level, AxisAlignedBox& aabb, Branch * parent):
+                        Leaf(BvHierarchy * owner, int level, AxisAlignedBox& aabb, Branch * parent):
                         Node(owner, level, aabb, parent) 
                         {};
@@ -397 +397 @@
 
                         // a leaf is empty when it does not posses renderables
-                        virtual bool isEmpty() const { return mBvRenderables.empty(); }
+                        virtual bool isEmpty() const { return mBvhRenderables.empty(); }
 
                         // a leaf has geometry when it has renderables
-                        virtual bool hasGeometry() const { return !mBvRenderables.empty(); }
+                        virtual bool hasGeometry() const { return !mBvhRenderables.empty(); }
 
                         // a leaf adds itself to the leaf set
@@ -406 +406 @@
 
                         // a leaf never has children 
-                        virtual KdTree::Node * getLeftChild() const { return 0; };
-                        virtual KdTree::Node * getRightChild() const { return 0; };
+                        virtual BvHierarchy::Node * getLeftChild() const { return 0; };
+                        virtual BvHierarchy::Node * getRightChild() const { return 0; };
 
                         virtual void queueVisibleObjects(unsigned long currentFrame, 
@@ -417 +417 @@
                         virtual void _updateBounds(bool recurse = true);
 
-                        virtual void remove(BvRenderable * rend)
-                        {
-                                mBvRenderables.remove(rend);
-                                //mBvRenderables.erase(find(mBvRenderables.begin(), mBvRenderables.end(), rend));
+                        virtual void remove(BvhRenderable * rend)
+                        {
+                                mBvhRenderables.remove(rend);
+                                //mBvhRenderables.erase(find(mBvhRenderables.begin(), mBvhRenderables.end(), rend));
                         };
 
-                        virtual void insert(BvRenderable * rend)
-                        {
-                                mBvRenderables.push_back(rend);
+                        virtual void insert(BvhRenderable * rend)
+                        {
+                                mBvhRenderables.push_back(rend);
                         };
 
-                        BvRenderableList mBvRenderables;
-                };
-
-                struct SplitCandidate
-                {
-                        SplitCandidate(PlaneEventList * e, int n, AxisAlignedBox& a,
-                                KdTree::Branch * p, Real c, Real d, SplitInfo * b, PlaneEvent::Side s):
+                        BvhRenderableList mBvhRenderables;
+                };
+
+                struct BvhSubdivisionCandidate
+                {
+                        BvhSubdivisionCandidate(BvhPlaneEventList * e, int n, AxisAlignedBox& a,
+                                BvHierarchy::Branch * p, Real c, Real d, BvhSplitInfo * b, BvhPlaneEvent::Side s):
                         events(e), nObjects(n), aabb(a), parent(p), cost(c), decrease(d), best(b), side(s)
                         { };
 
-                        bool operator < (const SplitCandidate& rhs) const
+                        bool operator < (const BvhSubdivisionCandidate& rhs) const
                         {
                                 return decrease < rhs.decrease;
                         };
 
-                        void operator = (const SplitCandidate& rhs)
+                        void operator = (const BvhSubdivisionCandidate& rhs)
                         {
                                 decrease = rhs.decrease;
@@ -461 +461 @@
                         Real cost;
                         int nObjects;
-                        PlaneEvent::Side side;
+                        BvhPlaneEvent::Side side;
                         AxisAlignedBox aabb;
-                        PlaneEventList * events;
-                        KdTree::Branch * parent;
-                        SplitInfo * best;
-                };
-
-                // typedef std::stack<SplitCandidate> SplitCandidatePQ;
-                typedef std::priority_queue<SplitCandidate> SplitCandidatePQ;
+                        BvhPlaneEventList *events;
+                        BvHierarchy::Branch * parent;
+                        BvhSplitInfo * best;
+                };
+
+                // typedef std::stack<BvhSubdivisionCandidate> SplitCandidatePQ;
+                typedef std::priority_queue<BvhSubdivisionCandidate> SplitCandidatePQ;
 
                 // nodestack for the stack-based rendering function
-                typedef std::stack<KdTree::Node *> NodeStack;
+                typedef std::stack<BvHierarchy::Node *> NodeStack;
         public:
-                friend class KdTreeHierarchyInterface;
-
-                typedef KdTree::Node * NodePtr;
-                typedef KdTree::Branch * BranchPtr;
-                typedef KdTree::Leaf * LeafPtr;
+                friend class BvHierarchyInterface;
+
+                typedef BvHierarchy::Node * NodePtr;
+                typedef BvHierarchy::Branch * BranchPtr;
+                typedef BvHierarchy::Leaf * LeafPtr;
 
                 typedef std::list<NodePtr> NodeList;
@@ -513 +513 @@
                 enum RenderMethod
                 {
-                        KDRM_INTERNAL,
-                        KDRM_GTP_VFC,
-                        KDRM_GTP_SWC,
-                        KDRM_GTP_CHC,
+                        BVHRM_INTERNAL,
+                        BVHRM_GTP_VFC,
+                        BVHRM_GTP_SWC,
+                        BVHRM_GTP_CHC,
                         // invalid modes, just for convenience
-                        KDRM_SIZE,
-                        KDRM_NOTSET
+                        BVHRM_SIZE,
+                        BVHRM_NOTSET
                 };
 
                 enum BuildMethod
                 {
-                        KDBM_RECURSIVE,
-                        KDBM_PRIORITYQUEUE,
+                        BVHBM_RECURSIVE,
+                        BVHBM_PRIORITYQUEUE,
                         // invalid modes, just for convenience
-                        KDBM_SIZE,
-                        KDBM_NOTSET
+                        BVHBM_SIZE,
+                        BVHBM_NOTSET
                 };
 
@@ -534 +534 @@
                 const static int HILITE_OFF  = -1;
                 
-                KdTree(int maxdepth, BuildMethod bm);
-                KdTree(int maxdepth, BuildMethod bm, int hilite, bool allboxes, bool shownodes);
-                virtual ~KdTree();
+                BvHierarchy(int maxdepth, BuildMethod bm);
+                BvHierarchy(int maxdepth, BuildMethod bm, int hilite, bool allboxes, bool shownodes);
+                virtual ~BvHierarchy();
 
                 // DEBUG
@@ -546 +546 @@
                 inline int  getHiLiteLevel(void) { return mHiLiteLevel; };
 
-                // toggles displaying the kdtree boxes
+                // toggles displaying the BvHierarchy boxes
                 inline void setShowAllBoxes(bool show) { mShowAllBoxes = show; };
                 inline bool getShowAllBoxes(void) { return mShowAllBoxes; };
@@ -559 +559 @@
                 bool getEnhancedVis(void);
 
-                NodePtr getRoot(void) const { return mKdRoot; };
-
-                // insert a new scene node into an existing kd-tree
-                void insert(BvRenderable * rend);
+                NodePtr getRoot(void) const { return mBvhRoot; };
+
+                // insert a new scene node into an existing bvhierarchy
+                void insert(BvhRenderable * rend);
                 // remove a scene node from the tree
-                void remove(BvRenderable * rend);
+                void remove(BvhRenderable * rend);
                 // function to initialize a kd-tree based on the contents of the scene
-                void build(BvRenderable * sceneRoot);
+                void build(BvhRenderable * sceneRoot);
 
                 // test visibility of objects and add to render queue
                 void queueVisibleObjects(BvHierarchyCamera* cam, RenderQueue* queue, bool onlyShadowCasters, 
-                        bool showBoxes, KdTree::NodeList& visibleNodes);
+                        bool showBoxes, BvHierarchy::NodeList& visibleNodes);
 
                 // find visible nodes & place in list
                 //void findVisibleNodes(NodeList& visibleNodes, Camera * cam);
 
-                /** Recurses the kdtree, adding any nodes intersecting with the 
+                /** Recurses the BvHierarchy, adding any nodes intersecting with the 
                 box/sphere/volume/ray into the given list.
                 It ignores the exclude scene node.
@@ -588 +588 @@
                 const TreeStats& getTreeStats(void) const { return mTreeStats; }
                 const FrameStats& getFramesStats(void) const { return mFrameStats; }
-                AxisAlignedBox getBox(void) { if (mKdRoot) return mKdRoot->mAABB; else return AxisAlignedBox(); }
+                AxisAlignedBox getBox(void) { if (mBvhRoot) return mBvhRoot->mAABB; else return AxisAlignedBox(); }
                 void setBuildMethod(BuildMethod bm) { mBuildMethod = bm; }
         protected:
@@ -594 +594 @@
                 void init();
                 // recursive insert funciton
-                void recInsert(KdTree::Node * node, BvRenderable * rend);
+                void recInsert(BvHierarchy::Node * node, BvhRenderable * rend);
                 // helper functions for insert
-                void recInsertNew(KdTree::Branch * parent, PlaneEvent::Side side, BvRenderable * rend);
-                void splitBox(const KdTree::Branch& parent, AxisAlignedBox& left, AxisAlignedBox& right);
-                void rebuildSubtree(KdTree::Node * node, BvRenderable * rend);
+                void recInsertNew(BvHierarchy::Branch * parent, BvhPlaneEvent::Side side, BvhRenderable * rend);
+                void splitBox(const BvHierarchy::Branch& parent, AxisAlignedBox& left, AxisAlignedBox& right);
+                void rebuildSubtree(BvHierarchy::Node * node, BvhRenderable * rend);
                 // build scene from a list of nodes rather than a hierarchy
-                KdTree::Node * buildFromList(BvRenderableList& nodelist, KdTree::Branch * parent, AxisAlignedBox& aabb);
-                void addRendToList(KdTree::Node * node, BvRenderableList& nodelist);
+                BvHierarchy::Node * buildFromList(BvhRenderableList& nodelist, BvHierarchy::Branch * parent, AxisAlignedBox& aabb);
+                void addRendToList(BvHierarchy::Node * node, BvhRenderableList& nodelist);
 
                 // recursively delete empty nodes
-                void recDelete(KdTree::Node * node);
+                void recDelete(BvHierarchy::Node * node);
 
                 // find the best plane for node division
-                SplitInfo * pqFindPlane(PlaneEventList * events, int nObjects, AxisAlignedBox& aabb, Real globalSA);
+                BvhSplitInfo * pqFindPlane(BvhPlaneEventList * events, int nObjects, AxisAlignedBox& aabb, Real globalSA);
 
                 // priority queue based build function
-                KdTree::Node * pqBuild(PlaneEventList& events, int nObjects, AxisAlignedBox& aabb, KdTree::Branch * parent);
+                BvHierarchy::Node * pqBuild(BvhPlaneEventList& events, int nObjects, AxisAlignedBox& aabb, BvHierarchy::Branch * parent);
                 // recursive build function
-                KdTree::Node * recBuild(PlaneEventList& events, int nObjects, AxisAlignedBox& aabb, KdTree::Branch * parent);
+                BvHierarchy::Node * recBuild(BvhPlaneEventList& events, int nObjects, AxisAlignedBox& aabb, BvHierarchy::Branch * parent);
 
                 // recursive rendering function
-                void recQueueVisibleObjects(KdTree::Node * node, unsigned long currentFrame, BvHierarchyCamera* cam,
+                void recQueueVisibleObjects(BvHierarchy::Node * node, unsigned long currentFrame, BvHierarchyCamera* cam,
                         RenderQueue* queue, bool onlyShadowCasters, bool showBoxes, 
-                        KdTree::NodeList& visibleNodes, bool fullVis = false);
+                        BvHierarchy::NodeList& visibleNodes, bool fullVis = false);
 
                 // recursively find visible nodes
-                //void recFindVisibleNodes(KdTree::Node * node, NodeList& visibleNodes, Camera * cam);
-
-                /** Recurses the kdtree, adding any nodes intersecting with the 
+                //void recFindVisibleNodes(BvHierarchy::Node * node, NodeList& visibleNodes, Camera * cam);
+
+                /** Recurses the BvHierarchy, adding any nodes intersecting with the 
                 box/sphere/volume/ray into the given list.
                 It ignores the exclude scene node.
@@ -631 +631 @@
                 void recFindNodesIn(const Ray &ray, std::list<SceneNode *> &list, SceneNode *exclude, Node * node, bool full = false);
 
-                // the root node of the kdtree
-                KdTree::Node * mKdRoot;
+                // the root node of the BvHierarchy
+                BvHierarchy::Node * mBvhRoot;
                 // Maximum depth of the tree
                 int mMaxDepth;
@@ -649 +649 @@
 
                 /** Visualization flags **/
-                // show/highlight selected level in kdtree
+                // show/highlight selected level in BvHierarchy
                 int mHiLiteLevel;
                 // show whole kd-tree
@@ -662 +662 @@
 
                 // DEBUG
-                void KdTree::dump(KdTree::Node * node);
-                Real KdTree::calcCost(KdTree::Node * node, Real vs);
-        }; // class KdTree
+                void BvHierarchy::dump(BvHierarchy::Node * node);
+                Real BvHierarchy::calcCost(BvHierarchy::Node * node, Real vs);
+        }; // class BvHierarchy
 
 } // namespace Ogre

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

@@ -13 +13 @@
 #include <OgreCamera.h>
 
-#define KDCAMPTR_CAST(cam) (static_cast<BvHierarchyCamera *>(cam))
+#define BVHCAMPTR_CAST(cam) (static_cast<BvHierarchyCamera *>(cam))
 
 namespace Ogre
@@ -23 +23 @@
         enum NodeVisibility
         {
-                KDNV_NONE,
-                KDNV_PART,
-                KDNV_FULL
+                BVHNV_NONE,
+                BVHNV_PART,
+                BVHNV_FULL
         };
 

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

@@ -16 +16 @@
 {
 
-class KdTreeSceneManager;
+class BvHierarchySceneManager;
 
-class KdTreeHierarchyInterface : public PlatformHierarchyInterface
+class BvHierarchyInterface : public PlatformHierarchyInterface
 {
 public:
-        KdTreeHierarchyInterface(KdTreeSceneManager *sm, RenderSystem *rsys);
+        BvHierarchyInterface(BvHierarchySceneManager *sm, RenderSystem *rsys);
 
-        virtual ~KdTreeHierarchyInterface() {};
+        virtual ~BvHierarchyInterface() {};
 
         /** Returns true if current node is leaf of the hierarchy. 

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

@@ -8 +8 @@
 */
 
-#ifndef _KdTreeSceneManager_H__
-#define _KdTreeSceneManager_H__
+#ifndef _BvHierarchySceneManager_H__
+#define _BvHierarchySceneManager_H__
 
 #include <OgreSceneManager.h>
@@ -19 +19 @@
 #include "OgreBvHierarchyInterface.h"
 
-#define KDTREE_MAX_DEPTH 12
+#define BvHierarchy_MAX_DEPTH 12
 
 namespace Ogre
 {
 
-class KdTreeSceneNode;
-
-class KdTreeSceneManager : public SceneManager
+class BvHierarchySceneNode;
+
+class BvHierarchySceneManager : public SceneManager
 {
 public:
-        KdTreeSceneManager(const String& name, GtpVisibility::VisibilityManager *vm);
-        ~KdTreeSceneManager(void);
+        BvHierarchySceneManager(const String& name, GtpVisibility::VisibilityManager *vm);
+        ~BvHierarchySceneManager(void);
 
         virtual const String& getTypeName(void) const;
 
-        //typedef std::list<KdTreeSceneNode *> NodeList;
+        //typedef std::list<BvHierarchySceneNode *> NodeList;
         //typedef std::list<WireBoundingBox *> BoxList;
 
         /************************************************************************/
-        /* Functions overridden form SceneManager for KdTree                    */
+        /* Functions overridden form SceneManager for BvHierarchy                    */
         /************************************************************************/
 
@@ -45 +45 @@
         virtual Camera* createCamera(const String& name);
 
-        /** Override from SceneManager to create SceneNodes as instance of KdTreeSceneNode
+        /** Override from SceneManager to create SceneNodes as instance of BvHierarchySceneNode
         */
         virtual SceneNode* createSceneNode(void);
-        /** Override from SceneManager to create SceneNodes as instance of KdTreeSceneNode
+        /** Override from SceneManager to create SceneNodes as instance of BvHierarchySceneNode
         */
         virtual SceneNode* createSceneNode(const String& name);
@@ -62 +62 @@
         bool getOptionKeys(StringVector &refKeys);
 
-        /** Overide from scene manager to destroy kdtree properly (before the scene graph is destroyed)
+        /** Overide from scene manager to destroy BvHierarchy properly (before the scene graph is destroyed)
         */
         virtual void clearScene();
@@ -110 +110 @@
 
         /************************************************************************/
-        /* Functions which are specific to the KdTree                           */
+        /* Functions which are specific to the BvHierarchy                           */
         /************************************************************************/
         
-        /** Update the KdTree with the node (more or less disabled now)
-        */
-        virtual void _updateNode(KdTreeSceneNode *node); // TODO: 
-
-        /** Show or hide the bounding boxes of KdTree nodes - obsolete, use options
+        /** Update the BvHierarchy with the node (more or less disabled now)
+        */
+        virtual void _updateNode(BvHierarchySceneNode *node); // TODO: 
+
+        /** Show or hide the bounding boxes of BvHierarchy nodes - obsolete, use options
         */
         virtual void setShowBoxes(bool showboxes);
@@ -124 +124 @@
         virtual bool getShowBoxes(void) const;
 
-        /** Recurses the kdtree, adding any nodes intersecting with the 
+        /** Recurses the BvHierarchy, adding any nodes intersecting with the 
         box/sphere/volume/ray into the given list.
         It ignores the exclude scene node.
@@ -162 +162 @@
         /** Render a list of scenenodes
         */
-        //virtual void _renderNodes(const BvRenderableList& nodelist, Camera * cam,
+        //virtual void _renderNodes(const BvhRenderableList& nodelist, Camera * cam,
         //      bool onlyShadowCasters, int leavePassesInQueue);
-        virtual void _renderNode(KdTree::NodePtr node, Camera * cam,
+        virtual void _renderNode(BvHierarchy::NodePtr node, Camera * cam,
                 bool onlyShadowCasters, int leavePassesInQueue);
 
@@ -181 +181 @@
         /** Returns hierarchy interface.
         */
-        KdTreeHierarchyInterface *GetHierarchyInterface();
+        BvHierarchyInterface *GetHierarchyInterface();
 
 protected:
@@ -223 +223 @@
 
         // the hierarchy interface for CHC
-        KdTreeHierarchyInterface *mHierarchyInterface;
+        BvHierarchyInterface *mHierarchyInterface;
 
         // if hierarchical culling is currently in use
@@ -273 +273 @@
 
         // remember visited scene nodes for viz
-        KdTree::NodeList mVisibleNodes;
+        BvHierarchy::NodeList mVisibleNodes;
 
         /************************************************************************/
         /* Kd-Tree specific options & members                                   */
         /************************************************************************/
-        // maximum depth of the kdtree
+        // maximum depth of the BvHierarchy
         int mMaxDepth;
 
-        // the kdtree which holds the scene
-        KdTree *mBvHierarchy;
-
-        // if bounding boxes of kdtree nodes are shown
+        // the BvHierarchy which holds the scene
+        BvHierarchy *mBvHierarchy;
+
+        // if bounding boxes of BvHierarchy nodes are shown
         bool mShowBoxes;
         // bounding boxes of kd nodes will be highlighted on this level of the kd tree
@@ -290 +290 @@
         // if all bounding boxes shall be displayed, not only the highlighted level
         bool mShowAllBoxes;
-        // visualize kdtree nodes or bounding boxes of objects in nodes
+        // visualize BvHierarchy nodes or bounding boxes of objects in nodes
         bool mShowNodes;
 
@@ -297 +297 @@
 
         // the method/algorithm used when rendering the scene
-        KdTree::RenderMethod mRenderMethod;
+        BvHierarchy::RenderMethod mRenderMethod;
 
         // the method of building the tree
-        KdTree::BuildMethod mBuildMethod;
+        BvHierarchy::BuildMethod mBuildMethod;
 
         /************************************************************************/
@@ -327 +327 @@
 
 
-/// Factory for KdTreeSceneManager
-class BvHierarchySceneManagerFactory : public SceneManagerFactory
+/// Factory for BvHierarchySceneManager
+class BvHierarchySceneManagerFactory: public SceneManagerFactory
 {
 protected:
@@ -337 +337 @@
         {
                 visManager = vm;
-        };
+        }
         ~BvHierarchySceneManagerFactory(void) {};
         /// Factory type name
@@ -347 +347 @@
 } // namespace Ogre
 
-#endif // _KdTreeSceneManager_H__
+#endif // _BvHierarchySceneManager_H__

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

@@ -12 +12 @@
 
 #include <OgreSceneNode.h>
-#include "OgreBvRenderable.h"
+#include "OgreBvhRenderable.h"
 
 namespace Ogre
 {
 
-        class KdTreeSceneNode : public SceneNode, public BvRenderable
+        class BvHierarchySceneNode : public SceneNode, public BvhRenderable
         {
         public:
-                KdTreeSceneNode(SceneManager *creator):
+                BvHierarchySceneNode(SceneManager *creator):
                   SceneNode(creator) {};
 
-                KdTreeSceneNode(SceneManager *creator, const String& name):
+                BvHierarchySceneNode(SceneManager *creator, const String& name):
                   SceneNode(creator, name) {};
 
-                ~KdTreeSceneNode() {};
+                ~BvHierarchySceneNode() {};
 
                 // gather info for kd-tree creation
-                virtual void computeScene(PlaneEventList& events, AxisAlignedBox& aabb, int& nObjects, bool includeChildren = true);
+                virtual void computeScene(BvhPlaneEventList& events, AxisAlignedBox& aabb, int& nObjects, bool includeChildren = true);
 
                 // add all contained objects to render queue

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

@@ -8 +8 @@
 */
 
-#ifndef _OgreBvRenderable_H__
-#define _OgreBvRenderable_H__
+#ifndef _OgreBvhRenderable_H__
+#define _OgreBvhRenderable_H__
 
 #include "OgreBvHierarchy.h"
@@ -18 +18 @@
         // interface which must be implemented by all objects which desire to be
         // placed in the kd-tree
-        class BvRenderable
+        class BvhRenderable
         {
         public:
-                BvRenderable():mSide(PlaneEvent::PES_BOTH), mClassified(false), mLastQueued(0), mBvHierarchy(0) {};
-                virtual ~BvRenderable()
+                BvhRenderable():mSide(BvhPlaneEvent::PES_BOTH), mClassified(false), mLastQueued(0), mBvHierarchy(0) {};
+                virtual ~BvhRenderable()
                 {
                         if (mBvHierarchy)
@@ -29 +29 @@
 
                 // gather the information required for the creation of the kd-tree
-                virtual void computeScene(PlaneEventList& events, AxisAlignedBox& aabb, int& nObjects, bool includeChildren = true) = 0;
+                virtual void computeScene(BvhPlaneEventList& events, AxisAlignedBox& aabb, int& nObjects, bool includeChildren = true) = 0;
 
                 // put all objects this element holds in the renedering queue
@@ -50 +50 @@
                 };
 
-                inline PlaneEvent::Side getSide()
+                inline BvhPlaneEvent::Side getSide()
                 {
                         return mSide;
                 };
-                inline void setSide(PlaneEvent::Side s)
+                inline void setSide(BvhPlaneEvent::Side s)
                 {
                         mSide = s;
@@ -65 +65 @@
                 };
                 // the following functions should work in O(log N)
-                inline bool isAttached(KdTree::LeafPtr leaf)
+                inline bool isAttached(BvHierarchy::LeafPtr leaf)
                 {
                         return mLeaves.find(leaf) != mLeaves.end();
                 };
-                inline bool attachTo(KdTree::LeafPtr leaf, KdTree * kdTree)
+                inline bool attachTo(BvHierarchy::LeafPtr leaf, BvHierarchy * BvHierarchy)
                 {
-                        if (mBvHierarchy == 0 || mBvHierarchy == kdTree)
-                                mBvHierarchy = kdTree;
+                        if (mBvHierarchy == 0 || mBvHierarchy == BvHierarchy)
+                                mBvHierarchy = BvHierarchy;
                         else
                                 return false;
 
-                        KdTree::LeafSet::_Pairib p = mLeaves.insert(leaf);
+                        BvHierarchy::LeafSet::_Pairib p = mLeaves.insert(leaf);
                         return p.second;
                 };
-                inline bool detachFrom(KdTree::LeafPtr leaf)
+                inline bool detachFrom(BvHierarchy::LeafPtr leaf)
                 {
                         bool success = (mLeaves.erase(leaf) == 1);
@@ -102 +102 @@
                 };
 
-                KdTree::LeafSet& getLeaves()
+                BvHierarchy::LeafSet& getLeaves()
                 {
                         return mLeaves;
@@ -113 +113 @@
                 Camera * mLastCam;
                 
-                // kdtree to which this renderable is attached
-                KdTree * mBvHierarchy;
-                // kdtree leaves which overlap this renderable
-                KdTree::LeafSet mLeaves;
+                // BvHierarchy to which this renderable is attached
+                BvHierarchy * mBvHierarchy;
+                // BvHierarchy leaves which overlap this renderable
+                BvHierarchy::LeafSet mLeaves;
 
                 // Flag for the SAH determining the "cheaper" side of the split plane
-                PlaneEvent::Side mSide;
+                BvhPlaneEvent::Side mSide;
                 // Flag for the SAH which marks if this renderable was already placed in the list after a split
                 bool mClassified;
-        }; // class BvRenderable
+        }; // class BvhRenderable
 
 } // namespace Ogre
 
-#endif // _OgreBvRenderable_H__
+#endif // _OgreBvhRenderable_H__

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreBvHierarchy.cpp

@@ -9 +9 @@
 
 #include "OgreBvHierarchy.h"
-#include "OgreBvRenderable.h"
+#include "OgreBvhRenderable.h"
 #include "OgreBvHierarchySceneNode.h"
 #include "OgreBvHierarchySceneManager.h"
@@ -25 +25 @@
 {
 
-enum Intersection
+enum BvhIntersection
 {
         OUTSIDE=0,
@@ -32 +32 @@
 };
 
-Intersection intersect( const Ray &one, const AxisAlignedBox &two )
+static BvhIntersection intersect( const Ray &one, const AxisAlignedBox &two )
 {
         // Null box?
@@ -99 +99 @@
 /** Checks how the second box intersects with the first.
 */
-Intersection intersect( const PlaneBoundedVolume &one, const AxisAlignedBox &two )
+static BvhIntersection intersect( const PlaneBoundedVolume &one, const AxisAlignedBox &two )
 {
         // Null box?
@@ -146 +146 @@
 /** Checks how the second box intersects with the first.
 */
-Intersection intersect( const AxisAlignedBox &one, const AxisAlignedBox &two )
+static BvhIntersection intersect( const AxisAlignedBox &one, const AxisAlignedBox &two )
 {
         // Null box?
@@ -180 +180 @@
 /** Checks how the box intersects with the sphere.
 */
-Intersection intersect( const Sphere &one, const AxisAlignedBox &two )
+static BvhIntersection intersect( const Sphere &one, const AxisAlignedBox &two )
 {
         // Null box?
@@ -235 +235 @@
 }
 
-Real PlaneEvent::KT = 2.0;
-Real PlaneEvent::KI = 1.0;
+Real BvhPlaneEvent::KT = 2.0;
+Real BvhPlaneEvent::KI = 1.0;
 
 //----------------------------------------------------------------------------
 // determine if this event is left or right of the reference event
-void PlaneEvent::classify(const PlaneEvent& e, PlaneEvent::Side side)
+void BvhPlaneEvent::classify(const BvhPlaneEvent& e, BvhPlaneEvent::Side side)
 {
         // only classify events of the same dimension
@@ -271 +271 @@
 //----------------------------------------------------------------------------
 // clip this event to an aabb (move it so that the plane on one of the box planes)
-PlaneEvent PlaneEvent::clip(AxisAlignedBox& box, PlaneEvent::Dimension dim)
+BvhPlaneEvent BvhPlaneEvent::clip(AxisAlignedBox& box, BvhPlaneEvent::Dimension dim)
 {
         Vector3 newpos = mPosition, min = box.getMinimum(), max = box.getMaximum();
@@ -279 +279 @@
                 newpos[dim] = max[dim];
 
-        return PlaneEvent(mRenderable, newpos, mDimension, mType);
+        return BvhPlaneEvent(mRenderable, newpos, mDimension, mType);
 }
 
@@ -285 +285 @@
 // the surface area heuristic to determine the cost of splitting the parent aabb
 // along the plane represented by this event
-void PlaneEvent::SAH(const AxisAlignedBox& parent, int nLeft, int nPlane, int nRight, SplitInfo& split)
+void BvhPlaneEvent::SAH(const AxisAlignedBox& parent, int nLeft, int nPlane, int nRight, BvhSplitInfo& split)
 {
         Real mu = splitBox(parent, split.bleft, split.bright);
@@ -314 +314 @@
 //----------------------------------------------------------------------------
 // split the parent aabb with the plane in this event
-Real PlaneEvent::splitBox(const AxisAlignedBox& parent, AxisAlignedBox& left, AxisAlignedBox& right)
+Real BvhPlaneEvent::splitBox(const AxisAlignedBox& parent, AxisAlignedBox& left, AxisAlignedBox& right)
 {
         Vector3 bmin = parent.getMinimum();
@@ -337 +337 @@
 //----------------------------------------------------------------------------
 // compute surface area of a box ... DUH!
-Real PlaneEvent::surfaceArea(const AxisAlignedBox& box)
+Real BvhPlaneEvent::surfaceArea(const AxisAlignedBox& box)
 {
         Vector3 sides = box.getMaximum() - box.getMinimum();
@@ -348 +348 @@
 // lookup the penalty for placing the splitting plane near to the edge of the AABB
 // 0.0 <= p <= 1.0, p = 0.5 means the plane divides the aabb in half
-Real PlaneEvent::lookupPenalty(Real p)
+Real BvhPlaneEvent::lookupPenalty(Real p)
 {
         // precomputed table of {x^6 + 1|0 <= x <= 1}
@@ -380 +380 @@
 // compute cost of the split, reward splitting of empty space (lambda, const),
 // penalize splitting off 'thin' slices (mu, const)
-Real PlaneEvent::splitCost(Real pLeft, Real pRight, int nLeft, int nRight)
+Real BvhPlaneEvent::splitCost(Real pLeft, Real pRight, int nLeft, int nRight)
 {
         // reward splitting off chunks of empty space
@@ -401 +401 @@
 // compute cost of the split, reward splitting of empty space (lambda, const),
 // penalize splitting off 'thin' slices (mu, parameter)
-Real PlaneEvent::splitCost(Real pLeft, Real pRight, int nLeft, int nRight, Real mu)
+Real BvhPlaneEvent::splitCost(Real pLeft, Real pRight, int nLeft, int nRight, Real mu)
 {
         // reward splitting off chunks of empty space
@@ -416 +416 @@
 // surface area heuristic modified for the priority queue method of building
 // the probabilities (p, pl, pr) are relative to the global (all enclosing) aabb
-void PlaneEvent::pqSAH(Real globalSA, Real parentSA, int nLeft, int nPlane, int nRight, 
-        AxisAlignedBox& parentBox, SplitInfo& split)
+void BvhPlaneEvent::pqSAH(Real globalSA, 
+                                                  Real parentSA, 
+                                                  int nLeft, 
+                                                  int nPlane, 
+                                                  int nRight, 
+                                                  AxisAlignedBox& parentBox, 
+                                                  BvhSplitInfo& split)
 {
         Real mu = splitBox(parentBox, split.bleft, split.bright);
@@ -446 +451 @@
 //----------------------------------------------------------------------------
 // compute split cost without any penalties
-Real PlaneEvent::pqSplitCost(Real pParent, Real pLeft, Real pRight, int nLeft, int nRight, Real mu)
+Real BvhPlaneEvent::pqSplitCost(Real pParent, Real pLeft, Real pRight, int nLeft, int nRight, Real mu)
 {
         return pParent * KT + (KI * (pLeft * nLeft + pRight * nRight));
@@ -453 +458 @@
 //----------------------------------------------------------------------------
 // DEBUG
-String PlaneEvent::print()
+String BvhPlaneEvent::print()
 {
         String dim, type;
@@ -473 +478 @@
 
 //----------------------------------------------------------------------------
-String SplitInfo::print()
+String BvhSplitInfo::print()
 {
         String sside;
-        if (side == PlaneEvent::PES_BOTH)
+        if (side == BvhPlaneEvent::PES_BOTH)
                 sside = "BOTH ";
-        if (side == PlaneEvent::PES_LEFT)
+        if (side == BvhPlaneEvent::PES_LEFT)
                 sside = "LEFT ";
-        if (side == PlaneEvent::PES_RIGHT)
+        if (side == BvhPlaneEvent::PES_RIGHT)
                 sside = "RIGHT";
         return "nLeft: " + StringConverter::toString(nleft, 4) + " nRight: " + 
@@ -492 +497 @@
 
 //----------------------------------------------------------------------------
-String KdTree::SplitCandidate::print()
+String BvHierarchy::BvhSubdivisionCandidate::print()
 {               
         String sside;
-        if (side == PlaneEvent::PES_BOTH)
+        if (side == BvhPlaneEvent::PES_BOTH)
                 sside = "BOTH ";
-        if (side == PlaneEvent::PES_LEFT)
+        if (side == BvhPlaneEvent::PES_LEFT)
                 sside = "LEFT ";
-        if (side == PlaneEvent::PES_RIGHT)
+        if (side == BvhPlaneEvent::PES_RIGHT)
                 sside = "RIGHT";
         return "List: " + StringConverter::toString(events->size(), 4) + " Objects: " +
@@ -513 +518 @@
 //----------------------------------------------------------------------------
 
-KdTree::KdTree(int maxdepth, BuildMethod bm): 
+BvHierarchy::BvHierarchy(int maxdepth, BuildMethod bm): 
 mMaxDepth(maxdepth), 
 mBuildMethod(bm), 
@@ -519 +524 @@
 mShowAllBoxes(false),
 mShowNodes(true),
-mKdRoot(0), 
+mBvhRoot(0), 
 mBuildLog(0)
 {
@@ -525 +530 @@
 }
 
-KdTree::KdTree(int maxdepth, BuildMethod bm, int hilite, bool allboxes, bool shownodes):
+BvHierarchy::BvHierarchy(int maxdepth, BuildMethod bm, int hilite, bool allboxes, bool shownodes):
 mMaxDepth(maxdepth), 
 mBuildMethod(bm), 
@@ -531 +536 @@
 mShowAllBoxes(allboxes),
 mShowNodes(shownodes),
-mKdRoot(0), 
+mBvhRoot(0), 
 mBuildLog(0)
 {
@@ -537 +542 @@
 }
 
-KdTree::~KdTree()
-{
-        delete mKdRoot;
-}
-
-void KdTree::init()
+BvHierarchy::~BvHierarchy()
+{
+        delete mBvhRoot;
+}
+
+void BvHierarchy::init()
 {
         MaterialPtr mat;
@@ -548 +553 @@
 
         // init visualization materials (unlit solid green/yellow)
-        mat = MaterialManager::getSingleton().getByName("KdTree/BoxHiLite");
+        mat = MaterialManager::getSingleton().getByName("BvHierarchy/BoxHiLite");
         if (mat.isNull())
         {
                 ColourValue green(0, 1, 0);
-                mat = MaterialManager::getSingleton().create("KdTree/BoxHiLite", "General");
+                mat = MaterialManager::getSingleton().create("BvHierarchy/BoxHiLite", "General");
                 //mat->setAmbient(green);
                 //mat->setDiffuse(green);
@@ -560 +565 @@
         }
 
-        mat = MaterialManager::getSingleton().getByName("KdTree/BoxViz");
+        mat = MaterialManager::getSingleton().getByName("BvHierarchy/BoxViz");
         if (mat.isNull())
         {
                 ColourValue yellow(1, 1, 0);
-                mat = MaterialManager::getSingleton().create("KdTree/BoxViz", "General");
+                mat = MaterialManager::getSingleton().create("BvHierarchy/BoxViz", "General");
                 //mat->setAmbient(yellow);
                 //mat->setDiffuse(yellow);
@@ -575 +580 @@
         try
         {
-                mBuildLog = LogManager::getSingleton().getLog(KDTREE_LOGNAME);
+                mBuildLog = LogManager::getSingleton().getLog(BvHierarchy_LOGNAME);
         }
         catch (Exception&)
         {               
-                mBuildLog = LogManager::getSingleton().createLog(KDTREE_LOGNAME);
+                mBuildLog = LogManager::getSingleton().createLog(BvHierarchy_LOGNAME);
         }
 
@@ -586 +591 @@
 
 /************************************************************************/
-/* KdTree insert/delete functions                                       */
+/* BvHierarchy insert/delete functions                                       */
 /************************************************************************/
 
-void KdTree::remove(BvRenderable * rend)
+void BvHierarchy::remove(BvhRenderable * rend)
 {
         // DEBUG
-        //LogManager::getSingleton().logMessage("-- Removing SceneNode: " + (static_cast<KdTreeSceneNode *>(rend))->getName());
+        //LogManager::getSingleton().logMessage("-- Removing SceneNode: " + (static_cast<BvHierarchySceneNode *>(rend))->getName());
         std::queue<LeafPtr> cleanup;
         LeafPtr leaf;
@@ -616 +621 @@
 }
 
-void KdTree::recDelete(KdTree::Node * node)
+void BvHierarchy::recDelete(BvHierarchy::Node * node)
 {
         if (node == 0) // DEBUG
         {
                 OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
-                        "SNAFU while inserting BvRenderable into KdTree.",
-                        "KdTree::recInsert" );
+                        "SNAFU while inserting BvhRenderable into BvHierarchy.",
+                        "BvHierarchy::recInsert" );
                 return;
         }
@@ -628 +633 @@
         if (node->isEmpty())
         {
-                if (node == mKdRoot)
-                {
-                        OGRE_DELETE(mKdRoot);
+                if (node == mBvhRoot)
+                {
+                        OGRE_DELETE(mBvhRoot);
                 } 
                 else
                 {
-                        KdTree::Branch * parent = KDBRANCHPTR_CAST(node->getParent());
+                        BvHierarchy::Branch * parent = BVHBRANCHPTR_CAST(node->getParent());
                         if (node == parent->mLeft)
                         {
@@ -648 +653 @@
 }
 
-void KdTree::insert(BvRenderable * rend)
+void BvHierarchy::insert(BvhRenderable * rend)
 {
         // make sure the tree exists
-        if (mKdRoot)
+        if (mBvhRoot)
         {
                 // make sure the renderable is inside the world bounding box
                 AxisAlignedBox aabb = rend->getBoundingBox();
-                AxisAlignedBox isect = mKdRoot->mAABB.intersection(aabb);
+                AxisAlignedBox isect = mBvhRoot->mAABB.intersection(aabb);
                 if (isect.getMinimum() == aabb.getMinimum() && isect.getMaximum() == aabb.getMaximum())
                 {
-                        recInsert(mKdRoot, rend);
+                        recInsert(mBvhRoot, rend);
                 }
                 else
                 {
                         //LogManager::getSingleton().logMessage("Inserted node outside of world AABB.");
-                        BvRenderableList nodelist;
+                        BvhRenderableList nodelist;
                         nodelist.push_back(rend);
-                        addRendToList(mKdRoot, nodelist);
-                        OGRE_DELETE(mKdRoot);
-                        mKdRoot = buildFromList(nodelist, 0, AxisAlignedBox());
+                        addRendToList(mBvhRoot, nodelist);
+                        OGRE_DELETE(mBvhRoot);
+                        mBvhRoot = buildFromList(nodelist, 0, AxisAlignedBox());
                 }
         }
@@ -677 +682 @@
 }
 
-void KdTree::recInsert(KdTree::Node * node, BvRenderable * rend)
+void BvHierarchy::recInsert(BvHierarchy::Node * node, BvhRenderable * rend)
 {
         if (node == 0) // DEBUG
         {
                 OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
-                        "SNAFU while inserting BvRenderable into KdTree.",
-                        "KdTree::recInsert" );
+                        "SNAFU while inserting BvhRenderable into BvHierarchy.",
+                        "BvHierarchy::recInsert" );
                 return;
         }
@@ -695 +700 @@
         else
         {
-                KdTree::Branch * branch = KDBRANCHPTR_CAST(node);
+                BvHierarchy::Branch * branch = BVHBRANCHPTR_CAST(node);
                 AxisAlignedBox aabb = rend->getBoundingBox();
                 Plane::Side smin = branch->mSplitPlane->getSide(aabb.getMinimum());
@@ -702 +707 @@
                 {
                         if (smax == Plane::NEGATIVE_SIDE ||
-                                (smax == Plane::NO_SIDE && branch->mPlaneSide == PlaneEvent::PES_LEFT))
+                                (smax == Plane::NO_SIDE && branch->mPlaneSide == BvhPlaneEvent::PES_LEFT))
                         {
                                 if (branch->mLeft)
                                         recInsert(branch->mLeft, rend);
                                 else
-                                        recInsertNew(branch, PlaneEvent::PES_LEFT, rend);
+                                        recInsertNew(branch, BvhPlaneEvent::PES_LEFT, rend);
                         }
                         else if (smin == Plane::POSITIVE_SIDE || 
-                                (smin == Plane::NO_SIDE && branch->mPlaneSide == PlaneEvent::PES_RIGHT))
+                                (smin == Plane::NO_SIDE && branch->mPlaneSide == BvhPlaneEvent::PES_RIGHT))
                         {
                                 if (branch->mRight)
                                         recInsert(branch->mRight, rend);
                                 else
-                                        recInsertNew(branch, PlaneEvent::PES_RIGHT, rend);
+                                        recInsertNew(branch, BvhPlaneEvent::PES_RIGHT, rend);
                         }
                 }
@@ -725 +730 @@
                                         recInsert(branch->mLeft, rend);
                                 else
-                                        recInsertNew(branch, PlaneEvent::PES_LEFT, rend);
+                                        recInsertNew(branch, BvhPlaneEvent::PES_LEFT, rend);
                         }
                         else if (smax == Plane::POSITIVE_SIDE && smin == Plane::NO_SIDE)
@@ -732 +737 @@
                                         recInsert(branch->mRight, rend);
                                 else
-                                        recInsertNew(branch, PlaneEvent::PES_RIGHT, rend);
+                                        recInsertNew(branch, BvhPlaneEvent::PES_RIGHT, rend);
                         }
                         else
@@ -744 +749 @@
 }
 
-void KdTree::recInsertNew(KdTree::Branch * parent, PlaneEvent::Side side, BvRenderable * rend)
+void BvHierarchy::recInsertNew(BvHierarchy::Branch * parent, BvhPlaneEvent::Side side, BvhRenderable * rend)
 {
         //LogManager::getSingleton().logMessage("## Inserting into new subtree");
 
         AxisAlignedBox left, rigth, aabb;
-        PlaneEventList events;
+        BvhPlaneEventList events;
         int nObjects;
         
@@ -756 +761 @@
         // override aabb
         splitBox(*parent, left, rigth);
-        if (side == PlaneEvent::PES_LEFT)
+        if (side == BvhPlaneEvent::PES_LEFT)
         {
                 aabb = left;
-                if (mBuildMethod == KDBM_RECURSIVE)
+                if (mBuildMethod == BVHBM_RECURSIVE)
                         parent->mLeft = recBuild(events, nObjects, aabb, parent);
-                else if (mBuildMethod == KDBM_PRIORITYQUEUE)
+                else if (mBuildMethod == BVHBM_PRIORITYQUEUE)
                         parent->mLeft = pqBuild(events, nObjects, aabb, parent);
                 else
                 {
                         OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 
-                                "Invalid build method for the KdTree.",
-                                "KdTree::buildFromList");
+                                "Invalid build method for the BvHierarchy.",
+                                "BvHierarchy::buildFromList");
                         parent->mLeft = 0;
                 }
                 
         }
-        else if (side == PlaneEvent::PES_RIGHT)
+        else if (side == BvhPlaneEvent::PES_RIGHT)
         {
                 aabb = rigth;
-                if (mBuildMethod == KDBM_RECURSIVE)
+                if (mBuildMethod == BVHBM_RECURSIVE)
                         parent->mRight = recBuild(events, nObjects, aabb, parent);
-                else if (mBuildMethod == KDBM_PRIORITYQUEUE)
+                else if (mBuildMethod == BVHBM_PRIORITYQUEUE)
                         parent->mRight = pqBuild(events, nObjects, aabb, parent);
                 else
                 {
                         OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 
-                                "Invalid build method for the KdTree.",
-                                "KdTree::buildFromList");
+                                "Invalid build method for the BvHierarchy.",
+                                "BvHierarchy::buildFromList");
                         parent->mRight = 0;
                 }
@@ -789 +794 @@
 }
 
-void KdTree::rebuildSubtree(KdTree::Node * node, BvRenderable * rend)
+void BvHierarchy::rebuildSubtree(BvHierarchy::Node * node, BvhRenderable * rend)
 {
         //LogManager::getSingleton().logMessage("## Rebuilding subtree");
@@ -795 +800 @@
         AxisAlignedBox aabb = node->mAABB;
         
-        BvRenderableList nodelist;
+        BvhRenderableList nodelist;
         nodelist.push_back(rend);
         addRendToList(node, nodelist);
 
-        if (node == mKdRoot)
-        {
-                OGRE_DELETE(mKdRoot);
-                mKdRoot = buildFromList(nodelist, 0, aabb);
+        if (node == mBvhRoot)
+        {
+                OGRE_DELETE(mBvhRoot);
+                mBvhRoot = buildFromList(nodelist, 0, aabb);
         }
         else
         {
-                KdTree::Branch * parent = KDBRANCHPTR_CAST(node->getParent());
+                BvHierarchy::Branch * parent = BVHBRANCHPTR_CAST(node->getParent());
 
                 if (node == parent->mLeft)
@@ -821 +826 @@
                 {
                         OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
-                                "SNAFU while inserting BvRenderable into KdTree.",
-                                "KdTree::recInsert" );
+                                "SNAFU while inserting BvhRenderable into BvHierarchy.",
+                                "BvHierarchy::recInsert" );
                 }
         }
@@ -828 +833 @@
 
 // compute both AABB then return the requested one.
-void KdTree::splitBox(const KdTree::Branch& parent, AxisAlignedBox& left, AxisAlignedBox& right)
+void BvHierarchy::splitBox(const BvHierarchy::Branch& parent, AxisAlignedBox& left, AxisAlignedBox& right)
 {
         Vector3 bmin = parent.mAABB.getMinimum();
@@ -845 +850 @@
 }
 
-void KdTree::addRendToList(KdTree::Node * node, BvRenderableList& nodelist)
+void BvHierarchy::addRendToList(BvHierarchy::Node * node, BvhRenderableList& nodelist)
 {
         if (node->isLeaf())
         {
-                KdTree::Leaf * leaf = KDLEAFPTR_CAST(node);
-                BvRenderableList::iterator it  = leaf->mBvRenderables.begin();
-                BvRenderableList::iterator end = leaf->mBvRenderables.end();
+                BvHierarchy::Leaf * leaf = BVHLEAFPTR_CAST(node);
+                BvhRenderableList::iterator it  = leaf->mBvhRenderables.begin();
+                BvhRenderableList::iterator end = leaf->mBvhRenderables.end();
                 while (it != end)
                 {
@@ -860 +865 @@
         else
         {
-                KdTree::Branch * branch = KDBRANCHPTR_CAST(node);
+                BvHierarchy::Branch * branch = BVHBRANCHPTR_CAST(node);
                 if (branch->mLeft)
                         addRendToList(branch->mLeft, nodelist);
@@ -869 +874 @@
 
 /************************************************************************/
-/* KdTree build functions                                               */
+/* BvHierarchy build functions                                               */
 /************************************************************************/
 
-void KdTree::build(BvRenderable * sceneRoot)
+void BvHierarchy::build(BvhRenderable * sceneRoot)
 {
         Timer *timer = Root::getSingleton().getTimer();
@@ -880 +885 @@
         
         // data we want to collect
-        PlaneEventList events;
+        BvhPlaneEventList events;
         AxisAlignedBox aabb;
         int nObjects = 0;
@@ -897 +902 @@
         aabb.merge(aabb.getMinimum()+Vector3(-1,-1,-1));
 
-        if (mBuildMethod == KDBM_RECURSIVE)
-                mKdRoot = recBuild(events, nObjects, aabb, 0);
-        else if (mBuildMethod == KDBM_PRIORITYQUEUE)
-                mKdRoot = pqBuild(events, nObjects, aabb, 0);
+        if (mBuildMethod == BVHBM_RECURSIVE)
+                mBvhRoot = recBuild(events, nObjects, aabb, 0);
+        else if (mBuildMethod == BVHBM_PRIORITYQUEUE)
+                mBvhRoot = pqBuild(events, nObjects, aabb, 0);
         else
         {
                 OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 
-                        "Invalid build method for the KdTree.",
-                        "KdTree::build");
-                mKdRoot = 0;
+                        "Invalid build method for the BvHierarchy.",
+                        "BvHierarchy::build");
+                mBvhRoot = 0;
         }
 
@@ -912 +917 @@
 
         String method = "Invalid";
-        if (mBuildMethod == KDBM_RECURSIVE)
+        if (mBuildMethod == BVHBM_RECURSIVE)
                 method = "Recursive";
-        else if (mBuildMethod == KDBM_PRIORITYQUEUE)
+        else if (mBuildMethod == BVHBM_PRIORITYQUEUE)
                 method = "Priority Queue";
 
@@ -931 +936 @@
 }
 
-KdTree::Node * KdTree::buildFromList(BvRenderableList& nodelist, KdTree::Branch * parent, AxisAlignedBox& aabb)
+BvHierarchy::Node * BvHierarchy::buildFromList(BvhRenderableList& nodelist, BvHierarchy::Branch * parent, AxisAlignedBox& aabb)
 {
         // data we want to collect
-        PlaneEventList events;
+        BvhPlaneEventList events;
         AxisAlignedBox nodeaabb;
         int nObjects = 0;
 
-        BvRenderableList::iterator it = nodelist.begin();
-        BvRenderableList::iterator end = nodelist.end();
+        BvhRenderableList::iterator it = nodelist.begin();
+        BvhRenderableList::iterator end = nodelist.end();
         while (it != end)
         {
@@ -954 +959 @@
         }
 
-        if (mBuildMethod == KDBM_RECURSIVE)
+        if (mBuildMethod == BVHBM_RECURSIVE)
                 return recBuild(events, nObjects, aabb, parent);
-        else if (mBuildMethod == KDBM_PRIORITYQUEUE)
+        else if (mBuildMethod == BVHBM_PRIORITYQUEUE)
                 return pqBuild(events, nObjects, aabb, parent);
         else
         {
                 OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 
-                        "Invalid build method for the KdTree.",
-                        "KdTree::buildFromList");
+                        "Invalid build method for the BvHierarchy.",
+                        "BvHierarchy::buildFromList");
                 return 0;
         }
 }
 
-KdTree::Node * KdTree::recBuild(PlaneEventList& events, int nObjects, AxisAlignedBox& aabb, KdTree::Branch * parent)
+BvHierarchy::Node * BvHierarchy::recBuild(BvhPlaneEventList& events, int nObjects, AxisAlignedBox& aabb, BvHierarchy::Branch * parent)
 {
         // determine the depth we are on
@@ -990 +995 @@
         }
 
-        SplitInfo split, best;
+        BvhSplitInfo split, best;
         best.cost = Math::POS_INFINITY;
 
-        PlaneEventList::iterator begin = events.begin();
-        PlaneEventList::iterator end = events.end();
-        PlaneEventList::iterator it = begin;
+        BvhPlaneEventList::iterator begin = events.begin();
+        BvhPlaneEventList::iterator end = events.end();
+        BvhPlaneEventList::iterator it = begin;
         // try all planes to find the best one for the given set of objects
         while (it != end)
         {
-                PlaneEventList::iterator p = it;
+                BvhPlaneEventList::iterator p = it;
                 pStart = pOn = pEnd = 0;
-                while (it != end && p->equalsType(*it, PlaneEvent::PET_END))
+                while (it != end && p->equalsType(*it, BvhPlaneEvent::PET_END))
                 {
                         it++; pEnd++;
                 }
-                while (it != end && p->equalsType(*it, PlaneEvent::PET_ON))
+                while (it != end && p->equalsType(*it, BvhPlaneEvent::PET_ON))
                 {
                         it++; pOn++;
                 }
-                while (it != end && p->equalsType(*it, PlaneEvent::PET_START))
+                while (it != end && p->equalsType(*it, BvhPlaneEvent::PET_START))
                 {
                         it++; pStart++;
@@ -1027 +1032 @@
         /************************************************/
         // check terminating condition
-        if (best.cost > PlaneEvent::KI*nObjects || level >= mMaxDepth)
+        if (best.cost > BvhPlaneEvent::KI*nObjects || level >= mMaxDepth)
         {
                 // Terminating condition reached, create leaf and add renderables to list
-                KdTree::Leaf * leaf = new KdTree::Leaf(this, level, aabb, parent);
-                BvRenderable *rend;
+                BvHierarchy::Leaf * leaf = new BvHierarchy::Leaf(this, level, aabb, parent);
+                BvhRenderable *rend;
                 it = begin;
                 while (it != end)
@@ -1057 +1062 @@
         else
         {
-                PlaneEventList eventsRight, eventsLeft;
+                BvhPlaneEventList eventsRight, eventsLeft;
                 it = begin;
                 // slightly redundant, since we mark each renderable up to 6 times
                 while (it != end)
                 {
-                        it->getRenderable()->setSide(PlaneEvent::PES_BOTH);
+                        it->getRenderable()->setSide(BvhPlaneEvent::PES_BOTH);
                         it->getRenderable()->setClassified(false);
                         it++;
@@ -1079 +1084 @@
                 {
                         // right-only nodes go in right list
-                        if (it->getRenderable()->getSide() == PlaneEvent::PES_RIGHT)
+                        if (it->getRenderable()->getSide() == BvhPlaneEvent::PES_RIGHT)
                         {
                                 if (!it->getRenderable()->isClassified())
@@ -1089 +1094 @@
                         }
                         // left-only nodes go in left list
-                        else if (it->getRenderable()->getSide() == PlaneEvent::PES_LEFT)
+                        else if (it->getRenderable()->getSide() == BvhPlaneEvent::PES_LEFT)
                         {
                                 if (!it->getRenderable()->isClassified())
@@ -1114 +1119 @@
 
                 // create a new branch node and continue recursion
-                KdTree::Branch * branch = new KdTree::Branch(this, level, aabb, parent, 
+                BvHierarchy::Branch * branch = new BvHierarchy::Branch(this, level, aabb, parent, 
                         best.event.getSplitPlane(), best.side);
 
@@ -1137 +1142 @@
 }
 
-KdTree::Node * KdTree::pqBuild(PlaneEventList& events, int nObjects, AxisAlignedBox& aabb, KdTree::Branch * parent)
+BvHierarchy::Node * BvHierarchy::pqBuild(BvhPlaneEventList& events, int nObjects, AxisAlignedBox& aabb, BvHierarchy::Branch * parent)
 {
         SplitCandidatePQ pqueue;
@@ -1143 +1148 @@
         Real globalSA;
 
-        KdTree::Node * newNode = 0, * topNode = 0;
+        BvHierarchy::Node * newNode = 0, * topNode = 0;
         // init global tree cost
-        globalTreeCost = PlaneEvent::KI * nObjects;
-        globalSA = PlaneEvent::surfaceArea(aabb);
-
-        PlaneEventList * e = new PlaneEventList(events);
+        globalTreeCost = BvhPlaneEvent::KI * nObjects;
+        globalSA = BvhPlaneEvent::surfaceArea(aabb);
+
+        BvhPlaneEventList * e = new BvhPlaneEventList(events);
 
         // inital split candidate
-        SplitInfo * best = pqFindPlane(e, nObjects, aabb, globalSA);
-        SplitCandidate splitcandidate(e, nObjects, aabb, parent, globalTreeCost, 
-                globalTreeCost - best->cost, best, PlaneEvent::PES_BOTH);
+        BvhSplitInfo * best = pqFindPlane(e, nObjects, aabb, globalSA);
+        BvhSubdivisionCandidate splitcandidate(e, nObjects, aabb, parent, globalTreeCost, 
+                globalTreeCost - best->cost, best, BvhPlaneEvent::PES_BOTH);
         pqueue.push(splitcandidate);
 
@@ -1160 +1165 @@
         while (!pqueue.empty())
         {
-                SplitCandidate sc = pqueue.top();
+                BvhSubdivisionCandidate sc = pqueue.top();
                 pqueue.pop();
 
@@ -1177 +1182 @@
                 {
                         // Terminating condition reached, create leaf and add renderables to list
-                        KdTree::Leaf * leaf = new KdTree::Leaf(this, level, sc.aabb, sc.parent);
-                        BvRenderable *rend;
-                        PlaneEventList::iterator begin = sc.events->begin();
-                        PlaneEventList::iterator end = sc.events->end();
-                        PlaneEventList::iterator it = begin;
+                        BvHierarchy::Leaf * leaf = new BvHierarchy::Leaf(this, level, sc.aabb, sc.parent);
+                        BvhRenderable *rend;
+                        BvhPlaneEventList::iterator begin = sc.events->begin();
+                        BvhPlaneEventList::iterator end = sc.events->end();
+                        BvhPlaneEventList::iterator it = begin;
                         while (it != end)
                         {
@@ -1205 +1210 @@
                 else
                 {
-                        PlaneEventList * eventsLeft = new PlaneEventList();
-                        PlaneEventList * eventsRight = new PlaneEventList();
-                        PlaneEventList::iterator begin = sc.events->begin();
-                        PlaneEventList::iterator end = sc.events->end();
-                        PlaneEventList::iterator it = begin;
+                        BvhPlaneEventList * eventsLeft = new BvhPlaneEventList();
+                        BvhPlaneEventList * eventsRight = new BvhPlaneEventList();
+                        BvhPlaneEventList::iterator begin = sc.events->begin();
+                        BvhPlaneEventList::iterator end = sc.events->end();
+                        BvhPlaneEventList::iterator it = begin;
                         // slightly redundant, since we mark each renderable up to 6 times
                         while (it != end)
                         {
-                                it->getRenderable()->setSide(PlaneEvent::PES_BOTH);
+                                it->getRenderable()->setSide(BvhPlaneEvent::PES_BOTH);
                                 it->getRenderable()->setClassified(false);
                                 it++;
@@ -1232 +1237 @@
                         {
                                 // right-only events go in the right list
-                                if (it->getRenderable()->getSide() == PlaneEvent::PES_RIGHT)
+                                if (it->getRenderable()->getSide() == BvhPlaneEvent::PES_RIGHT)
                                 {
                                         if (!it->getRenderable()->isClassified())
@@ -1243 +1248 @@
                                 }
                                 // left-only events go in the left list
-                                else if (it->getRenderable()->getSide() == PlaneEvent::PES_LEFT)
+                                else if (it->getRenderable()->getSide() == BvhPlaneEvent::PES_LEFT)
                                 {
                                         if (!it->getRenderable()->isClassified())
@@ -1268 +1273 @@
 
                         // create a new branch node
-                        KdTree::Branch * branch = new KdTree::Branch(this, level, sc.aabb, sc.parent, 
+                        BvHierarchy::Branch * branch = new BvHierarchy::Branch(this, level, sc.aabb, sc.parent, 
                                 sc.best->event.getSplitPlane(), sc.best->side);
 
@@ -1279 +1284 @@
                         {
                                 best = pqFindPlane(eventsLeft, nLeftS + nBothS, sc.best->bleft, globalSA);
-                                Real old = PlaneEvent::surfaceArea(sc.best->bleft)/globalSA*PlaneEvent::KI*(nLeftS + nBothS);
-                                SplitCandidate scleft(eventsLeft, nLeftS + nBothS, sc.best->bleft, 
-                                        branch, old, old - best->cost, best, PlaneEvent::PES_LEFT);
+                                Real old = BvhPlaneEvent::surfaceArea(sc.best->bleft)/globalSA*BvhPlaneEvent::KI*(nLeftS + nBothS);
+                                BvhSubdivisionCandidate scleft(eventsLeft, nLeftS + nBothS, sc.best->bleft, 
+                                        branch, old, old - best->cost, best, BvhPlaneEvent::PES_LEFT);
                                 pqueue.push(scleft);
                         }
@@ -1293 +1298 @@
                         {
                                 best = pqFindPlane(eventsRight, nBothS + nRightS, sc.best->bright, globalSA);
-                                Real old = PlaneEvent::surfaceArea(sc.best->bright)/globalSA*PlaneEvent::KI*(nBothS + nRightS);
-                                SplitCandidate scright(eventsRight, nBothS + nRightS, sc.best->bright, 
-                                        branch, old, old - best->cost, best, PlaneEvent::PES_RIGHT);
+                                Real old = BvhPlaneEvent::surfaceArea(sc.best->bright)/globalSA*BvhPlaneEvent::KI*(nBothS + nRightS);
+                                BvhSubdivisionCandidate scright(eventsRight, nBothS + nRightS, sc.best->bright, 
+                                        branch, old, old - best->cost, best, BvhPlaneEvent::PES_RIGHT);
                                 pqueue.push(scright);
                         }
@@ -1316 +1321 @@
                 if (sc.parent)
                 {
-                        if (sc.side == PlaneEvent::PES_LEFT)
+                        if (sc.side == BvhPlaneEvent::PES_LEFT)
                         {
                                 sc.parent->mLeft = newNode;
                         }
-                        else if (sc.side == PlaneEvent::PES_RIGHT)
+                        else if (sc.side == BvhPlaneEvent::PES_RIGHT)
                         {
                                 sc.parent->mRight = newNode;
@@ -1327 +1332 @@
                         {
                                 OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
-                                        "PQBUILD SNAFU - CHILD I AM NOT LEFT NOR RIGHT","KdTree::pqBuild");
+                                        "PQBUILD SNAFU - CHILD I AM NOT LEFT NOR RIGHT","BvHierarchy::pqBuild");
                         }
                 }
@@ -1344 +1349 @@
 
 //-------------------------------------------------------------------------
-SplitInfo * KdTree::pqFindPlane(PlaneEventList * events, int nObjects, AxisAlignedBox& aabb, Real globalSA)
+BvhSplitInfo * BvHierarchy::pqFindPlane(BvhPlaneEventList * events, int nObjects, AxisAlignedBox& aabb, Real globalSA)
 {
         static const int dim = 3;
@@ -1354 +1359 @@
         }
 
-        SplitInfo split, best;
+        BvhSplitInfo split, best;
         best.cost = Math::POS_INFINITY;
 
-        Real parentSA = PlaneEvent::surfaceArea(aabb);
-
-        PlaneEventList::iterator begin = events->begin();
-        PlaneEventList::iterator end = events->end();
-        PlaneEventList::iterator it = begin;
+        Real parentSA = BvhPlaneEvent::surfaceArea(aabb);
+
+        BvhPlaneEventList::iterator begin = events->begin();
+        BvhPlaneEventList::iterator end = events->end();
+        BvhPlaneEventList::iterator it = begin;
         // try all planes to find the best one for the given set of objects
         while (it != end)
         {
-                PlaneEventList::iterator p = it;
+                BvhPlaneEventList::iterator p = it;
                 pStart = pOn = pEnd = 0;
-                while (it != end && p->equalsType(*it, PlaneEvent::PET_END))
+                while (it != end && p->equalsType(*it, BvhPlaneEvent::PET_END))
                 {
                         it++; pEnd++;
                 }
-                while (it != end && p->equalsType(*it, PlaneEvent::PET_ON))
+                while (it != end && p->equalsType(*it, BvhPlaneEvent::PET_ON))
                 {
                         it++; pOn++;
                 }
-                while (it != end && p->equalsType(*it, PlaneEvent::PET_START))
+                while (it != end && p->equalsType(*it, BvhPlaneEvent::PET_START))
                 {
                         it++; pStart++;
@@ -1388 +1393 @@
                 nLeft[d] += pStart; nLeft[d] += pOn; nPlane[d] = 0;
         }
-        return new SplitInfo(best);
+        return new BvhSplitInfo(best);
 }
 
 /************************************************************************/
-/* KdTree rendering functions                                           */
+/* BvHierarchy rendering functions                                           */
 /************************************************************************/
 
 //-------------------------------------------------------------------------
-void KdTree::queueVisibleObjects(BvHierarchyCamera* cam, RenderQueue* queue, bool onlyShadowCasters, 
-        bool showBoxes, KdTree::NodeList& visibleNodes)
+void BvHierarchy::queueVisibleObjects(BvHierarchyCamera* cam, RenderQueue* queue, bool onlyShadowCasters, 
+        bool showBoxes, BvHierarchy::NodeList& visibleNodes)
 {
         mFrameStats.clear();
         cam->mNumVisQueries = 0;
 
-        if (mKdRoot)
-                recQueueVisibleObjects(mKdRoot, Root::getSingleton().getCurrentFrameNumber(),
+        if (mBvhRoot)
+                recQueueVisibleObjects(mBvhRoot, Root::getSingleton().getCurrentFrameNumber(),
                         cam, queue, onlyShadowCasters, showBoxes, visibleNodes);
 
@@ -1410 +1415 @@
 
 //-------------------------------------------------------------------------
-void KdTree::recQueueVisibleObjects(KdTree::Node * node, unsigned long currentFrame, 
+void BvHierarchy::recQueueVisibleObjects(BvHierarchy::Node * node, unsigned long currentFrame, 
         BvHierarchyCamera* cam, RenderQueue* queue, bool onlyShadowCasters, bool showBoxes, 
-        KdTree::NodeList& visibleNodes, bool fullVis)
-{
-        BvHierarchyCamera::NodeVisibility vis = BvHierarchyCamera::KDNV_PART;
+        BvHierarchy::NodeList& visibleNodes, bool fullVis)
+{
+        BvHierarchyCamera::NodeVisibility vis = BvHierarchyCamera::BVHNV_PART;
         // test visibility
         //if (cam->isVisible(node->mAABB))
         if (fullVis || 
-                ((vis = (cam->*getVisibility)(node->mAABB)) != BvHierarchyCamera::KDNV_NONE))
+                ((vis = (cam->*getVisibility)(node->mAABB)) != BvHierarchyCamera::BVHNV_NONE))
         {
                 visibleNodes.push_back(node);
 
-                bool v = (fullVis || vis == BvHierarchyCamera::KDNV_FULL);
+                bool v = (fullVis || vis == BvHierarchyCamera::BVHNV_FULL);
 
                 node->queueVisibleObjects(currentFrame, cam, queue, onlyShadowCasters, showBoxes, v);
@@ -1447 +1452 @@
 
 //-------------------------------------------------------------------------
-void KdTree::setEnhancedVis(bool enh)
+void BvHierarchy::setEnhancedVis(bool enh)
 {
         if (enh)
@@ -1456 +1461 @@
 
 //-------------------------------------------------------------------------
-bool KdTree::getEnhancedVis()
+bool BvHierarchy::getEnhancedVis()
 {
         return getVisibility == &BvHierarchyCamera::getVisibilityEnhanced;
@@ -1462 +1467 @@
 
 //-------------------------------------------------------------------------
-//void KdTree::findVisibleNodes(NodeList& visibleNodes, Camera * cam)
+//void BvHierarchy::findVisibleNodes(NodeList& visibleNodes, Camera * cam)
 //{
-//      if (mKdRoot)
-//              recFindVisibleNodes(mKdRoot, visibleNodes, cam);
+//      if (mBvhRoot)
+//              recFindVisibleNodes(mBvhRoot, visibleNodes, cam);
 //}
 
 ////-------------------------------------------------------------------------
-//void KdTree::recFindVisibleNodes(KdTree::Node * node, NodeList& visibleNodes, Camera * cam)
+//void BvHierarchy::recFindVisibleNodes(BvHierarchy::Node * node, NodeList& visibleNodes, Camera * cam)
 //{
 //      // test visibility
@@ -1483 +1488 @@
 //}
 
-void KdTree::findNodesIn(const AxisAlignedBox &box, std::list<SceneNode *> &list, SceneNode *exclude)
-{
-        if (mKdRoot)
-                recFindNodesIn(box, list, exclude, mKdRoot);
-}
-
-void KdTree::findNodesIn(const Sphere &sphere, std::list<SceneNode *> &list, SceneNode *exclude)
-{
-        if (mKdRoot)
-                recFindNodesIn(sphere, list, exclude, mKdRoot);
-}
-
-void KdTree::findNodesIn(const PlaneBoundedVolume &volume, std::list<SceneNode *> &list, SceneNode *exclude)
-{
-        if (mKdRoot)
-                recFindNodesIn(volume, list, exclude, mKdRoot);
-}
-
-void KdTree::findNodesIn(const Ray &ray, std::list<SceneNode *> &list, SceneNode *exclude)
-{
-        if (mKdRoot)
-                recFindNodesIn(ray, list, exclude, mKdRoot);
-}
-
-void KdTree::recFindNodesIn(const AxisAlignedBox &box, std::list<SceneNode *> &list, SceneNode *exclude, Node * node, bool full)
+void BvHierarchy::findNodesIn(const AxisAlignedBox &box, std::list<SceneNode *> &list, SceneNode *exclude)
+{
+        if (mBvhRoot)
+                recFindNodesIn(box, list, exclude, mBvhRoot);
+}
+
+void BvHierarchy::findNodesIn(const Sphere &sphere, std::list<SceneNode *> &list, SceneNode *exclude)
+{
+        if (mBvhRoot)
+                recFindNodesIn(sphere, list, exclude, mBvhRoot);
+}
+
+void BvHierarchy::findNodesIn(const PlaneBoundedVolume &volume, std::list<SceneNode *> &list, SceneNode *exclude)
+{
+        if (mBvhRoot)
+                recFindNodesIn(volume, list, exclude, mBvhRoot);
+}
+
+void BvHierarchy::findNodesIn(const Ray &ray, std::list<SceneNode *> &list, SceneNode *exclude)
+{
+        if (mBvhRoot)
+                recFindNodesIn(ray, list, exclude, mBvhRoot);
+}
+
+void BvHierarchy::recFindNodesIn(const AxisAlignedBox &box, std::list<SceneNode *> &list, SceneNode *exclude, Node * node, bool full)
 {
         // check intersection
         if ( !full )
         {
-                Intersection isect = intersect(box, node->_getWorldAABB());
+                BvhIntersection isect = intersect(box, node->_getWorldAABB());
 
                 if ( isect == OUTSIDE )
@@ -1522 +1527 @@
         if (node->isLeaf())
         {
-                LeafPtr leaf = KDLEAFPTR_CAST(node);
-                for (BvRenderableList::iterator it = leaf->mBvRenderables.begin();
-                        it != leaf->mBvRenderables.end(); it ++)
+                LeafPtr leaf = BVHLEAFPTR_CAST(node);
+                for (BvhRenderableList::iterator it = leaf->mBvhRenderables.begin();
+                        it != leaf->mBvhRenderables.end(); it ++)
                 {
                         SceneNode *sn = dynamic_cast<SceneNode *>(*it);
@@ -1536 +1541 @@
                                 else
                                 {
-                                        Intersection nsect = intersect(box, sn->_getWorldAABB());
+                                        BvhIntersection nsect = intersect(box, sn->_getWorldAABB());
 
                                         if ( nsect != OUTSIDE )
@@ -1555 +1560 @@
 }
 
-void KdTree::recFindNodesIn(const Sphere &sphere, std::list<SceneNode *> &list, SceneNode *exclude, Node * node, bool full)
+void BvHierarchy::recFindNodesIn(const Sphere &sphere, std::list<SceneNode *> &list, SceneNode *exclude, Node * node, bool full)
 {
         // TODO
 }
 
-void KdTree::recFindNodesIn(const PlaneBoundedVolume &volume, std::list<SceneNode *> &list, SceneNode *exclude, Node * node, bool full)
+void BvHierarchy::recFindNodesIn(const PlaneBoundedVolume &volume, std::list<SceneNode *> &list, SceneNode *exclude, Node * node, bool full)
 {
         // TODO
 }
 
-void KdTree::recFindNodesIn(const Ray &ray, std::list<SceneNode *> &list, SceneNode *exclude, Node * node, bool full)
+void BvHierarchy::recFindNodesIn(const Ray &ray, std::list<SceneNode *> &list, SceneNode *exclude, Node * node, bool full)
 {
         // TODO
@@ -1571 +1576 @@
 
 /************************************************************************/
-/* KdTree debug & helper functions                                      */
+/* BvHierarchy debug & helper functions                                      */
 /************************************************************************/
 
 //-------------------------------------------------------------------------
-void KdTree::dump()
-{
-        //LogManager::getSingleton().logMessage("#@#@#@#@ Dumping KdTree #@#@#@#@");
-        mBuildLog->logMessage("#@#@#@#@ Dumping KdTree #@#@#@#@");
-        if (mKdRoot)
-                dump(mKdRoot);
+void BvHierarchy::dump()
+{
+        //LogManager::getSingleton().logMessage("#@#@#@#@ Dumping BvHierarchy #@#@#@#@");
+        mBuildLog->logMessage("#@#@#@#@ Dumping BvHierarchy #@#@#@#@");
+        if (mBvhRoot)
+                dump(mBvhRoot);
 }
 
 //-------------------------------------------------------------------------
-void KdTree::dump(KdTree::Node * node)
+void BvHierarchy::dump(BvHierarchy::Node * node)
 {
         //LogManager * log = LogManager::getSingletonPtr();
-        KdTreeSceneNode * scenenode;
+        BvHierarchySceneNode * scenenode;
         String pad;
         int p;
@@ -1599 +1604 @@
         if (node->isLeaf())
         {
-                KdTree::Leaf * leaf = KDLEAFPTR_CAST(node);
-                BvRenderableList::iterator it  = leaf->mBvRenderables.begin();
-                BvRenderableList::iterator end = leaf->mBvRenderables.end();
+                BvHierarchy::Leaf * leaf = BVHLEAFPTR_CAST(node);
+                BvhRenderableList::iterator it  = leaf->mBvhRenderables.begin();
+                BvhRenderableList::iterator end = leaf->mBvhRenderables.end();
                 while (it != end)
                 {
-                        scenenode = dynamic_cast<KdTreeSceneNode *>(*it);
+                        scenenode = dynamic_cast<BvHierarchySceneNode *>(*it);
                         mBuildLog->logMessage(pad + "# Leaf   level " + 
                                 StringConverter::toString(node->getLevel()) + 
@@ -1614 +1619 @@
         else
         {
-                KdTree::Branch * branch = KDBRANCHPTR_CAST(node);
+                BvHierarchy::Branch * branch = BVHBRANCHPTR_CAST(node);
                 if (branch->mLeft)
                 {
@@ -1631 +1636 @@
 
 //-------------------------------------------------------------------------
-Real KdTree::calcCost()
-{
-        if (mKdRoot)
-                return calcCost(mKdRoot, PlaneEvent::surfaceArea(mKdRoot->mAABB));
+Real BvHierarchy::calcCost()
+{
+        if (mBvhRoot)
+                return calcCost(mBvhRoot, BvhPlaneEvent::surfaceArea(mBvhRoot->mAABB));
         else
                 return 0;
@@ -1640 +1645 @@
 
 //-------------------------------------------------------------------------
-Real KdTree::calcCost(KdTree::Node * node, Real vs)
+Real BvHierarchy::calcCost(BvHierarchy::Node * node, Real vs)
 {
         if (node == 0)
@@ -1647 +1652 @@
         if (node->isLeaf())
         {
-                KdTree::Leaf * leaf = KDLEAFPTR_CAST(node);
-                return (PlaneEvent::surfaceArea(node->mAABB)/vs) *
-                        PlaneEvent::KI * leaf->mBvRenderables.size();
+                BvHierarchy::Leaf * leaf = BVHLEAFPTR_CAST(node);
+                return (BvhPlaneEvent::surfaceArea(node->mAABB)/vs) *
+                        BvhPlaneEvent::KI * leaf->mBvhRenderables.size();
         }
         else
         {
-                KdTree::Branch * branch = KDBRANCHPTR_CAST(node);
-                return (PlaneEvent::surfaceArea(node->mAABB)/vs) * PlaneEvent::KT + 
+                BvHierarchy::Branch * branch = BVHBRANCHPTR_CAST(node);
+                return (BvhPlaneEvent::surfaceArea(node->mAABB)/vs) * BvhPlaneEvent::KT + 
                         calcCost(branch->mLeft, vs) + calcCost(branch->mRight, vs);
         }
@@ -1660 +1665 @@
 
 /************************************************************************/
-/* KdTree::Node/Branch/Leaf functions                                   */
+/* BvHierarchy::Node/Branch/Leaf functions                                   */
 /************************************************************************/
 
 //-------------------------------------------------------------------------
-KdTree::Leaf::~Leaf()
+BvHierarchy::Leaf::~Leaf()
 {
         // detach all scene nodes in the case that we are rebuilding
         // the tree but not the scene
-        BvRenderableList::iterator it = mBvRenderables.begin();
-        BvRenderableList::iterator end = mBvRenderables.end();
+        BvhRenderableList::iterator it = mBvhRenderables.begin();
+        BvhRenderableList::iterator end = mBvhRenderables.end();
         while (it != end)
         {
@@ -1675 +1680 @@
                 it++;
         }
-        mBvRenderables.clear();
+        mBvhRenderables.clear();
 }
 
 //-------------------------------------------------------------------------
-void KdTree::Leaf::queueVisibleObjects(unsigned long currentFrame, 
+void BvHierarchy::Leaf::queueVisibleObjects(unsigned long currentFrame, 
         Camera* cam, RenderQueue* queue, bool onlyShadowCasters, bool showBoxes, bool fullVis)
 {
-        BvRenderableList::iterator it  = mBvRenderables.begin();
-        BvRenderableList::iterator end = mBvRenderables.end();
+        BvhRenderableList::iterator it  = mBvhRenderables.begin();
+        BvhRenderableList::iterator end = mBvhRenderables.end();
         while (it != end)
         {                       
@@ -1699 +1704 @@
 
 //-------------------------------------------------------------------------
-void KdTree::Leaf::getGeometryList(GtpVisibility::GeometryVector *geometryList)
-{
-        BvRenderableList::iterator it = mBvRenderables.begin();
-        BvRenderableList::iterator end = mBvRenderables.end();
+void BvHierarchy::Leaf::getGeometryList(GtpVisibility::GeometryVector *geometryList)
+{
+        BvhRenderableList::iterator it = mBvhRenderables.begin();
+        BvhRenderableList::iterator end = mBvhRenderables.end();
         while (it != end)
         {
@@ -1712 +1717 @@
 //-------------------------------------------------------------------------
 // update the world aabb based on the contained geometry
-void KdTree::Leaf::_updateBounds(bool recurse)
+void BvHierarchy::Leaf::_updateBounds(bool recurse)
 {
         // reset box
@@ -1718 +1723 @@
 
         // merge boxes from attached geometry
-        BvRenderableList::iterator it = mBvRenderables.begin();
-        BvRenderableList::iterator end = mBvRenderables.end();
+        BvhRenderableList::iterator it = mBvhRenderables.begin();
+        BvhRenderableList::iterator end = mBvhRenderables.end();
         while (it != end)
         {

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreBvHierarchyCamera.cpp

@@ -32 +32 @@
         // Null boxes always invisible
         if ( box.isNull() )
-                return KDNV_NONE;
+                return BVHNV_NONE;
 
         // Make any pending updates to the calculated frustum planes
@@ -75 +75 @@
 
                 if ( all_outside )
-                        return KDNV_NONE;
+                        return BVHNV_NONE;
         }
 
         if ( all_inside )
-                return KDNV_FULL;
+                return BVHNV_FULL;
         else
-                return KDNV_PART;
+                return BVHNV_PART;
 }
 
@@ -94 +94 @@
         if (mCullFrustum)
         {
-                return mCullFrustum->isVisible(box, culledBy) ? KDNV_PART : KDNV_NONE;
+                return mCullFrustum->isVisible(box, culledBy) ? BVHNV_PART : BVHNV_NONE;
         }
         else
         {
-                return Frustum::isVisible(box, culledBy) ? KDNV_PART : KDNV_NONE;
+                return Frustum::isVisible(box, culledBy) ? BVHNV_PART : BVHNV_NONE;
         }
 }

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreBvHierarchyInterface.cpp

@@ -8 +8 @@
 */
 
-#include "OgreBvRenderable.h"
+#include "OgreBvhRenderable.h"
 #include "OgreBvHierarchySceneManager.h"
 #include "OgreBvHierarchyInterface.h"
@@ -15 +15 @@
 {
 
-KdTreeHierarchyInterface::KdTreeHierarchyInterface(KdTreeSceneManager *sm, RenderSystem *rsys):
+BvHierarchyInterface::BvHierarchyInterface(BvHierarchySceneManager *sm, RenderSystem *rsys):
 PlatformHierarchyInterface(sm, rsys)
 {
@@ -21 +21 @@
 }
 
-bool KdTreeHierarchyInterface::IsLeaf(GtpVisibility::HierarchyNode *node) const
+bool BvHierarchyInterface::IsLeaf(GtpVisibility::HierarchyNode *node) const
 {
-        return KDNODEPTR_CAST(node)->isLeaf();
+        return BVHNODEPTR_CAST(node)->isLeaf();
 }
 
-void KdTreeHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node)
+void BvHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node)
 {
         ++ mNumTraversedNodes;
 
-        KdTree::Node * kdnode = KDNODEPTR_CAST(node);
+        BvHierarchy::Node * kdnode = BVHNODEPTR_CAST(node);
 
         // if the node is a leaf and has geometry => render it
@@ -49 +49 @@
 }
 
-void KdTreeHierarchyInterface::RenderNode(GtpVisibility::HierarchyNode *node)
+void BvHierarchyInterface::RenderNode(GtpVisibility::HierarchyNode *node)
 {
-        KdTree::Node * kdnode = KDNODEPTR_CAST(node);
+        BvHierarchy::Node * kdnode = BVHNODEPTR_CAST(node);
         if (kdnode->lastRendered() != mFrameId)
         {
                 kdnode->setLastRendered(mFrameId);
-                KdTreeSceneManager * ksm = static_cast<KdTreeSceneManager *>(mSceneManager);
+                BvHierarchySceneManager * ksm = static_cast<BvHierarchySceneManager *>(mSceneManager);
 
                 ksm->_renderNode(kdnode, mCamera, mOnlyShadowCasters, mLeavePassesInQueue);
@@ -63 +63 @@
 }
 
-void KdTreeHierarchyInterface::PullUpVisibility(GtpVisibility::HierarchyNode *node) const
+void BvHierarchyInterface::PullUpVisibility(GtpVisibility::HierarchyNode *node) const
 {
-        KdTree::Node * kdnode = KDNODEPTR_CAST(node);
+        BvHierarchy::Node * kdnode = BVHNODEPTR_CAST(node);
 
         while (kdnode && !kdnode->isNodeVisible())
@@ -74 +74 @@
 }
 
-float KdTreeHierarchyInterface::GetSquaredDistance(GtpVisibility::HierarchyNode *node) const
+float BvHierarchyInterface::GetSquaredDistance(GtpVisibility::HierarchyNode *node) const
 {
-        const Vector3 pos = KDNODEPTR_CAST(node)->mAABB.getCenter();
+        const Vector3 pos = BVHNODEPTR_CAST(node)->mAABB.getCenter();
         return (mCameraPosition - pos).squaredLength();
 }
 
-AxisAlignedBox * KdTreeHierarchyInterface::GetBoundingBox(GtpVisibility::HierarchyNode *node)
+AxisAlignedBox * BvHierarchyInterface::GetBoundingBox(GtpVisibility::HierarchyNode *node)
 {
         // reuse box if node is the same
@@ -87 +87 @@
         {
                 mSavedNode = node;
-                mBox = KDNODEPTR_CAST(node)->_getWorldAABB();
+                mBox = BVHNODEPTR_CAST(node)->_getWorldAABB();
         }
 
@@ -93 +93 @@
 }
 
-bool KdTreeHierarchyInterface::HasGeometry(GtpVisibility::HierarchyNode *node) const
+bool BvHierarchyInterface::HasGeometry(GtpVisibility::HierarchyNode *node) const
 {
-        return KDNODEPTR_CAST(node)->hasGeometry();
+        return BVHNODEPTR_CAST(node)->hasGeometry();
 }
 
-void KdTreeHierarchyInterface::SetNodeVisible(GtpVisibility::HierarchyNode *node, const bool visible) const
+void BvHierarchyInterface::SetNodeVisible(GtpVisibility::HierarchyNode *node, const bool visible) const
 {
-        KDNODEPTR_CAST(node)->setNodeVisible(visible);
+        BVHNODEPTR_CAST(node)->setNodeVisible(visible);
 }
 
-bool KdTreeHierarchyInterface::IsNodeVisible(GtpVisibility::HierarchyNode *node) const
+bool BvHierarchyInterface::IsNodeVisible(GtpVisibility::HierarchyNode *node) const
 {
-        return KDNODEPTR_CAST(node)->isNodeVisible();
+        return BVHNODEPTR_CAST(node)->isNodeVisible();
 }
 
-void KdTreeHierarchyInterface::SetLastVisited(GtpVisibility::HierarchyNode *node, const unsigned int frameId) const
+void BvHierarchyInterface::SetLastVisited(GtpVisibility::HierarchyNode *node, const unsigned int frameId) const
 {
-        KDNODEPTR_CAST(node)->setLastVisited(frameId);
+        BVHNODEPTR_CAST(node)->setLastVisited(frameId);
 }
 
-unsigned int KdTreeHierarchyInterface::LastVisited(GtpVisibility::HierarchyNode *node) const
+unsigned int BvHierarchyInterface::LastVisited(GtpVisibility::HierarchyNode *node) const
 {
-        return KDNODEPTR_CAST(node)->lastVisited();
+        return BVHNODEPTR_CAST(node)->lastVisited();
 }
 
-void KdTreeHierarchyInterface::VisualizeCulledNode(GtpVisibility::HierarchyNode *node, 
+void BvHierarchyInterface::VisualizeCulledNode(GtpVisibility::HierarchyNode *node, 
                                                                                                    GtpVisibility::CullingType type) const
 {
-        WireBoundingBox *box = KDNODEPTR_CAST(node)->getWireBoundingBox();
+        WireBoundingBox *box = BVHNODEPTR_CAST(node)->getWireBoundingBox();
 
         if (type == GtpVisibility::FRUSTUM_CULLED)
@@ -132 +132 @@
         }
 
-        dynamic_cast<KdTreeSceneManager *>(mSceneManager)->getRenderQueue()->addRenderable(box);
+        dynamic_cast<BvHierarchySceneManager *>(mSceneManager)->getRenderQueue()->addRenderable(box);
 }
 
-void KdTreeHierarchyInterface::GetNodeGeometryList(GtpVisibility::HierarchyNode *node, 
+void BvHierarchyInterface::GetNodeGeometryList(GtpVisibility::HierarchyNode *node, 
                                                                                                    GtpVisibility::GeometryVector *geometryList, 
                                                                                                    bool includeChildren) 
 {
-        KDNODEPTR_CAST(node)->getGeometryList(geometryList);
+        BVHNODEPTR_CAST(node)->getGeometryList(geometryList);
 }
 

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreBvHierarchySceneManager.cpp

@@ -27 +27 @@
 {
 
-KdTreeSceneManager::KdTreeSceneManager(const String& name, GtpVisibility::VisibilityManager *vm):
+BvHierarchySceneManager::BvHierarchySceneManager(const String& name, GtpVisibility::VisibilityManager *vm):
 SceneManager(name), 
 mVisibilityManager(vm), 
 mBvHierarchy(0), 
-mMaxDepth(KDTREE_MAX_DEPTH),
+mMaxDepth(BvHierarchy_MAX_DEPTH),
 mShowBoxes(false),
 mHiLiteLevel(0),
 mShowAllBoxes(false),
 mEnhancedVisiblity(true),
-mBuildMethod(KdTree::KDBM_RECURSIVE),
-mRenderMethod(KdTree::KDRM_INTERNAL),
+mBuildMethod(BvHierarchy::BVHBM_RECURSIVE),
+mRenderMethod(BvHierarchy::BVHRM_INTERNAL),
 mShowVisualization(false),
 mRenderNodesForViz(false),
@@ -64 +64 @@
         // Replace root node with my node
         OGRE_DELETE(mSceneRoot);
-        mSceneRoot = new KdTreeSceneNode(this, "root node");
+        mSceneRoot = new BvHierarchySceneNode(this, "root node");
         mSceneRoot->_notifyRootNode();
 
         // init heirarchy interface
-        mHierarchyInterface = new KdTreeHierarchyInterface(this, mDestRenderSystem);
-}
-
-KdTreeSceneManager::~KdTreeSceneManager(void)
+        mHierarchyInterface = new BvHierarchyInterface(this, mDestRenderSystem);
+}
+
+BvHierarchySceneManager::~BvHierarchySceneManager(void)
 {
         delete mHierarchyInterface;
@@ -77 +77 @@
 }
 
-void KdTreeSceneManager::clearScene()
+void BvHierarchySceneManager::clearScene()
 {
         // DEBUG
@@ -90 +90 @@
 
 
-const String& KdTreeSceneManager::getTypeName(void) const
+const String& BvHierarchySceneManager::getTypeName(void) const
 {
         return BvHierarchySceneManagerFactory::FACTORY_TYPE_NAME;
 }
 
-void KdTreeSceneManager::setShowBoxes(bool showboxes)
+void BvHierarchySceneManager::setShowBoxes(bool showboxes)
 {
         mShowBoxes = showboxes;
 }
 
-bool KdTreeSceneManager::getShowBoxes(void) const
+bool BvHierarchySceneManager::getShowBoxes(void) const
 {
         return mShowBoxes;
 }
 
-bool KdTreeSceneManager::setOption(const String& strKey, const void* pValue)
-{
-        // change max depth of the kdtree
+bool BvHierarchySceneManager::setOption(const String& strKey, const void* pValue)
+{
+        // change max depth of the BvHierarchy
         // rebuild the tree if already exists
-        if (strKey == "KdTreeMaxDepth")
+        if (strKey == "BvHierarchyMaxDepth")
         {
                 int maxdepth = *static_cast<const int *>(pValue);
@@ -132 +132 @@
                 if (kt > 0)
                 {
-                        PlaneEvent::KT = kt;
+                        BvhPlaneEvent::KT = kt;
                         return true;
                 }
@@ -145 +145 @@
                 if (ki > 0)
                 {
-                        PlaneEvent::KI = ki;
+                        BvhPlaneEvent::KI = ki;
                         return true;
                 }
@@ -153 +153 @@
                 }
         }
-        else if (strKey == "RebuildKdTree")
+        else if (strKey == "RebuildBvHierarchy")
         {
                 OGRE_DELETE(mBvHierarchy);
-                mBvHierarchy = new KdTree(mMaxDepth, mBuildMethod, mHiLiteLevel, mShowAllBoxes, mShowNodes);
-                mBvHierarchy->build(static_cast<KdTreeSceneNode *>(mSceneRoot));
+                mBvHierarchy = new BvHierarchy(mMaxDepth, mBuildMethod, mHiLiteLevel, mShowAllBoxes, mShowNodes);
+                mBvHierarchy->build(static_cast<BvHierarchySceneNode *>(mSceneRoot));
                 mBvHierarchy->setEnhancedVis(mEnhancedVisiblity);
                 return true;
@@ -172 +172 @@
         else if (strKey == "BuildMethod")
         {
-                KdTree::BuildMethod bm = *static_cast<const KdTree::BuildMethod *>(pValue);
-                if (bm == KdTree::KDBM_RECURSIVE || bm == KdTree::KDBM_PRIORITYQUEUE)
+                BvHierarchy::BuildMethod bm = *static_cast<const BvHierarchy::BuildMethod *>(pValue);
+                if (bm == BvHierarchy::BVHBM_RECURSIVE || bm == BvHierarchy::BVHBM_PRIORITYQUEUE)
                 {
                         mBuildMethod = bm;
@@ -185 +185 @@
         else if (strKey == "RenderMethod")
         {
-                KdTree::RenderMethod rm = *static_cast<const KdTree::RenderMethod *>(pValue);
-                if (rm == KdTree::KDRM_INTERNAL)
+                BvHierarchy::RenderMethod rm = *static_cast<const BvHierarchy::RenderMethod *>(pValue);
+                if (rm == BvHierarchy::BVHRM_INTERNAL)
                 {
                         mRenderMethod = rm;
                         return true;
                 }
-                else if (rm == KdTree::KDRM_GTP_VFC)
+                else if (rm == BvHierarchy::BVHRM_GTP_VFC)
                 {
                         mRenderMethod = rm;
@@ -198 +198 @@
                                 .setOption("Algorithm", &cmt);
                 }
-                else if (rm == KdTree::KDRM_GTP_SWC)
+                else if (rm == BvHierarchy::BVHRM_GTP_SWC)
                 {
                         mRenderMethod = rm;
@@ -205 +205 @@
                                 .setOption("Algorithm", &cmt);
                 }
-                else if (rm == KdTree::KDRM_GTP_CHC)
+                else if (rm == BvHierarchy::BVHRM_GTP_CHC)
                 {
                         mRenderMethod = rm;
@@ -227 +227 @@
                         int val = *static_cast<const int *>(pValue);
                         if (val == GtpVisibility::VisibilityEnvironment::FRUSTUM_CULLING)
-                                mRenderMethod = KdTree::KDRM_GTP_VFC;
+                                mRenderMethod = BvHierarchy::BVHRM_GTP_VFC;
                         else if (val == GtpVisibility::VisibilityEnvironment::STOP_AND_WAIT_CULLING)
-                                mRenderMethod = KdTree::KDRM_GTP_SWC;
+                                mRenderMethod = BvHierarchy::BVHRM_GTP_SWC;
                         else if (val == GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING)
-                                mRenderMethod = KdTree::KDRM_GTP_CHC;
+                                mRenderMethod = BvHierarchy::BVHRM_GTP_CHC;
                         // default, should never happen
                         else
-                                mRenderMethod = KdTree::KDRM_INTERNAL;
+                                mRenderMethod = BvHierarchy::BVHRM_INTERNAL;
                 }
                 else
                 {
-                        mRenderMethod = KdTree::KDRM_INTERNAL;
+                        mRenderMethod = BvHierarchy::BVHRM_INTERNAL;
                 }
                 return success;
         }
-        else if (strKey == "ShowKdTree")
+        else if (strKey == "ShowBvHierarchy")
         {
                 bool sk = *static_cast<const bool *>(pValue);
@@ -406 +406 @@
 }
 
-bool KdTreeSceneManager::getOption(const String& strKey, void* pDestValue)
-{
-        if (strKey == "KdTreeMaxDepth")
+bool BvHierarchySceneManager::getOption(const String& strKey, void* pDestValue)
+{
+        if (strKey == "BvHierarchyMaxDepth")
         {
                 *static_cast<int *>(pDestValue) = mMaxDepth;
@@ -415 +415 @@
         else if (strKey == "KT")
         {
-                *static_cast<Real *>(pDestValue) = PlaneEvent::KT;
+                *static_cast<Real *>(pDestValue) = BvhPlaneEvent::KT;
                 return true;
         }
         else if (strKey == "KI")
         {
-                *static_cast<Real *>(pDestValue) = PlaneEvent::KI;
+                *static_cast<Real *>(pDestValue) = BvhPlaneEvent::KI;
                 return true;
         }
@@ -433 +433 @@
         else if (strKey == "BuildMethod")
         {
-                *static_cast<KdTree::BuildMethod *>(pDestValue) = mBuildMethod;
+                *static_cast<BvHierarchy::BuildMethod *>(pDestValue) = mBuildMethod;
                 return true;
         }
         else if (strKey == "RenderMethod")
         {
-                *static_cast<KdTree::RenderMethod *>(pDestValue) = mRenderMethod;
-                return true;
-        }
-        else if (strKey == "ShowKdTree")
+                *static_cast<BvHierarchy::RenderMethod *>(pDestValue) = mRenderMethod;
+                return true;
+        }
+        else if (strKey == "ShowBvHierarchy")
         {
                 *static_cast<bool *>(pDestValue) = mShowBoxes;
@@ -464 +464 @@
         else if (strKey == "NumFrustumCulledNodes")
         {
-                if (mRenderMethod == KdTree::KDRM_INTERNAL)
+                if (mRenderMethod == BvHierarchy::BVHRM_INTERNAL)
                 {
                         unsigned int numnodes = 0;
@@ -477 +477 @@
         else if (strKey == "NumQueryCulledNodes")
         {
-                if (mRenderMethod == KdTree::KDRM_INTERNAL)
+                if (mRenderMethod == BvHierarchy::BVHRM_INTERNAL)
                 {
                         * static_cast<unsigned int *>(pDestValue) = 0;
@@ -495 +495 @@
         else if (strKey == "NumRenderedNodes")
         {
-                if (mRenderMethod == KdTree::KDRM_INTERNAL)
+                if (mRenderMethod == BvHierarchy::BVHRM_INTERNAL)
                 {
                         unsigned int numnodes = 0;
@@ -508 +508 @@
         else if (strKey == "NumQueriesIssued")
         {
-                if (mRenderMethod == KdTree::KDRM_INTERNAL)
+                if (mRenderMethod == BvHierarchy::BVHRM_INTERNAL)
                 {
                         * static_cast<unsigned int *>(pDestValue) = 0;
@@ -517 +517 @@
         else if (strKey == "NumTraversedNodes")
         {
-                if (mRenderMethod == KdTree::KDRM_INTERNAL)
+                if (mRenderMethod == BvHierarchy::BVHRM_INTERNAL)
                 {
                         unsigned int numnodes = 0;
@@ -557 +557 @@
 }
 
-bool KdTreeSceneManager::getOptionKeys(StringVector &refKeys)
+bool BvHierarchySceneManager::getOptionKeys(StringVector &refKeys)
 {
         refKeys.push_back("Algorithm");
@@ -570 +570 @@
         refKeys.push_back("KI");
         refKeys.push_back("KT");
-        refKeys.push_back("KdTreeMaxDepth");
+        refKeys.push_back("BvHierarchyMaxDepth");
         refKeys.push_back("LoadViewCells");
         refKeys.push_back("NumHierarchyNodes");
         refKeys.push_back("PrepareVisualization");
-        refKeys.push_back("RebuildKdTree");
+        refKeys.push_back("RebuildBvHierarchy");
         refKeys.push_back("RenderMethod");
         refKeys.push_back("RenderNodesContentForViz");
@@ -580 +580 @@
         refKeys.push_back("RenderTransparentsForItemBuffer");
         refKeys.push_back("ShowAllBoxes");
-        refKeys.push_back("ShowKdTree");
+        refKeys.push_back("ShowBvHierarchy");
         refKeys.push_back("ShowNodes");
         refKeys.push_back("SkyBoxEnabled");
@@ -595 +595 @@
 }
 
-bool KdTreeSceneManager::getOptionValues(const String & key, StringVector &refValueList)
+bool BvHierarchySceneManager::getOptionValues(const String & key, StringVector &refValueList)
 {
         return SceneManager::getOptionValues(key, refValueList);
 }
 
-void KdTreeSceneManager::setVisibilityManager(GtpVisibility::VisibilityManager *visManager)
+void BvHierarchySceneManager::setVisibilityManager(GtpVisibility::VisibilityManager *visManager)
 {
         mVisibilityManager = visManager;
 }
 
-GtpVisibility::VisibilityManager * KdTreeSceneManager::getVisibilityManager()
+GtpVisibility::VisibilityManager * BvHierarchySceneManager::getVisibilityManager()
 {
         return mVisibilityManager;
 }
 
-GtpVisibility::VisibilityManager * KdTreeSceneManager::GetVisibilityManager()
+GtpVisibility::VisibilityManager * BvHierarchySceneManager::GetVisibilityManager()
 {
         return mVisibilityManager;
 }
 
-KdTreeHierarchyInterface * KdTreeSceneManager::GetHierarchyInterface()
+BvHierarchyInterface * BvHierarchySceneManager::GetHierarchyInterface()
 {
         return mHierarchyInterface;
 }
 
-Camera* KdTreeSceneManager::createCamera(const String& name)
+Camera* BvHierarchySceneManager::createCamera(const String& name)
 {
         // Check name not used
@@ -637 +637 @@
 }
 
-SceneNode* KdTreeSceneManager::createSceneNode(void)
-{
-        SceneNode* sn = new KdTreeSceneNode(this);
+SceneNode* BvHierarchySceneManager::createSceneNode(void)
+{
+        SceneNode* sn = new BvHierarchySceneNode(this);
         assert(mSceneNodes.find(sn->getName()) == mSceneNodes.end());
         mSceneNodes[sn->getName()] = sn;
@@ -645 +645 @@
 }
 
-SceneNode* KdTreeSceneManager::createSceneNode(const String& name)
+SceneNode* BvHierarchySceneManager::createSceneNode(const String& name)
 {
         // Check name not used
@@ -653 +653 @@
                         Exception::ERR_DUPLICATE_ITEM,
                         "A scene node with the name " + name + " already exists",
-                        "KdTreeSceneManager::createSceneNode" );
-        }
-
-        SceneNode* sn = new KdTreeSceneNode(this, name);
+                        "BvHierarchySceneManager::createSceneNode" );
+        }
+
+        SceneNode* sn = new BvHierarchySceneNode(this, name);
         mSceneNodes[sn->getName()] = sn;
         return sn;
 }
 
-Entity * KdTreeSceneManager::createEntity(const String& entityName, const String& meshName)
+Entity * BvHierarchySceneManager::createEntity(const String& entityName, const String& meshName)
 {
         Entity *ent = SceneManager::createEntity(entityName, meshName);
@@ -677 +677 @@
 
 // make sure it's called only for non-empty nodes .. avoids one uneccessary funciton call
-void KdTreeSceneManager::_updateNode(KdTreeSceneNode *node)
+void BvHierarchySceneManager::_updateNode(BvHierarchySceneNode *node)
 {
         //LogManager::getSingleton().logMessage("### _updateNode called for " + node->getName());
 
-        /* Rebuild kdtree when it was wiped out
+        /* Rebuild BvHierarchy when it was wiped out
                 * Usually this happens only before the first frame
                 * The initial AABB shall enclose all objects present
@@ -691 +691 @@
         if (!mBvHierarchy)
         {
-                mBvHierarchy = new KdTree(mMaxDepth, mBuildMethod);
-                mBvHierarchy->build(static_cast<KdTreeSceneNode *>(mSceneRoot));
+                mBvHierarchy = new BvHierarchy(mMaxDepth, mBuildMethod);
+                mBvHierarchy->build(static_cast<BvHierarchySceneNode *>(mSceneRoot));
                 mBvHierarchy->setEnhancedVis(mEnhancedVisiblity);
         }
@@ -713 +713 @@
                 
                 //delete mBvHierarchy;
-                //mBvHierarchy = new KdTree(mMaxDepth);
-                //mBvHierarchy->build(static_cast<KdTreeSceneNode *>(mSceneRoot));
-        }
-
-}
-
-void KdTreeSceneManager::_updateSceneGraph(Camera* cam)
+                //mBvHierarchy = new BvHierarchy(mMaxDepth);
+                //mBvHierarchy->build(static_cast<BvHierarchySceneNode *>(mSceneRoot));
+        }
+
+}
+
+void BvHierarchySceneManager::_updateSceneGraph(Camera* cam)
 {
         mVisibilityManager->GetCullingManager()->SetHierarchyInterface(mHierarchyInterface);
@@ -727 +727 @@
 }
 
-void KdTreeSceneManager::_findVisibleObjects(Camera *cam, bool onlyShadowCasters)
-{
-        if (mRenderMethod == KdTree::KDRM_INTERNAL)
+void BvHierarchySceneManager::_findVisibleObjects(Camera *cam, bool onlyShadowCasters)
+{
+        if (mRenderMethod == BvHierarchy::BVHRM_INTERNAL)
         {
                 getRenderQueue()->clear();
@@ -742 +742 @@
                         {
                                 // determine visibility
-                                mBvHierarchy->queueVisibleObjects(KDCAMPTR_CAST(cam), getRenderQueue(), onlyShadowCasters, mShowBoxes, mVisibleNodes);
+                                mBvHierarchy->queueVisibleObjects(BVHCAMPTR_CAST(cam), getRenderQueue(), onlyShadowCasters, mShowBoxes, mVisibleNodes);
                                 // apply view cell pvs
                                 updatePvs(cam);
@@ -767 +767 @@
                                 getRenderQueue()->clear();
                                 if (mBvHierarchy)
-                                        mBvHierarchy->queueVisibleObjects(KDCAMPTR_CAST(cam), getRenderQueue(), onlyShadowCasters, mShowBoxes, mVisibleNodes);
+                                        mBvHierarchy->queueVisibleObjects(BVHCAMPTR_CAST(cam), getRenderQueue(), onlyShadowCasters, mShowBoxes, mVisibleNodes);
                         }
 
@@ -781 +781 @@
 }
 
-void KdTreeSceneManager::_renderVisibleObjects()
-{
-        if (mRenderMethod == KdTree::KDRM_INTERNAL)
+void BvHierarchySceneManager::_renderVisibleObjects()
+{
+        if (mRenderMethod == BvHierarchy::BVHRM_INTERNAL)
         {
                 SceneManager::_renderVisibleObjects();
@@ -884 +884 @@
                         if (mUseDepthPass)
                         {
-                                KdTree::NodeList::const_iterator it, end = mVisibleNodes.end();
+                                BvHierarchy::NodeList::const_iterator it, end = mVisibleNodes.end();
                                 for (it = mVisibleNodes.begin(); it != end; it++)
                                 {
@@ -917 +917 @@
 
 
-void KdTreeSceneManager::_renderNode(KdTree::NodePtr node, Camera * cam, 
+void BvHierarchySceneManager::_renderNode(BvHierarchy::NodePtr node, Camera * cam, 
                                                                          bool onlyShadowCasters, int leavePassesInQueue)
 {
@@ -932 +932 @@
 
 //-----------------------------------------------------------------------
-const Pass *KdTreeSceneManager::_setPass(const Pass* pass, bool evenIfSuppressed)
-{
-        if (mRenderMethod == KdTree::KDRM_INTERNAL)
+const Pass *BvHierarchySceneManager::_setPass(const Pass* pass, bool evenIfSuppressed)
+{
+        if (mRenderMethod == BvHierarchy::BVHRM_INTERNAL)
         {
                 return SceneManager::_setPass(pass);
@@ -1007 +1007 @@
 }
 //-----------------------------------------------------------------------
-void KdTreeSceneManager::renderBasicQueueGroupObjects(RenderQueueGroup* pGroup,
+void BvHierarchySceneManager::renderBasicQueueGroupObjects(RenderQueueGroup* pGroup,
                                                                                                           QueuedRenderableCollection::OrganisationMode om)
 {
@@ -1028 +1028 @@
 
                 // Do transparents (always descending)
-                if (mRenderMethod == KdTree::KDRM_INTERNAL || !mSkipTransparents)
+                if (mRenderMethod == BvHierarchy::BVHRM_INTERNAL || !mSkipTransparents)
                 {
                         renderObjects(pPriorityGrp->getTransparents(), 
@@ -1038 +1038 @@
 }
 //-----------------------------------------------------------------------
-bool KdTreeSceneManager::validatePassForRendering(Pass* pass)
-{
-        if (mRenderMethod == KdTree::KDRM_INTERNAL)
+bool BvHierarchySceneManager::validatePassForRendering(Pass* pass)
+{
+        if (mRenderMethod == BvHierarchy::BVHRM_INTERNAL)
         {
                 return SceneManager::validatePassForRendering(pass);
@@ -1059 +1059 @@
 }
 //-----------------------------------------------------------------------
-void KdTreeSceneManager::_renderQueueGroupObjects(RenderQueueGroup* pGroup, 
+void BvHierarchySceneManager::_renderQueueGroupObjects(RenderQueueGroup* pGroup, 
                                                                                                   QueuedRenderableCollection::OrganisationMode om)
 {
-        if (mRenderMethod == KdTree::KDRM_INTERNAL || !mIsItemBufferPhase)
+        if (mRenderMethod == BvHierarchy::BVHRM_INTERNAL || !mIsItemBufferPhase)
         {
                 SceneManager::_renderQueueGroupObjects(pGroup, om);
@@ -1081 +1081 @@
 }
 //-----------------------------------------------------------------------
-void KdTreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(
+void BvHierarchySceneManager::renderAdditiveStencilShadowedQueueGroupObjects(
         RenderQueueGroup* pGroup, QueuedRenderableCollection::OrganisationMode om)
 {
@@ -1115 +1115 @@
 }
 //-----------------------------------------------------------------------
-void KdTreeSceneManager::renderModulativeStencilShadowedQueueGroupObjects(
+void BvHierarchySceneManager::renderModulativeStencilShadowedQueueGroupObjects(
         RenderQueueGroup* pGroup, QueuedRenderableCollection::OrganisationMode om)
 {
@@ -1140 +1140 @@
 }
 //-----------------------------------------------------------------------
-void KdTreeSceneManager::InitDepthPass()
+void BvHierarchySceneManager::InitDepthPass()
 {
         MaterialPtr depthMat = MaterialManager::getSingleton().getByName("Visibility/DepthPass");
@@ -1161 +1161 @@
 }
 //-----------------------------------------------------------------------
-void KdTreeSceneManager::InitItemBufferPass()
+void BvHierarchySceneManager::InitItemBufferPass()
 {
         MaterialPtr itemBufferMat = MaterialManager::getSingleton().
@@ -1185 +1185 @@
 }
 //-----------------------------------------------------------------------
-void KdTreeSceneManager::PrepareVisualization(Camera *cam)
+void BvHierarchySceneManager::PrepareVisualization(Camera *cam)
 {
         // add player camera for visualization purpose
@@ -1206 +1206 @@
                 unsigned long frameid = 0;
 
-                if (mRenderMethod == KdTree::KDRM_INTERNAL)
+                if (mRenderMethod == BvHierarchy::BVHRM_INTERNAL)
                         frameid = Root::getSingleton().getCurrentFrameNumber();
                 else
                         frameid = mHierarchyInterface->GetFrameId();
 
-                for (KdTree::NodeList::iterator it = mVisibleNodes.begin(); it != mVisibleNodes.end(); ++it)
+                for (BvHierarchy::NodeList::iterator it = mVisibleNodes.begin(); it != mVisibleNodes.end(); ++it)
                 {
                         if (mRenderNodesForViz && (*it)->isLeaf())
                         {
                                 WireBoundingBox * wirebox = (*it)->getWireBoundingBox();
-                                wirebox->setMaterial("KdTree/BoxViz");
+                                wirebox->setMaterial("BvHierarchy/BoxViz");
                                 getRenderQueue()->addRenderable(wirebox);
                         }
@@ -1228 +1228 @@
 }
 //-----------------------------------------------------------------------
-void KdTreeSceneManager::InitVisibilityCulling(Camera *cam)
+void BvHierarchySceneManager::InitVisibilityCulling(Camera *cam)
 {
         // reset culling manager stats
@@ -1300 +1300 @@
 
 //-------------------------------------------------------------------------
-void KdTreeSceneManager::SetObjectsVisible(const bool visible)
+void BvHierarchySceneManager::SetObjectsVisible(const bool visible)
 {
         GtpVisibilityPreprocessor::ObjectContainer::iterator it, it_end = mObjects.end();
@@ -1313 +1313 @@
 }
 //-----------------------------------------------------------------------
-bool KdTreeSceneManager::LoadViewCells(const String &filename)
+bool BvHierarchySceneManager::LoadViewCells(const String &filename)
 {
         // objects are set to invisible initially
         SetObjectsVisible(false);
 
-        const string bboxesFilename = mVisibilityManager->GetVisibilityEnvironment()->getViewCellsFileName();
+        const string bboxesFilename = 
+                mVisibilityManager->GetVisibilityEnvironment()->getViewCellsFileName();
 
         // converter between view cell ids and Ogre entites 
         GtpVisibilityPreprocessor::IndexedBoundingBoxContainer iboxes;
+#if 0
         OgreBoundingBoxConverter bconverter(this);
 
@@ -1329 +1331 @@
 
         return (mViewCellsManager != NULL);
+#endif
 }
 //-------------------------------------------------------------------------
-void KdTreeSceneManager::applyViewCellPvs(GtpVisibilityPreprocessor::ViewCell *vc, 
+void BvHierarchySceneManager::applyViewCellPvs(GtpVisibilityPreprocessor::ViewCell *vc, 
                                                                                                         const bool load)
 {       // NOTE: should not happen, rather apply view cell representing unbounded space then
@@ -1356 +1359 @@
 }
 //-------------------------------------------------------------------------
-void KdTreeSceneManager::updatePvs(Camera *cam)
+void BvHierarchySceneManager::updatePvs(Camera *cam)
 {
         if (!(mViewCellsLoaded && mUseViewCells))
@@ -1406 +1409 @@
 
 //-----------------------------------------------------------------------
-void KdTreeSceneManager::WriteLog()
+void BvHierarchySceneManager::WriteLog()
 {
         std::stringstream d;
@@ -1427 +1430 @@
 
 /************************************************************************/
-/* Factory for KdTreeSceneManager                                       */
+/* Factory for BvHierarchySceneManager                                       */
 /************************************************************************/
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-const String BvHierarchySceneManagerFactory::FACTORY_TYPE_NAME = "KdTreeSceneManager";
+const String BvHierarchySceneManagerFactory::FACTORY_TYPE_NAME = "BvHierarchySceneManager";
 //-----------------------------------------------------------------------
 void BvHierarchySceneManagerFactory::initMetaData(void) const
@@ -1444 +1447 @@
         const String& instanceName)
 {
-        return new KdTreeSceneManager(instanceName, visManager);
+        return new BvHierarchySceneManager(instanceName, visManager);
 }
 //-----------------------------------------------------------------------

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreBvHierarchySceneNode.cpp

@@ -18 +18 @@
         // TRIVIA: this function is _not_ called for nodes which did not change since the last frame
         // only exception: the root node ... it's aabb should be null however, so we don't care
-        void KdTreeSceneNode::_updateBounds(void)
+        void BvHierarchySceneNode::_updateBounds(void)
         {
                 // Reset bounds first
@@ -33 +33 @@
                 if (!mWorldAABB.isNull())
                 {
-                        static_cast<KdTreeSceneManager *>(mCreator)->_updateNode(this);
+                        static_cast<BvHierarchySceneManager *>(mCreator)->_updateNode(this);
                 }
         }
 
-        void KdTreeSceneNode::computeScene(PlaneEventList& events, AxisAlignedBox& aabb, int& nObjects, bool includeChildren)
+        void BvHierarchySceneNode::computeScene(BvhPlaneEventList& events, AxisAlignedBox& aabb, int& nObjects, bool includeChildren)
         {
                 /**************************************************************************************/
                 /* HACK: do not include camera node, FUCKS UP world AABB really BAD, dunno why        */
-                /* TODO: find a generic solution where MOVABLE nodes are NOT INSERTED into the KDTREE */
+                /* TODO: find a generic solution where MOVABLE nodes are NOT INSERTED into the BvHierarchy */
                 /**************************************************************************************/
                 //if (mName == "PlayerCamNode")
@@ -55 +55 @@
                         if (getExcludedMovables().find(i->second->getMovableType()) == getExcludedMovables().end())
                         {
-                                //LogManager::getSingleton().getLog(KDTREE_LOGNAME)->logMessage("Adding movable type " + i->second->getMovableType() + " to KdTree");
+                                //LogManager::getSingleton().getLog(BvHierarchy_LOGNAME)->logMessage("Adding movable type " + i->second->getMovableType() + " to BvHierarchy");
                                 // Merge world bounds of each object
                                 mWorldAABB.merge(i->second->getWorldBoundingBox(true));
@@ -61 +61 @@
                 }
 
-                // create information for KdTree/SAH
+                // create information for BvHierarchy/SAH
                 if (!mWorldAABB.isNull())
                 {
@@ -71 +71 @@
 
                         // generate events
-                        PlaneEvent::Dimension axes[] = 
-                                {PlaneEvent::PED_X, PlaneEvent::PED_Y, PlaneEvent::PED_Z};
+                        BvhPlaneEvent::Dimension axes[] = 
+                                {BvhPlaneEvent::PED_X, BvhPlaneEvent::PED_Y, BvhPlaneEvent::PED_Z};
                         Vector3 min = mWorldAABB.getMinimum();
                         Vector3 max = mWorldAABB.getMaximum();
@@ -80 +80 @@
                                 if (min[i] == max[i])
                                 {       
-                                        //e = new PlaneEvent(this, min, axes[i], PlaneEvent::PET_ON);
+                                        //e = new BvhPlaneEvent(this, min, axes[i], BvhPlaneEvent::PET_ON);
                                         //sceneinfo.events.push_back(*e);
-                                        events.push_back(PlaneEvent(this, min, axes[i], PlaneEvent::PET_ON));
+                                        events.push_back(BvhPlaneEvent(this, min, axes[i], BvhPlaneEvent::PET_ON));
                                 }
                                 else
                                 {
-                                        //e = new PlaneEvent(this, min, axes[i], PlaneEvent::PET_START);
+                                        //e = new BvhPlaneEvent(this, min, axes[i], BvhPlaneEvent::PET_START);
                                         //sceneinfo.events.push_back(*e);
-                                        //e = new PlaneEvent(this, max, axes[i], PlaneEvent::PET_END);
+                                        //e = new BvhPlaneEvent(this, max, axes[i], BvhPlaneEvent::PET_END);
                                         //sceneinfo.events.push_back(*e);
-                                        events.push_back(PlaneEvent(this, min, axes[i], PlaneEvent::PET_START));
-                                        events.push_back(PlaneEvent(this, max, axes[i], PlaneEvent::PET_END));
+                                        events.push_back(BvhPlaneEvent(this, min, axes[i], BvhPlaneEvent::PET_START));
+                                        events.push_back(BvhPlaneEvent(this, max, axes[i], BvhPlaneEvent::PET_END));
                                 }
                         }
@@ -102 +102 @@
                         for (child = mChildren.begin(); child != mChildren.end(); ++child)
                         {
-                                KdTreeSceneNode* sceneChild = static_cast<KdTreeSceneNode*>(child->second);
+                                BvHierarchySceneNode* sceneChild = static_cast<BvHierarchySceneNode*>(child->second);
                                 sceneChild->computeScene(events, aabb, nObjects);
                         }
@@ -108 +108 @@
         }
 
-        //void KdTreeSceneNode::_findVisibleObjects(Camera* cam, RenderQueue* queue, 
+        //void BvHierarchySceneNode::_findVisibleObjects(Camera* cam, RenderQueue* queue, 
         //      bool includeChildren, bool displayNodes, bool onlyShadowCasters)
-        void KdTreeSceneNode::queueObjects(Camera* cam, RenderQueue* queue, bool onlyShadowCasters)
+        void BvHierarchySceneNode::queueObjects(Camera* cam, RenderQueue* queue, bool onlyShadowCasters)
         {
                 //SceneNode::_findVisibleObjects(cam, queue, includeChildren, displayNodes, onlyShadowCasters);
@@ -136 +136 @@
         }
 
-        void KdTreeSceneNode::getGeometryList(GtpVisibility::GeometryVector *geometryList)
+        void BvHierarchySceneNode::getGeometryList(GtpVisibility::GeometryVector *geometryList)
         {
                 SceneNode::ObjectIterator objIt = getAttachedObjectIterator();
@@ -154 +154 @@
 
         // recalculate the world aabb
-        AxisAlignedBox KdTreeSceneNode::getBoundingBox(void) const
+        AxisAlignedBox BvHierarchySceneNode::getBoundingBox(void) const
         {
                 return mWorldAABB;
         }
 
-        KdTreeSceneNode::StringSet& KdTreeSceneNode::getExcludedMovables(void)
+        BvHierarchySceneNode::StringSet& BvHierarchySceneNode::getExcludedMovables(void)
         {
                 static StringSet sExluded;
@@ -175 +175 @@
 
         // DEBUG
-        String KdTreeSceneNode::dumpToString(void)
+        String BvHierarchySceneNode::dumpToString(void)
         {
                 String objects;

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreKdTree.cpp

@@ -25 +25 @@
 {
 
-enum Intersection
+enum BvhIntersection
 {
         OUTSIDE=0,
@@ -32 +32 @@
 };
 
-Intersection intersect( const Ray &one, const AxisAlignedBox &two )
+static BvhIntersection intersect( const Ray &one, const AxisAlignedBox &two )
 {
         // Null box?
@@ -99 +99 @@
 /** Checks how the second box intersects with the first.
 */
-Intersection intersect( const PlaneBoundedVolume &one, const AxisAlignedBox &two )
+static BvhIntersection intersect( const PlaneBoundedVolume &one, const AxisAlignedBox &two )
 {
         // Null box?
@@ -146 +146 @@
 /** Checks how the second box intersects with the first.
 */
-Intersection intersect( const AxisAlignedBox &one, const AxisAlignedBox &two )
+static BvhIntersection intersect( const AxisAlignedBox &one, const AxisAlignedBox &two )
 {
         // Null box?
@@ -180 +180 @@
 /** Checks how the box intersects with the sphere.
 */
-Intersection intersect( const Sphere &one, const AxisAlignedBox &two )
+static BvhIntersection intersect( const Sphere &one, const AxisAlignedBox &two )
 {
         // Null box?
@@ -1512 +1512 @@
         if ( !full )
         {
-                Intersection isect = intersect(box, node->_getWorldAABB());
+                BvhIntersection isect = intersect(box, node->_getWorldAABB());
 
                 if ( isect == OUTSIDE )
@@ -1536 +1536 @@
                                 else
                                 {
-                                        Intersection nsect = intersect(box, sn->_getWorldAABB());
+                                        BvhIntersection nsect = intersect(box, sn->_getWorldAABB());
 
                                         if ( nsect != OUTSIDE )

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreVisibilitySceneManagerDll.cpp

@@ -30 +30 @@
 #include <OgreLogManager.h>
 
+#include "OgreBvHierarchySceneManager.h"
 #include "VisibilityManager.h"
 #include "VisibilityEnvironment.h"
@@ -39 +40 @@
 
 
-OcclusionCullingSceneManagerFactory *occlusionCullingPlugin;
+OcclusionCullingSceneManagerFactory *occlusionCullingFactory;
 KdTreeSceneManagerFactory *kdTreeFactory;
 KdTerrainSceneManagerFactory *kdTerrainFactory;
+BvHierarchySceneManagerFactory *bvHierarchyFactory;
 
 //-----------------------------------------------------------------------
@@ -51 +53 @@
 
         // Create new scene manager
-        occlusionCullingPlugin = new OcclusionCullingSceneManagerFactory(visManager);
+        occlusionCullingFactory = new OcclusionCullingSceneManagerFactory(visManager);
         kdTreeFactory = new KdTreeSceneManagerFactory(visManager);
         kdTerrainFactory = new KdTerrainSceneManagerFactory(visManager);
+        bvHierarchyFactory = new BvHierarchySceneManagerFactory(visManager);
+
         // Construct listener manager singleton
         new TerrainPageSourceListenerManager();
@@ -59 +63 @@
 
         // Register
-        Root::getSingleton().addSceneManagerFactory(occlusionCullingPlugin);
+        Root::getSingleton().addSceneManagerFactory(occlusionCullingFactory);
         Root::getSingleton().addSceneManagerFactory(kdTreeFactory);
         Root::getSingleton().addSceneManagerFactory(kdTerrainFactory);
+        Root::getSingleton().addSceneManagerFactory(bvHierarchyFactory);
 }
 //-----------------------------------------------------------------------
 extern "C" void __declspec(dllexport) dllShutdownPlugin()
 {
-        Root::getSingleton().removeSceneManagerFactory(occlusionCullingPlugin);
+        Root::getSingleton().removeSceneManagerFactory(occlusionCullingFactory);
         Root::getSingleton().removeSceneManagerFactory(kdTreeFactory);
         Root::getSingleton().removeSceneManagerFactory(kdTerrainFactory);
+        Root::getSingleton().removeSceneManagerFactory(bvHierarchyFactory);
+
         // destroy listener manager
         delete TerrainPageSourceListenerManager::getSingletonPtr();
@@ -78 +85 @@
         //delete heightmapTerrainPageSource;
         // BUG: crashes on delete!!!! FIX this 
-        delete occlusionCullingPlugin;
+        delete occlusionCullingFactory;
         delete kdTreeFactory;
         delete kdTerrainFactory;
+        delete bvHierarchyFactory;
 
         delete visManager;

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/Plugin_VisibilitySceneManager.vcproj

@@ -352 +352 @@
         <Files>
                 <Filter
-                        Name="SceneManager_Plugins"
+                        Name="OcclusionCullingSceneManager"
                         Filter="">
                         <Filter
@@ -382 +382 @@
                 </Filter>
                 <Filter
-                        Name="VisibilitySceneManager"
+                        Name="BvHierarchySceneManager"
                         Filter="">
                         <Filter
-                                Name="Header Files"
-                                Filter="h;hpp;hxx;hm;inl;inc">
-                                <File
-                                        RelativePath="..\include\OgreBoundingBoxConverter.h">
-                                </File>
-                                <File
-                                        RelativePath="..\include\OgreMeshInstance.h">
-                                </File>
-                                <File
-                                        RelativePath="..\include\OgreOcclusionQueriesQueryManager.h">
-                                </File>
-                                <File
-                                        RelativePath="..\include\OgrePlatformHierarchyInterface.h">
-                                </File>
-                                <File
-                                        RelativePath="..\include\OgrePlatformOcclusionQuery.h">
-                                </File>
-                                <File
-                                        RelativePath="..\include\OgrePlatformQueryManager.h">
-                                </File>
-                                <File
-                                        RelativePath="..\include\OgreSceneContentGenerator.h">
-                                </File>
-                                <File
-                                        RelativePath="..\include\OgreSceneNodeHierarchyInterface.h">
-                                </File>
-                                <File
-                                        RelativePath="..\include\OgreSolidBoundingBox.h">
-                                </File>
-                                <File
-                                        RelativePath="..\include\OgreSolidHalfBoundingBox.h">
-                                </File>
-                                <File
-                                        RelativePath="..\include\OgreTypeConverter.h">
-                                </File>
-                                <File
-                                        RelativePath="..\include\OgreVisibilityOptionsManager.h">
-                                </File>
-                        </Filter>
-                        <Filter
-                                Name="Source Files"
-                                Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm">
-                                <File
-                                        RelativePath="..\src\OgreBoundingBoxConverter.cpp">
-                                </File>
-                                <File
-                                        RelativePath="..\src\OgreMeshInstance.cpp">
-                                </File>
-                                <File
-                                        RelativePath="..\src\OgreOcclusionQueriesQueryManager.cpp">
-                                </File>
-                                <File
-                                        RelativePath="..\src\OgrePlatformHierarchyInterface.cpp">
-                                </File>
-                                <File
-                                        RelativePath="..\src\OgrePlatformOcclusionQuery.cpp">
-                                </File>
-                                <File
-                                        RelativePath="..\src\OgrePlatformQueryManager.cpp">
-                                </File>
-                                <File
-                                        RelativePath="..\src\OgreSceneContentGenerator.cpp">
-                                </File>
-                                <File
-                                        RelativePath="..\src\OgreSceneNodeHierarchyInterface.cpp">
-                                </File>
-                                <File
-                                        RelativePath="..\src\OgreSolidBoundingBox.cpp">
-                                </File>
-                                <File
-                                        RelativePath="..\src\OgreSolidHalfBoundingBox.cpp">
-                                </File>
-                                <File
-                                        RelativePath="..\src\OgreTypeConverter.cpp">
-                                </File>
-                                <File
-                                        RelativePath="..\src\OgreVisibilityOptionsManager.cpp">
-                                </File>
-                                <File
-                                        RelativePath="..\src\OgreVisibilitySceneManagerDll.cpp">
+                                Name="src"
+                                Filter="">
+                                <File
+                                        RelativePath=".\OgreBvHierarchy.cpp">
+                                </File>
+                                <File
+                                        RelativePath=".\OgreBvHierarchyCamera.cpp">
+                                </File>
+                                <File
+                                        RelativePath=".\OgreBvHierarchyInterface.cpp">
+                                </File>
+                                <File
+                                        RelativePath=".\OgreBvHierarchySceneManager.cpp">
+                                </File>
+                                <File
+                                        RelativePath=".\OgreBvHierarchySceneNode.cpp">
+                                </File>
+                        </Filter>
+                        <Filter
+                                Name="include"
+                                Filter="">
+                                <File
+                                        RelativePath="..\include\OgreBvHierarchy.h">
+                                </File>
+                                <File
+                                        RelativePath="..\include\OgreBvHierarchyCamera.h">
+                                </File>
+                                <File
+                                        RelativePath="..\include\OgreBvHierarchyInterface.h">
+                                </File>
+                                <File
+                                        RelativePath="..\include\OgreBvHierarchySceneManager.h">
+                                </File>
+                                <File
+                                        RelativePath="..\include\OgreBvHierarchySceneNode.h">
+                                </File>
+                                <File
+                                        RelativePath="..\include\OgreBvhRenderable.h">
                                 </File>
                         </Filter>
@@ -563 +521 @@
                                 </File>
                         </Filter>
+                </Filter>
+                <Filter
+                        Name="Header Files"
+                        Filter="h;hpp;hxx;hm;inl;inc">
+                        <File
+                                RelativePath="..\include\OgreBoundingBoxConverter.h">
+                        </File>
+                        <File
+                                RelativePath="..\include\OgreMeshInstance.h">
+                        </File>
+                        <File
+                                RelativePath="..\include\OgreOcclusionQueriesQueryManager.h">
+                        </File>
+                        <File
+                                RelativePath="..\include\OgrePlatformHierarchyInterface.h">
+                        </File>
+                        <File
+                                RelativePath="..\include\OgrePlatformOcclusionQuery.h">
+                        </File>
+                        <File
+                                RelativePath="..\include\OgrePlatformQueryManager.h">
+                        </File>
+                        <File
+                                RelativePath="..\include\OgreSceneContentGenerator.h">
+                        </File>
+                        <File
+                                RelativePath="..\include\OgreSceneNodeHierarchyInterface.h">
+                        </File>
+                        <File
+                                RelativePath="..\include\OgreSolidBoundingBox.h">
+                        </File>
+                        <File
+                                RelativePath="..\include\OgreSolidHalfBoundingBox.h">
+                        </File>
+                        <File
+                                RelativePath="..\include\OgreTypeConverter.h">
+                        </File>
+                        <File
+                                RelativePath="..\include\OgreVisibilityOptionsManager.h">
+                        </File>
+                </Filter>
+                <Filter
+                        Name="Source Files"
+                        Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm">
+                        <File
+                                RelativePath="..\src\OgreBoundingBoxConverter.cpp">
+                        </File>
+                        <File
+                                RelativePath="..\src\OgreMeshInstance.cpp">
+                        </File>
+                        <File
+                                RelativePath="..\src\OgreOcclusionQueriesQueryManager.cpp">
+                        </File>
+                        <File
+                                RelativePath="..\src\OgrePlatformHierarchyInterface.cpp">
+                        </File>
+                        <File
+                                RelativePath="..\src\OgrePlatformOcclusionQuery.cpp">
+                        </File>
+                        <File
+                                RelativePath="..\src\OgrePlatformQueryManager.cpp">
+                        </File>
+                        <File
+                                RelativePath="..\src\OgreSceneContentGenerator.cpp">
+                        </File>
+                        <File
+                                RelativePath="..\src\OgreSceneNodeHierarchyInterface.cpp">
+                        </File>
+                        <File
+                                RelativePath="..\src\OgreSolidBoundingBox.cpp">
+                        </File>
+                        <File
+                                RelativePath="..\src\OgreSolidHalfBoundingBox.cpp">
+                        </File>
+                        <File
+                                RelativePath="..\src\OgreTypeConverter.cpp">
+                        </File>
+                        <File
+                                RelativePath="..\src\OgreVisibilityOptionsManager.cpp">
+                        </File>
+                        <File
+                                RelativePath="..\src\OgreVisibilitySceneManagerDll.cpp">
+                        </File>
                 </Filter>
                 <File