source: GTP/trunk/Lib/Vis/Preprocessing/src/RayCaster.h @ 2187

Revision 2187, 3.8 KB checked in by mattausch, 18 years ago (diff)
Line 
1#ifndef _RayCaster_H__
2#define _RayCaster_H__
3
4#include "Containers.h"
5#include <string>
6#include "Vector3.h"
7#include "VssRay.h"
8
9//
10
11
12namespace GtpVisibilityPreprocessor {
13
14
15class Intersectable;
16class VssRay;
17class SimpleRayContainer;
18class AxisAlignedBox3;
19//class Vector3;
20struct VssRayContainer;
21class Preprocessor;
22struct SimpleRay;
23
24
25/** This class provides an interface for ray casting.
26*/
27class RayCaster
28{
29
30public:
31       
32        enum {
33          INTERNAL_RAYCASTER = 0,
34          INTEL_RAYCASTER
35        };
36
37        RayCaster(const Preprocessor &preprocessor);
38
39        virtual ~RayCaster();
40
41        virtual int Type() const = 0;
42
43        /** Wrapper for casting single ray.
44                @returns ray or NULL if invalid
45        */
46        VssRay *CastRay(const SimpleRay &simpleRay,
47                                        const AxisAlignedBox3 &box,
48                                        const bool castDoubleRay);
49
50        virtual int CastRay(const SimpleRay &simpleRay,
51                                                VssRayContainer &vssRays,
52                                                const AxisAlignedBox3 &box,
53                                                const bool castDoubleRay,
54                                                const bool pruneInvalidRays = true) = 0;
55
56        virtual void CastRays16(SimpleRayContainer &rays,
57                                                        VssRayContainer &vssRays,
58                                                        const AxisAlignedBox3 &sbox,
59                                                        const bool castDoubleRay,
60                                                        const bool pruneInvalidRays = true) = 0;
61
62  virtual void CastRays(
63                                                SimpleRayContainer &rays,
64                                                VssRayContainer &vssRays,
65                                                const AxisAlignedBox3 &sbox,
66                                                const bool castDoubleRay,
67                                                const bool pruneInvalidRays = true);
68
69  /*virtual void CastRaysEye4(SimpleRayContainer &rays,
70                                                          VssRayContainer &vssRays,
71                                                          const AxisAlignedBox3 &sbox,
72                                                          const bool castDoubleRay,
73                                                          const bool pruneInvalidRays = true) = 0;
74*/
75        virtual void
76        SortRays(SimpleRayContainer &rays);
77
78
79  // pool of vss rays to be used in one pass of the sampling
80  struct VssRayPool {
81        VssRayPool(): mRays(NULL), mIndex(0), mNumber(0)
82        {}
83
84        ~VssRayPool()
85        {
86                DEL_PTR(mRays);
87        }
88       
89        void Reserve(const int number) {
90                DEL_PTR(mRays);
91                mRays = new VssRay[number];
92                mNumber = number;
93        }
94       
95        void Clear() {
96          mIndex = 0;
97        }
98        VssRay *Alloc() {
99                // reset pool
100                if (mIndex == mNumber)
101                        mIndex = 0;
102          return mRays + mIndex ++;
103        }
104  protected:
105        VssRay *mRays;
106        int mIndex;
107        int mNumber;
108  };
109
110  VssRayPool mVssRayPool;
111
112  void ReserveVssRayPool(const int n) {
113        mVssRayPool.Reserve(n);
114  }
115 
116  void InitPass() {
117        mVssRayPool.Clear();
118  }
119
120
121protected:
122
123        VssRay *RequestRay(const Vector3 &origin,
124                                           const Vector3 &termination,
125                                           Intersectable *originObject,
126                                           Intersectable *terminationObject,
127                                           const int pass,
128                                           const float pdf);
129
130  void _SortRays(SimpleRayContainer &rays,
131                                 const int l,
132                                 const int r,
133                                 const int depth,
134                                 float box[12]);
135       
136  struct Intersection
137  {
138          Intersection(): mObject(NULL), mFaceId(0)
139          {}
140
141          Intersection(const Vector3 &p, const Vector3 &n, Intersectable *o, const int f):
142          mPoint(p), mNormal(n), mObject(o), mFaceId(f)
143          {}
144
145          Intersection(const Vector3 &p): mPoint(p), mObject(NULL), mFaceId(0)
146          {}
147          Vector3 mPoint;
148          Vector3 mNormal;
149          Intersectable *mObject;
150          int mFaceId;
151  };
152
153
154  int ProcessRay(const SimpleRay &ray,
155          Intersection &hitA,
156          Intersection &hitB,
157          VssRayContainer &vssRays,
158          const AxisAlignedBox3 &box,
159          const bool castDoubleRay,
160          const bool pruneInvalidRays = true);
161
162  /** Checks if ray is valid.
163          I.e., the ray is in valid view space.
164          @note: clamps the ray to valid view space.
165  */
166  bool ValidateRay(const Vector3 &origin,
167          const Vector3 &direction,
168          const AxisAlignedBox3 &box,
169          Intersection &hit);
170
171  bool
172          ClipToViewSpaceBox(const Vector3 &origin,
173          const Vector3 &termination,
174          Vector3 &clippedOrigin,
175          Vector3 &clippedTermination);
176
177
178
179
180
181
182  const Preprocessor &mPreprocessor;
183};
184
185
186}
187
188#endif
Note: See TracBrowser for help on using the repository browser.