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

#include "CoherentHierarchicalCullingManager.h"
#include "CullingLogManager.h"

#include <time.h>
#include <sstream>


namespace GtpVisibility {


static int batchSize = 5;

//-----------------------------------------------------------------------
CoherentHierarchicalCullingManager::CoherentHierarchicalCullingManager():
mAssumedVisibility(0)
{
}
//-----------------------------------------------------------------------
CoherentHierarchicalCullingManager::CoherentHierarchicalCullingManager(
                                                                                                                const unsigned int assumedVisibility):
mAssumedVisibility(assumedVisibility)
{
}
//-----------------------------------------------------------------------
void CoherentHierarchicalCullingManager::AssignAssumedVisibility(GtpVisibility::HierarchyNode *node)
{
        if (!mHierarchyInterface->IsNodeVisible(node))
                // previously invisible nodes: give random offset just for the first test after
                // becoming visible to avoid that all nodes are tested in the same frame
                mHierarchyInterface->SetNodeAssumedVisible(node, rand() * mAssumedVisibility / RAND_MAX);
        else
                mHierarchyInterface->SetNodeAssumedVisible(node, mAssumedVisibility);
}
//-----------------------------------------------------------------------
void CoherentHierarchicalCullingManager::RenderScene()
{
        if (0) CullingLogManager::GetSingleton()->LogMessage("chc");
        QueryQueue queryQueue;
        unsigned int visiblePixels = 0;
        
        /////////////
        //-- PART 1: process finished occlusion queries

        while (!mHierarchyInterface->GetQueue()->empty() || !queryQueue.empty())
        {
                //////////
                //-- only wait for result if there are no nodes to process

                while (!queryQueue.empty() && 
                           (NodeInvalid(queryQueue.front().first) ||
                            queryQueue.front().second->GetQueryResult(
                                             visiblePixels, mHierarchyInterface->GetQueue()->empty())))
                {
                        HierarchyNode *node = queryQueue.front().first;
                        queryQueue.pop();

                        // "invalid nodes" happen for hierarchies that have geometry
                        // not neccessarily in the leaves:
                        // parent was tested invisible => remove children from queue

                        if (1 && NodeInvalid(node))
                                continue;

                        // tested visible
                        if (visiblePixels > mVisibilityThreshold)
                        {
                                // assing the #frames the node is assumed to stay visible
                                AssignAssumedVisibility(node);

                                // for previously visible interior node which contains geometry: 
                                // ensure that we did not already traverse this node 
                                // (which means that the visibility flag is set)
                                if (!mHierarchyInterface->IsNodeVisible(node))
                                        mHierarchyInterface->TraverseNode(node);

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

                ++ mNumQueryCulledNodes;

                                if (mVisualizeCulledNodes)
                                        mHierarchyInterface->VisualizeCulledNode(node, QUERY_CULLED);
                        }
                        
                        // update node's visited flag
                        mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());   
                }
                
                ////////////////
                //-- PART 2: hierarchical traversal

                if (!mHierarchyInterface->GetQueue()->empty())
                {
                        HierarchyNode *node = mHierarchyInterface->GetQueue()->top();
                        mHierarchyInterface->GetQueue()->pop();
                                
                        // parent was tested invisible => remove children from queue
                        if (1 && NodeInvalid(node))
                                continue;

                        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 
                                const bool skipQuery = wasVisible &&
                                                                           DecideVisible(node) && 
                                                                           mHierarchyInterface->HasGeometry(node);

                                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);
                                                        
                                // set node's visibility classification
                                // we identify previously visible / invisible nodes in the query queue
                                mHierarchyInterface->SetNodeVisible(node, wasVisible && issueQuery);

                                if (issueQuery)
                                {
                                        ++ mNumQueriesIssued;
                                        
                                        const bool testGeometry = wasVisible && mHierarchyInterface->IsLeaf(node) && mTestGeometryForVisibleLeaves;

                                        queryQueue.push(QueryPair(node, mHierarchyInterface->
                                                IssueNodeOcclusionQuery(node, testGeometry)));
                                }
                                else
                                {
                                        // skip testing previously visible nodes without geometry
                    // just update node's visited flag
                                        mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());
                                }

                                // always traverse a node if it was visible
                                if (wasVisible)
                                {
                                        mHierarchyInterface->TraverseNode(node);
                                }
                        }
                }
        }
}
//-----------------------------------------------------------------------
void CoherentHierarchicalCullingManager::SetAssumedVisibility(const unsigned int assumedVisibility)
{
        mAssumedVisibility = assumedVisibility;
}
//-----------------------------------------------------------------------
inline bool CoherentHierarchicalCullingManager::DecideVisible(HierarchyNode *node) const
{
        mHierarchyInterface->DecNodeAssumedVisible(node);
        //std::stringstream d; d << "node visible: " << mHierarchyInterface->GetNodeAssumedVisible(node);
        //CullingLogManager::GetSingleton()->LogMessage(d.str());
        return mHierarchyInterface->GetNodeAssumedVisible(node) > 0;
}
//-----------------------------------------------------------------------
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);
}
//-----------------------------------------------------------------------
bool CoherentHierarchicalCullingManager::NodeInvalid(HierarchyNode *node) const
{
        // parent was tested invisible in this frame
        HierarchyNode *parent = mHierarchyInterface->GetParent(node);
    return 
                parent && 
                (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId()) && 
                !mHierarchyInterface->IsNodeVisible(parent);
}
//-----------------------------------------------------------------------
void CoherentHierarchicalCullingManager::SetTestGeometryForVisibleLeaves(const bool testGeometry)
{
        mTestGeometryForVisibleLeaves = testGeometry;
}
//-----------------------------------------------------------------------
bool CoherentHierarchicalCullingManager::GetTestGeometryForVisibleLeaves()
{
        return mTestGeometryForVisibleLeaves;
}

}