source: trunk/VUT/GtpVisibilityPreprocessor/src/Mesh.h @ 170

#ifndef _Mesh_H__
#define _Mesh_H__

#include <vector>
using namespace std;
#include "Intersectable.h"
#include "Plane3.h"
#include "Matrix4x4.h"
#include "AxisAlignedBox3.h"
#include "Material.h"


class MeshInstance;
class MeshKdTree;

/// default vertex container for Mesh
typedef std::vector<Vector3> VertexContainer;

/// vertex index container
typedef std::vector<int> VertexIndexContainer;


/** Patch used as an element of the mesh */
class Face {
public:
  Face():mVertexIndices() {}
  Face(const int a, const int b, const int c):mVertexIndices(3) {
    mVertexIndices[0] = a;
    mVertexIndices[1] = b;
    mVertexIndices[2] = c;
  }

  Face(const int a, const int b, const int c, const int d):mVertexIndices(4) {
    mVertexIndices[0] = a;
    mVertexIndices[1] = b;
    mVertexIndices[2] = c;
    mVertexIndices[3] = d;
  }

  Face(const VertexIndexContainer &vertices):mVertexIndices(vertices) {}
  
  /// list of vertex pointers
  VertexIndexContainer mVertexIndices;
};

/// default patch container for Mesh
typedef std::vector<Face *> FaceContainer;

/** Mesh containing polygonal patches */
class Mesh {


public:

  /// Default constructor
  Mesh():mVertices(), mFaces(), mMaterial(NULL), mKdTree(NULL) {}
  
  /// Constructor with container preallocation
  Mesh(const int vertices,
       const int faces):mVertices(),
                        mFaces(),
                        mMaterial(NULL)
  {
    mVertices.reserve(vertices);
    mFaces.reserve(faces);
  }
  
  ~Mesh() {
    for (int i=0; i < mFaces.size(); i++)
      delete mFaces[i];
  }
  
  void AddFace(Face *face) 
  {
    mFaces.push_back(face);
  }
  
  void Preprocess();

  /** Axis aligned bounding box of the mesh */
  AxisAlignedBox3 mBoundingBox;
  
  /** Vertices forming the mesh */
  VertexContainer mVertices;
  
  /** Patches forming the mesh */
  FaceContainer mFaces;
  
  /** Global mesh material */
  Material *mMaterial;
  
  /** true if the mesh is a convex mesh */
  bool mIsConvex;

  MeshKdTree *mKdTree;
  
  int
  CastRay(
          Ray &ray,
          MeshInstance *instance
          );

  int
  CastRayToSelectedFaces(
                         Ray &ray,
                         const vector<int> &faces,
                         MeshInstance *instance
                         );

  int
  CastRayToFace(
                const int faceIndex,
                Ray &ray,
                float &nearestT,
                int &nearestFace,
                MeshInstance *instance
                );

  
  int
  RayFaceIntersection(const int faceIndex,
                      const Ray &ray,
                      float &t,
                      const float nearestT
                      );
  
  Plane3 GetFacePlane(const int faceIndex);

  AxisAlignedBox3 GetFaceBox(const int faceIndex);
  
};

class MeshInstance : public Intersectable {
protected:
  static int mailID;
  int mailbox;
  float mVisibility;
  Mesh *mMesh;
  
public:
  MeshInstance(Mesh *mesh):mMesh(mesh), mVisibility(1.0f), mailbox(0)
  {
  }
  
  void Mail() { mailbox = mailID; }
  static void NewMail() { mailID++; }
  bool Mailed() const { return mailbox == mailID; }
  

  Mesh *GetMesh() { return mMesh; }

  virtual AxisAlignedBox3 GetBox() {
    return mMesh->mBoundingBox;
  }

  virtual int
  CastRay(
          Ray &ray
          );
  
  virtual int
  CastRay(
          Ray &ray,
          const vector<int> &faces
          );


};


class MeshTransformedInstance : public MeshInstance
{
public:
  MeshTransformedInstance(Mesh *mesh):MeshInstance(mesh)
  {
    mWorldTransform = IdentityMatrix();
  }
  
  virtual AxisAlignedBox3 GetBox() {
    return Transform(mMesh->mBoundingBox,
                     mWorldTransform);
  }

  virtual int
  CastRay(
          Ray &ray
          );

private:
  Matrix4x4 mWorldTransform;
  
};



#endif