Changeset 1320 for GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreBvHierarchySceneManager.cpp

Timestamp:

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

Author:

mattausch

Message:

 

File:

• GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreBvHierarchySceneManager.cpp (moved) (moved from GTP/trunk/Lib/Vis/OnlineCullingCHC/src/OgreBvHierarchySceneManager.cpp) (55 diffs)

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);
 }
 //-----------------------------------------------------------------------