source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderTraverser.cpp @ 2784

#include "RenderTraverser.h"
#include "glInterface.h"
#include "Camera.h"
#include "SceneEntity.h"
#include "RenderState.h"
#include "Geometry.h"
#include "Timer/PerfTimer.h"


using namespace std;


namespace CHCDemoEngine
{

        
void TraversalStatistics::Reset()
{
        mNumTraversedNodes = 0;
        mNumQueryCulledNodes = 0;
        mNumFrustumCulledNodes = 0;
        
        mNumRenderedGeometry = 0;
        mNumRenderedTriangles = 0;
        mNumRenderedNodes = 0;

        mNumPreviouslyVisibleNodeQueries = 0;
        mNumIssuedQueries = 0;
        mNumStateChanges = 0;

        mRenderTime = 0;
}



/******************************************************/
/*           RenderTraverser implementation           */
/******************************************************/


RenderTraverser::RenderTraverser():  
mVisibilityThreshold(0),
mBvh(NULL), 
mUseOptimization(false),
mFrameId(-1),
mUseRenderQueue(false),
mAssumedVisibleFrames(10),
mMaxBatchSize(50)
{
}


RenderTraverser::~RenderTraverser()
{
        mQueryHandler.DestroyQueries();
}


void RenderTraverser::EnqueueNode(BvhNode *node)
{
        mBvh->CalcDistance(node);
        mDistanceQueue.push(node);
}


void RenderTraverser::TraverseNode(BvhNode *node)
{
        ++ mStats.mNumTraversedNodes;

        if (node->IsVirtualLeaf())
        {
                RenderNode(node);
        }
        else 
        {
                // for non leafs this renders only the bounding volume (if the flag is set)
                BvhInterior *interior = static_cast<BvhInterior *>(node);

                EnqueueNode(interior->GetFront());
                EnqueueNode(interior->GetBack());
        }
}


void RenderTraverser::RenderNode(BvhNode *node)
{
        if (node->GetLastRenderedFrame() != mFrameId)
        {
                if (mRenderState->SetState(RenderState::RENDER))
                        ++ mStats.mNumStateChanges;
                
                node->SetLastRenderedFrame(mFrameId);

                int geometrySize;
                SceneEntity **entities = mBvh->GetGeometry(node, geometrySize);

                mStats.mNumRenderedGeometry += geometrySize;
                ++ mStats.mNumRenderedNodes;
                
                for (int i = 0; i < geometrySize; ++ i)
                {
                        SceneEntity *ent = entities[i];
                        mStats.mNumRenderedTriangles += ent->GetGeometry()->GetNumTriangles();

                        if (mUseRenderQueue)
                                mRenderQueue.Enqueue(ent);
                        else
                                ent->Render(mRenderState);
                }               
        }
}


void RenderTraverser::SetHierarchy(Bvh *bvh)
{
        mBvh = bvh;
}


void RenderTraverser::SetRenderState(RenderState *state)
{
        mRenderState = state;
        mRenderQueue.SetRenderState(state);
}


void RenderTraverser::RenderScene()
{
        PerfTimer timer;

        timer.Start();

        //InitTiming();
        //long t1, t2;
        //t1 = GetTime();

        glEnableClientState(GL_VERTEX_ARRAY);
        glEnableClientState(GL_NORMAL_ARRAY);

        ++ mFrameId;

        mBvh->InitFrame();

        mStats.Reset();
        mQueryHandler.ResetQueries();
        
        EnqueueNode(mBvh->GetRoot());


        ///////////
        //-- the actual rendering algorithm

        Traverse();

        mRenderState->Reset();

        glDisableClientState(GL_VERTEX_ARRAY);
        glDisableClientState(GL_NORMAL_ARRAY);

        //t2 = GetTime();
        //mStats.mRenderTime = TimeDiff(t1, t2);
        mStats.mRenderTime = timer.Elapsedms();
}


void RenderTraverser::SetUseRenderQueue(bool useRenderQueue)
{
        mUseRenderQueue = useRenderQueue;
        std::cout << "using render queue: " << mUseRenderQueue << std::endl;
}


void RenderTraverser::SetVisibilityThreshold(int threshold)
{
        mVisibilityThreshold = threshold;
}


void RenderTraverser::SetUseOptimization(bool useOptimization)
{
        mUseOptimization = useOptimization;
}


void RenderTraverser::SetAssumedVisibleFrames(int assumedVisibleFrames)
{
        mAssumedVisibleFrames = assumedVisibleFrames;
}


void RenderTraverser::SetMaxBatchSize(int batchSize)
{
        mMaxBatchSize = batchSize;
}


void RenderTraverser::SetUseMultiQueries(bool useMultiQueries)
{
        mUseMultiQueries = useMultiQueries;
        std::cout << "using multiqueries: " << mUseMultiQueries << std::endl;
}



OcclusionQuery *RenderTraverser::IssueOcclusionQuery(BvhNode *node, bool wasVisible)
{
        OcclusionQuery *query = mQueryHandler.RequestQuery();
        query->AddNode(node);

        IssueOcclusionQuery(*query, wasVisible);

        return query;
}


void RenderTraverser::IssueOcclusionQuery(const OcclusionQuery &query, bool wasVisible)
{
        ++ mStats.mNumIssuedQueries;

        if (mUseRenderQueue && (mRenderState->GetMode() == RenderState::RENDER))
        {
                //cout << "render queue: " << mRenderQueue.GetSize() << endl;
                mRenderQueue.Render();
                mRenderQueue.Clear();
        }

        query.BeginQuery();

        if (wasVisible)
                ++ mStats.mNumPreviouslyVisibleNodeQueries;

        // if this node is a previous visible leaf:
        // leaves will be rendered anyway => we can also test with the real geometry 
        if (wasVisible && mUseOptimization)
        {
                for (size_t i = 0; i < query.GetSize(); ++ i)
                        RenderNode(query.GetNodes()[i]);
        }
        else
        {
                // change to query mode and render box
                if (mRenderState->SetState(RenderState::QUERY))
                        ++ mStats.mNumStateChanges;

                mBvh->RenderBoundingBoxes(query.GetNodes(), mRenderState);
        }

        query.EndQuery();
}


}