Changeset 86 for trunk/VUT/GtpVisibility

Timestamp:

05/06/05 01:39:32 (20 years ago)

Author:

mattausch

Message:

 

Location:

trunk/VUT/GtpVisibility

Files:

• include/HierarchyInterface.h (modified) (2 diffs)
• include/OcclusionQuery.h (modified) (1 diff)
• src/CoherentHierarchicalCullingManager.cpp (modified) (4 diffs)
• src/FrustumCullingManager.cpp (modified) (1 diff)
• src/HierarchyInterface.cpp (modified) (2 diffs)
• src/StopAndWaitCullingManager.cpp (modified) (2 diffs)

trunk/VUT/GtpVisibility/include/HierarchyInterface.h

@@ -36 +36 @@
                 @returns occlusion query for this node
         */
-        virtual OcclusionQuery *IssueOcclusionQuery(HierarchyNode *node) = 0;
+        virtual OcclusionQuery *IssueOcclusionQuery(HierarchyNode *node, 
+                const bool wasVisible = false) = 0;
         /** Sets the root of the scene hierarchy.
                 @param root the hierarchy root
@@ -105 +106 @@
         */
         unsigned int GetNumRenderedNodes();
+        /** Optimization when issuing occlusion test: test is done with actual geometry 
+                rather than the bounding box
+                @param useOptimization if the optimization should be used
+        */
+        void SetUseOptimization(bool useOptimization);
 
 protected:
         
+        bool mUseOptimization;
         unsigned int mFrameId;
 

trunk/VUT/GtpVisibility/include/OcclusionQuery.h

@@ -9 +9 @@
 {
 public:
-//      OcclusionQuery();
         virtual ~OcclusionQuery() {};
         /** Returns the result of an occlusion query in terms of visible pixels.
-                @returns number of visible pixels
+                @param queryResult the number of visible pixels if the result was available
+                @param waitForResult if we should wait for the result until available
+                @returns if the result was already available
         */
-        virtual unsigned int GetQueryResult() const = 0;
-        /** Returns true if the result of the query is available, false otherwise.
-                @returns if result is available
-        */
-        virtual bool ResultAvailable() const = 0;
+        virtual bool GetQueryResult(unsigned int &queryResult, 
+                const bool waitForResult) const = 0;
         /** Begins occlusion query.
                 @remark the query counts the number of visible pixels between it's begin and end

trunk/VUT/GtpVisibility/src/CoherentHierarchicalCullingManager.cpp

@@ -1 +1 @@
 #include "CoherentHierarchicalCullingManager.h"
-//#include <windows.h>
+#include <windows.h>
 
 namespace GtpVisibility {
@@ -8 +8 @@
 {
         mNumFrustumCulledNodes = mNumQueryCulledNodes = 0;
-        //OutputDebugString("Coherent Culling\n");
+//      OutputDebugString("Coherent Culling\n");
 
         QueryQueue queryQueue;
-        
+        unsigned int visiblePixels = 0;
+        bool isAvailable = false;
+
         //-- PART 1: process finished occlusion queries
         while (!mHierarchyInterface->GetQueue()->empty() || !queryQueue.empty())
         {
                 while (!queryQueue.empty() && 
-                           (queryQueue.front().second->ResultAvailable() || mHierarchyInterface->GetQueue()->empty()))
+                           queryQueue.front().second->GetQueryResult(visiblePixels, 
+                                                                        mHierarchyInterface->GetQueue()->empty()))
                 {
                         HierarchyNode *node = queryQueue.front().first;
-                                        
-                        // wait until result available
-                        unsigned int visiblePixels = queryQueue.front().second->GetQueryResult();
-                        
+                                                
                         queryQueue.pop();
 
@@ -67 +67 @@
                                 
                                 // identify nodes that we cannot skip queries for
-                                bool mustQuery = !wasVisible || mHierarchyInterface->HasGeometry(node) || mHierarchyInterface->IsLeaf(node);
+                                bool mustQuery = !wasVisible || mHierarchyInterface->HasGeometry(node) || 
+                                        mHierarchyInterface->IsLeaf(node);
 
                                 // reset node's visibility classification 
@@ -78 +79 @@
                                 if (mustQuery)
                                 {
-                                        queryQueue.push(QueryPair(node, mHierarchyInterface->IssueOcclusionQuery(node)));
+                                        queryQueue.push(QueryPair(node, 
+                                                mHierarchyInterface->IssueOcclusionQuery(node, wasVisible)));
                                 }
                                         

trunk/VUT/GtpVisibility/src/FrustumCullingManager.cpp

@@ -1 +1 @@
 #include "FrustumCullingManager.h"
-//#include <windows.h>
+#include <windows.h>
 
 namespace GtpVisibility {

trunk/VUT/GtpVisibility/src/HierarchyInterface.cpp

@@ -8 +8 @@
 HierarchyInterface::HierarchyInterface(): 
 mFrameId(0), mNumTraversedNodes(0), mNumRenderedNodes(0), 
-mSceneRoot(0), mPreviousNode(0), mCurrentTestIdx(0)
+mSceneRoot(0), mPreviousNode(0), mCurrentTestIdx(0), mUseOptimization(true)
 {       
         mDistanceQueue = new DistanceQueue(GreaterDistance<HierarchyNode *>(this));
@@ -64 +64 @@
         return mNumRenderedNodes;
 }
+
+void HierarchyInterface::SetUseOptimization(bool useOptimization)
+{
+        mUseOptimization = useOptimization;
+}
+
 } // namespace GtpVisibility

trunk/VUT/GtpVisibility/src/StopAndWaitCullingManager.cpp

@@ -1 +1 @@
 #include "StopAndWaitCullingManager.h"
-//#include <windows.h>
+#include <windows.h>
 
 namespace GtpVisibility {
@@ -35 +35 @@
                         }
 
+                        unsigned int visiblePixels = 0;
+
+                        mHierarchyInterface->IssueOcclusionQuery(node)->GetQueryResult(visiblePixels, true);
+
                         // node visible
-                        if (mHierarchyInterface->IssueOcclusionQuery(node)->GetQueryResult() > 
-                                mVisibilityThreshold)
+                        if (visiblePixels > mVisibilityThreshold)
                         {
                                 mHierarchyInterface->TraverseNode(node);