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

Revision 2543, 6.6 KB checked in by mattausch, 17 years ago (diff)
Line 
1#ifndef _GtpVisibilityHierarchyInterface_H__
2#define _GtpVisibilityHierarchyInterface_H__
3
4
5#include "DistanceQueue.h"
6#include <stack>
7
8
9namespace GtpVisibility {
10
11enum  CullingType {QUERY_CULLED, FRUSTUM_CULLED};
12
13typedef std::vector<HierarchyNode *> NodeVector;
14//typedef std::vector<GtpVisibility::Mesh *> GeometryVector;
15//typedef std::vector<GtpVisibility::Patch *> PatchVector;
16
17typedef std::pair<HierarchyNode *, OcclusionQuery *> QueryPair;
18typedef std::pair<HierarchyNode *, bool> PendingQuery;
19typedef std::queue<QueryPair> QueryQueue;
20typedef std::queue<PendingQuery> PendingQueue;
21
22typedef std::vector<HierarchyNode *> HierarchyNodeContainer;
23
24
25/**     Class which implements an interface for the operations on a hierarchy
26        of a scene.
27        It has to be implemented for any rendering engine to use the CHC algorithm.
28*/
29class HierarchyInterface
30{
31public:
32        /** Default constructor.
33        */
34        HierarchyInterface();
35        virtual ~HierarchyInterface();
36        /** Returns true if current node is leaf of the hierarchy.
37                @param node hierarchy node
38                @returns true if node is leaf
39        */
40    virtual bool IsLeaf(HierarchyNode *node) const = 0;
41        /** Traverses and renders the hierarchy from the given node.
42                @param node the hierarchy node
43        */
44        virtual void TraverseNode(HierarchyNode *node) = 0;
45        /** Renders the given hierarchy node.
46                @param node current hierarchy node to be rendered
47        */
48        virtual void RenderNode(HierarchyNode *node) = 0;
49        /** Pulls up the visibility from the current node recursively to the parent nodes.
50                @param node the current node
51        */
52        virtual void PullUpVisibility(HierarchyNode *node) const = 0;
53        /** Issue a occlusion query for this node.
54                @param node the current hierarchy node
55                @param testGeometry (if geometry should be tested instead of the bb).
56                @returns occlusion query for this node
57        */
58        virtual OcclusionQuery *IssueNodeOcclusionQuery(HierarchyNode *node,
59                                                                                                        const bool testGeometry = false) = 0;
60        /** Returns distance of the node to the view plane.
61                @param node the hierarchy node
62        */                     
63        virtual float GetSquaredDistance(HierarchyNode *node) const = 0;
64        /** Checks if the node is visible from the current view frustum.
65                @param node the current node
66                @param intersects returns true if the current node intersects the near plane
67        */
68        virtual bool CheckFrustumVisible(HierarchyNode *node,
69                                                                         bool &intersects) = 0;
70       
71        /** Returns true if there is renderable geometry attached to this node
72                @param node the current node
73                @returns if the node has renderable geometry
74        */
75    virtual bool HasGeometry(HierarchyNode *node) const = 0;
76        /** Sets the visible flag for this node.
77                @param node the current node
78                @param visible the visible flag
79        */
80        virtual void SetNodeVisible(HierarchyNode *node,
81                                                                const bool visible) const = 0;
82        /** Returns true if node has the visible flag set. See set
83        */
84        virtual bool IsNodeVisible(HierarchyNode *node) const = 0;
85        /** Sets the last visited frame id for this node.
86                @param node the current node
87                @param frameId the current frame id
88        */
89        virtual void SetLastVisited(HierarchyNode *node,
90                                                                const unsigned int frameId) const = 0;
91       
92
93        virtual void DetermineFullVisibility(GtpVisibility::HierarchyNode *node) const = 0;
94
95        virtual HierarchyNode *GetRandomLeaf(HierarchyNode *root) = 0;
96        virtual bool IsNodeFullyVisible(GtpVisibility::HierarchyNode *node) const = 0;
97
98        virtual void CollectLeaves(HierarchyNode *root, HierarchyNodeContainer &nodes) = 0;
99
100        /** Collects only leaves that are found visible by view frustum culling.
101        */
102        //virtual void CollectVisibleLeaves(HierarchyNode *root, HierarchyNodeContainer &nodes) = 0;
103
104        virtual void RenderNodeRecursive(HierarchyNode *node) = 0;
105
106        /** Returns frame id when this node was last visited by the traverser. See set
107        */
108        virtual unsigned int LastVisited(HierarchyNode *node) const = 0;
109               
110        /** Visualization of a culled node, dependent on the culling type.
111                @param node the hierarchy node to be visualized
112                @param type can be one of FRUSTUM_CULLED, QUERY_CULLED
113        */
114        virtual void VisualizeCulledNode(HierarchyNode *node,
115                                                                         CullingType type) const = 0;
116
117        /** Sets the root of the scene hierarchy.
118                @param root the hierarchy root
119        */
120        void SetHierarchyRoot(HierarchyNode *root);
121    /** Get the root of the scene hierarchy.
122                @return the hierarchy root
123        */
124        HierarchyNode *GetHierarchyRoot() const;
125        /** Sets the scene root and initialises this hierarchy interface for a traversal.               
126                @remark also resets the statistics evaluated in the last traversal
127        */
128        void InitTraversal();
129        /** Returns current frame id.
130                @returns frame id
131        */
132        unsigned int GetFrameId() const;
133        /** Returns a pointer to the distance queue.
134                @returns current distance queue.
135                @remark the distance queue stores hierarchy nodes in a front-to-back order
136        */
137        DistanceQueue *GetQueue();
138        /** Checks if the node is visible from the current view frustum.
139                @param node the current node
140        */
141        bool CheckFrustumVisible(HierarchyNode *node);
142        /** Returns number of traversed nodes.
143        */
144        unsigned int GetNumTraversedNodes();
145        /** Returns number of rendered nodes.
146        */
147        unsigned int GetNumRenderedNodes();
148        /** Returns vector of visible hierarchy nodes from previous render.
149        */
150        std::vector<HierarchyNode *> *GetVisibleNodes();
151        /** Pulls up the last visited information of this node.
152        */
153        virtual void PullUpLastVisited(HierarchyNode *node, const int frameId) const = 0;
154        /** Returns parent node.
155        */
156        virtual HierarchyNode *GetParent(HierarchyNode *node) = 0;
157        /** Returns #frames this node is assumed to be visible.
158        */
159        virtual int GetNodeAssumedVisible(HierarchyNode *node) = 0;
160        /** Sets #frames this node is assumed to be visible.
161        */
162        virtual void SetNodeAssumedVisible(HierarchyNode *node, int assumedVisible) = 0;
163        /** Decreases #frames this node is assumed to be visible.
164        */
165        virtual void DecNodeAssumedVisible(HierarchyNode *node) = 0;
166
167protected:
168
169        /// the current frame number
170        unsigned int mFrameId;
171       
172        /// index of the lcurrent occlusion query in the array of queries
173        /// NOTE: should rather be iterator
174        int mCurrentTestIdx;
175       
176        /// number of traversed nodes
177        unsigned int mNumTraversedNodes;
178
179        /// The queue is useful for rendering hierarchy nodes in front to back order.
180        DistanceQueue *mDistanceQueue;
181
182        /// the root of the hierarchy
183        HierarchyNode *mHierarchyRoot;
184       
185        /// buffer for a node pointer
186        HierarchyNode *mOldNode;
187
188        /// list of rendered hierarchy nodes (e.g., useful for exact visibility queries)
189        std::vector<HierarchyNode *> mVisibleNodes;
190};
191
192} // namespace GtpVisibility
193
194#endif // GtpVisisibilityHierarchyInterface_H
Note: See TracBrowser for help on using the repository browser.