source: trunk/VUT/GtpVisibility/include/HierarchyInterface.h @ 155

#ifndef _GtpVisibilityHierarchyInterface_H__
#define _GtpVisibilityHierarchyInterface_H__

#include "DistanceQueue.h"
#include "VisibilityMesh.h"
#include <stack>

namespace GtpVisibility {

enum  CullingType {QUERY_CULLED, FRUSTUM_CULLED};

typedef std::vector<HierarchyNode *> HierarchyNodeList;
typedef std::vector<GtpVisibility::Mesh *> GeometryList;
typedef std::pair<HierarchyNode *, OcclusionQuery *> QueryPair;
typedef std::queue<QueryPair> QueryQueue;
typedef std::stack<HierarchyNode *> TraversalStack;

/**     Class which implements a hierarchy interface for a scene hierarchy.
*/
class HierarchyInterface
{
public:
        /** Default constructor.
        */
        HierarchyInterface();
        virtual ~HierarchyInterface();
        /** Returns true if current node is leaf of the hierarchy. 
                @param node hierarchy node
                @returns true if node is leaf
        */
    virtual bool IsLeaf(HierarchyNode *node) const = 0;
        /** Traverses and renders the given node. 
                @param node the hierarchy node
        */
        virtual void TraverseAndRenderNode(HierarchyNode *node) = 0;
        /** Renders current hierarchy node.
                @param node current hierarchy node to be rendered
        */
        virtual void RenderNode(HierarchyNode *node) = 0;
        /** Pulls up the visibility from the current node recursively to the parent nodes. 
                @param node the current node 
        */
        virtual void PullUpVisibility(HierarchyNode *node) = 0;
        /** Issue a occlusion query for this node. 
                @param node the current hierarchy node
                @returns occlusion query for this node
        */
        virtual OcclusionQuery *IssueOcclusionQuery(HierarchyNode *node, 
                const bool wasVisible = false) = 0;
        /** Sets the root of the scene hierarchy.
                @param root the hierarchy root
        */
        void SetHierarchyRoot(HierarchyNode *root);
    /** Get the root of the scene hierarchy.
                @return the hierarchy root
        */
        HierarchyNode *GetHierarchyRoot() const;
        /** Sets the scene root and initialises this hierarchy interface for a traversal.
                @param frontToBack 
                        if traversal is initialised for front-to-back rendering or
                        simple traversal of the nodes.
                @remark also resets the statistics evaluated in the last traversal
        */
        void InitTraversal(bool frontToBack = true);
        /** Returns current frame id.
                @returns frame id
        */
        unsigned int GetFrameId() const;
        /** Returns a pointer to the distance queue.
                @returns current distance queue.
                @remark the distance queue stores hierarchy nodes in a front-to-back order
        */
        DistanceQueue *GetQueue();
        /** Returns distance of the node to the view plane.
                @param node1 the hierarchy node
        */                      
        virtual float GetSquaredDistance(HierarchyNode *node) const = 0;
        /** Checks if the node is visible from the current view frustum.
                @param node the current node
                @param intersects returns true if the current node intersects the near plane
        */
        virtual bool CheckFrustumVisible(HierarchyNode *node, bool &intersects) = 0;
        /** Checks if the node is visible from the current view frustum.
                @param node the current node
        */
        bool CheckFrustumVisible(HierarchyNode *node);
        /** Returns next available occlusion query or creates new one.
                @return the next occlusion query
        */
        virtual OcclusionQuery *GetNextOcclusionQuery() = 0;
        /** Returns true if there is renderable geometry attached to this node
                @param node the current node
                @returns if the node has renderable geometry
        */
    virtual bool HasGeometry(HierarchyNode *node) const = 0;
        /** Sets the visible flag for this node.
                @param node the current node
                @param visible the visible flag
        */
        virtual void SetNodeVisible(HierarchyNode *node, const bool visible) = 0;
        /** Returns true if node has the visible flag set. See set
        */
        virtual bool IsNodeVisible(HierarchyNode *node) const = 0;
        /** Sets the last visited frame id for this node.
                @param node the current node
                @param frameId the current frame id
        */
        virtual void SetLastVisited(HierarchyNode *node, 
                                                                const unsigned int frameId) = 0;
        /** Returns frame id when this node was last visited by the traverser. See set
        */
        virtual unsigned int LastVisited(HierarchyNode *node) const = 0;
        /** Returns number of traversed nodes.
        */
        unsigned int GetNumTraversedNodes();
        /** Returns number of rendered nodes.
        */
        unsigned int GetNumRenderedNodes();
                
        //bool mIsShadowPass;

        /** Visualization of a culled node, dependent on the culling type. 
                @param type can be one of FRUSTUM_CULLED, QUERY_CULLED
        */
        virtual void VisualizeCulledNode(HierarchyNode *node, 
                CullingType type) = NULL;

        /** Returns vector of previously rendered hierarchy nodes.
        */
        std::vector<HierarchyNode *> *GetRenderedNodes();
        /** Returns vector of previoulsy rendered geometry.
        */
        
        /** Issue a occlusion query for this mesh.
                @param node the current mesh
                @returns occlusion query for this node
        */
        virtual GtpVisibility::OcclusionQuery *IssueOcclusionQuery(GtpVisibility::Mesh *mesh) = 0;

        /** Returns the geometry of a given hierarchy node. 
                @param node the hierarchy node containing the geometry
                @param geometryList geometry is returned in this list
                @param includeChildren if the geometry of the children should be taken into account
        */
        virtual void GetNodeGeometryList(GtpVisibility::HierarchyNode *node,    
                                                         GeometryList *geometryList, 
                                                         bool includeChildren) = 0;


        /** Renders the given geometry.
        */
        virtual void RenderGeometry(GtpVisibility::Mesh *geom) = 0;

        /** Sets node id to specified value. 
        */
        virtual void SetNodeId(HierarchyNode *node, int id) = 0;
        /** Returns id of given node. 
        */
        virtual int GetNodeId(HierarchyNode *node) = 0;

        /** This is an optimization when issuing the occlusion test. 
                The test is done with actual geometry rather than the bounding 
                box of leave nodes previously marked as visible
                @param testGeometry if this optimization should be used
                @remark this option is only useful for the coherent hierarchical culling algorithm
        */
        void TestGeometryForVisibleLeaves(bool testGeometry);

        /** 
                Traverses hierarchy and returns next node.
                @returns next node in hierarchy.
        */
        virtual HierarchyNode *GetNextNode() = 0;

protected:
        /// chc optimization for testing geometry of leaves instead of bounding box
        bool mTestGeometryForVisibleLeaves;

        unsigned int mFrameId;

        int mCurrentTestIdx;
        
        /// number of traversed nodes
        unsigned int mNumTraversedNodes;
        /// the distance queue used for rendering of nodes in front to back order.
        DistanceQueue *mDistanceQueue;
        /// internal structure for traversal
        TraversalStack *mTraversalStack;

        /// the root of the hierarchy
        HierarchyNode *mHierarchyRoot;
        
        // buffer for a node pointer
        HierarchyNode *mSavedNode;

        std::vector<HierarchyNode *> mRenderedNodes;
};
} // namespace GtpVisibility

#endif // GtpVisisibilityHierarchyInterface_H