source: GTP/trunk/App/Demos/Vis/CHC_revisited/CHCPlusPlusTraverser.cpp @ 2774

#include "CHCPlusPlusTraverser.h"
#include "RenderState.h"

using namespace std;

namespace CHCDemo
{


CHCPlusPlusTraverser::CHCPlusPlusTraverser()
{
}


void CHCPlusPlusTraverser::HandleQueryResult(OcclusionQuery *query)
{
        // wait until result available
        const int visible = query->GetQueryResult() > mVisibilityThreshold;

        BvhNode *node = query->GetFrontNode();

        if (visible)
        {
                // node was previously invisible
                if (!node->IsVisible())
                {
                        // reset flag
                        node->SetTimesTestedInvisible(0);
                        node->SetAssumedVisibleFrameId(mFrameId + mAssumedVisibleFrames);
                }
                else
                        // randomize first invokation
                        node->SetAssumedVisibleFrameId(mFrameId + Random(mAssumedVisibleFrames + 1));

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

        node->SetVisible(visible);
}


void CHCPlusPlusTraverser::Traverse()
{
        //-- PART 1: process finished occlusion queries
        while (!mDistanceQueue.empty() || !mQueryQueue.empty())
        {
                bool resultAvailable;
                while (!mQueryQueue.empty() && 
                           (mDistanceQueue.empty() || (resultAvailable = mQueryQueue.front()->ResultAvailable())))
                {
                        while (!resultAvailable && !mVQueue.empty())
                        {
                                BvhNode *node = mVQueue.front();
                                mVQueue.pop();
                                
                                OcclusionQuery *query = IssueOcclusionQuery(node, true);

                                mQueryQueue.push(query);
                                resultAvailable = mQueryQueue.front()->ResultAvailable();
                        }
                        
                        OcclusionQuery *query = mQueryQueue.front();
                        mQueryQueue.pop();

                        HandleQueryResult(query);
                }       

                //-- 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 testFeasible = (!wasVisible || (node->IsVirtualLeaf() && 
                                                (node->GetAssumedVisibleFrameId() <= mFrameId)));

                                        // node was not recently tested => reset flag 
                                        if (node->GetLastVisitedFrame() != mFrameId - 1)
                                                node->SetTimesTestedInvisible(0);

                                        // update node's visited flag
                                        node->SetLastVisitedFrame(mFrameId);
                                        
                                        // skip testing previously visible interior nodes
                                        if (testFeasible)
                                        {
                                                if (!wasVisible)
                                                {
                                                        QueryPreviouslyInvisibleNodes(node);
                                                }
                                                else
                                                {
                                                        mVQueue.push(node);
                                                }
                                        }
                                        
                                        // always traverse a node if it was previously visible
                                        if (wasVisible)
                                                TraverseNode(node);
                                }
                        }
                        else
                        {
                                // for stats
                                ++ mStats.mNumFrustumCulledNodes;
                        }
                }

                // distance queue empty: feed the remaining multiqueries to
                // be able to proceed traversal
                if (mDistanceQueue.empty())
                {
                        IssueMultiQueries();
                }
        }

        // render the rest of the objects
        if (mUseRenderQueue)
        {
                if (mRenderState->SetState(RenderState::RENDER))
                        ++ mStats.mNumStateChanges;

                mRenderQueue.Render();
                mRenderQueue.Clear();
        }


        //////////////
        //-- issue remaining previously visible node queries

        while (!mVQueue.empty())
        {
                BvhNode *node = mVQueue.front();
                mVQueue.pop();

                OcclusionQuery *query = IssueOcclusionQuery(node, true);
                mQueryQueue.push(query);
        }

        while (!mQueryQueue.empty())
        {
                OcclusionQuery *query = mQueryQueue.front();
                mQueryQueue.pop();

                HandleQueryResult(query);
        }
}



void CHCPlusPlusTraverser::QueryPreviouslyInvisibleNodes(BvhNode *node)
{
        mIQueue.push(node);

        if (mIQueue.size() > mMaxBatchSize)
        {
                IssueMultiQueries();
        }
}


OcclusionQuery * CHCPlusPlusTraverser::GetNextMultiQuery(BvhNodeQueue &iqueue)
{
        OcclusionQuery *query = mQueryHandler.RequestQuery();

        float pFail = 1.0f; 
        float maxBatchVal = 0.0f;
        float newPBatch = 1.0f;
        float newBatchVal;

        // issue next query
        while (!iqueue.empty())
        {
                BvhNode *node = iqueue.front();
                newPBatch *= mVisibilityPredictor.GetProbability(node);

                if (query->GetNodes().empty())
                {
                        newBatchVal = 1.0f;
                }
                else
                {
                        int newSize = query->GetSize() + 1;
                        newBatchVal = newSize / (1.0f + (1.0f - newPBatch) * newSize);
                }

                if (newBatchVal <= maxBatchVal)
                        break;

                iqueue.pop();
                query->AddNode(node);

                maxBatchVal = newBatchVal;
        }

        IssueOcclusionQuery(*query, false);

        return query;
}


void CHCPlusPlusTraverser::IssueMultiQueries()
{
        if (0 && mUseRenderQueue)
        {
                if (mRenderState->SetState(RenderState::RENDER))
                        ++ mStats.mNumStateChanges;
        
                mRenderQueue.Render();
                mRenderQueue.Clear();
        }

        while (!mIQueue.empty())
        {
                BvhNode *node = mIQueue.front();
                mIQueue.pop();

                OcclusionQuery *query = GetNextMultiQuery(mIQueue);
                //OcclusionQuery *query = IssueOcclusionQuery(node);

                mQueryQueue.push(query);
        }
}


}