source: GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.h @ 2709

Revision 2709, 9.2 KB checked in by mattausch, 16 years ago (diff)

sheduling dynamic object only when necessary

Line 
1#ifndef _Preprocessor_H__
2#define _Preprocessor_H__
3
4#include <string>
5//
6#include "Containers.h"
7#include "Mesh.h"
8#include "KdTree.h"
9#include "SimpleRay.h"
10
11
12namespace GtpVisibilityPreprocessor {
13
14class PreprocessorThread; 
15class RenderSimulator;
16class SceneGraph;
17class Exporter;
18class ViewCellsManager;
19class BspTree;
20class VspOspTree;
21class VspBspTree;
22class RenderSimulator;
23struct VssRayContainer;
24class SamplingStrategy;
25class GlRendererBuffer;
26class VspTree;
27class HierarchyManager;
28class BvHierarchy;
29class Intersectable;
30class VssRay;
31class RayCaster;
32class GlobalLinesRenderer;
33class SceneGraphLeaf;
34class GlRendererWidget;
35class IntersectableGroup;
36
37
38/** Namespace for the external visibility preprocessor
39
40    This namespace includes all classes which are created by the VUT (Vienna University
41    of Technology) for the External Visibility Preprocessor of the GTP (GameTools Project)
42    (www.gametools.org).
43*/
44 
45/** Main class of the visibility preprocessor. Responsible for loading and
46    saving of the input and output files. Initiates construction of the kD-tree,
47    viewcell loading/generation and the visibility computation itself.
48*/
49class Preprocessor
50{
51        friend class RayCaster;
52        friend class IntelRayCaster;
53        friend class InternalRayCaster;
54        friend class HavranRayCaster;
55
56public:
57        /** Default constructor initialising e.g., KD tree and BSP tree.
58        */
59        Preprocessor();
60
61        virtual ~Preprocessor();
62        /** Load the input scene.
63                @param filename file to load
64                @return true on success
65        */
66        virtual bool LoadScene(const string &filename);
67        /** Export all preprocessed data in a XML format understandable by the
68                PreprocessingInterface of the GtpVisibilityPreprocessor Module.
69                The file can be compressed depending on the environement settings.
70                @return true on successful export
71        */
72        virtual bool ExportPreprocessedData(const string &filename);
73        /** Build the KdTree of currently loaded occluders/occludees/viewcells. The construction
74                is driven by the environment settings, which also sais which of the three types of
75                entities should be used to drive the heuristical construction (only occluders by default)
76        */
77        virtual bool BuildKdTree();
78        /** Compute visibility method. This method has to be reimplemented by the actual
79                Preprocessor implementation (e.g. SamplingPreprocessor, ExactPreprocessor,
80                GlobalSamplingpreprocessor)
81        */
82        virtual bool ComputeVisibility() = 0;
83        /** Post Process the computed visibility. By default applys the visibility filter
84                (if specified in the environment and export the preprocessed data
85        */
86        virtual bool PostProcessVisibility();
87        /** View cells are either loaded or prepared for generation, according to the chosen environment
88                object. Important evironment options are, e.g, the view cell type.
89                Should be done after scene loading (i.e., some options are based on scene type).
90        */
91        bool PrepareViewCells();
92        /** Construct viewcells from the scratch
93        */
94        bool ConstructViewCells();
95        /** Returns the specified sample strategy, NULL if no valid strategy.
96        */
97        SamplingStrategy *GenerateSamplingStrategy(const int strategyId);
98        /** Export preprocessor data.
99        */
100        bool Export(const string &filename, const bool scene, const bool kdtree); 
101
102        virtual void KdTreeStatistics(ostream &s);
103        virtual void BspTreeStatistics(ostream &s);
104
105        /** Loads samples from file.
106        @param samples returns the stored sample rays
107        @param objects needed to associate the objects ids
108        @returns true if samples were loaded successfully
109        */
110        bool LoadSamples(VssRayContainer &samples, ObjectContainer &objects) const;
111
112        /** Exports samples to file.
113                @returns true if samples were written successfully
114        */
115        bool ExportSamples(const VssRayContainer &samples) const;
116
117        bool LoadKdTree(const string &filename);
118        bool ExportKdTree(const string &filename);
119
120        virtual bool
121        ExportRays(const char *filename,
122                           const VssRayContainer &vssRays,
123                           const int number,
124                           const bool exportScene = false
125                           );
126
127        bool ExportRayAnimation(const char *filename,
128                                                        const vector<VssRayContainer> &vssRays);
129
130        virtual int     GenerateRays(const int number,
131                                                         SamplingStrategy &strategy,
132                                                         SimpleRayContainer &rays);
133
134        virtual int GenerateRays(const int number,
135                                                         const int raysType,
136                                                         SimpleRayContainer &rays);
137
138        bool GenerateRayBundle(SimpleRayContainer &rayBundle,
139                                                   const SimpleRay &mainRay,
140                                                   const int number,
141                                                   const int shuffleType) const;
142
143        virtual void CastRays(SimpleRayContainer &rays,
144                                                  VssRayContainer &vssRays,
145                                                  const bool castDoubleRays,
146                                                  const bool pruneInvalidRays = true);
147
148        virtual void
149                CastRaysWithHwGlobalLines(
150                SimpleRayContainer &rays,
151                VssRayContainer &vssRays,
152                const bool castDoubleRays,
153                const bool pruneInvalidRays
154                );
155
156        /** Compute pixel error of the current PVS solution by sampling given number of viewpoints.
157        */
158        virtual void ComputeRenderError();
159
160        /** Returns a view cells manager of the given name.
161        */
162        ViewCellsManager *CreateViewCellsManager(const char *name);
163
164        GlRendererBuffer *GetRenderer();
165
166        bool InitRayCast(const string &externKdTree, const string &internKdTree);
167
168        bool LoadInternKdTree(const string &internKdTree);
169
170        bool ExportObj(const string &filename, const ObjectContainer &objects);
171
172        Intersectable *GetParentObject(const int index) const;
173        Vector3 GetParentNormal(const int index) const;
174
175        /** Sets a preprocessor thread.
176        */
177        void SetThread(PreprocessorThread *t);
178
179        /** Returns a preprocessor thread.
180        */
181        PreprocessorThread *GetThread() const;
182
183        Intersectable *GetObjectById(const int id);
184
185        void PrepareHwGlobalLines();
186
187        virtual void DeterminePvsObjects(VssRayContainer &rays);
188
189        static bool LoadObjects(const string &filename,
190                                                        ObjectContainer &pvsObjects,
191                                                        const ObjectContainer &preprocessorObject);
192
193        /** Adds dynamic geometry
194        */
195        SceneGraphLeaf *LoadDynamicGeometry(const string &filename);
196
197        /** Register the dynamic object to be handled by the ray caster for visibility
198                computation.
199        */
200        void RegisterDynamicObject(SceneGraphLeaf *leaf);
201       
202        void UpdateObjectInRayCaster(SceneGraphLeaf *l);
203       
204        void ScheduleUpdateDynamicObjects();
205        void UpdateDynamicObjects();
206        /** Notify the preprocessor that an object has been deleted
207        */
208        virtual void ObjectRemoved(SceneGraphLeaf *object);
209
210
211
212        /////////////////////////
213
214        bool mSynchronize;
215
216        /// scene graph loaded from file
217        SceneGraph *mSceneGraph;
218
219        /// raw array of objects
220        ObjectContainer mObjects;
221
222        /// kD-tree organizing the scene graph (occluders + occludees) + viewcells
223        KdTree *mKdTree;
224        AxisAlignedBox3 sceneBox;
225
226        /// View space partition bsp tree
227        VspBspTree *mVspBspTree;
228        /// BSP tree representing the viewcells
229        BspTree *mBspTree;
230
231        /// list of all loaded occluders
232        ObjectContainer mOccluders;
233        /// list of all loaded occludees
234        ObjectContainer mOccludees;
235        /// the view cells manager
236        ViewCellsManager *mViewCellsManager;
237
238        DynamicObjectsContainer mDynamicObjects;
239
240        /// greedy optimized hierarchy for both objects and view cells
241        VspOspTree *mVspOspTree;
242
243        bool mUseGlRenderer;
244        bool mUseGlDebugger;
245
246        bool mUseHwGlobalLines;
247        bool mLoadViewCells;
248
249        bool mDetectEmptyViewSpace;
250
251        bool mQuitOnFinish;
252        bool mLoadMeshes;
253        bool mComputeVisibility;
254
255        bool mExportVisibility;
256        string mVisibilityFileName;
257
258        bool mApplyVisibilityFilter;
259        bool mApplyVisibilitySpatialFilter;
260
261        float mVisibilityFilterWidth;
262
263        int mPass;
264
265        bool mStopComputation;
266
267        bool mExportObj;
268
269        bool mExportRays;
270        bool mExportAnimation;
271        int mExportNumRays;
272
273        ofstream mStats;
274
275        GlRendererBuffer *renderer;
276        GlRendererWidget *mRendererWidget;
277
278        int mTotalSamples;
279        int mCurrentSamples;
280
281        int mTotalTime;
282        int mSamplesPerPass;
283        int mSamplesPerEvaluation;
284 
285        int mTotalRaysCast;
286
287        RayCaster *mRayCaster;
288
289        // triangle pvs for gvs
290        // hack: should be in gvspreprocessor but pulled
291        // out here for visualization purpose
292        ObjectContainer mTrianglePvs;
293
294        // generic stats vector that can be used for anything
295        int mGenericStats[2];
296
297        //std::vector<int> mDummyBuffer;
298
299
300protected:
301
302        bool LoadBinaryObj(const std::string &filename,
303                       SceneGraphLeaf *root,
304                                           std::vector<FaceParentInfo> *parents,
305                                           float scale = -1.0f);
306
307        bool ExportBinaryObj(const std::string &filename, SceneGraphLeaf *root);
308
309        void SetupRay(Ray &ray, const Vector3 &point,
310                      const Vector3 &direction) const;
311
312        void EvalPvsStat();
313
314        virtual void EvalViewCellHistogram();
315
316        /** Notify the preprocessor that an object has moved and must be reevaluated.
317        */
318        virtual void ObjectMoved(SceneGraphLeaf *object);
319       
320
321
322        /////////////////////////
323
324        GlobalLinesRenderer *mGlobalLinesRenderer;
325
326        /// samples used for construction of the BSP view cells tree.
327        int mBspConstructionSamples;
328        /// samples used for construction of the VSP OSP tree.
329        int mVspOspConstructionSamples;
330        /// Simulates rendering of the scene.
331        RenderSimulator *mRenderSimulator;
332
333        vector<FaceParentInfo> mFaceParents;
334
335        /// if box around view space should be used
336        bool mUseViewSpaceBox;
337
338        PreprocessorThread *mThread;
339
340        bool mUpdateDynamicObjects;
341
342       
343};
344
345extern Preprocessor *preprocessor;
346
347}
348
349#endif
Note: See TracBrowser for help on using the repository browser.