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

Revision 1292, 8.1 KB checked in by bittner, 18 years ago (diff)

intel ray caster updates

Line 
1#ifndef _Preprocessor_H__
2#define _Preprocessor_H__
3
4#include <string>
5using namespace std;
6#include "Containers.h"
7#include "Mesh.h"
8#include "KdTree.h"
9
10// matt: remove qt dependencies
11//#include <QObject>
12
13namespace GtpVisibilityPreprocessor {
14
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;
31
32/** Namespace for the external visibility preprocessor
33
34    This namespace includes all classes which are created by the VUT (Vienna University
35    of Technology) for the External Visibility Preprocessor of the GTP (GameTools Project)
36    (www.gametools.org).
37*/
38 
39/** Main class of the visibility preprocessor. Responsible for loading and
40    saving of the input and output files. Initiates construction of the kD-tree,
41    viewcell loading/generation and the visibility computation itself.
42*/
43// matt: remove qt dependencies
44class Preprocessor// : public QObject
45{
46  //Q_OBJECT
47
48public:
49        /** Default constructor initialising e.g., KD tree and BSP tree.
50        */
51        Preprocessor();
52
53   virtual ~Preprocessor();
54
55  /** Load the input scene.
56      @param filename file to load
57          @return true on success
58  */
59  virtual bool LoadScene(const string filename);
60 
61  /** Export all preprocessed data in a XML format understandable by the
62      PreprocessingInterface of the GtpVisibilityPreprocessor Module. The file can be compressed depending
63      on the environement settings.
64      @return true on successful export
65  */
66  virtual bool ExportPreprocessedData(const string filename);
67 
68  /** Build the KdTree of currently loaded occluders/occludees/viewcells. The construction
69      is driven by the environment settings, which also sais which of the three types of
70      entities should be used to drive the heuristical construction (only occluders by default)
71  */
72  virtual bool BuildKdTree();
73
74  /** Compute visibility method. This method has to be reimplemented by the actual
75      Preprocessor implementation (e.g. SamplingPreprocessor, ExactPreprocessor,
76      GlobalSamplingpreprocessor)
77    */
78  virtual bool ComputeVisibility() = 0;
79
80  /** Post Process the computed visibility. By default applys the visibility filter
81          (if specified in the environment and export the preprocessed data */
82  virtual bool PostProcessVisibility();
83
84  /** View cells are either loaded or prepared for generation, according to the chosen environment
85      object. Important evironment options are, e.g, the view cell type.
86      Should be done after scene loading (i.e., some options are based on scene type).
87  */
88  bool PrepareViewCells();
89
90  /** Construct viewcells (if not already loaded) */
91  bool
92  ConstructViewCells();
93
94  /** Returns the specified sample strategy, NULL if no valid strategy.
95  */
96  SamplingStrategy *GenerateSamplingStrategy(const int strategyId) const;
97
98  bool
99  Export( const string filename,
100          const bool scene,
101          const bool kdtree,
102          const bool bsptree
103          );
104 
105 
106  virtual void KdTreeStatistics(ostream &s);
107  virtual void BspTreeStatistics(ostream &s);
108
109  /** Loads samples from file.
110          @param samples returns the stored sample rays
111          @param objects needed to associate the objects ids
112          @returns true if samples were loaded successfully
113  */
114  bool LoadSamples(VssRayContainer &samples,
115                                   ObjectContainer &objects) const;
116
117  /** Exports samples to file.
118          @returns true if samples were written successfully
119  */
120  bool ExportSamples(const VssRayContainer &samples) const;
121
122  bool LoadKdTree();
123  bool ExportKdTree();
124
125  /** Get Sample rays of particular type, returns false if this
126          type of rays is not supported by the preprocessor
127  */
128  enum {
129        OBJECT_BASED_DISTRIBUTION,
130        DIRECTION_BASED_DISTRIBUTION,
131        DIRECTION_BOX_BASED_DISTRIBUTION,
132        SPATIAL_BOX_BASED_DISTRIBUTION,
133        RSS_BASED_DISTRIBUTION,
134        RSS_SILHOUETTE_BASED_DISTRIBUTION,
135        VSS_BASED_DISTRIBUTION,
136        OBJECT_DIRECTION_BASED_DISTRIBUTION,
137        OBJECTS_INTERIOR_DISTRIBUTION
138  };
139 
140  enum {
141          INTERNAL_RAYCASTER = 0,
142          INTEL_RAYCASTER
143  };
144
145  virtual bool
146  GenerateRays(
147                           const int number,
148                           const int raysType,
149                           SimpleRayContainer &rays
150                           );
151 
152  virtual void CastRays(SimpleRayContainer &rays,
153                                                VssRayContainer &vssRays);
154
155  /** Returns a view cells manager of the given name.
156  */
157  ViewCellsManager *CreateViewCellsManager(const char *name);
158  /** Returns a hierarchy manager of the given name.
159  */
160  HierarchyManager *CreateHierarchyManager(const char *name);
161   
162  GlRendererBuffer *GetRenderer() { return renderer;}
163
164  bool InitRayCast(const string externKdTree);
165
166  int CastRay(
167          const Vector3 &viewPoint,
168          const Vector3 &direction,
169          const float probability,
170          VssRayContainer &vssRays,
171          const AxisAlignedBox3 &box
172          );
173
174  Intersectable *
175  CastSimpleRay(
176                                const Vector3 &viewPoint,
177                                const Vector3 &direction,
178                                const AxisAlignedBox3 &box,
179                                Vector3 &point,
180                                Vector3 &normal
181                                );
182 
183  ////////////////////////////////////////////////
184
185  /// scene graph loaded from file
186  SceneGraph *mSceneGraph;
187
188  /// raw array of objects
189  ObjectContainer mObjects;
190 
191  /// kD-tree organizing the scene graph (occluders + occludees) + viewcells
192  KdTree *mKdTree;
193  /// View space partition bsp tree
194  VspBspTree *mVspBspTree;
195  // view space partition tree
196  VspTree *mVspTree;
197  HierarchyManager *mHierarchyManager;
198  /// BSP tree representing the viewcells
199  BspTree *mBspTree;
200 
201  /// list of all loaded occluders
202  ObjectContainer mOccluders;
203  /// list of all loaded occludees
204  ObjectContainer mOccludees;
205   
206 
207  ViewCellsManager *mViewCellsManager;
208
209  /// greedy optimized hierarchy for both objects and view cells
210  VspOspTree *mVspOspTree;
211
212  bool mUseGlRenderer;
213  bool mUseGlDebugger;
214
215  bool mLoadViewCells;
216 
217  bool mDetectEmptyViewSpace;
218
219  bool mQuitOnFinish;
220  bool mLoadPolygonsAsMeshes;
221  bool mComputeVisibility;
222
223  bool mExportVisibility;
224  string mVisibilityFileName;
225 
226  bool mApplyVisibilityFilter;
227  bool mApplyVisibilitySpatialFilter;
228
229  float mVisibilityFilterWidth;
230 
231  int GetRayCastMethod() { return mRayCastMethod; }
232  void SetRayCastMethod(int rayCastMethod) { mRayCastMethod = rayCastMethod; }
233
234  int mPass;
235
236protected:
237
238        void SetupRay(Ray &ray, const Vector3 &point, const Vector3 &direction);
239
240  int
241  ProcessRay(
242                         const Vector3 &viewPoint,
243                         const Vector3 &direction,
244                         Intersectable *objectA,
245                         Vector3 &pointA,
246                         const Vector3 &normalA,
247                         Intersectable *objectB,
248                         Vector3 &pointB,
249                         const Vector3 &normalB,
250                         const float probability,
251                         VssRayContainer &vssRays,
252                         const AxisAlignedBox3 &box);
253 
254  int CastInternalRay(
255                                          const Vector3 &viewPoint,
256                                          const Vector3 &direction,
257                                          const float probability,
258                                          VssRayContainer &vssRays,
259                                          const AxisAlignedBox3 &box);
260 
261  int CastIntelDoubleRay(
262                                                 const Vector3 &viewPoint,
263                                                 const Vector3 &direction,
264                                                 const float probability,
265                                                 VssRayContainer &vssRays,
266                                                 const AxisAlignedBox3 &box);
267 
268  Intersectable *CastIntelSingleRay(
269                                                                        const Vector3 &viewPoint,
270                                                                        const Vector3 &direction,
271                                                                        Vector3 &tPoint,
272                                                                        const AxisAlignedBox3 &box);
273 
274  /////////////////////////
275
276        int mRayCastMethod;
277  /// samples used for construction of the BSP view cells tree.
278  int mBspConstructionSamples;
279  /// samples used for construction of the VSP OSP tree.
280  int mVspOspConstructionSamples;
281  /** Simulates rendering of the scene.
282  */
283  RenderSimulator *mRenderSimulator;
284
285 
286  vector<FaceParentInfo> mFaceParents;
287 
288  GlRendererBuffer *renderer;
289// matt: remove qt dependencies
290//signals:
291  void EvalPvsStat();
292
293  protected:
294
295 
296  void CastRays16(const int i,
297                                  SimpleRayContainer &rays,
298                                  VssRayContainer &vssRays,
299                                  const AxisAlignedBox3 &sbox);
300 
301};
302
303//extern Preprocessor *preprocessor;
304
305}
306
307#endif
Note: See TracBrowser for help on using the repository browser.