Changeset 2332 for GTP/trunk/Lib/Vis/OnlineCullingCHC/src

Timestamp:

04/23/07 16:19:30 (18 years ago)

Author:

mattausch

Message:

implemented part of rendering estimation of wimmer et al. for view space / object space subdivision.
warning: not working with undersampling estimation + local visibility based subdivision.

Location:

GTP/trunk/Lib/Vis/OnlineCullingCHC/src

Files:

• CoherentHierarchicalCullingManager.cpp (modified) (8 diffs)
• RandomUpdateCullingManager.cpp (modified) (2 diffs)

GTP/trunk/Lib/Vis/OnlineCullingCHC/src/CoherentHierarchicalCullingManager.cpp

@@ -33 +33 @@
         while (!mHierarchyInterface->GetQueue()->empty() || !queryQueue.empty())
         {
-                bool resultAvailable = false;
-
+                //////////
                 //-- only wait for result if there are no nodes to process
                 while (!queryQueue.empty() && 
-                                queryQueue.front().second->GetQueryResult(visiblePixels, 
-                                mHierarchyInterface->GetQueue()->empty()))
+                           (NodeInvalid(queryQueue.front().first) ||
+                            queryQueue.front().second->GetQueryResult(
+                                             visiblePixels, mHierarchyInterface->GetQueue()->empty())))
                 {
                         HierarchyNode *node = queryQueue.front().first;
-                        
                         queryQueue.pop();
-                        
+
+                        // parent was tested invisible => remove children from queue
+                        if (NodeInvalid(node))
+                        {
+                                //CullingLogManager::GetSingleton()->LogMessage("skipping this node");
+                                continue;
+                        }
+                        // tested visible
                         if (visiblePixels > mVisibilityThreshold)
                         {
-                                // in case geometry is in omterior node: ensure that we only traverse once
+                                // in case geometry is in interior node: ensure that we only traverse once
                                 if (!mHierarchyInterface->IsNodeVisible(node))
                                 {
@@ -58 +64 @@
                                 mHierarchyInterface->SetNodeVisible(node, false);
 
-                                ++ mNumQueryCulledNodes;
+                ++ mNumQueryCulledNodes;
                                 
                                 if (mVisualizeCulledNodes)
@@ -65 +71 @@
                                 }
                         }
+                        
+                        // update node's visited flag
+                        mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());   
                 }
                 
@@ -73 +82 @@
                         mHierarchyInterface->GetQueue()->pop();
                                 
+                        // parent was tested invisible => remove children from queue
+                        if (NodeInvalid(node))
+                        {
+                                //CullingLogManager::GetSingleton()->LogMessage("skipping this node");
+                                continue;
+                        }
+
                         bool intersects = false;
 
@@ -96 +112 @@
                                 
                                 // if we assume node to be visible in this frame => skip query 
-                                bool skipQuery = wasVisible && (mAssumedVisibility > 0) && 
-                                        DecideVisible(node) && mHierarchyInterface->HasGeometry(node);
+                                const bool skipQuery = wasVisible && 
+                                                           (mAssumedVisibility > 0) && 
+                                                                           DecideVisible(node) && 
+                                                                           mHierarchyInterface->HasGeometry(node);
 
                                 if (skipQuery)
@@ -113 +131 @@
                                 mHierarchyInterface->SetNodeVisible(node, wasVisible && issueQuery);
 
-                                // update node's visited flag
-                                mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());
-                                
                                 // skip testing previously visible nodes without geometry
                                 if (issueQuery)
@@ -124 +139 @@
                                                 IssueNodeOcclusionQuery(node, wasVisible)));
                                 }
-                                
+                                else
+                                {
+                                        // update node's visited flag
+                                        mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());
+                                }
+
                                 // always traverse a node if it was visible
                                 if (wasVisible)
@@ -164 +184 @@
         mHierarchyInterface->TraverseNode(node);
 }
-
+//-----------------------------------------------------------------------
+bool CoherentHierarchicalCullingManager::NodeInvalid(HierarchyNode *node) const
+{
+        // parent was tested invisible in this frame
+        HierarchyNode *parent = mHierarchyInterface->GetParent(node);
+    return 
+                parent && 
+                (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId()) && 
+                !mHierarchyInterface->IsNodeVisible(parent);
+}
 } // namespace GtpVisibility

GTP/trunk/Lib/Vis/OnlineCullingCHC/src/RandomUpdateCullingManager.cpp

@@ -105 +105 @@
                         else
                         {
-                                // identify previously visible nodes
-                                const bool wasVisible = mHierarchyInterface->IsNodeVisible(node) && 
-                                        (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId() - 1);
-                                
-                                // if we assume node to be visible in this frame => skip query 
-                                const bool skipQuery = wasVisible && (mAssumedVisibility > 0) && 
-                                        DecideVisible(node) && mHierarchyInterface->HasGeometry(node);
-
-                                if (skipQuery)
-                                {
-                                        SkipQuery(node);
-                                        continue;
-                                }
-                                                                
+                                
                                 if (mHierarchyInterface->IsNodeFullyVisible(node))
                                 {
@@ -162 +149 @@
                                 }
 
+                                // identify previously visible nodes
+                                const bool wasVisible = mHierarchyInterface->IsNodeVisible(node) && 
+                                        (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId() - 1);
+                                        
+
+                                // if we assume node to be visible in this frame => skip query 
+                                const bool skipQuery = wasVisible && (mAssumedVisibility > 0) && 
+                                        DecideVisible(node) && mHierarchyInterface->HasGeometry(node);
+
+                                if (skipQuery)
+                                {
+                                        SkipQuery(node);
+                                        continue;
+                                }
+                                                        
                 // identify nodes that we cannot skip queries for
                                 // geometry not only in leaves => test for renderable geometry