source: GTP/trunk/Lib/Vis/OnlineCullingCHC/include/HierarchyInterface.h @ 2555

#ifndef _GtpVisibilityHierarchyInterface_H__
#define _GtpVisibilityHierarchyInterface_H__


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


namespace GtpVisibility {

enum  CullingType {QUERY_CULLED, FRUSTUM_CULLED};

typedef std::vector<HierarchyNode *> NodeVector;
//typedef std::vector<GtpVisibility::Mesh *> GeometryVector;
//typedef std::vector<GtpVisibility::Patch *> PatchVector;

typedef std::pair<HierarchyNode *, OcclusionQuery *> QueryPair;
typedef std::pair<HierarchyNode *, bool> PendingQuery;
typedef std::queue<QueryPair> QueryQueue;
typedef std::queue<PendingQuery> PendingQueue;

typedef std::vector<HierarchyNode *> HierarchyNodeContainer;


/**     Class which implements an interface for the operations on a hierarchy
        of a scene. 
        It has to be implemented for any rendering engine to use the CHC algorithm.
*/
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 hierarchy from the given node. 
                @param node the hierarchy node
        */
        virtual void TraverseNode(HierarchyNode *node) = 0;
        /** Renders the given 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) const = 0;
        /** Issue a occlusion query for this node. 
                @param node the current hierarchy node
                @param testGeometry (if geometry should be tested instead of the bb).
                @returns occlusion query for this node
        */
        virtual OcclusionQuery *IssueNodeOcclusionQuery(HierarchyNode *node, 
                                                                                                        const bool testGeometry = false) = 0;
        /** Returns distance of the node to the view plane.
                @param node 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;
        
        /** 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) const = 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) const = 0;
        

        virtual void DetermineFullVisibility(GtpVisibility::HierarchyNode *node) const = 0;

        virtual HierarchyNode *GetRandomLeaf(HierarchyNode *root) = 0;
        virtual bool IsNodeFullyVisible(GtpVisibility::HierarchyNode *node) const = 0;

        virtual void CollectLeaves(HierarchyNode *root, HierarchyNodeContainer &nodes) = 0;

        /** Collects only leaves that are found visible by view frustum culling.
        */
        //virtual void CollectVisibleLeaves(HierarchyNode *root, HierarchyNodeContainer &nodes) = 0;

        virtual void RenderNodeRecursive(HierarchyNode *node) = 0;

        /** Returns frame id when this node was last visited by the traverser. See set
        */
        virtual unsigned int LastVisited(HierarchyNode *node) const = 0;
                
        /** Visualization of a culled node, dependent on the culling type. 
                @param node the hierarchy node to be visualized
                @param type can be one of FRUSTUM_CULLED, QUERY_CULLED
        */
        virtual void VisualizeCulledNode(HierarchyNode *node, 
                                                                         CullingType type) const = 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.               
                @remark also resets the statistics evaluated in the last traversal
        */
        void InitTraversal();
        /** 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();
        /** Checks if the node is visible from the current view frustum.
                @param node the current node
        */
        bool CheckFrustumVisible(HierarchyNode *node);
        /** Returns number of traversed nodes.
        */
        unsigned int GetNumTraversedNodes();
        /** Returns number of rendered nodes.
        */
        unsigned int GetNumRenderedNodes();
        /** Returns vector of visible hierarchy nodes from previous render.
        */
        std::vector<HierarchyNode *> *GetVisibleNodes();
        /** Pulls up the last visited information of this node.
        */
        virtual void PullUpLastVisited(HierarchyNode *node, const int frameId) const = 0;
        /** Returns parent node.
        */
        virtual HierarchyNode *GetParent(HierarchyNode *node) = 0;
        /** Returns #frames this node is assumed to be visible.
        */
        virtual int GetNodeAssumedVisible(HierarchyNode *node) = 0;
        /** Sets #frames this node is assumed to be visible.
        */
        virtual void SetNodeAssumedVisible(HierarchyNode *node, int assumedVisible) = 0;
        /** Decreases #frames this node is assumed to be visible.
        */
        virtual void DecNodeAssumedVisible(HierarchyNode *node) = 0;
        
        virtual void AddToQueue(GtpVisibility::HierarchyNode *node) = 0;

        virtual void RenderQueue() = 0;

        virtual void TraverseNode2(GtpVisibility::HierarchyNode *node) = 0;

protected:

        /// the current frame number
        unsigned int mFrameId;
        
        /// index of the lcurrent occlusion query in the array of queries
        /// NOTE: should rather be iterator
        int mCurrentTestIdx;
        
        /// number of traversed nodes
        unsigned int mNumTraversedNodes;

        /// The queue is useful for rendering hierarchy nodes in front to back order.
        DistanceQueue *mDistanceQueue;

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

        /// list of rendered hierarchy nodes (e.g., useful for exact visibility queries)
        std::vector<HierarchyNode *> mVisibleNodes;
};

} // namespace GtpVisibility

#endif // GtpVisisibilityHierarchyInterface_H