collisiondetectors/CD_Simple.cpp

Go to the documentation of this file.

//## begin module%36FB166B02B2.cm preserve=no
//        %X% %Q% %Z% %W%
//## end module%36FB166B02B2.cm

//## begin module%36FB166B02B2.cp preserve=no
//## end module%36FB166B02B2.cp

//## Module: CD_Simple%36FB166B02B2; Pseudo Package body
//## Source file: C:\project\mpk\code\CollisionDetectors\CD_Simple.cpp

//## begin module%36FB166B02B2.additionalIncludes preserve=no
//## end module%36FB166B02B2.additionalIncludes

//## begin module%36FB166B02B2.includes preserve=yes
//## end module%36FB166B02B2.includes

// CD_Simple
#include "CollisionDetectors\CD_Simple.h"
// Mesh
#include "geometry\Mesh.h"
//## begin module%36FB166B02B2.additionalDeclarations preserve=yes
//## end module%36FB166B02B2.additionalDeclarations


// Class CD_Simple 

CD_Simple::CD_Simple (Universe& universe)
  //## begin CD_Simple::CD_Simple%922561219.hasinit preserve=no
  //## end CD_Simple::CD_Simple%922561219.hasinit
  //## begin CD_Simple::CD_Simple%922561219.initialization preserve=yes
  : 
        CollisionDetectorBase( universe ),
        CD_BasicStyle( universe ),
        CD_Linear( universe ),
        CD_LinearContinuous( universe )
  //## end CD_Simple::CD_Simple%922561219.initialization
{
  //## begin CD_Simple::CD_Simple%922561219.body preserve=yes
        //create a new VCollide module for the mesh system
        Mesh::ResetVcollide() ;
  //## end CD_Simple::CD_Simple%922561219.body
}

CD_Simple::CD_Simple (const CD_Simple& right)
  //## begin CD_Simple::CD_Simple%925235859.hasinit preserve=no
  //## end CD_Simple::CD_Simple%925235859.hasinit
  //## begin CD_Simple::CD_Simple%925235859.initialization preserve=yes
  : 
        CollisionDetectorBase( right ),
        CD_BasicStyle( right ),
        CD_Linear( right ),
        CD_LinearContinuous( right )
  //## end CD_Simple::CD_Simple%925235859.initialization
{
  //## begin CD_Simple::CD_Simple%925235859.body preserve=yes
//      assert( false ) ;       //IMPROVE: i'm not too sure that this function works
        Mesh::ResetVcollide() ;
  //## end CD_Simple::CD_Simple%925235859.body
}


CD_Simple::~CD_Simple()
{
  //## begin CD_Simple::~CD_Simple%.body preserve=yes
  //## end CD_Simple::~CD_Simple%.body
}



//## Other Operations (implementation)
bool CD_Simple::IsInterfering (const Configuration& config)
{
  //## begin CD_Simple::IsInterfering%923255749.body preserve=yes

        //check all the entities against one another
        for( int i = 0; i < entities.size(); i++ )
        {
                for( int j = i + 1 ; j < entities.size(); j++ )
                {
                        Entity* e1 = entities[ i ] ;
                        Entity* e2 = entities[ j ] ;

                        //if the two entities are in the same base frame then intersection is impossible - implied CSG union
                        int e1Base = e1->BaseFrame() ;
                        int e2Base = e2->BaseFrame() ;
                        bool shouldPerform = false ;
                        shouldPerform |= this->ShouldPerformCollisionCheck( e1Base, e2Base ) ;
                        shouldPerform |= this->ShouldPerformCollisionCheck( e2Base, e1Base ) ;
                        if( !shouldPerform )
                        {
                                continue ;
                        }
                        if( e1->BaseFrame() == e2->BaseFrame() )
                        {
                                continue ;
                        }
                        if( abs( e1->BaseFrame() - e2->BaseFrame() ) == 1 )
                        {
                                continue ;              //IMPROVE:this skips out if the frames are adjacent - but it's a hack
                        }
                        //test e1 for interference with e2
                        if( e1->CanCheckInterference( e2 ) )
                        {
                                if( e1->IsInterfering( e2 ) )
                                {
                                        return true ;
                                };
                        }
                        else
                        {
                                //assert( e2->CanCheckInterference( e1 ) );             //IMPROVE: this assert needs to be here to verify that all collisions are taken care of
                                if( e2->IsInterfering( e1 ) )
                                {
                                        return true ;
                                }
                        }
                }
        }


        return false ;
  //## end CD_Simple::IsInterfering%923255749.body
}

CollisionDetectorBase* CD_Simple::Clone () const
{
  //## begin CD_Simple::Clone%925235857.body preserve=yes
        CD_InterfaceToCollisionQueries* CDitc = dynamic_cast< CD_Bool* >( new CD_Simple( *this ) ) ;
        CollisionDetectorBase* returnMe = dynamic_cast< CollisionDetectorBase* >( CDitc );
        return returnMe ;
  //## end CD_Simple::Clone%925235857.body
}

// Additional Declarations
  //## begin CD_Simple%36FB166B02B2.declarations preserve=yes
  //## end CD_Simple%36FB166B02B2.declarations

//## begin module%36FB166B02B2.epilog preserve=yes
//## end module%36FB166B02B2.epilog

---