source: trunk/VUT/GtpVisibility/src/CoherentHierarchicalCullingManager.cpp @ 346

Revision 346, 5.0 KB checked in by mattausch, 19 years ago (diff)

updated terrain removed debug messages from chc
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        bool isAvailable = false;
27        //Ogre::LogManager::getSingleton().logMessage("Coherent Hierarchical Culling");
28
29        //-- PART 1: process finished occlusion queries
30        while (!mHierarchyInterface->GetQueue()->empty() || !queryQueue.empty())
31        {
32                while (!queryQueue.empty() &&
33                           queryQueue.front().second->GetQueryResult(visiblePixels,
34                                                                        mHierarchyInterface->GetQueue()->empty()))
35                {
36                HierarchyNode *node = queryQueue.front().first;
37                       
38                        queryQueue.pop();
39
40                        if (visiblePixels > mVisibilityThreshold)
41                        {
42                                mHierarchyInterface->PullUpVisibility(node);
43                                mHierarchyInterface->TraverseNode(node);
44                        }
45                        else
46                        {       
47                                ++ mNumQueryCulledNodes;
48                               
49                                if(mVisualizeCulledNodes)
50                                {
51                                        mHierarchyInterface->VisualizeCulledNode(node, QUERY_CULLED);
52                                }
53                        }
54                }
55               
56                //-- PART 2: hierarchical traversal
57                if (!mHierarchyInterface->GetQueue()->empty())
58                {
59                        HierarchyNode *node = mHierarchyInterface->GetQueue()->top();
60                        mHierarchyInterface->GetQueue()->pop();
61                               
62                        bool intersects = false;
63
64                        if (!mHierarchyInterface->CheckFrustumVisible(node, intersects))
65                        {
66                                ++ mNumFrustumCulledNodes;
67                               
68                                if (mVisualizeCulledNodes)
69                                {
70                                        mHierarchyInterface->VisualizeCulledNode(node, FRUSTUM_CULLED);
71                                }
72                        }
73                        // -- if node intersects near plane, skip query because wrong results possible
74                        else if (intersects)
75                        {
76                                SkipQuery(node);
77                        }
78                        else
79                        {
80                                // identify previously visible nodes
81                                bool wasVisible = mHierarchyInterface->IsNodeVisible(node) &&
82                                        (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId() - 1);
83                               
84                                // if we assume node to be visible in this frame => skip query
85                                // TODO: check this (not the expected speed up)
86                                if (wasVisible && (mAssumedVisibility > 0) &&  DecideVisible(node) && mHierarchyInterface->HasGeometry(node))
87                                {
88                                        SkipQuery(node);
89
90                                        continue;
91                                }
92
93                // identify nodes that we cannot skip queries for
94                                // geometry not only in leaves => test for renderable geometry
95                                // we also need to test if node was processed in current frame, otherwise
96                                // node is tested several times because of priority queue
97                                bool issueQuery = (mHierarchyInterface->LastVisited(node) != mHierarchyInterface->GetFrameId())
98                                                && (!wasVisible || mHierarchyInterface->HasGeometry(node));
99                                                       
100                                // reset node's visibility classification
101                                mHierarchyInterface->SetNodeVisible(node, false);
102
103                                // update node's visited flag
104                                mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());
105
106                                // skip testing previously visible nodes without geometry
107                                if (issueQuery)
108                                {
109                                        ++ mNumQueriesIssued;
110                                       
111                                        queryQueue.push(QueryPair(node, mHierarchyInterface->
112                                                IssueNodeOcclusionQuery(node, wasVisible)));
113                                }
114                               
115                                // always traverse a node if it was visible
116                                if (wasVisible)
117                                {
118                                        mHierarchyInterface->TraverseNode(node);
119                                }
120                        }
121                }
122        }
123}
124//-----------------------------------------------------------------------
125void CoherentHierarchicalCullingManager::SetAssumedVisibility(const unsigned int assumedVisibility)
126{
127        mAssumedVisibility = assumedVisibility;
128       
129        mThreshold = 0;
130
131        if (mAssumedVisibility > 0)
132        {
133                mThreshold =  RAND_MAX - RAND_MAX / mAssumedVisibility;
134        }
135        //std::stringstream d; d << "*** setting assumed vis: " << mAssumedVisibility; Ogre::LogManager::getSingleton().logMessage(d.str());
136}
137//-----------------------------------------------------------------------
138inline bool CoherentHierarchicalCullingManager::DecideVisible(HierarchyNode *node) const
139{
140        //bool result = rand() < mThreshold; std::stringstream d; d << "Assumed vis: " << mAssumedVisibility << ", result: " << result;
141        //Ogre::LogManager::getSingleton().logMessage(d.str()); return result;
142       
143        return rand() < mThreshold;
144}
145//-----------------------------------------------------------------------
146inline void CoherentHierarchicalCullingManager::SkipQuery(HierarchyNode *node) const
147{
148        // -- set node to be visible in this frame, then traverse it
149        mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());
150       
151        mHierarchyInterface->PullUpVisibility(node);                   
152        mHierarchyInterface->TraverseNode(node);
153}
154
155} // namespace GtpVisibility
Note: See TracBrowser for help on using the repository browser.