source: GTP/trunk/Lib/Vis/OnlineCullingCHC/src/CoherentHierarchicalCullingManager.cpp @ 938

Revision 938, 5.4 KB checked in by mattausch, 19 years ago (diff)
Line 
1#include "CoherentHierarchicalCullingManager.h"
2#include <OgreLogManager.h>
3
4namespace GtpVisibility {
5
6//-----------------------------------------------------------------------
7CoherentHierarchicalCullingManager::CoherentHierarchicalCullingManager()
8{
9        SetAssumedVisibility(0);
10        // initialise random generator in case we use assumed visibility
11        srand(time(NULL));
12}
13//-----------------------------------------------------------------------
14CoherentHierarchicalCullingManager::CoherentHierarchicalCullingManager(const unsigned int
15                                                                                                                                           assumedVisibility)
16{
17        SetAssumedVisibility(assumedVisibility);
18        // initialise random generator in case we use assumed visibility
19        srand(time(NULL));
20}
21//-----------------------------------------------------------------------
22void CoherentHierarchicalCullingManager::RenderScene()
23{
24        QueryQueue queryQueue;
25        unsigned int visiblePixels = 0;
26       
27        //Ogre::LogManager::getSingleton().logMessage("chc");
28        //-- PART 1: process finished occlusion queries
29        while (!mHierarchyInterface->GetQueue()->empty() || !queryQueue.empty())
30        {
31                //if (mHierarchyInterface->GetQueue()->empty())
32                //      Ogre::LogManager::getSingleton().logMessage("distance queue empty!!");
33
34                // only wait for result if there are no nodes to process
35                while (!queryQueue.empty() &&
36                           queryQueue.front().second->GetQueryResult(visiblePixels,
37                                                                        mHierarchyInterface->GetQueue()->empty()))
38                {
39                HierarchyNode *node = queryQueue.front().first;
40                       
41                        queryQueue.pop();
42
43                        if (visiblePixels > mVisibilityThreshold)
44                        {
45                                // in case geometry is in omterior node: ensure that we only traverse once
46                                if (!mHierarchyInterface->IsNodeVisible(node))
47                                {
48                                        mHierarchyInterface->TraverseNode(node);
49                                }
50
51                                mHierarchyInterface->PullUpVisibility(node);
52                        }
53                        else
54                        {       
55                                mHierarchyInterface->SetNodeVisible(node, false);
56
57                                ++ mNumQueryCulledNodes;
58                               
59                                if (mVisualizeCulledNodes)
60                                {
61                                        mHierarchyInterface->VisualizeCulledNode(node, QUERY_CULLED);
62                                }
63                        }
64                }
65               
66                //-- PART 2: hierarchical traversal
67                if (!mHierarchyInterface->GetQueue()->empty())
68                {
69                        //Ogre::LogManager::getSingleton().logMessage("traversal");
70                        HierarchyNode *node = mHierarchyInterface->GetQueue()->top();
71                        mHierarchyInterface->GetQueue()->pop();
72                               
73                        bool intersects = false;
74
75                        if (!mHierarchyInterface->CheckFrustumVisible(node, intersects))
76                        {
77                                ++ mNumFrustumCulledNodes;
78                               
79                                if (mVisualizeCulledNodes)
80                                {
81                                        mHierarchyInterface->VisualizeCulledNode(node, FRUSTUM_CULLED);
82                                }
83                        }
84                        // -- if node intersects near plane, skip query because wrong results possible
85                        else if (intersects)
86                        {
87                                SkipQuery(node);
88                        }
89                        else
90                        {
91                                // identify previously visible nodes
92                                bool wasVisible = mHierarchyInterface->IsNodeVisible(node) &&
93                                        (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId() - 1);
94                               
95                                // if we assume node to be visible in this frame => skip query
96                                bool skipQuery = wasVisible && (mAssumedVisibility > 0) &&
97                                        DecideVisible(node) && mHierarchyInterface->HasGeometry(node);
98
99                                //if (mHierarchyInterface->LastVisited(node) >= mHierarchyInterface->GetFrameId())
100                                //      Ogre::LogManager::getSingleton().logMessage("error");
101                               
102                                if (skipQuery)
103                                {
104                                        SkipQuery(node);
105                                        continue;
106                                }
107
108                // identify nodes that we cannot skip queries for
109                                // geometry not only in leaves => test for renderable geometry
110                                bool issueQuery = !wasVisible || mHierarchyInterface->HasGeometry(node);
111                                                       
112                                // reset node's visibility classification
113                                // set visibe if geometry in node so we only traverse once
114                                mHierarchyInterface->SetNodeVisible(node, wasVisible && issueQuery);
115
116                                // update node's visited flag
117                                mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());
118
119                                // skip testing previously visible nodes without geometry
120                                if (issueQuery)
121                                {
122                                        ++ mNumQueriesIssued;
123                                       
124                                        queryQueue.push(QueryPair(node, mHierarchyInterface->
125                                                IssueNodeOcclusionQuery(node, wasVisible)));
126                                }
127                               
128                                // always traverse a node if it was visible
129                                if (wasVisible)
130                                {
131                                        mHierarchyInterface->TraverseNode(node);
132                                }
133                        }
134                }
135        }
136}
137//-----------------------------------------------------------------------
138void CoherentHierarchicalCullingManager::SetAssumedVisibility(const unsigned int assumedVisibility)
139{
140        mAssumedVisibility = assumedVisibility;
141       
142        mThreshold = 0;
143
144        if (mAssumedVisibility > 0)
145        {
146                mThreshold = RAND_MAX - RAND_MAX / mAssumedVisibility;
147                if (mAssumedVisibility > 100) // fix visibility
148                        mThreshold = RAND_MAX;
149        }
150        //std::stringstream d; d << "*** setting assumed vis: " << mAssumedVisibility; Ogre::LogManager::getSingleton().logMessage(d.str());
151}
152//-----------------------------------------------------------------------
153inline bool CoherentHierarchicalCullingManager::DecideVisible(HierarchyNode *node) const
154{
155        //bool result = rand() < mThreshold; std::stringstream d; d << "Assumed vis: " << mAssumedVisibility << ", result: " << result;
156        //Ogre::LogManager::getSingleton().logMessage(d.str()); return result;
157       
158        return rand() < mThreshold;
159}
160//-----------------------------------------------------------------------
161inline void CoherentHierarchicalCullingManager::SkipQuery(HierarchyNode *node) const
162{
163        // -- set node to be visible in this frame, then traverse it
164        mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());
165       
166        mHierarchyInterface->PullUpVisibility(node);                   
167        mHierarchyInterface->TraverseNode(node);
168}
169
170} // namespace GtpVisibility
Note: See TracBrowser for help on using the repository browser.