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