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

#include "CoherentHierarchicalCullingManager.h"
#include <OgreLogManager.h>

namespace GtpVisibility {

//-----------------------------------------------------------------------
CoherentHierarchicalCullingManager::CoherentHierarchicalCullingManager()
{
        SetAssumedVisibility(0);
        // initialise random generator in case we use assumed visibility
        srand(time(NULL));
}
//-----------------------------------------------------------------------
CoherentHierarchicalCullingManager::CoherentHierarchicalCullingManager(const unsigned int 
                                                                                                                                           assumedVisibility)
{
        SetAssumedVisibility(assumedVisibility);
        // initialise random generator in case we use assumed visibility
        srand(time(NULL));
}
//-----------------------------------------------------------------------
void CoherentHierarchicalCullingManager::RenderScene()
{
        QueryQueue queryQueue;
        unsigned int visiblePixels = 0;
        
        //Ogre::LogManager::getSingleton().logMessage("chc");
        //-- PART 1: process finished occlusion queries
        while (!mHierarchyInterface->GetQueue()->empty() || !queryQueue.empty())
        {
                //if (mHierarchyInterface->GetQueue()->empty())
                //      Ogre::LogManager::getSingleton().logMessage("distance queue empty!!");
                bool resultAvailable = false;

                //-- only wait for result if there are no nodes to process
                while (!queryQueue.empty() && 
                                queryQueue.front().second->GetQueryResult(visiblePixels, 
                                mHierarchyInterface->GetQueue()->empty()))
                {
                
                /*while (!queryQueue.empty() && 
                           ((resultAvailable = queryQueue.front().second->GetQueryResult(visiblePixels, false)) ||
                mHierarchyInterface->GetQueue()->empty()))
                {
                        if (!resultAvailable) visiblePixels = 0;//1e20; // render if result not available
                        */
                HierarchyNode *node = queryQueue.front().first;
                        
                        queryQueue.pop();
                        
                        if (visiblePixels > mVisibilityThreshold)
                        {
                                // in case geometry is in omterior node: ensure that we only traverse once
                                if (!mHierarchyInterface->IsNodeVisible(node))
                                {
                                        mHierarchyInterface->TraverseNode(node);
                                }

                                mHierarchyInterface->PullUpVisibility(node);
                        }
                        else
                        {       
                                mHierarchyInterface->SetNodeVisible(node, false);

                                ++ mNumQueryCulledNodes;
                                
                                if (mVisualizeCulledNodes)
                                {
                                        mHierarchyInterface->VisualizeCulledNode(node, QUERY_CULLED);
                                }
                        }
                }
                
                //-- PART 2: hierarchical traversal
                if (!mHierarchyInterface->GetQueue()->empty())
                {
                        //Ogre::LogManager::getSingleton().logMessage("traversal");
                        HierarchyNode *node = mHierarchyInterface->GetQueue()->top();
                        mHierarchyInterface->GetQueue()->pop();
                                
                        bool intersects = false;

                        if (!mHierarchyInterface->CheckFrustumVisible(node, intersects))
                        {
                                ++ mNumFrustumCulledNodes;
                                
                                if (mVisualizeCulledNodes)
                                {
                                        mHierarchyInterface->VisualizeCulledNode(node, FRUSTUM_CULLED);
                                }
                        }
                        // -- if node intersects near plane, skip query because wrong results possible
                        else if (intersects)
                        {
                                SkipQuery(node);
                        }
                        else
                        {
                                // identify previously visible nodes
                                bool wasVisible = mHierarchyInterface->IsNodeVisible(node) && 
                                        (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId() - 1);
                                
                                // if we assume node to be visible in this frame => skip query 
                                bool skipQuery = wasVisible && (mAssumedVisibility > 0) && 
                                        DecideVisible(node) && mHierarchyInterface->HasGeometry(node);

                                //if (mHierarchyInterface->LastVisited(node) >= mHierarchyInterface->GetFrameId())
                                //      Ogre::LogManager::getSingleton().logMessage("error");
                                
                                if (skipQuery)
                                {
                                        SkipQuery(node);
                                        continue;
                                }

                // identify nodes that we cannot skip queries for
                                // geometry not only in leaves => test for renderable geometry
                                bool issueQuery = !wasVisible || mHierarchyInterface->HasGeometry(node);
                                                        
                                // reset node's visibility classification
                                // set visibe if geometry in node so we only traverse once
                                mHierarchyInterface->SetNodeVisible(node, wasVisible && issueQuery);

                                // update node's visited flag
                                mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());

                                // skip testing previously visible nodes without geometry
                                if (issueQuery)
                                {
                                        ++ mNumQueriesIssued;
                                        
                                        queryQueue.push(QueryPair(node, mHierarchyInterface->
                                                IssueNodeOcclusionQuery(node, wasVisible)));
                                }
                                
                                // always traverse a node if it was visible
                                if (wasVisible)
                                {
                                        mHierarchyInterface->TraverseNode(node);
                                }
                        }
                }
        }
}
//-----------------------------------------------------------------------
void CoherentHierarchicalCullingManager::SetAssumedVisibility(const unsigned int assumedVisibility)
{
        mAssumedVisibility = assumedVisibility;
        
        mThreshold = 0;

        if (mAssumedVisibility > 0)
        {
                mThreshold = RAND_MAX - RAND_MAX / mAssumedVisibility;
                if (mAssumedVisibility > 100) // fix visibility
                        mThreshold = RAND_MAX;
        }
        //std::stringstream d; d << "*** setting assumed vis: " << mAssumedVisibility; Ogre::LogManager::getSingleton().logMessage(d.str());
}
//-----------------------------------------------------------------------
inline bool CoherentHierarchicalCullingManager::DecideVisible(HierarchyNode *node) const
{
        //bool result = rand() < mThreshold; std::stringstream d; d << "Assumed vis: " << mAssumedVisibility << ", result: " << result;
        //Ogre::LogManager::getSingleton().logMessage(d.str()); return result;
        
        return rand() < mThreshold;
}
//-----------------------------------------------------------------------
inline void CoherentHierarchicalCullingManager::SkipQuery(HierarchyNode *node) const
{
        // -- set node to be visible in this frame, then traverse it
        mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());
        
        mHierarchyInterface->PullUpVisibility(node);                    
        mHierarchyInterface->TraverseNode(node);
}

} // namespace GtpVisibility