source: GTP/trunk/App/Demos/Vis/CHC_revisited/RenderTraverser.h @ 2767

#ifndef __RENDERTRAVERSER_H
#define __RENDERTRAVERSER_H

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



namespace CHCDemo
{

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 mNumIssuedQueries;

        long 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;}
        /** Sets visible pixels threshold for visibility classification
        */
        void SetVisibilityThreshold(int threshold);
        /** Returns visibility threshold
        */
        int GetVisibilityThreshold() const;
        /** renders a visualization of the hierarchy
        */
        void RenderVisualization();
        /** use optimization to take leaf nodes instead of bounding box for occlusion queries   
        */
        void SetUseOptimization(bool useOptimization);
        /** Sets the current render state
        */
        void SetRenderState(RenderState *state);

        void SetUseRenderQueue(bool useRenderQueue);
        const TraversalStatistics &GetStats() const { return mStats; }

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 specified node
        */
        OcclusionQuery *IssueOcclusionQuery(BvhNode *node, bool wasVisible);
        /** switches to normal render mode
        */
        void Switch2GLRenderState();
        /** switches to occlusion query mode (geometry not rendered on the screen)
        */
        void Switch2GLQueryState();
        /** Retunrs true if the current bvh node intersects the near plane.
        */
        inline bool IntersectsNearPlane(BvhNode *node) const; 
        /** Enqueues a bvh node.
        */
        void EnqueueNode(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;

        bool mIsQueryMode;

        RenderState *mRenderState;

        QueryHandler mQueryHandler;

        TraversalStatistics mStats;

        QueryQueue mQueryQueue;

        int mVisibilityThreshold;
        
        bool mUseOptimization;

        RenderQueue mRenderQueue;

        bool mUseRenderQueue;
};


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


}



#endif // RENDERTRAVERSER_H