basic/geometry/Mesh.cpp

Go to the documentation of this file.

//## begin module%37431D0E02A4.cm preserve=no
//        %X% %Q% %Z% %W%
//## end module%37431D0E02A4.cm

//## begin module%37431D0E02A4.cp preserve=no
//## end module%37431D0E02A4.cp

//## Module: Mesh%37431D0E02A4; Pseudo Package body
//## Source file: C:\project\mpk\code\geometry\Mesh.cpp

//## begin module%37431D0E02A4.additionalIncludes preserve=no
//## end module%37431D0E02A4.additionalIncludes

//## begin module%37431D0E02A4.includes preserve=yes
#include <additional/streams/mystreams.h>
#include <geometry/IGS/IGS_MeshTri.h>
#include <math\math2.h>
#include "math\Vector4.h"
#include "geometry\Mesh.h"
#include "geometry\MPK_Segment.h"


//## begin Mesh::maxVcollideIndex%374F30DD01C0.attr preserve=no  private: static int {UA} -1
int Mesh::maxVcollideIndex = -1;
//## end Mesh::maxVcollideIndex%374F30DD01C0.attr

//## begin Mesh::vcollide%374F32D60339.attr preserve=no  private: static VCollide* {UA} NULL
VCollide* Mesh::vcollide = NULL;
//## end Mesh::vcollide%374F32D60339.attr

//## begin Mesh::countInstances%380CDEEA014D.attr preserve=no  private: static int {UA} 0
int Mesh::countInstances = 0;
//## end Mesh::countInstances%380CDEEA014D.attr





Mesh::Mesh (FrameManager* frameManager)
  //## begin Mesh::Mesh%927145471.hasinit preserve=no
  //## end Mesh::Mesh%927145471.hasinit
  //## begin Mesh::Mesh%927145471.initialization preserve=yes
  :ObjectBase( frameManager ) ,
  vcollideIndex( -1 )
  //## end Mesh::Mesh%927145471.initialization
{
  //## begin Mesh::Mesh%927145471.body preserve=yes
        countInstances++ ;
  //## end Mesh::Mesh%927145471.body
}

Mesh::Mesh (const Mesh& right)
  //## begin Mesh::Mesh%927145472.hasinit preserve=no
  //## end Mesh::Mesh%927145472.hasinit
  //## begin Mesh::Mesh%927145472.initialization preserve=yes
  :ObjectBase( right ),
  vcollideIndex( -1 )
  //## end Mesh::Mesh%927145472.initialization
{
  //## begin Mesh::Mesh%927145472.body preserve=yes

        //add all the vertexes in the right
        this->vertexes = right.vertexes;
        
        //add all the facets in the right
        this->facets = right.facets;

        countInstances++ ;
  //## end Mesh::Mesh%927145472.body
}

//=============================================================================
// Constructor
//
// Description: creates a mesh out of an IGS_MeshTri
//=============================================================================
Mesh::Mesh( const IGS_MeshTri& right )
:
        ObjectBase( NULL )
{
        int i;
        int size = right.GetNumVertexes();
        for( i = 0; i < size; i++ )
        {
                const Vector4& vertex = right.GetVertex( i );
                IJG_Assert( vertex.Magnitude() < 1000.0 );      //gerneally vertexes this big are actually just errors in file IO
                this->AddVertex( vertex );
        }

        size = right.GetNumTriangles();
        for( i = 0; i < size; i++ )
        {
                const IGS_MeshTri::Triangle& triangle = right.GetTriangle( i );
                this->AddFacet( Facet( triangle.v0, triangle.v1, triangle.v2 ) );
        }
}

Mesh::~Mesh()
{
  //## begin Mesh::~Mesh%.body preserve=yes
        if( vcollide != NULL )
        {
                delete vcollide ;
                vcollide = NULL ;
        }
        facets.clear() ;
        vertexes.clear() ;
        countInstances-- ;
  //## end Mesh::~Mesh%.body
}



//## Other Operations (implementation)
bool Mesh::CanCheckInterference (const Entity* entity) const
{
  //## begin Mesh::CanCheckInterference%927145473.body preserve=yes
        if( dynamic_cast< const Mesh* >( entity ) != NULL )
        {
                return true ;
        }
        return false ;
  //## end Mesh::CanCheckInterference%927145473.body
}

Entity* Mesh::Clone () const
{
  //## begin Mesh::Clone%927145474.body preserve=yes
        return new Mesh( *this ) ;
  //## end Mesh::Clone%927145474.body
}

bool Mesh::IsInterfering (const Entity* entity) const
{
  //## begin Mesh::IsInterfering%927145475.body preserve=yes
        //IMPROVE: add this back in later
        //assert( CanCheckInterference( entity ) ) ;    //IMPROVE: this should be error handled
        
        //determine the type of the entity
        if( dynamic_cast< const Mesh* >( entity ) != NULL )
        {
                return( IsInterfering( dynamic_cast< const Mesh* >( entity ) ) ) ;
        }
        else
        {
                //IMPROVE: this should cause an assertion, remove the return statement
                return false ;
                assert( false ) ;       //should never get to here due to the assert( CanCheckInterference )
        }
        return false ;
  //## end Mesh::IsInterfering%927145475.body
}

//=============================================================================
// Mesh::GetFacets
//=============================================================================
FACETVECTOR& Mesh::GetFacets()
{
    return facets;
}

//=============================================================================
// Mesh::GetFacets
//=============================================================================
const FACETVECTOR& Mesh::GetFacets() const
{
    return facets;
}

//=============================================================================
// Mesh::GetVertexes
//=============================================================================
VECTOR4VECTOR& Mesh::GetVertexes()
{
    return vertexes;
}

//=============================================================================
// Mesh::GetVertexes
//=============================================================================
const VECTOR4VECTOR& Mesh::GetVertexes() const
{
    return vertexes;
}

void Mesh::AddFacet (const Facet& facet)
{
  //## begin Mesh::AddFacet%927145476.body preserve=yes
        if( facet.vertexNumbers.size() < 3 )
        {
                //trying to add an invalid facet
                return;
        }
        facets.push_back( facet ) ;             //IMPROVE: use a mapping here, not a vector 
  //## end Mesh::AddFacet%927145476.body
}

void Mesh::AddVertex (const Vector4& vertex)
{
  //## begin Mesh::AddVertex%927145477.body preserve=yes
        vertexes.push_back( vertex ) ;          //IMPROVE: use a mapping here, not a vector
  //## end Mesh::AddVertex%927145477.body
}

bool Mesh::ReadFromIcollideFile (std::string fileName)
{
        return true ;
  //## end Mesh::ReadFromIcollideFile%927145478.body
}

//got to here


void Mesh::SetCoordinates (const std::vector<Vector4>& vertexes)
{
  //## begin Mesh::SetCoordinates%927307376.body preserve=yes
        this->vertexes.clear() ;
        for( int i = 0; i < vertexes.size(); i++ )
        {
                this->vertexes.push_back( vertexes[ i ] ) ;
        }
  //## end Mesh::SetCoordinates%927307376.body
}

void Mesh::TransformVerticies (const Matrix4x4& transform)
{
  //## begin Mesh::TransformVerticies%927223871.body preserve=yes
        for( int i = 0; i < vertexes.size(); i++ )
        {
                Vector4 old = vertexes[ i ] ;
                Vector4 transformed = transform * vertexes[ i ] ;
                Vector4& stored = vertexes[ i ] ;
                stored = transformed ;
        }
  //## end Mesh::TransformVerticies%927223871.body
}

void Mesh::SetCoordinateEnumerations (const std::vector< std::vector < unsigned int > >& vertexes)
{
  //## begin Mesh::SetCoordinateEnumerations%927307377.body preserve=yes
        facets.clear() ;
        int vertexSize = vertexes.size() ;
        for( int i = 0; i < vertexes.size(); i++ )
        {
                const std::vector< unsigned int >& facetPoints = vertexes[ i ] ;
                Facet facet ;
                int facetsSize = vertexes[ i ].size() ;
                for( int j = 0; j < facetPoints.size(); j++ )
                {
                        facet.vertexNumbers.push_back( facetPoints[ j ] ) ;
                }
                if( facet.vertexNumbers.size() >=3 )
                {
                        facets.push_back( facet ) ;
                }
                else
                {
                        //attempting to add an invalid facet
                }
        }
  //## end Mesh::SetCoordinateEnumerations%927307377.body
}

//got to here

void Mesh::AddToVcollide (VCollide& vcollide) const
{
  //## begin Mesh::AddToVcollide%927920610.body preserve=yes
        assert( vcollideIndex == -1 ) ;

        //ask vcollide to create a new object
        int success = vcollide.NewObject( &vcollideIndex );
        if( vcollideIndex > maxVcollideIndex )
        {
                maxVcollideIndex = vcollideIndex ;
        }
        assert( success == VC_OK ) ;

        //need to add each triangle to vcollide individually
        for( int i = 0; i < facets.size(); i++ )
        {
                Facet face = facets[ i ] ;
                int edges = face.vertexNumbers.size() ;
                assert( edges == 3 ) ;
                double v1[ 3 ] ;
                double v2[ 3 ] ;
                double v3[ 3 ] ;

                //copy the vertex points of the mesh into the arrays above
                for( int j = 0; j < 3; j++ )
                {
                        v1[ j ] = vertexes[ face.vertexNumbers[ 0 ] ][ j ] ;
                        v2[ j ] = vertexes[ face.vertexNumbers[ 1 ] ][ j ] ;
                        v3[ j ] = vertexes[ face.vertexNumbers[ 2 ] ][ j ] ;
                }
                vcollide.AddTri( v1, v2, v3 ) ;
        }

        //tell VCollide that we're done adding the object
        success = vcollide.EndObject() ;
        if( success == VC_ERR_EMPTY_OBJECT )
        {
                vcollideIndex = -1 ;    //this is an empty object - it won't collide with anything
                assert( false ) ;
        }
        assert( success == VC_OK ) ;

        //deactivate the object from all collision detection queries
        //IMPROVE: This is not working at present- 
        //for( i = 0; i < maxVcollideIndex; i++ )
        //{
        //      success = vcollide.DeactivatePair( vcollideIndex, i ) ;
        //      assert( success == VC_OK ) ;
        //}
        //success = vcollide->DeactivateObject ( vcollideIndex );
        //assert( success == VC_OK ) ;

  //## end Mesh::AddToVcollide%927920610.body
}

bool Mesh::IsInterfering (const Mesh* entity) const
{
  //## begin Mesh::IsInterfering%927920611.body preserve=yes

        static int numberOfTimesCalled = 0 ;
        numberOfTimesCalled++ ;

        //make sure the vcollide library is instantiated
        if( vcollide == NULL )
        {
                vcollide = new( VCollide ) ;
        }

        //make sure this mesh has been added to the vcollide detector
        if( vcollideIndex == -1 )
        {
                AddToVcollide( *vcollide ) ;
        }

        //make sure that the target mesh has also been added to the vcollide detector
        if( entity->vcollideIndex == -1 )
        {
                entity->AddToVcollide( *vcollide ) ;
        }

        //query vcollide to see if the two entities intersect
        //set the pair of objects to test intersections
        int success = vcollide->ActivatePair( vcollideIndex, entity->vcollideIndex ) ;
        assert( success == VC_OK ) ;

        //update the transformation matricies associated with these objects
        double trans1[4][4] ;
        double trans2[4][4] ;
        Matrix4x4 m1 = GetTransform() ; 
        Matrix4x4 m2 = entity->GetTransform() ;
        for( int i = 0; i < 4; i++ )
        {
                for( int j = 0; j < 4; j++ )
                {
                        trans1[ j ][ i ] = m1( j, i ) ;         //IMPROVE: this loop is potentially slow
                        trans2[ j ][ i ] = m2( j, i ) ;
                }
        }

        vcollide->UpdateTrans( vcollideIndex, trans1 ) ;
        vcollide->UpdateTrans( entity->vcollideIndex, trans2 ) ;

        //query the collisions
        success = vcollide->Collide() ;
        assert( success = VC_OK ) ;

        VCReportType vcrep[ 1 ] ;
        int number = vcollide->Report( 1, vcrep ) ;

        //look at the actual report

        //unset the pair of objects to test intersections
        vcollide->DeactivatePair( vcollideIndex, entity->vcollideIndex ) ;
        //vcollide

        if( number > 0 )
        {
                return true ;
        }
        return false ;
  //## end Mesh::IsInterfering%927920611.body
}

void Mesh::ResetVcollide ()
{
  //## begin Mesh::ResetVcollide%927936640.body preserve=yes
        delete vcollide ;       //IMPROVE: do I need to delete all the objects too? I hope not
        vcollide = NULL ;
        vcollide = new VCollide ;
        maxVcollideIndex = -1 ;
  //## end Mesh::ResetVcollide%927936640.body
}
//got to here

void Mesh::Splice (const Mesh& mesh)
{
  //## begin Mesh::Splice%931291668.body preserve=yes
        //IMPROVE: make this splicing a little bit smarter
        int vertexSize = vertexes.size() ;

    int i;
        for( i = 0; i < mesh.vertexes.size(); i++ )
        {
                vertexes.push_back( mesh.vertexes[ i ] ) ;
        }

        for( i = 0; i < mesh.facets.size(); i++ )
        {
                Facet f = mesh.facets[ i ] ;
                for( int j = 0; j < f.vertexNumbers.size(); j++ )
                {
                        f.vertexNumbers[ j ] += vertexSize ;
                }
                facets.push_back( f ) ;
        }
        assert( false ) ;
  //## end Mesh::Splice%931291668.body
}

void Mesh::SetFrame (const Matrix4x4& frame)
{
  //## begin Mesh::SetFrame%928263344.body preserve=yes
        TransformVerticies( frame ) ;   //IMPROVE: repeated calls to this functino will have the wrong result
  //## end Mesh::SetFrame%928263344.body
}

bool Mesh::IsInterfering (const MPK_Sphere* entity) const
{
  //## begin Mesh::IsInterfering%931291670.body preserve=yes
        //IMPROVE: this is not going to be efficient

        //iterate through all the facets
        for( int f = 0; f < facets.size(); f++ )
        {
                Facet facet = facets[ f ] ;
                //check the endpoints of the facet
        int i;
                for( i = 0; i < facet.vertexNumbers.size(); i++ )
                {
                        Vector4 offset = ( entity->Position() - vertexes[ facet.vertexNumbers[ i ] ] ) ;
                        double distance = offset.MagSquared() ;
                        if( distance < Sqr( entity->Radius() ) )
                        {
                                return true ;
                        }
                }

                //check the segments making up the facet
                for( i = 0; i < facet.vertexNumbers.size(); i++ )
                {
                        int v1 = i ;
                        int v2 = ( i + 1 ) % facet.vertexNumbers.size() ;

            MPK::Segment s( this->frameManager ) ;      //IMPROVE: can't I use a segment without a framemanager?
                        s.SetStart( vertexes[ v1 ] ) ;
                        s.SetEnd( vertexes[ v2 ] ) ;
                        if( s.IsInterfering( entity ) )
                        {
                                return true ;
                        }
                }

                //check the sphere and this facet's interior
                assert( false ) ;
        }
        return false ;
  //## end Mesh::IsInterfering%931291670.body
}

void Mesh::Serialize (ostream& os) const
{
  //## begin Mesh::Serialize%934154736.body preserve=yes
        using std::endl ;
        os << "#mesh" << endl ;

        //output all the vertexes
        os << "#vertexes " << vertexes.size() << endl ;
    int i;
        for( i = 0; i < vertexes.size(); i++ )
        {
                os << vertexes[ i ] << endl ;
        }

        //output all the facets
        os << "#facets " << facets.size() << endl ;
        for( i = 0; i < facets.size(); i++ )
        {
                os << facets[ i ] << endl ; 
        }

        os << "#end_mesh" << endl ;
  //## end Mesh::Serialize%934154736.body
}

void Mesh::Deserialize(IfstreamWithComments& is)
{

  //## begin Mesh::Deserialize%934154737.body preserve=yes
        char marker[ 300 ] = "" ;

        //input the vertexes
        vertexes.clear() ;
        eatwhite( is ) ;
        is.getline( marker, 300, ' ' ) ;
        assert( strcmp( marker, "#vertexes" ) == 0 ) ;
        int vertexNumber = -1 ;
        is >> vertexNumber ;

    int i;
        for( i = 0; i < vertexNumber; i++ )
        {
                Vector4 readIn ;
                is >> readIn ;
                vertexes.push_back( readIn ) ;
        }
/*
        //input the facets
        facets.clear() ;
        eatwhite( is ) ;
        is.getline( marker, 300, ' ' ) ;
        assert( strcmp( marker, "#facets" ) == 0 ) ;
        int facetNumber = -1 ;
        is >> facetNumber ;

        for( i = 0; i < facetNumber; i++ )
        {
                Facet readIn ;
                is >> readIn ;
                facets.push_back( readIn ) ;
        }
 
    eatwhite( is ) ;
        is.getline( marker, 300 ) ;
        assert( strcmp( marker, "#end_mesh" ) == 0 ) ;

*/
  //## end Mesh::Deserialize%934154737.body
}

bool Mesh::Validate () const
{
  //## begin Mesh::Validate%971655314.body preserve=yes
        int i;
        for( i = 0; i < this->vertexes.size(); i++ )
        {
                Vector4 vertex = vertexes[ i ];
        }

        for( i = 0; i < facets.size(); i++ )
        {
                Facet f = facets[ i ];
                int j;
                for( j = 0; j < f.vertexNumbers.size(); j++ )
                {
                        int vertexNum = f.vertexNumbers[ j ];
                        if( vertexNum > vertexes.size() )
                        {
                                return false;
                        }

                        if( vertexNum < 0 )
                        {
                                return false;
                        }
                }
        }
        return true;
  //## end Mesh::Validate%971655314.body
}

// Additional Declarations
  //## begin Mesh%37431D0E02A4.declarations preserve=yes
int Mesh::TotalPolys() const
{
        return facets.size() ;
}

bool Mesh::Verify() const
{
        return true;
}
  //## end Mesh%37431D0E02A4.declarations
//## begin module%37431D0E02A4.epilog preserve=yes
//## end module%37431D0E02A4.epilog

---