source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderTraverser.h @ 2787

#ifndef __RENDERTRAVERSER_H
#define __RENDERTRAVERSER_H

#include <queue>
#include "Bvh.h"
#include "OcclusionQuery.h"
#include "Camera.h"
#include "RenderQueue.h"



namespace CHCDemoEngine
{

class Camera;
class Matrix4x4;



struct TraversalStatistics
{
public:

        void Reset();

        //////////
        //-- several statistics for a rendering pass

        int mNumTraversedNodes;
        int mNumQueryCulledNodes;
        int mNumFrustumCulledNodes;
        
        int mNumRenderedGeometry;
        int mNumRenderedTriangles;
        int mNumRenderedNodes;

        int mNumIssuedQueries;
        int mNumStateChanges;
        int mNumPreviouslyVisibleNodeQueries;
        
        double mRenderTime;
};



/** Abstract class implementing a scene traversal for rendering.
*/
class RenderTraverser
{
public:
        
        enum {CULL_FRUSTUM, STOP_AND_WAIT, CHC, CHCPLUSPLUS, NUM_RENDERMODES};

        RenderTraverser();
        ~RenderTraverser();

        //! Renders the scene with the specified method
        /**
                The method is one of
                CULL_FRUSTUM: view frustum culling only
                STOP_AND_WAIT: hierarchical stop and wait algorithm
                CHC: coherent hierarchical algorithm
                CHCPLUSPLUS: coherent hierarchical algorithm revisited
        */
        void RenderScene();
        /** Sets the scene hierarchy.
        */
        void SetHierarchy(Bvh *bvh);
        /** Sets the camera.
        */
        void SetCamera(Camera *cam)  {mCamera = cam;}
        /** Renders a visualization of the hierarchy
        */
        void RenderVisualization();
        /** Sets the current render state
        */
        void SetRenderState(RenderState *state);
        /** The traversal statistics
        */
        const TraversalStatistics &GetStats() const { return mStats; }
        /** The current frame id
        */
        int GetCurrentFrameId() const { return mFrameId; }


        //////////////////
        //-- options for the different rendering algorithms

        /** If a render queue should be used to batch up and sort scene entities before
                rendering.
        */
        void SetUseRenderQueue(bool useRenderQueue);
        /** Sets visible pixels threshold for visibility classification
        */
        void SetVisibilityThreshold(int threshold);


        ///////////////////
        //-- CHC / CHC ++ related options


        /** CHC optimization to query the geometry itself instead of the bounding box.
        */
        void SetUseOptimization(bool useOptimization);
        /** The number of frames a previously visible node is assumed to stay visible.
        */
        void SetAssumedVisibleFrames(int assumedVisibleFrames);
        /** The maximum batch size for the i-queue
        */
        void SetMaxBatchSize(int batchSize);
        /** If multiqueries should be used.
        */
        void SetUseMultiQueries(bool useMultiQueries);
        /** If thight bounds should be used or the bounding boxes should be tested.
        */
        void SetUseTightBounds(bool useTightBounds);

protected:

        /** This is the actual rendering algorithm. It must be implemented by all
                the subclasses.
        */
        virtual void Traverse() = 0;
        /** Hierarchy traversal
        */
        void TraverseNode(BvhNode *node);
        /** Issues occlusion query for a single node
        */
        OcclusionQuery *IssueOcclusionQuery(BvhNode *node, bool wasVisible);
        /** Issue multiquery.
        */
        void IssueOcclusionQuery(const OcclusionQuery &query, bool wasVisible);
        /** Retunrs true if the current bvh node intersects the near plane.
        */
        inline bool IntersectsNearPlane(BvhNode *node) const; 
        /** Enqueues a bvh node for distance traversal
        */
        void EnqueueNode(BvhNode *node);
        /** Renders the bvh node.
        */
        void RenderNode(BvhNode *node);


        ////////////
        //-- members

        /// the current camera
        Camera *mCamera;
        /// the root of the scene hierarchy
        Bvh *mBvh;
        /// the priority queue used for front to back traversal
        TraversalQueue mDistanceQueue; 
        /// the current frame id
        int mFrameId;
        /// the current render state
        RenderState *mRenderState;
        /// manages creation and destruction of the queries
        QueryHandler mQueryHandler;
        /// the statisitcs
        TraversalStatistics mStats;
        
        RenderQueue mRenderQueue;


        /////////////////
        //-- algorithm parametes

        int mVisibilityThreshold;
        
        bool mUseOptimization;

        bool mUseRenderQueue;

        int mAssumedVisibleFrames;

        int mMaxBatchSize;

        bool mUseMultiQueries;

        bool mUseTightBounds;
};


inline bool RenderTraverser::IntersectsNearPlane(BvhNode *node) const
{ 
        return mBvh->GetDistance(node) < mCamera->GetNear();
}


}



#endif // RENDERTRAVERSER_H