source: GTP/trunk/Lib/Vis/Preprocessing/src/Mesh.cpp @ 1344

#include "Ray.h"
#include "Mesh.h"
#include "MeshKdTree.h"
#include "Triangle3.h"
#include "ResourceManager.h"

namespace GtpVisibilityPreprocessor {

bool MeshDebug = false;

int Intersectable::sMailId = 1;//2147483647;
int Intersectable::sReservedMailboxes = 1;

struct SortableVertex {

  Vector3 vertex;

  int originalId;
  int newId;
  int finalPos;

  SortableVertex() {}

  SortableVertex(const Vector3 &v,
                                 const int id):
        vertex(v),
        originalId(id),
        newId(id)
  {}
  
  friend bool operator<(const SortableVertex &a,
                                                const SortableVertex &b)
  {
        if (a.vertex.x < b.vertex.x)
          return true;
        else
          if (a.vertex.x > b.vertex.x)
                return false;
        
        if (a.vertex.y < b.vertex.y)
          return true;
        else
          if (a.vertex.y > b.vertex.y)
                return false;
        
        if (a.vertex.z < b.vertex.z)
          return true;
        else
          //      if (a.z > b.z)
          return false;
        
        //      return false;
  }

};


void
Mesh::ComputeBoundingBox()
{

  mBox.Initialize();
  VertexContainer::const_iterator vi = mVertices.begin();
  for (; vi != mVertices.end(); vi++) {
    mBox.Include(*vi);
  }
//mBox.Enlarge(1e-4f);
}

void
Mesh::Preprocess(bool cleanup)
{
  if (cleanup)
        Cleanup();
 
        ComputeBoundingBox();
 
        /** true if it is a watertight convex mesh 
        */
        mIsConvex = false;

        if (mFaces.size() > MeshKdTree::mTermMinCost) 
        {
                mKdTree = new MeshKdTree(this);
                MeshKdLeaf *root = (MeshKdLeaf *)mKdTree->GetRoot();
                
                for (int i = 0; i < mFaces.size(); i++)
                        root->mFaces.push_back(i);
                
                cout<<"KD";
                
                mKdTree->Construct();

                if (mKdTree->GetRoot()->IsLeaf()) 
                {
                        cout<<"d";
                        delete mKdTree;
                        mKdTree = NULL;
                }
        }
}


void
Mesh::IndexVertices()
{
  int i;
  // check whether the vertices can be simplfied and reindexed
  vector<SortableVertex> svertices(mVertices.size());

  for (i=0; i < mVertices.size(); i++)
        svertices[i] = SortableVertex(mVertices[i], i);

  sort(svertices.begin(), svertices.end());

  for (i=0; i < svertices.size() - 1; i++)
        if (svertices[i].vertex == svertices[i+1].vertex)
          svertices[i+1].newId = svertices[i].newId;

  // remove the same vertices
  int k = 0;
  mVertices[0] = svertices[0].vertex;
  svertices[0].finalPos = 0;
  
  for (i=1; i < svertices.size(); i++) {
        if (svertices[i].newId != svertices[i-1].newId)
          k++;
        
        mVertices[k] = svertices[i].vertex;
        svertices[i].finalPos = k;
  }

  mVertices.resize(k + 1);
  
  vector<int> remapBuffer(svertices.size());
  for (i = 0; i < svertices.size(); i++)
        remapBuffer[svertices[i].originalId] = svertices[i].finalPos;
  
  // remap all faces
  
  for (int faceIndex = 0; faceIndex < mFaces.size(); faceIndex++) {
        Face *face = mFaces[faceIndex];
        for (int i = 0; i < face->mVertexIndices.size(); i++) {
          face->mVertexIndices[i] = remapBuffer[face->mVertexIndices[i]];
        }
  }
}

AxisAlignedBox3
Mesh::GetFaceBox(const int faceIndex)
{
  Face *face = mFaces[faceIndex];
  AxisAlignedBox3 box;
  box.SetMin( mVertices[face->mVertexIndices[0]] );
  box.SetMax(box.Min());
  for (int i = 1; i < face->mVertexIndices.size(); i++) {
    box.Include(mVertices[face->mVertexIndices[i]]);
  }
  return box;
}

int
Mesh::CastRayToFace(
                                        const int faceIndex,
                                        Ray &ray,
                                        float &nearestT,
                                        Vector3 &nearestNormal,
                                        int &nearestFace,
                                        Intersectable *instance
                                        )
{
  float t;
  int hit = 0;
  Vector3 normal;
  if (RayFaceIntersection(faceIndex, ray, t, normal, nearestT) == Ray::INTERSECTION) {
    switch (ray.GetType()) {
    case Ray::GLOBAL_RAY:
      ray.intersections.push_back(Ray::Intersection(t, normal, instance, faceIndex));
      hit++;
      break;
    case Ray::LOCAL_RAY:
      nearestT = t;
          nearestNormal = normal;
      nearestFace = faceIndex;
      hit++;
      break;
    case Ray::LINE_SEGMENT:
      if (t <= 1.0f) {
                ray.intersections.push_back(Ray::Intersection(t, normal, instance, faceIndex));
                hit++;
      }
      break;
    }
  }
  return hit;
}

int
Mesh::CastRay(
                          Ray &ray,
                          MeshInstance *instance
                          )
{
  if (mKdTree) {
    return mKdTree->CastRay(ray, instance);
  }
  
  int faceIndex = 0;
  int hits = 0;
  float nearestT = MAX_FLOAT;
  Vector3 nearestNormal;
  int nearestFace = -1;
  
  if (ray.GetType() == Ray::LOCAL_RAY && ray.intersections.size())
    nearestT = ray.intersections[0].mT;

        
  for ( ;
                faceIndex < mFaces.size();
                faceIndex++) {
    hits += CastRayToFace(faceIndex, ray, nearestT, nearestNormal, nearestFace, instance);
    if (mIsConvex && nearestFace != -1)
      break;
  }
  
  if ( hits && ray.GetType() == Ray::LOCAL_RAY ) {
    if (ray.intersections.size())
      ray.intersections[0] = Ray::Intersection(nearestT, nearestNormal, instance, nearestFace);
    else
      ray.intersections.push_back(Ray::Intersection(nearestT, nearestNormal, instance, nearestFace));
  }
  
  return hits;
}

int
Mesh::CastRayToSelectedFaces(
                                                         Ray &ray,
                                                         const vector<int> &faces,
                                                         Intersectable *instance
                                                         )
{
  vector<int>::const_iterator fi;
  int faceIndex = 0;
  int hits = 0;
  float nearestT = MAX_FLOAT;
  Vector3 nearestNormal;
  int nearestFace = -1;
  
  if (ray.GetType() == Ray::LOCAL_RAY && ray.intersections.size())
    nearestT = ray.intersections[0].mT;

  for ( fi = faces.begin();
                fi != faces.end();
                fi++) {
    hits += CastRayToFace(*fi, ray, nearestT, nearestNormal, nearestFace, instance);
    if (mIsConvex && nearestFace != -1)
      break;
  }
  
  if ( hits && ray.GetType() == Ray::LOCAL_RAY ) {
    if (ray.intersections.size())
      ray.intersections[0] = Ray::Intersection(nearestT, nearestNormal,instance, nearestFace);
    else
      ray.intersections.push_back(Ray::Intersection(nearestT, nearestNormal,instance, nearestFace));
  }
  
  return hits;
}


// int_lineseg returns 1 if the given line segment intersects a 2D
// ray travelling in the positive X direction.  This is used in the
// Jordan curve computation for polygon intersection.
inline int
int_lineseg(float px,
                        float py,
                        float u1,
                        float v1,
                        float u2,
                        float v2)
{
  float ydiff;

  u1 -= px; u2 -= px;     // translate line
  v1 -= py; v2 -= py;

  if ((v1 > 0 && v2 > 0) ||
      (v1 < 0 && v2 < 0) ||
      (u1 < 0 && u2 < 0))
    return 0;

  if (u1 > 0 && u2 > 0)
    return 1;

  ydiff = v2 - v1;
  if (fabs(ydiff) < Limits::Small) {      // denominator near 0
    if (((fabs(v1) > Limits::Small) ||
                 (u1 > 0) || (u2 > 0)))
      return 0;
    return 1;
  }
  
  double t = -v1 / ydiff;                 // Compute parameter

  double thresh;

  if (ydiff < 0.0f)
        thresh = -1e-20;
  else
        thresh = 1e-20;

  
  return (u1 + t * (u2 - u1)) > thresh; //-Limits::Small;
}



// intersection with the polygonal face of the mesh
int
Mesh::RayFaceIntersection(const int faceIndex,
                                                  const Ray &ray,
                                                  float &t,
                                                  Vector3 &normal,
                                                  const float nearestT
                                                  )
{
  Face *face  = mFaces[faceIndex];

  Plane3 plane = GetFacePlane(faceIndex);
  float dot = DotProd(plane.mNormal, ray.GetDir());

  if (MeshDebug) {
        cout<<endl<<endl;
        cout<<"normal="<<plane.mNormal<<endl;
        cout<<"dot="<<dot<<endl;
  }
  
        
  // Watch for near-zero denominator
  // ONLY single sided polygons!!!!!
  if (ray.mFlags & Ray::CULL_BACKFACES) {
        if (dot > -Limits::Small)
          //  if (fabs(dot) < Limits::Small)
          return Ray::NO_INTERSECTION;
  } else {
        if (fabs(dot) < Limits::Small)
          return Ray::NO_INTERSECTION;
  }
  
  normal = plane.mNormal;

  t = (-plane.mD - DotProd(plane.mNormal, ray.GetLoc())) / dot;

  if (MeshDebug)
        cout<<"t="<<t<<endl;

  if (t <= Limits::Small)
    return Ray::INTERSECTION_OUT_OF_LIMITS;
  
  if (t >= nearestT) {
    return Ray::INTERSECTION_OUT_OF_LIMITS; // no intersection was found
  }
  
  int count = 0;
  float u, v, u1, v1, u2, v2;
  int i;

  int paxis = plane.mNormal.DrivingAxis();

  
  // Project the intersection point onto the coordinate plane
  // specified by which.
  ray.Extrap(t).ExtractVerts(&u, &v, paxis);


  int size = (int)face->mVertexIndices.size();

  if (MeshDebug)
        cout<<"size="<<size<<endl;
  
  mVertices[face->mVertexIndices[size - 1]].
    ExtractVerts(&u1, &v1, paxis );
  
  //$$JB changed 12.4.2006 from 0 ^^
  if (0 && size <= 4) {
    // assume a convex face
    for (i = 0; i < size; i++) {
      mVertices[face->mVertexIndices[i]].ExtractVerts(&u2, &v2, paxis);
      // line u1, v1, u2, v2
      if ((v1 - v2)*(u - u1) + (u2 - u1)*(v - v1) > 0) {
                if (MeshDebug)
                  cout<<"exit on "<<i<<endl;
                return Ray::NO_INTERSECTION;
          }
      u1 = u2;
      v1 = v2;
    }
    
    return Ray::INTERSECTION;
  }
  
  // We're stuck with the Jordan curve computation.  Count number
  // of intersections between the line segments the polygon comprises
  // with a ray originating at the point of intersection and
  // travelling in the positive X direction.
  for (i = 0; i < size; i++) {
    mVertices[face->mVertexIndices[i]].ExtractVerts(&u2, &v2, paxis);
    count += (int_lineseg(u, v, u1, v1, u2, v2) != 0);
    u1 = u2;
    v1 = v2;
  }

  if (MeshDebug)
        cout<<"count="<<count<<endl;

  // We hit polygon if number of intersections is odd.
  return (count & 1) ? Ray::INTERSECTION : Ray::NO_INTERSECTION;
}

int
Mesh::GetRandomSurfacePoint(Vector3 &point, Vector3 &normal)
{
  const int faceIndex = (int)RandomValue(0, (Real)((int)mFaces.size()-1));
  
  // assume the face is convex and generate a convex combination
  //
  Face *face = mFaces[faceIndex];
 
  point = Vector3(0,0,0);
  float sum = 0.0f;
  
  for (int i = 0; i < face->mVertexIndices.size(); i++) {
    float r = RandomValue(0,1);
    sum += r;
    point += mVertices[face->mVertexIndices[i]]*r;
  }
  point *= 1.0f/sum;
        
        normal = GetFacePlane(faceIndex).mNormal;

        return faceIndex;
}

int
Mesh::GetRandomVisibleSurfacePoint(Vector3 &point,
                                                                   Vector3 &normal,
                                                                   const Vector3 &viewpoint,
                                                                   const int maxTries)
{
  Plane3 plane;
  int faceIndex = (int)RandomValue(0, (Real)((int)mFaces.size()-1));
        int tries;
  for (tries = 0; tries < maxTries; tries++) {
    Face *face = mFaces[faceIndex];
    plane = GetFacePlane(faceIndex);
    
    if (plane.Side(viewpoint) > 0) {
      point = Vector3(0,0,0);
      float sum = 0.0f;
      // pickup a point inside this triangle
      for (int i = 0; i < face->mVertexIndices.size(); i++) {
                                float r = RandomValue(0,1);
                                sum += r;
                                point += mVertices[face->mVertexIndices[i]]*r;
      }
      point *= 1.0f/sum;
      break;
    }
  }
  
  normal = plane.mNormal;
  return (tries < maxTries) ? faceIndex + 1 : 0;
}


Plane3
Mesh::GetFacePlane(const int faceIndex)
{
  Face *face = mFaces[faceIndex];
        return Plane3(mVertices[face->mVertexIndices[0]],
                                                                mVertices[face->mVertexIndices[1]],
                                                                mVertices[face->mVertexIndices[2]]);
}

bool
Mesh::ValidateFace(const int i)
{
        Face *face = mFaces[i];

        Plane3 plane = Plane3(mVertices[face->mVertexIndices[0]],
                                                  mVertices[face->mVertexIndices[1]],
                                                  mVertices[face->mVertexIndices[2]]);
        
        if (!eq(Magnitude(plane.mNormal), 1.0f))
                return false;

        return true;
}

void
Mesh::Cleanup()
{
        int toRemove = 0;
        FaceContainer newFaces;
        for (int i=0; i < mFaces.size(); i++)
                if (ValidateFace(i)) {
                        newFaces.push_back(mFaces[i]);
                } else {
                        cout<<"d";
                        delete mFaces[i];
                        toRemove++;
                }
        
        if (toRemove) {
                mFaces = newFaces;
        }
        
        // cleanup vertices??
}


void
Mesh::AddTriangle(const Triangle3 &triangle)
{
  int index = (int)mVertices.size();

  for (int i=0; i < 3; i++) {
    mVertices.push_back(triangle.mVertices[i]);
  }
  
  AddFace(new Face(index + 0, index + 1, index + 2) );
}

void
Mesh::AddRectangle(const Rectangle3 &rect)
{
  int index = (int)mVertices.size();

  for (int i=0; i < 4; i++) {
    mVertices.push_back(rect.mVertices[i]);
  }
  
  AddFace(new Face(index + 0, index + 1, index + 2, index + 3) );
}

void
Mesh::AssignRandomMaterial()
{  
        mMaterial = MaterialManager::GetSingleton()->CreateResource();
  
        Material randMat = RandomMaterial();

        mMaterial->mDiffuseColor = randMat.mDiffuseColor;
        mMaterial->mSpecularColor = randMat.mSpecularColor;
        mMaterial->mAmbientColor = randMat.mAmbientColor;
}


Mesh *CreateMeshFromBox(const AxisAlignedBox3 &box)
{
        Mesh *mesh = MeshManager::GetSingleton()->CreateResource();

        // add 8 vertices of the box
        const int index = (int)mesh->mVertices.size();
        
        for (int i=0; i < 8; ++ i) 
        {
        Vector3 v;
                box.GetVertex(i, v);
                mesh->mVertices.push_back(v);
        }

        mesh->AddFace(new Face(index + 0, index + 1, index + 3, index + 2) );
        mesh->AddFace(new Face(index + 0, index + 2, index + 6, index + 4) );
        mesh->AddFace(new Face(index + 4, index + 6, index + 7, index + 5) );
  
        mesh->AddFace(new Face(index + 3, index + 1, index + 5, index + 7) );
        mesh->AddFace(new Face(index + 0, index + 4, index + 5, index + 1) );
        mesh->AddFace(new Face(index + 2, index + 3, index + 7, index + 6) );
  
        return mesh;
}


Mesh::Mesh(const int id, const int vertices, const int faces):
mFaces(),
mMaterial(NULL),
mKdTree(NULL),
mVertices(),
mIsConvex(false),
mIsWatertight(false),
mId(id)
{
    mVertices.reserve(vertices);
    mFaces.reserve(faces);
}


Mesh::Mesh(const int id): 
mId(id), mVertices(), mFaces(), mMaterial(NULL), mKdTree(NULL) 
{}


// apply transformation to each vertex
void Mesh::ApplyTransformation(const Matrix4x4 &m)
{
        VertexContainer::iterator it, it_end = mVertices.end();

        for (it = mVertices.begin(); it != it_end; ++ it)
        {
                (*it) = m * (*it);        
        }
}


Mesh::Mesh(const Mesh &rhs):
mKdTree(NULL)
{
        mVertices = rhs.mVertices;
        mFaces.reserve(rhs.mFaces.size());
        mId = rhs.mId;
        mMaterial = rhs.mMaterial;
        
        FaceContainer::const_iterator it, it_end = rhs.mFaces.end();

        for (it = rhs.mFaces.begin(); it != it_end; ++ it)
        {
                Face *face = *it;
                mFaces.push_back(new Face(*face));
        }
}


Mesh& Mesh::operator=(const Mesh& m) 
{
    if (this == &m) 
                return *this;
 
        CLEAR_CONTAINER(mFaces);

        mVertices = m.mVertices;
        mFaces.reserve(m.mFaces.size());
        mMaterial = m.mMaterial;
        // note: we don't copy id on purpose
        //mId = m.mId;
        
        FaceContainer::const_iterator it, it_end = m.mFaces.end();

        for (it = m.mFaces.begin(); it != it_end; ++ it)
        {
                Face *face = *it;
                mFaces.push_back(new Face(*face));
        }

        return *this;
}


Mesh::~Mesh()
{
        for (int i=0; i < mFaces.size(); ++ i)
                delete mFaces[i];

        DEL_PTR(mKdTree);
}
  

void Mesh::Clear() 
{
        mVertices.clear();
        mFaces.clear();

        DEL_PTR(mKdTree);
}

/********************************************************/
/*                      MeshInstance implementation             */
/********************************************************/

int
MeshInstance::CastRay(
                                          Ray &ray
                                          )
{
  int res = mMesh->CastRay(ray, this);
  return res;
}

int
MeshInstance::CastRay(
                                          Ray &ray,
                                          const vector<int> &faces
                                          )
{
  return mMesh->CastRayToSelectedFaces(ray, faces, this);
}



int
MeshInstance::GetRandomSurfacePoint(Vector3 &point, Vector3 &normal)
{
  return mMesh->GetRandomSurfacePoint(point, normal);
}

int
MeshInstance::GetRandomVisibleSurfacePoint(Vector3 &point,
                                                                                   Vector3 &normal,
                                                                                   const Vector3 &viewpoint,
                                                                                   const int maxTries)
{
        return mMesh->GetRandomVisibleSurfacePoint(point, normal, viewpoint, maxTries);
}


void MeshInstance::SetMaterial(Material *mat)
{
        mMaterial = mat;
}

Material *MeshInstance::GetMaterial() const
{
        return mMaterial;
}


Vector3 MeshInstance::GetNormal(const int idx) const
{
        return mMesh->GetFacePlane(idx).mNormal;
}



/*************************************************************/
/*           TransformedMeshInstance implementation          */
/*************************************************************/


TransformedMeshInstance::TransformedMeshInstance(Mesh *mesh): 
MeshInstance(mesh)
{
    mWorldTransform = IdentityMatrix();
}


int TransformedMeshInstance::GetRandomSurfacePoint(Vector3 &point, Vector3 &normal)
{
  int index = mMesh->GetRandomSurfacePoint(point, normal);
  point = mWorldTransform*point;
  normal = TransformNormal(mWorldTransform, normal);
  return index;
}


int TransformedMeshInstance::CastRay(Ray &ray)
{
        ray.ApplyTransform(Invert(mWorldTransform));
        
        const int res = mMesh->CastRay(ray, this);
        ray.ApplyTransform(mWorldTransform);

    return res;
}


int TransformedMeshInstance::CastRay(Ray &ray, const vector<int> &faces)
{
        ray.ApplyTransform(Invert(mWorldTransform));

        const int res = mMesh->CastRayToSelectedFaces(ray, faces, this);
        ray.ApplyTransform(mWorldTransform);

         return res;
}


void TransformedMeshInstance::ApplyWorldTransform(const Matrix4x4 &m)
{
        mWorldTransform = m * mWorldTransform;
}


void TransformedMeshInstance::LoadWorldTransform(const Matrix4x4 &m)
{
        mWorldTransform = m;
}


void TransformedMeshInstance::GetWorldTransform(Matrix4x4 &m) const
{
        m = mWorldTransform;
}


AxisAlignedBox3 TransformedMeshInstance::GetBox() const 
{
    return Transform(mMesh->mBox, mWorldTransform);
}


void TransformedMeshInstance::GetTransformedMesh(Mesh &transformedMesh) const
{
        // copy mesh
        transformedMesh = *mMesh;
        transformedMesh.ApplyTransformation(mWorldTransform);
}


Vector3 TransformedMeshInstance::GetNormal(const int idx) const
{
        Mesh mesh;
        GetTransformedMesh(mesh);
        return mesh.GetFacePlane(idx).mNormal;
}

}