source: GTP/trunk/App/Demos/Vis/CHC_revisited/CHCTraverser.cpp @ 2764

#include "CHCTraverser.h"
#include "SceneEntity.h"


namespace CHCDemo
{

CHCTraverser::CHCTraverser(): RenderTraverser() 
{
}


CHCTraverser::~CHCTraverser()
{
        //DelQueries();
}


void CHCTraverser::Render()
{
        mStats.Reset();
        mRenderState->mTexturesEnabled = false;
        EnqueueNode(mBvh->GetRoot());

        QueryQueue queryQueue;

        //-- PART 1: process finished occlusion queries
        while (!mDistanceQueue.empty() || !queryQueue.empty())
        {
                while (!queryQueue.empty() && 
                           (queryQueue.front()->ResultAvailable() || mDistanceQueue.empty()))
                {
                        OcclusionQuery *query = queryQueue.front();
                        queryQueue.pop();
                        
                        // wait until result available
                        int visiblePixels = query->GetQueryResult();

                        if (visiblePixels > mVisibilityThreshold)
                        {
                                BvhNode *node = query->GetFrontNode();

                                mBvh->MakeParentsVisible(node);
                                TraverseNode(node);
                        }
                        else
                        {
                                ++ mStats.mNumQueryCulledNodes;
                        }
                }       

                //-- PART 2: hierarchical traversal
                if (!mDistanceQueue.empty())
                {
                        BvhNode *node = mDistanceQueue.top();
                        mDistanceQueue.pop();
        
                        if (mBvh->IsWithinViewFrustum(node))
                        {
                                // for near plane intersecting bounding box possible 
                                // wrong results => skip occlusion query
                                if (IntersectsNearPlane(node))
                                {
                                        // update node's visited flag
                                        node->SetLastVisitedFrame(mFrameID);
                                        node->SetVisible(true);
                                        mBvh->MakeParentsVisible(node);

                                        TraverseNode(node);
                                }
                                else
                                {               
                                        // identify previously visible nodes
                                        const bool wasVisible = node->IsVisible() && (node->GetLastVisitedFrame() == mFrameID - 1);
                                        
                                        // identify nodes that we cannot skip queries for
                                        const bool leafOrWasInvisible = 
                                                (node->GetLastVisitedFrame() != mFrameID) && (!wasVisible || node->IsVirtualLeaf());

                                        // reset node's visibility classification 
                                        node->SetVisible(false);

                                        // update node's visited flag
                                        node->SetLastVisitedFrame(mFrameID);
                                        
                                        // skip testing previously visible interior nodes
                                        if (leafOrWasInvisible)
                                        {
                                                OcclusionQuery *query = IssueOcclusionQuery(node, wasVisible);
                                                queryQueue.push(query);
                                        }
                                        
                                        // always traverse a node if it was visible
                                        if (wasVisible)
                                                TraverseNode(node);
                                }
                        }
                        else
                        {
                                // for stats
                                ++ mStats.mNumFrustumCulledNodes;
                        }
                }
        }
}

}