basic/geometry/ObjectGroup.cpp

Go to the documentation of this file.

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

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

//## Module: ObjectGroup%36FE80AD0258; Pseudo Package body
//## Source file: E:\mpk\code\geometry\ObjectGroup.cpp

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

//## begin module%36FE80AD0258.includes preserve=yes
#include <assert.h>
#include <additional/streams/mystreams.h>
#include <geometry/IGS/IGS_Group.h>
//## end module%36FE80AD0258.includes

// ObjectGroup
#include "geometry\ObjectGroup.h"
// Frame
#include "geometry\Frame.h"
//## begin module%36FE80AD0258.additionalDeclarations preserve=yes
//## end module%36FE80AD0258.additionalDeclarations

// Class ObjectGroup 

ObjectGroup::ObjectGroup (FrameManager* frameManager)
  //## begin ObjectGroup::ObjectGroup%926969419.hasinit preserve=no
  //## end ObjectGroup::ObjectGroup%926969419.hasinit
  //## begin ObjectGroup::ObjectGroup%926969419.initialization preserve=yes
    :ObjectBase( frameManager ),
        baseFrame( NULL ),
        offsetFrame( NULL )
  //## end ObjectGroup::ObjectGroup%926969419.initialization
{
  //## begin ObjectGroup::ObjectGroup%926969419.body preserve=yes
  //## end ObjectGroup::ObjectGroup%926969419.body
}

ObjectGroup::ObjectGroup (const ObjectGroup& right)
  //## begin ObjectGroup::ObjectGroup%926969420.hasinit preserve=no
  //## end ObjectGroup::ObjectGroup%926969420.hasinit
  //## begin ObjectGroup::ObjectGroup%926969420.initialization preserve=yes
    :   ObjectBase( right ),
  baseFrame( right.baseFrame ),
  offsetFrame( right.offsetFrame )

  //## end ObjectGroup::ObjectGroup%926969420.initialization
{
  //## begin ObjectGroup::ObjectGroup%926969420.body preserve=yes
        //clone each of the objects in the original group
        for( int i = 0; i < right.objects.size(); i++ )
        {
                ObjectBase* object = static_cast< ObjectBase* >( right.objects[ i ]->Clone() ) ;
                objects.push_back( object ) ;
        }
  //## end ObjectGroup::ObjectGroup%926969420.body
}

//=============================================================================
// Constructor
//
// Description: create an object group from an IGS group
//=============================================================================
ObjectGroup::ObjectGroup( const IGS_Group& right )
:
        ObjectBase( NULL )
{
        int i;
        int size = right.objects.size();
        for( i = 0; i < size; i++ )
        {
                IGS_Object* object = right.objects[ i ];
                ObjectBase* mpkObject = ObjectBase::Create( object );
                this->AddObject( mpkObject );
                delete mpkObject;
        }
}


ObjectGroup::~ObjectGroup()
{
  //## begin ObjectGroup::~ObjectGroup%.body preserve=yes
        int size = objects.size() ;
        for( int i = 0; i < objects.size() ; i++ )
        {
                assert( i < objects.size() ) ;
                ObjectBase* deleteMe = objects[ i ] ;
                delete( deleteMe ) ;
                objects[ i ] = NULL ;
        }
  //## end ObjectGroup::~ObjectGroup%.body
}



//## Other Operations (implementation)
const ObjectBase* ObjectGroup::operator [] (const unsigned int index) const
{
  //## begin ObjectGroup::operator[]%922649203.body preserve=yes
        assert( index < objects.size() ); 
        return( objects[ index ] ) ;
  //## end ObjectGroup::operator[]%922649203.body
}

int ObjectGroup::AddObject (const ObjectBase* object)
{
    if( object != NULL )
    {
            objects.push_back( reinterpret_cast<ObjectBase*>( object->Clone() ) ) ;
    }
        return objects.size() - 1 ;
}

bool ObjectGroup::IsInterfering (const Entity* entity) const
{
  //## begin ObjectGroup::IsInterfering%925235847.body preserve=yes
        for( int i = 0; i < objects.size(); i++ )
        {
                const Entity* e1 = objects[ i ] ;
                const Entity* e2 = entity ;
                bool forwardTest = e1->CanCheckInterference( e2 ) ;             //IMPROVE: inline all this stuff
                bool reverseTest = e2->CanCheckInterference( e1 ) ;
                
                if( forwardTest )
                {
                        if( e1->IsInterfering( e2 ) )
                        {
                                return true ;
                        }
                }
                else
                {
                        //IMPROVE: need to say something if geometry is incompatable
                        //assert( reverseTest != false ) ;
                        if( e2->IsInterfering( e1 ) )
                        {
                                return true ;
                        }
                }
        }
        return false ;
        //IMPROVE: use a bounding volume?
  //## end ObjectGroup::IsInterfering%925235847.body
}

void ObjectGroup::SetFrameManager (FrameManager* frameManager)
{
  //## begin ObjectGroup::SetFrameManager%926969418.body preserve=yes
        //need to set the frame manager of all the contained objects
        Entity::SetFrameManager( frameManager ) ;
        for( int i = 0 ; i < objects.size(); i++ )
        {
                objects[ i ]->SetFrameManager( frameManager ) ;
        }
  //## end ObjectGroup::SetFrameManager%926969418.body
}

//removes all the elements from the group
void ObjectGroup::Clear()
{
        this->objects.empty();
}


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

bool ObjectGroup::CanCheckInterference (const Entity* entity) const
{
  //## begin ObjectGroup::CanCheckInterference%926969422.body preserve=yes
        //check if each of the underlying objects can check interference with this entity
        for( int i = 0; i < objects.size(); i++ )
        {
                const Entity* e1 = objects[ i ] ;
                const Entity* e2 = entity ;
                bool forwardTest = e1->CanCheckInterference( e2 ) ;             //IMPROVE: inline all this stuff
                bool reverseTest = e2->CanCheckInterference( e1 ) ;
                if( !forwardTest && !reverseTest )
                {
                        return false ;
                }
        }
        return true ;
  //## end ObjectGroup::CanCheckInterference%926969422.body
}

void ObjectGroup::SetBaseFrame (const unsigned int baseFrame)
{
  //## begin ObjectGroup::SetBaseFrame%927936639.body preserve=yes
        ObjectBase::SetBaseFrame( baseFrame ); 
        for( int i = 0; i < objects.size(); i++ )
        {
                objects[ i ]->SetBaseFrame( baseFrame ) ;
        }
  //## end ObjectGroup::SetBaseFrame%927936639.body
}

void ObjectGroup::SetFrame (const Matrix4x4& frame)
{
  //## begin ObjectGroup::SetFrame%928263343.body preserve=yes
        for( int i = 0 ; i < objects.size(); i++ )
        {
                objects[ i ]->SetFrame( frame ) ;
        }
  //## end ObjectGroup::SetFrame%928263343.body
}

unsigned int ObjectGroup::Size () const
{
  //## begin ObjectGroup::Size%928344303.body preserve=yes
        return objects.size() ;
  //## end ObjectGroup::Size%928344303.body
}

void ObjectGroup::Serialize (ostream& os) const
{
  //## begin ObjectGroup::Serialize%934220963.body preserve=yes
        using std::endl ;

        //form a list of all the serializable objects
        std::vector< MPK_Serializable* > serializable ;

    int i;
        for( i = 0; i < objects.size(); i++ )
        {
                ObjectBase* object = objects[ i ] ;
                MPK_Serializable* sObject = dynamic_cast< MPK_Serializable* >( object );
                assert( sObject != NULL ) ;
                serializable.push_back( sObject ) ;
        }

        os << "#object_group" << endl ;
        os << serializable.size() << endl ;

        for( i = 0; i < serializable.size(); i++ )
        {
                serializable[ i ]->Serialize( os ) ;
        }
        os << "#end_object_group" << endl ;
  //## end ObjectGroup::Serialize%934220963.body
}

void ObjectGroup::Deserialize (IfstreamWithComments& is)
{
  //## begin ObjectGroup::Deserialize%934220964.body preserve=yes
        int size = -1 ;
        is >> size ;

        for( int i = 0; i < size; i++ )
        {
                ObjectBase* object = ObjectBase::Deserialize( is );
                AddObject( object ) ;
                delete object ;
        }

        char marker[ 300 ] ;
        eatwhite( is ) ;
        is.getline( marker, 300 ) ;
        assert( strcmp( marker, "#end_object_group" ) == 0 ) ;

  //## end ObjectGroup::Deserialize%934220964.body
}

// Additional Declarations
  //## begin ObjectGroup%36FE80AD0258.declarations preserve=yes
int ObjectGroup::TotalPolys() const
{
        int totalPolys = 0 ;
        for( int i = 0; i < objects.size(); i++ )
        {
                totalPolys += objects[ i ]->TotalPolys() ;
        }
        return totalPolys ;
};
  //## end ObjectGroup%36FE80AD0258.declarations

bool ObjectGroup::Verify() const
{
        assert( false );
        return true;
}

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

---