source: GTP/trunk/Lib/Vis/Preprocessing/src/Mesh.h @ 1419

Revision 1419, 7.6 KB checked in by mattausch, 18 years ago (diff)
RevLine 
[372]1#ifndef _Mesh_H__
2#define _Mesh_H__
3
4#include <vector>
5using namespace std;
6#include "Intersectable.h"
7#include "Plane3.h"
8#include "Matrix4x4.h"
9#include "AxisAlignedBox3.h"
10#include "Material.h"
[863]11#include "Containers.h"
[372]12
[863]13
[860]14namespace GtpVisibilityPreprocessor {
15
[878]16extern bool MeshDebug;
17
[372]18struct Triangle3;
19class MeshInstance;
20class MeshKdTree;
21
22
[1344]23/** Patch used as an element of the mesh
24*/
[752]25struct Face {
26
[372]27public:
28  Face(): mVertexIndices() {}
[752]29
[372]30  Face(const int a, const int b, const int c):mVertexIndices(3) {
31    mVertexIndices[0] = a;
32    mVertexIndices[1] = b;
33    mVertexIndices[2] = c;
34  }
35
36  Face(const int a, const int b, const int c, const int d):
37  mVertexIndices(4) {
38    mVertexIndices[0] = a;
39    mVertexIndices[1] = b;
40    mVertexIndices[2] = c;
41    mVertexIndices[3] = d;
42  }
43
[752]44  Face(const VertexIndexContainer &vertices):mVertexIndices(vertices.size()) {
45        for (int i=0;  i < vertices.size(); i++)
46          mVertexIndices[i] = vertices[i];
47  }
[372]48 
[1328]49  ////////////////////////////
[1327]50
[372]51  /// list of vertex pointers
52  VertexIndexContainer mVertexIndices; 
53};
54
[863]55
56
57/// default vertex container for Mesh
58typedef vector<Vector3> VertexContainer;
59
[372]60/// default patch container for Mesh
61typedef std::vector<Face *> FaceContainer;
62
63/** Mesh containing polygonal patches */
64class Mesh {
65
66public:
67
68  /// Default constructor
[1001]69  Mesh():mVertices(), mFaces(), mMaterial(NULL), mKdTree(NULL), mId(0) {}
70
[372]71  /// Constructor with container preallocation
[1001]72  Mesh(const int vertices, const int faces):
[372]73    mFaces(),
74    mMaterial(NULL),
75    mKdTree(NULL),
76    mVertices(),
77    mIsConvex(false),
[1001]78    mIsWatertight(false),
79        mId(0)
[372]80  {
81    mVertices.reserve(vertices);
82    mFaces.reserve(faces);
83  }
[1001]84
85  /** Constructor setting a unqiue mesh id.
86  */
87  Mesh(const int id);
88
89  /** Setting unique mesh id and using preallocation.
90  */
91  Mesh(const int id, const int vertices, const int faces);
92
93  /** Copy constructor making a deep copy of the faces.
94  */
95  Mesh(const Mesh &rhs);
96
97  /** Assignement operator.
98        @note does not copy id
99        @note preprocess may be necessary
100  */
101  Mesh& operator=(const Mesh& m);
102
[1005]103  ~Mesh();
104  void Clear();
[752]105 
106  void IndexVertices();
107 
108  void AssignRandomMaterial();
[372]109  void AddTriangle(const Triangle3 &triangle);
110  void AddRectangle(const Rectangle3 &triangle);
111
[693]112  void Cleanup();
113 
114  bool ValidateFace(const int face);
[372]115
116  void AddFace(Face *face)
117  {
118    mFaces.push_back(face);
119  }
[859]120
121  void ComputeBoundingBox();
[1001]122
123  /** This function must be called after creating the mesh
124        because it creates the local kd tree and the bounding box.
125        */
[1292]126  void Preprocess(const bool cleanup = true);
[372]127
[1001]128  /** Applies transformation to the mesh.
129        @note: meshkdtree will most likely be outdated after transformation, thus
130        another preprocess might be necessary. 
131        */
132  void ApplyTransformation(const Matrix4x4 &m);
133
134  /** Axis aligned bounding box of the mesh in local mesh coordinates.
135  */
[372]136  AxisAlignedBox3 mBox;
137 
[1001]138  /** Vertices forming the mesh.
139  */
[372]140  VertexContainer mVertices;
141 
[1001]142  /** Patches forming the mesh.
143  */
[372]144  FaceContainer mFaces;
145 
[1001]146  /** Global mesh material.
147  */
[372]148  Material *mMaterial;
149 
[1001]150  /** true if the mesh is a convex mesh.
151  */
[372]152  bool mIsConvex;
153
[1001]154  /** true if the mesh is a convex mesh.
155  */
[372]156  bool mIsWatertight;
157
158  MeshKdTree *mKdTree;
[1001]159
[372]160  int
[1001]161  CastRay(Ray &ray, MeshInstance *instance);
[372]162       
163  int
164  CastRayToSelectedFaces(
[1001]165                                                 Ray &ray,
166                                                 const vector<int> &faces,
167                                                 Intersectable *instance
168                                                 );
[372]169       
170  int
171  CastRayToFace(
[1001]172                                const int faceIndex,
173                                Ray &ray,
174                                float &nearestT,
[1199]175                                Vector3 &nearestNormal,
[1001]176                                int &nearestFace,
177                                Intersectable *instance
178                                );
[372]179       
180 
181  int
182  RayFaceIntersection(const int faceIndex,
[1199]183                                          const Ray &ray,
184                                          float &t,
185                                          Vector3 &normal,
186                                          const float nearestT
187                                          );
[372]188 
[1418]189  Plane3 GetFacePlane(const int faceIndex) const;
[372]190
191  AxisAlignedBox3 GetFaceBox(const int faceIndex);
192
193  int GetRandomSurfacePoint(Vector3 &point, Vector3 &normal);
194
[492]195  int
196  GetRandomVisibleSurfacePoint(Vector3 &point,
197                                                           Vector3 &normal,
198                                                           const Vector3 &viewpoint,
199                                                           const int maxTries
200                                                           );
[1001]201 
202  /** Returns unique mesh id.
203  */
204  int GetId() const
205  {
206          return mId;
207  }
208
[1418]209
210  Vector3 GetNormal(const int idx) const;
211
[1419]212  // $$ matt temp
213  bool CheckMesh() const;
214
215  void Print(ostream &app) const;
216
217  virtual ostream &Describe(ostream &s) const {
[492]218        return s<<"Mesh #vertices="<<(int)mVertices.size()<<" #faces="<<(int)mFaces.size();
219  }
[752]220 
[1001]221  /** Creates a mesh from a axis aligned bounding box.
222      The mesh is handled from the resource manager.
[991]223  */
224  friend Mesh *CreateMeshFromBox(const AxisAlignedBox3 &box);
[1001]225
[1419]226  friend ostream& operator<< (ostream &s, const Vector3 &A);
227
[1001]228protected:
229
230  /// Unique id of this mesh.
231  int mId;
[372]232};
233
[492]234
[1419]235// Overload << operator for C++-style output
236inline ostream&
237operator<< (ostream &s, const Mesh &A)
238{
239        A.Print(s);
240        return s;
241}
242
243
[372]244class MeshInstance : public Intersectable {
[1001]245
[372]246public:
[1001]247  MeshInstance(Mesh *mesh):Intersectable(), mMesh(mesh), mMaterial(NULL)
[372]248  {
249  }
250
251  int GetRandomSurfacePoint(Vector3 &point, Vector3 &normal);
252
253        int
254        GetRandomVisibleSurfacePoint(Vector3 &point,
255                                                                                                                         Vector3 &normal,
256                                                                                                                         const Vector3 &viewpoint,
257                                                                                                                         const int maxTries
258                                                                                                                         );
259
260
261  Mesh *GetMesh() { return mMesh; }
262
[1020]263  virtual AxisAlignedBox3 GetBox() const {
[372]264    return mMesh->mBox;
265  }
266
[1004]267  virtual int CastRay(Ray &ray);
[372]268
[1020]269  virtual bool IsConvex() const { return mMesh->mIsConvex; }
270  virtual bool IsWatertight() const { return mMesh->mIsWatertight; }
[372]271  virtual float IntersectionComplexity() {  return (float)mMesh->mFaces.size(); }
272
[1020]273  virtual int NumberOfFaces() const {  return (int)mMesh->mFaces.size(); }
[387]274
[372]275  virtual int Type() const { return MESH_INSTANCE; }
276
277  virtual int
278  CastRay(
279          Ray &ray,
280          const vector<int> &faces
281          );
282
283
284        virtual ostream &Describe(ostream &s) {
285                s<<"MeshInstance Id="<<GetId();
286                return mMesh->Describe(s);
287        }
288       
[1001]289        /** Sets the material. this overrides the material from
290                the mesh itself.
291        */
292        void SetMaterial(Material *mat);
293
294        /** Returns the material of this mesh instance.
295                if not defined, returns the material of the mesh itself.
296        */
297        Material *GetMaterial() const;
298
[1344]299        virtual Vector3 GetNormal(const int idx) const;
300
[1001]301protected:
302
303        Mesh *mMesh;
304        /** This material overrides the mesh material;
305        */
306        Material *mMaterial; 
[372]307};
308
309
[1001]310/** This mesh instance includes a world transform. Use this
311        class if the same mesh should be instantiated on different places.
312*/
[1004]313class TransformedMeshInstance: public MeshInstance
[372]314{
315public:
[1001]316  TransformedMeshInstance(Mesh *mesh);
[372]317 
[1020]318  virtual AxisAlignedBox3 GetBox() const;
[1001]319   
[372]320 
[1001]321  virtual int CastRay(Ray &ray);
[372]322
[1004]323  virtual int CastRay(Ray &ray, const vector<int> &faces);
324
[372]325  virtual int Type() const { return TRANSFORMED_MESH_INSTANCE; }
326
327  int GetRandomSurfacePoint(Vector3 &point, Vector3 &normal);
328
[1001]329  /** Transforms this mesh instance by m.
330  */
331  void ApplyWorldTransform(const Matrix4x4 &m);
332
333  /** Loads the transformation matrix into this mesh instance.
334  */
335  void LoadWorldTransform(const Matrix4x4 &m);
336
337  /** The transformation is returned in m.
338  */
[1020]339  void GetWorldTransform(Matrix4x4 &m) const;
[1001]340
[1004]341  /** Transforms a mesh according to the stored world transform.
[1020]342          @param transformedMesh returns the tranformed mesh.
[1002]343  */
[1020]344  void GetTransformedMesh(Mesh &transformedMesh) const;
[1002]345
[1344]346  Vector3 GetNormal(const int idx) const;
347
[1001]348protected:
349
350        /// the transformation matrix   
351        Matrix4x4 mWorldTransform;
[372]352 
353};
354
[860]355}
[372]356
357#endif
Note: See TracBrowser for help on using the repository browser.