Changeset 2258 for GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src

Timestamp:

03/18/07 00:26:49 (18 years ago)

Author:

mattausch

Message:

 

Location:

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src

Files:

• OgreBvHierarchyInterface.cpp (modified) (2 diffs)
• OgreOcclusionCullingSceneManager.cpp (modified) (7 diffs)
• OgreOctreeHierarchyInterface.cpp (modified) (5 diffs)

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

@@ -49 +49 @@
 }
 
+
 void BvHierarchyInterface::RenderNode(GtpVisibility::HierarchyNode *node)
 {
@@ -62 +63 @@
         }
 }
+
 
 void BvHierarchyInterface::PullUpVisibility(GtpVisibility::HierarchyNode *node) const

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

@@ -12 +12 @@
 #include <OgreIteratorWrappers.h>
 #include <OgreHeightmapTerrainPageSource.h>
-#include "VspBspTree.h"
-#include "Containers.h"
+//#include "Containers.h"
 #include "ViewCellsManager.h"
 #include <OgreConfigFile.h>
 #include "OgreTypeConverter.h"
 #include "OgreMeshInstance.h"
-#include "common.h"
+//#include "common.h"
 #include "OgreBoundingBoxConverter.h"
 #include <OgreManualObject.h>
@@ -775 +774 @@
                                                                                                                 bool onlyShadowCasters)
 {
-        // clear render queue
-        // fully reset it after some frames
-        const bool flushQueue = 
-                mDeleteQueueAfterRendering && ((mCurrentFrame % mFlushRate) == 0);
-        getRenderQueue()->clear(flushQueue);
-
-        ++ mCurrentFrame;
-
         if (mShowVisualization)
     {
@@ -790 +781 @@
                 PrepareVisualization(cam);
                 
-                        // lists only used for visualization
+                // lists only used for visualization
                 mVisible.clear();
                 mBoxes.clear();
@@ -797 +788 @@
         }
         
-
-        mVisible.clear();
-        mBoxes.clear();
-
         ///////////
         //-- set visibility according to pvs of current view cell
@@ -820 +807 @@
         else if (mUseDepthPass)
         {
+                mVisible.clear();
+                mBoxes.clear();
+
+                // clear render queue before depth pass
+                getRenderQueue()->clear();
+
                 // render scene once in order to fill depth buffer
                 RenderHierarchicalCulling();
         }
-        
-        // only shadow casters will be rendered in shadow texture pass
-        //if (0) mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
 }
 //-----------------------------------------------------------------------
@@ -838 +828 @@
         }
 
-        //const bool flushQueue = mDeleteQueueAfterRendering && ((mCurrentFrame % mFlushRate) == 0);
-        //++ mCurrentFrame;
+        // clear render queue
+        // fully reset it after some frames
+        const bool flushQueue = 
+                mDeleteQueueAfterRendering && ((mCurrentFrame % mFlushRate) == 0);
+        
+        ++ mCurrentFrame;
 
         // create material for item buffer pass
@@ -956 +950 @@
 
         // remove rest from queue
-#if 0
         getRenderQueue()->clear(flushQueue);
-#endif
+
         
         if (0) WriteLog(); // write out stats

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

@@ -9 +9 @@
 
 //-----------------------------------------------------------------------
-OctreeHierarchyInterface::OctreeHierarchyInterface(OctreeSceneManager *sm, RenderSystem *rsys): 
+OctreeHierarchyInterface::OctreeHierarchyInterface(OctreeSceneManager *sm, 
+                                                                                                   RenderSystem *rsys): 
 SceneNodeHierarchyInterface(sm, rsys)
-{
-}
+{}
 //-----------------------------------------------------------------------
 void OctreeHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node)
@@ -27 +27 @@
         
         
+        // if not all subtrees are empty
+        if (!IsLeaf(node))
+        {
+                Octree *nextChild;
+
+                if ((nextChild = octree->mChildren[0][0][0]) != NULL)
+                        mDistanceQueue->push(nextChild);
+                if ((nextChild = octree->mChildren[0][0][1]) != NULL)
+                        mDistanceQueue->push(nextChild);
+                if ((nextChild = octree->mChildren[0][1][0]) != NULL)
+                        mDistanceQueue->push(nextChild);
+                if ((nextChild = octree->mChildren[0][1][1]) != NULL)
+                mDistanceQueue->push(nextChild);
+                if ((nextChild = octree->mChildren[1][0][0]) != NULL)
+                        mDistanceQueue->push(nextChild);
+                if ((nextChild = octree->mChildren[1][0][1]) != NULL)
+                        mDistanceQueue->push(nextChild);
+                if ((nextChild = octree->mChildren[1][1][0]) != NULL)
+                        mDistanceQueue->push(nextChild);
+                if ((nextChild = octree->mChildren[1][1][1]) != NULL)
+                        mDistanceQueue->push(nextChild);
+        }
+}
+//-----------------------------------------------------------------------
+HierarchyNode *OctreeHierarchyInterface::GetRandomLeaf() 
+{ 
+        return NULL;
+}
+//-----------------------------------------------------------------------
+bool OctreeHierarchyInterface::GIsNodeFullyVisible(GtpVisibility::HierarchyNode *node) const
+{
+        return static_cast<Octree *>(node)->isOctreeFullyVisible();
+}
+//-----------------------------------------------------------------------
+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())
+        {
+                // render everything from here
+                if (octree->isOctreeFullyVisible())
+                {               
+                        RenderNodeRecursive(node);
+                        return;
+                }
+
+                RenderNode(node);
+        }
+                
         // if not all subtrees are empty
         if (!IsLeaf(node))
@@ -107 +160 @@
 }
 //-----------------------------------------------------------------------
+void OctreeHierarchyInterface::DetermineFullVisibility(GtpVisibility::HierarchyNode *node) const
+{               
+        Octree *octant = static_cast<Octree *>(node);
+
+        // leaf node: terminate recursion
+        if (IsLeaf(node))
+        {
+                octant->setOctreeFullyVisible(octant->isOctreeVisible());
+                return;
+        }
+
+        octant->setOctreeFullyVisible(false);
+
+        Octree *nextChild;
+
+        for (int i = 0; i < 8; ++ i)
+        {
+                int x = i & 4;
+                int y = i & 2;
+                int z = i & 1;
+
+                if ((nextChild = octant->mChildren[x][y][z]) != NULL)
+                {
+                        DetermineFullVisibility(nextChild);
+                        if (!nextChild->isOctreeFullyVisible())
+                        return;
+                }
+        }
+
+        // all children fully visible => pull up
+        octant->setOctreeFullyVisible(true);
+}
+//-----------------------------------------------------------------------
 void OctreeHierarchyInterface::RenderNode(GtpVisibility::HierarchyNode *node)
 {
@@ -118 +204 @@
                         static_cast<OctreeSceneManager *>(mSceneManager);
 
-                ocm->_renderOctant(mCamera, octant, mOnlyShadowCasters, mLeavePassesInQueue);
+                ocm->_renderOctant(mCamera, 
+                                                   octant, 
+                                                   mOnlyShadowCasters, 
+                                                   mLeavePassesInQueue);
 
                 mVisibleNodes.push_back(node);
         }
-#endif
-        
+#endif  
 }
 //-----------------------------------------------------------------------
@@ -189 +277 @@
 }
 
+
 } // namespace Ogre