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

Revision 147, 4.1 KB checked in by mattausch, 19 years ago (diff)

fixed average fps + shadow maps
Line 
1#include "CoherentHierarchicalCullingManager.h"
2#include <OgreLogManager.h>
3
4namespace GtpVisibility {
5
6//-----------------------------------------------------------------------
7CoherentHierarchicalCullingManager:: CoherentHierarchicalCullingManager():
8mAssumedVisibility(0), mThreshold(0)
9{
10        // initialise random generator because of assumed visibility
11        srand(time(NULL));
12}
13//-----------------------------------------------------------------------
14void CoherentHierarchicalCullingManager::RenderScene()
15{
16        QueryQueue queryQueue;
17        unsigned int visiblePixels = 0;
18        bool isAvailable = false;
19       
20        //-- PART 1: process finished occlusion queries
21        while (!mHierarchyInterface->GetQueue()->empty() || !queryQueue.empty())
22        {
23                while (!queryQueue.empty() &&
24                           queryQueue.front().second->GetQueryResult(visiblePixels,
25                                                                        mHierarchyInterface->GetQueue()->empty()))
26                {
27                HierarchyNode *node = queryQueue.front().first;
28                       
29                        queryQueue.pop();
30
31                        if (visiblePixels > mVisibilityThreshold)
32                        {
33                                mHierarchyInterface->PullUpVisibility(node);
34                                mHierarchyInterface->TraverseNode(node);
35                        }
36                        else
37                        {       
38                                mNumQueryCulledNodes ++;
39                               
40                                if(mVisualizeCulledNodes)
41                                {
42                                        mHierarchyInterface->VisualizeCulledNode(node, QUERY_CULLED);
43                                }
44                        }
45                }
46               
47                //-- PART 2: hierarchical traversal
48                if (!mHierarchyInterface->GetQueue()->empty())
49                {
50                        HierarchyNode *node = mHierarchyInterface->GetQueue()->top();
51                        mHierarchyInterface->GetQueue()->pop();
52                               
53                        bool intersects = false;
54
55                        if (!mHierarchyInterface->CheckFrustumVisible(node, intersects))
56                        {
57                                ++ mNumFrustumCulledNodes;
58                               
59                                if (mVisualizeCulledNodes)
60                                {
61                                        mHierarchyInterface->VisualizeCulledNode(node, FRUSTUM_CULLED);
62                                }
63                        }
64                        else
65                        {
66                                // if intersects near plane => skip occlusion query because wrong results possible
67                                if (intersects)
68                                {
69                                        // update octant's visited flag
70                                        mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());
71
72                                        mHierarchyInterface->PullUpVisibility(node);                   
73                                        mHierarchyInterface->TraverseNode(node);
74
75                                        continue;
76                                }
77
78                                // identify previously visible nodes
79                                bool wasVisible = mHierarchyInterface->IsNodeVisible(node) &&
80                                        (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId() - 1);
81                                // if visibility is assumed to be true in this frame
82                                bool assumeVisible = wasVisible && (mAssumedVisibility > 0) && DecideVisible(node);
83
84                                // identify nodes that we cannot skip queries for
85                                // geometry not only in leaves => test for renderable geometry
86                                bool issueQuery = !wasVisible ||
87                                        (mHierarchyInterface->HasGeometry(node) && !assumeVisible);
88                                                               
89                                // reset node's visibility classification
90                                mHierarchyInterface->SetNodeVisible(node, !issueQuery && assumeVisible);
91
92                                // update node's visited flag
93                                mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());
94                       
95                                // skip testing previously visible nodes without geometry
96                                if (issueQuery)
97                                {
98                                        ++ mNumQueriesIssued;
99                                       
100                                        queryQueue.push(QueryPair(node, mHierarchyInterface->
101                                                IssueOcclusionQuery(node, wasVisible)));
102                                }
103                               
104                                // always traverse a node if it was visible
105                                if (wasVisible)
106                                {
107                                        mHierarchyInterface->TraverseNode(node);
108                                }
109                        }
110                }
111        }
112}
113//-----------------------------------------------------------------------
114void CoherentHierarchicalCullingManager::SetAssumedVisibility(unsigned int assumedVisibility)
115{
116        mAssumedVisibility = assumedVisibility;
117       
118        mThreshold = 0;
119
120        if (mAssumedVisibility > 0)
121        {
122                mThreshold =  RAND_MAX - RAND_MAX / mAssumedVisibility;
123        }
124        //std::stringstream d; d << "*** setting assumed vis: " << mAssumedVisibility; Ogre::LogManager::getSingleton().logMessage(d.str());
125}
126//-----------------------------------------------------------------------
127bool CoherentHierarchicalCullingManager::DecideVisible(HierarchyNode *node) const
128{
129        /*bool result = rand() < mThreshold;
130        std::stringstream d; d << "Assumed vis: " << mAssumedVisibility << ", result: " << result;
131        Ogre::LogManager::getSingleton().logMessage(d.str()); return result;*/
132       
133        return rand() < mThreshold;
134}
135} // namespace GtpVisibility
Note: See TracBrowser for help on using the repository browser.