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

Revision 2306, 6.7 KB checked in by mattausch, 18 years ago (diff)
Line 
1#ifndef _GtpVisibilityHierarchyInterface_H__
2#define _GtpVisibilityHierarchyInterface_H__
3
4#include "DistanceQueue.h"
5//#include "VisibilityMesh.h"
6#include <stack>
7
8namespace GtpVisibility {
9
10enum  CullingType {QUERY_CULLED, FRUSTUM_CULLED};
11
12typedef std::vector<HierarchyNode *> NodeVector;
13//typedef std::vector<GtpVisibility::Mesh *> GeometryVector;
14//typedef std::vector<GtpVisibility::Patch *> PatchVector;
15
16typedef std::pair<HierarchyNode *, OcclusionQuery *> QueryPair;
17typedef std::pair<HierarchyNode *, bool> PendingQuery;
18typedef std::queue<QueryPair> QueryQueue;
19typedef std::queue<PendingQuery> PendingQueue;
20
21typedef std::vector<HierarchyNode *> HierarchyNodeContainer;
22
23
24/**     Class which implements an interface for the operations on a hierarchy
25        of a scene.
26        It has to be implemented for any rendering engine to use the CHC algorithm.
27*/
28class HierarchyInterface
29{
30public:
31        /** Default constructor.
32        */
33        HierarchyInterface();
34        virtual ~HierarchyInterface();
35        /** Returns true if current node is leaf of the hierarchy.
36                @param node hierarchy node
37                @returns true if node is leaf
38        */
39    virtual bool IsLeaf(HierarchyNode *node) const = 0;
40        /** Traverses and renders the hierarchy from the given node.
41                @param node the hierarchy node
42        */
43        virtual void TraverseNode(HierarchyNode *node) = 0;
44        /** Renders the given hierarchy node.
45                @param node current hierarchy node to be rendered
46        */
47        virtual void RenderNode(HierarchyNode *node) = 0;
48        /** Pulls up the visibility from the current node recursively to the parent nodes.
49                @param node the current node
50        */
51        virtual void PullUpVisibility(HierarchyNode *node) const = 0;
52        /** Issue a occlusion query for this node.
53                @param node the current hierarchy node
54                @param wasVisible if the node was visible in the last frame: based
55                on this the method can decide on the way of querying
56                @returns occlusion query for this node
57        */
58        virtual OcclusionQuery *IssueNodeOcclusionQuery(HierarchyNode *node,
59                                                                                                        const bool wasVisible = 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        virtual void RenderNodeRecursive(HierarchyNode *node) = 0;
101
102        /** Returns frame id when this node was last visited by the traverser. See set
103        */
104        virtual unsigned int LastVisited(HierarchyNode *node) const = 0;
105               
106        /** Visualization of a culled node, dependent on the culling type.
107                @param node the hierarchy node to be visualized
108                @param type can be one of FRUSTUM_CULLED, QUERY_CULLED
109        */
110        virtual void VisualizeCulledNode(HierarchyNode *node,
111                                                                         CullingType type) const = 0;
112
113        /** Sets the root of the scene hierarchy.
114                @param root the hierarchy root
115        */
116        void SetHierarchyRoot(HierarchyNode *root);
117    /** Get the root of the scene hierarchy.
118                @return the hierarchy root
119        */
120        HierarchyNode *GetHierarchyRoot() const;
121       
122        /** This is an optimization when issuing the occlusion test.
123                The test is done with actual geometry rather than the bounding
124                box of leave nodes previously marked as visible.
125
126                @param testGeometry if this optimization should be used
127                @remark this option is only useful for the coherent hierarchical culling algorithm
128        */
129        void TestGeometryForVisibleLeaves(bool testGeometry);
130
131        /** Sets the scene root and initialises this hierarchy interface for a traversal.               
132                @remark also resets the statistics evaluated in the last traversal
133        */
134        void InitTraversal();
135        /** Returns current frame id.
136                @returns frame id
137        */
138        unsigned int GetFrameId() const;
139        /** Returns a pointer to the distance queue.
140                @returns current distance queue.
141                @remark the distance queue stores hierarchy nodes in a front-to-back order
142        */
143        DistanceQueue *GetQueue();
144
145        /** Checks if the node is visible from the current view frustum.
146                @param node the current node
147        */
148        bool CheckFrustumVisible(HierarchyNode *node);
149
150        /** Returns number of traversed nodes.
151        */
152        unsigned int GetNumTraversedNodes();
153        /** Returns number of rendered nodes.
154        */
155        unsigned int GetNumRenderedNodes();
156
157        /** Returns vector of visible hierarchy nodes from previous render.
158        */
159        std::vector<HierarchyNode *> *GetVisibleNodes();
160
161        virtual void PullUpLastVisited(GtpVisibility::HierarchyNode *node, const int frameId) const = 0;
162        virtual void DetermineVisibilityRatio(GtpVisibility::HierarchyNode *node) const = 0;
163        virtual float GetNodeVisibilityRatio(GtpVisibility::HierarchyNode *node) const = 0;
164
165protected:
166
167
168        /// chc optimization for testing geometry of leaves instead of bounding box
169        bool mTestGeometryForVisibleLeaves;
170        /// the current frame number
171        unsigned int mFrameId;
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 *mSavedNode;
187
188        /// list of rendered hierarchy nodes (e.g., useful for exact visibility queries)
189        std::vector<HierarchyNode *> mVisibleNodes;
190};
191} // namespace GtpVisibility
192
193#endif // GtpVisisibilityHierarchyInterface_H
Note: See TracBrowser for help on using the repository browser.