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

Timestamp:

10/05/07 15:36:52 (17 years ago)

Author:

mattausch

Message:

added partial implementation of chc++. problem: bounding box rendering in Ogre is VERY slow

Location:

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE

Files:

• include/OgreOctreeHierarchyInterface.h (modified) (2 diffs)
• include/OgrePlatformHierarchyInterface.h (modified) (2 diffs)
• src/OgreBiHierarchySceneManager.cpp (modified) (2 diffs)
• src/OgreOcclusionCullingSceneManager.cpp (modified) (1 diff)
• src/OgreOctreeHierarchyInterface.cpp (modified) (2 diffs)
• src/OgrePlatformHierarchyInterface.cpp (modified) (2 diffs)
• src/OgrePlatformOcclusionQuery.cpp (modified) (1 diff)

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

@@ -33 +33 @@
         */
         void TraverseNode(GtpVisibility::HierarchyNode *node);
+        void TraverseNode2(GtpVisibility::HierarchyNode *node);
         /** @copydoc HierarchyInterface::RenderNode */
         void RenderNode(GtpVisibility::HierarchyNode *node);
@@ -83 +84 @@
         void RenderGeometryBounds(GtpVisibility::HierarchyNode *node);
 
+        void AddToQueue(GtpVisibility::HierarchyNode *node);
+
+        void RenderQueue();
 
 protected:

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

@@ -140 +140 @@
         int GetTestGeometryBounds();
 
-
+        virtual void AddToQueue(GtpVisibility::HierarchyNode *node) {};
+
+        virtual void RenderQueue() {};
+
+        virtual void TraverseNode2(GtpVisibility::HierarchyNode *node) {};
+        
 protected:
 
@@ -187 +192 @@
 
         bool mTestGeometryBounds;
+
+        bool mTestMode;
 };
 

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

@@ -218 +218 @@
                 {
                         mRenderMethod = rm;
-                        int cmt = GtpVisibility::VisibilityEnvironment::RANDOM_UPDATE_CULLING;
+                        int cmt = GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING_PLUSPLUS;
                         return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface)
                                 .setOption("Algorithm", &cmt);
@@ -242 +242 @@
                         else if (val == GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING)
                                 mRenderMethod = BiHierarchy::BIHRM_GTP_CHC;
-                        else if (val == GtpVisibility::VisibilityEnvironment::RANDOM_UPDATE_CULLING)
+                        else if (val == GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING_PLUSPLUS)
                                 mRenderMethod = BiHierarchy::BIHRM_GTP_RU;
                         // default, should never happen

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

@@ -323 +323 @@
                          LogManager::getSingleton().logMessage("Using stop and wait algorithm");
                  }
-                else if (val == "RUC")
+                else if (val == "CHC++")
                 {
                          algorithm = 
-                                 GtpVisibility::VisibilityEnvironment::RANDOM_UPDATE_CULLING;
-
-                         LogManager::getSingleton().logMessage("Using random update culling");
+                                 GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING_PLUSPLUS;
+
+                         LogManager::getSingleton().logMessage("Using chc ++");
                  }
                  else if (val == "VFC")

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

@@ -32 +32 @@
                 Octree *nextChild;
 
-                for (int z = 0; z < 2; ++ z)
-                {       
-                        for (int y = 0; y < 2; ++ y)
-                        {
-                                for (int x = 0; x < 2; ++ x)
-                                {
-                                        nextChild = octree->mChildren[x][y][z];
-        
-                                        if (nextChild)
-                        GetQueue()->push(nextChild);
-                                }
-            }
-        }
+                nextChild = octree->mChildren[0][0][0]; if (nextChild) GetQueue()->push(nextChild);
+                nextChild = octree->mChildren[1][0][0]; if (nextChild) GetQueue()->push(nextChild);
+                nextChild = octree->mChildren[0][1][0]; if (nextChild) GetQueue()->push(nextChild);
+                nextChild = octree->mChildren[1][1][0]; if (nextChild) GetQueue()->push(nextChild);
+                nextChild = octree->mChildren[0][0][1]; if (nextChild) GetQueue()->push(nextChild);
+                nextChild = octree->mChildren[1][0][1]; if (nextChild) GetQueue()->push(nextChild);
+                nextChild = octree->mChildren[0][1][1]; if (nextChild) GetQueue()->push(nextChild);
+                nextChild = octree->mChildren[1][1][1]; if (nextChild) GetQueue()->push(nextChild);
+        }
+}
+//-----------------------------------------------------------------------
+void OctreeHierarchyInterface::TraverseNode2(GtpVisibility::HierarchyNode *node)
+{
+        ++ mNumTraversedNodes;
+
+        Octree *octree = static_cast<Octree *>(node);
+
+        // if we come across some renderable geometry => render it
+        if (!octree->mNodes.empty())
+        {
+                AddToQueue(node);
+        }
+        
+        // if not all subtrees are empty
+        if (!IsLeaf(node))
+        {
+                Octree *nextChild;
+
+                nextChild = octree->mChildren[0][0][0]; if (nextChild) GetQueue()->push(nextChild);
+                nextChild = octree->mChildren[1][0][0]; if (nextChild) GetQueue()->push(nextChild);
+                nextChild = octree->mChildren[0][1][0]; if (nextChild) GetQueue()->push(nextChild);
+                nextChild = octree->mChildren[1][1][0]; if (nextChild) GetQueue()->push(nextChild);
+                nextChild = octree->mChildren[0][0][1]; if (nextChild) GetQueue()->push(nextChild);
+                nextChild = octree->mChildren[1][0][1]; if (nextChild) GetQueue()->push(nextChild);
+                nextChild = octree->mChildren[0][1][1]; if (nextChild) GetQueue()->push(nextChild);
+                nextChild = octree->mChildren[1][1][1]; if (nextChild) GetQueue()->push(nextChild);
         }
 }
@@ -195 +218 @@
         if (octant->lastRendered() != mFrameId)
         {
+                mTestMode = false;
+
                 octant->setLastRendered(mFrameId);
                 OctreeSceneManager *ocm = 
                         static_cast<OctreeSceneManager *>(mSceneManager);
 
-                ocm->_renderOctant(mCamera, 
+                ocm->_addOctantToQueue(mCamera, 
                                                    octant, 
                                                    mOnlyShadowCasters, 
                                                    mLeavePassesInQueue);
 
+                ocm->_renderOctant(mLeavePassesInQueue);
+
                 mVisibleNodes.push_back(node);
         }
+#endif  
+}
+//-----------------------------------------------------------------------
+void OctreeHierarchyInterface::AddToQueue(GtpVisibility::HierarchyNode *node)
+{
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
+        Octree *octant = static_cast<Octree *>(node);
+
+        if (octant->lastRendered() != mFrameId)
+        {
+                OctreeSceneManager *ocm = 
+                        static_cast<OctreeSceneManager *>(mSceneManager);
+
+                octant->setLastRendered(mFrameId);
+
+                ocm->_addOctantToQueue(mCamera, 
+                                                   octant, 
+                                                   mOnlyShadowCasters, 
+                                                   mLeavePassesInQueue);
+
+                mVisibleNodes.push_back(node);
+        }
+#endif  
+}
+//-----------------------------------------------------------------------
+void OctreeHierarchyInterface::RenderQueue()
+{
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
+        mTestMode = false;
+
+        OctreeSceneManager *ocm = 
+                        static_cast<OctreeSceneManager *>(mSceneManager);
+        ocm->_renderOctant(mLeavePassesInQueue);
 #endif  
 }

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

@@ -98 +98 @@
         
         mRenderSystem->_setWorldMatrix(Ogre::Matrix4::IDENTITY);
-        mSceneManager->useRenderableViewProjModeWrapper(solidBox);
+        //mSceneManager->useRenderableViewProjModeWrapper(solidBox);
         
         // set no depth write, no color, no lighting material
-        mSceneManager->setPassWrapper(solidBox->getTechnique()->getPass(0));
+        if (!mTestMode)
+        {
+                mTestMode = true;
+                mSceneManager->setPassWrapper(solidBox->getTechnique()->getPass(0));
+        }
+
         solidBox->SetupBoundingBoxVertices(*box);
 
@@ -147 +152 @@
         // create materials for node visualization
         CreateNodeVizMaterials();
+
+        mTestMode = false;
 }
 //-----------------------------------------------------------------------

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

@@ -29 +29 @@
                                                                                         const bool waitForResult) const
 {
-        // return mHardwareOcclusionQuery->pullOcclusionQuery(&visiblePixels, waitForResult);
-
-        bool isAvailable = true;
-
-        if (!waitForResult)
+        if (waitForResult || !mHardwareOcclusionQuery->isStillOutstanding())
         {
-                isAvailable = !mHardwareOcclusionQuery->isStillOutstanding();
+                //return mHardwareOcclusionQuery->pullOcclusionQuery(&visiblePixels);
+                mHardwareOcclusionQuery->pullOcclusionQuery(&visiblePixels);
+                return true;
         }
 
-//std::stringstream d; d << mHardwareOcclusionQuery << ", available: " << isAvailable << ", waitforresult: " << waitForResult;
-//              Ogre::LogManager::getSingleton().logMessage(d.str());
-
-        if (isAvailable)
-                return mHardwareOcclusionQuery->pullOcclusionQuery(&visiblePixels);
-        
         return false;
 }