MercuryODE.cpp

Go to the documentation of this file.

#include "global.h"
#include "MercuryODE.h"
#include "MercuryUtil.h"
#include "MercuryShapes.h"
#include "MercuryLoadableModel.h"
#include "MercuryLog.h"
#include "MercuryTheme.h"
#include "MercuryPoly.h"

//#ifdef WIN32
#if defined(WIN32) && !defined(__GNUC__)
#pragma comment(lib, "ode.lib")
#endif

MercuryODEObject::MercuryODEObject()
{
    m_oAccumulatedMass.mass = 0;
    m_oBody = 0;
    m_oSpace = 0;
    m_wasActive = true;
}

MercuryODEObject::~MercuryODEObject()
{
//  if ( m_oBody )
//      dBodyDestroy( m_oBody );
}

CLASS_FUNCTION_VOID_NOARGS( MercuryODEObject, RemoveODE );
void MercuryODEObject::RemoveODE()
{
        dBodyDestroy( m_oBody );
}


REGISTER_ODE_OBJECT_CLASS( MercuryODEObjectLoadable );

MercuryODEObjectLoadable::~MercuryODEObjectLoadable( )
{
    unsigned i;
    for ( i = 0; i < m_vMercuryShapes.size(); i++ )
        SAFE_DELETE( m_vMercuryShapes[i] );

    for ( i = 0; i < m_vTrimeshes.size(); i++ )
        SAFE_DELETE( m_vTrimeshes[i] );
}

bool MercuryODEObjectLoadable::LoadFromINI( MercuryINI & pINI, 
        const MString & sShapeName, const dWorldID & oWorld )
{
    unsigned int i;
    m_oParentWorld = oWorld;

    if ( m_vMercuryShapes.size() > 0 )      //We cannot double-load objects
        return false;

    if ( m_oSpace == 0 )                    //We must have our object space set up for us.
        return false;

    unsigned iNumPieces = pINI.GetValueI( sShapeName, "NumPieces" );

    //Pre-resize the trimesh and shape's arrays
    m_vMercuryShapes.resize( iNumPieces );
    m_vTrimeshes.resize( iNumPieces );

    for( i = 0; i < m_vMercuryShapes.size(); i++ )
    {
        m_vTrimeshes[i] = NULL;
        m_vMercuryShapes[i] = NULL;
    }

    if ( m_bBodied )
    {
        m_oBody = dBodyCreate ( oWorld );
        m_oAccumulatedMass.setZero();
        m_oAccumulatedMass.c[0] = 0;
        m_oAccumulatedMass.c[1] = 0;
        m_oAccumulatedMass.c[2] = 0;

    }

    //Pre Rotation Matrix
    dQuaternion q1,q2,q3,q4,qSum;
    dMatrix3 PRERtx;
    dQFromAxisAndAngle (q1, 1, 0, 0, m_pPreRotation.x / 57.2958f );
    dQFromAxisAndAngle (q2, 0, 1, 0, m_pPreRotation.y / 57.2958f );
    dQMultiply0( q4, q1, q2 );
    dQFromAxisAndAngle (q3, 0, 0, 1, m_pPreRotation.z / 57.2958f );
    dQMultiply0( qSum, q4, q3 );
    dQtoR ( qSum, PRERtx);

    //Now, see if we have one or more geoms to deal with.
    for ( i = 0; i < iNumPieces; i++ )
    {
        MString sPieceName = ssprintf( "Piece%d", i+1 );
        
        unsigned    iPieceType  = pINI.GetValueI( sShapeName, sPieceName + "Type", 0 );
        bool        bUsesODE    = pINI.GetValueB( sShapeName, sPieceName + "UsesODE", true );
        bool        bVisible    = pINI.GetValueB( sShapeName, sPieceName + "Visible", true );
        MString     sFileName   = pINI.GetValueS( sShapeName, sPieceName + "Filename" );    //Optional
        float       fDensity    = pINI.GetValueF( sShapeName, sPieceName + "Density", 0 );

        if ( bVisible )
        {
            switch ( iPieceType )
            {
            case 0:     //Sphere
                {
                MercuryShape * s = new MercuryShape;
                s->SetName( sPieceName + sShapeName );
                s->Init();
                //Make a sphere with stacks/slices based on the INI file
                s->MakeSphere(  pINI.GetValueI( sShapeName, sPieceName + "Stacks", 24 ),
                                pINI.GetValueI( sShapeName, sPieceName + "Slices", 48 ) );
                
                //Load the PNG file based on the theme
                s->LoadImage( THEME.GetPathToGraphic( sFileName ) );

                //Set all other information for the sphere here
                float fRadius = pINI.GetValueF( sShapeName, sPieceName + "Radius", 1 );
                s->SetScale( MercuryPoint( fRadius, fRadius, fRadius ) );

                //Put our sphere in the vector of objects so it gets deleted in the end.
                m_vMercuryShapes[i] = s;
                break;
                }
            case 1:     //Cylinder
                {
                    //For info, refer to sphere
                MercuryShape * s = new MercuryShape;
                s->SetName( sPieceName + sShapeName );
                s->Init();
                s->MakeCylinder(pINI.GetValueI( sShapeName, sPieceName + "Stacks", 24 ),
                                pINI.GetValueI( sShapeName, sPieceName + "Slices", 48 ) );
                s->LoadImage( THEME.GetPathToGraphic( sFileName ) );
                float fRadius = pINI.GetValueF( sShapeName, sPieceName + "Radius", 1 );
                float fLength = pINI.GetValueF( sShapeName, sPieceName + "Length", 1 );
                s->SetScale( MercuryPoint( fRadius, fRadius, fLength ) );
                m_vMercuryShapes[i] = s;
                break;
                }
            case 2:
                {
                    //For info, refer to sphere
                MercuryShape * s = new MercuryShape;
                s->SetName( sPieceName + sShapeName );
                s->Init();
                s->MakeBox( );
                s->LoadImage( THEME.GetPathToGraphic( sFileName ) );
                s->SetScaleX( pINI.GetValueF( sShapeName, sPieceName + "LengthX", 1 ) );
                s->SetScaleY( pINI.GetValueF( sShapeName, sPieceName + "LengthY", 1 ) );
                s->SetScaleZ( pINI.GetValueF( sShapeName, sPieceName + "LengthZ", 1 ) );
                m_vMercuryShapes[i] = s;
                break;
                }
            case 3: //Model
                {
                //Refer to sphere
                MercuryModel* s = new MercuryLoadableModel();
                s->SetName( sPieceName + sShapeName );
                s->Init();
                s->Load( THEME.GetPathToModel( sFileName ) );
                s->SetScaleX( pINI.GetValueF( sShapeName, sPieceName + "LengthX", 1 ) );
                s->SetScaleY( pINI.GetValueF( sShapeName, sPieceName + "LengthY", 1 ) );
                s->SetScaleZ( pINI.GetValueF( sShapeName, sPieceName + "LengthZ", 1 ) );
                m_vMercuryShapes[i] = s;
                break;
                }
            default:
                LOG.Warn( ssprintf( "Unknown piece type '%d' in shape: %s", iPieceType, sShapeName.c_str() ) );
                break;
            };
            
            //if we loaded the object, continue here.
            if ( m_vMercuryShapes[i] )
            {
                //Set all other information for the file.
                m_vMercuryShapes[i]->SetX( pINI.GetValueF( sShapeName, sPieceName + "X" ) );
                m_vMercuryShapes[i]->SetY( pINI.GetValueF( sShapeName, sPieceName + "Y" ) );
                m_vMercuryShapes[i]->SetZ( pINI.GetValueF( sShapeName, sPieceName + "Z" ) );
                m_vMercuryShapes[i]->SetRotX( pINI.GetValueF( sShapeName, sPieceName + "RotX" ) );
                m_vMercuryShapes[i]->SetRotY( pINI.GetValueF( sShapeName, sPieceName + "RotY" ) );
                m_vMercuryShapes[i]->SetRotZ( pINI.GetValueF( sShapeName, sPieceName + "RotZ" ) );

                //Add the object, so MercuryFrame/MercuryObject will handle it for us
                AddObject( m_vMercuryShapes[i] );
            }
        }

        if ( bUsesODE )
        {
            dGeomID cg = 0;
            switch ( iPieceType )
            {
            case 0:     //Sphere
                cg = dCreateSphere( 0, pINI.GetValueF( sShapeName, sPieceName + "Radius", 1 ) );
                if ( fDensity > 0 )
                {
                    dMass pTempSph;
                    pTempSph.setSphere( fDensity,
                        pINI.GetValueF( sShapeName, sPieceName + "Radius", 1 ) );
                    pTempSph.c[0] = pINI.GetValueF( sShapeName, sPieceName + "X" );
                    pTempSph.c[1] = pINI.GetValueF( sShapeName, sPieceName + "Y" );
                    pTempSph.c[2] = pINI.GetValueF( sShapeName, sPieceName + "Z" );
                    m_oAccumulatedMass.add( &pTempSph );
                }
                break;
            case 1:     //Cylinder
                cg = dCreateCCylinder( 0, 
                    pINI.GetValueF( sShapeName, sPieceName + "Radius", 1 ),
                    pINI.GetValueF( sShapeName, sPieceName + "Length", 1 ) );
                if ( fDensity > 0 )
                {
                    dMass pTempCyl;
                    pTempCyl.setCappedCylinder( fDensity, 1, 
                        pINI.GetValueF( sShapeName, sPieceName + "Radius", 1 ),
                        pINI.GetValueF( sShapeName, sPieceName + "Length", 1 )/2 );
                    m_oAccumulatedMass.add( &pTempCyl );
                }
                break;
            case 2:     //Box
                cg = dCreateBox ( 0, 
                    pINI.GetValueF( sShapeName, sPieceName + "LengthX", 1 ),
                    pINI.GetValueF( sShapeName, sPieceName + "LengthY", 1 ),
                    pINI.GetValueF( sShapeName, sPieceName + "LengthZ", 1 ) );
                if ( fDensity > 0 )
                {
                    dMass pTempBox;
                    pTempBox.setBox( fDensity,
                        pINI.GetValueF( sShapeName, sPieceName + "LengthX", 1 ),
                        pINI.GetValueF( sShapeName, sPieceName + "LengthY", 1 ),
                        pINI.GetValueF( sShapeName, sPieceName + "LengthZ", 1 ) );
                    m_oAccumulatedMass.add( &pTempBox );
                }
                break;
            case 3:     //Model
                {
                //Note about use of variables:
                //  s: original MercuryModel
                //  c: this triangle's InternalTrimesh
                //  j,k,l,m,n: counter objects (for loops)
                //  p: the poly we are using for work

                MercuryPoint pResize( pINI.GetValueF( sShapeName, sPieceName + "LengthX", 1 ),
                    pINI.GetValueF( sShapeName, sPieceName + "LengthY", 1 ),
                    pINI.GetValueF( sShapeName, sPieceName + "LengthZ", 1 ) );
                //Get the corresponding model.  We know it's a model.
                MercuryModel * s = (MercuryModel*)(void*)m_vMercuryShapes[i];

                //Make a new internatl trimesh here and cache it to be c
                m_vTrimeshes[i] = new InternalTrimesh;
                InternalTrimesh * c = m_vTrimeshes[i];
                MercuryMesh* mesh = s->GetMesh(0);

                unsigned int j;
//              bool bBackfaces = pINI.GetValueB( sShapeName, 
//                  sPieceName + "PhysicsBackfaces", 0 );

                //Since we're not rewhelding the verticies,
                //we know we have 3*number of poly's indexes 
                //potentially *2 if we are doing backfaces
                //and 3*number of poly's verts.
                c->m_iIndexCount =  mesh->NumIndices(); //*(bBackfaces+1);//Backfaces are useless and broken now.
//              c->m_iVertexCount = G->NumVertices();
                c->m_iVertexCount = mesh->NumVertices();

                //allocate space for our indices and verticies
                c->m_aIndices = new int[mesh->NumIndices()];
                c->m_aVerts = new dVector3[mesh->NumVertices()];

                for( j = 0; j < mesh->NumIndices(); j++ )
                {
                    int index = mesh->GetIndicesPtr()[j];
                    c->m_aIndices[j] = index;
                }

                for( j = 0; j < mesh->NumVertices(); j++ )
                {
                    c->m_aVerts[j][0] = mesh->GetVerticePtr()[j].GetX() * pResize.x;
                    c->m_aVerts[j][1] = mesh->GetVerticePtr()[j].GetY() * pResize.y;
                    c->m_aVerts[j][2] = mesh->GetVerticePtr()[j].GetZ() * pResize.z;
                }
                
                //Create the trimesh data
                c->m_oTriData = dGeomTriMeshDataCreate();
    
                //Build the geom
                dGeomTriMeshDataBuildSimple( c->m_oTriData,
                    (float*)c->m_aVerts,c->m_iVertexCount,
                    c->m_aIndices, c->m_iIndexCount );
                
                //Actually create the ODE object
                cg = dCreateTriMesh( 0, c->m_oTriData, 0, 0, 0 );
                }
                if ( fDensity > 0 )
                {
                    dMass pTempSph;
                    pTempSph.setSphere( fDensity,
                        pINI.GetValueF( sShapeName, sPieceName + "Radius", 1 ) );
                    m_oAccumulatedMass.add( &pTempSph );
                }
                break;
            default:
                LOG.Warn( ssprintf( "Unknown piece type '%d' in shape: %s", iPieceType, sShapeName.c_str() ) );
                break;
            }

            if ( cg )
            {
                //If we have a GeomID (loading was successful)
                //set it's rotation and position according to what
                //it's piece info is, independent to it's body's center.
                dQuaternion q1,q2,q3,q4,qSum;
                dMatrix3 Rtx;
                dQFromAxisAndAngle (q1, 1, 0, 0, pINI.GetValueF( sShapeName, sPieceName + "RotX" ) / 57.2958f );
                dQFromAxisAndAngle (q2, 0, 1, 0, pINI.GetValueF( sShapeName, sPieceName + "RotY" ) / 57.2958f );
                dQMultiply0( q4, q1, q2 );
                dQFromAxisAndAngle (q3, 0, 0, 1, pINI.GetValueF( sShapeName, sPieceName + "RotZ" ) / 57.2958f );
                dQMultiply0( qSum, q4, q3 );

                dQtoR ( qSum, Rtx);

                dGeomSetRotation( cg, Rtx );


                dGeomSetPosition( cg, 
                    pINI.GetValueF( sShapeName, sPieceName + "X" ),
                    pINI.GetValueF( sShapeName, sPieceName + "Y" ),
                    pINI.GetValueF( sShapeName, sPieceName + "Z" ) );

                //Make a transform so the movement we made before
                //will be independent from space.  Put this transform
                //in the world space.
                dGeomID Tran = dCreateGeomTransform( m_oSpace );

                dGeomSetData( Tran, this );

                dGeomTransformSetCleanup( Tran, 1 );
                dGeomTransformSetGeom( Tran, cg );
                m_vAllGeoms.push_back( cg );
                m_vAllTransforms.push_back( Tran );
                if ( m_bBodied )
                {
                    //If it's bodied, set the body.
                    dGeomSetBody( Tran, m_oBody );
                }
                else
                {
                    dGeomSetRotation( Tran, PRERtx );
                    dGeomSetPosition( Tran, 
                        m_pPrePosition.x,
                        m_pPrePosition.y,
                        m_pPrePosition.z );
                }
            }
        }
    }

    //If it's bodied, then set the outer rotation and such
    //based on what was sent in beforehand
    if ( m_bBodied )
    {
        dBodySetMass( m_oBody, &m_oAccumulatedMass );
        dBodySetPosition( m_oBody, 
            m_pPrePosition.x,
            m_pPrePosition.y,
            m_pPrePosition.z );
        dBodySetRotation( m_oBody, PRERtx );
    } else
        SetRot( m_pPreRotation );

    MString sParameterList = pINI.GetValueS( sShapeName, "Properties" );
    while ( sParameterList.size() > 0 )
    {
        int i = BytesUntil( sParameterList.c_str(), ",", 0, sParameterList.length(), 1 );   //Find next comma
        if ( i == (int)sParameterList.size() )
        {
            SetParameter( sParameterList, PSElement( pINI.GetValueS( sShapeName, sParameterList ) ) );
            break;
        }
        SetParameter( sParameterList.substr( 0, i ), PSElement( pINI.GetValueS( sShapeName, sParameterList.substr( 0, i ) ) ) );
        sParameterList = sParameterList.substr( i+1 );                  //and change the remaining parameters
    }

    return true;
}

void MercuryODEObjectLoadable::Update( const float dTime )
{
    //If the object is bodied, then we will
    //have to update it's MercuryObject's info (location & position)
    if ( m_bBodied && m_wasActive )
    {
        const float * sz1 = dBodyGetPosition ( m_oBody );

        SetX( sz1[0] );
        SetY( sz1[1] );
        SetZ( sz1[2] );

        SetRotationMode( RM_QUATERNION );
        SetRotationQuaternion( (float*)dBodyGetQuaternion(m_oBody) );
    }
    MercuryODEObject::Update( dTime );
}

CLASS_FUNCTION_VOID_NOARGS( MercuryODEObjectLoadable, RemoveODE );
void MercuryODEObjectLoadable::RemoveODE()
{
    unsigned i;
    MercuryODEObject::RemoveODE();
    for( i = 0; i < m_vAllTransforms.size(); i++ )
        dGeomDestroy( m_vAllTransforms[i] );
}

MercuryODEWorld::MercuryODEWorld( )
{
}

void MercuryODEWorld::Init()
{
    MercuryObject::Init();

    //Make the world
    m_oWorld = dWorldCreate();
    m_oSpace = dHashSpaceCreate (0);

    //Make the plane
    m_oGround = dCreatePlane( m_oSpace, 0, 0, 1, 0 );

    //Make the joint group (for collisions)
    m_oJointGroup = dJointGroupCreate(0);

    dWorldSetAutoDisableFlag(m_oWorld, true);
    dWorldSetAutoDisableLinearThreshold (m_oWorld, 0.1f);
    dWorldSetAutoDisableAngularThreshold (m_oWorld, 0.1f);
}

MercuryODEWorld::~MercuryODEWorld()
{
    //Kill all underlings first, then destroy the spaces, this way, when they delete themselves, we won't have an issue.

    FOREACH_Object(m_objects, i)
    if ( i->bAutoDelete )
        SAFE_DELETE(i->pObject);

    dSpaceDestroy ( m_oSpace );
    dWorldDestroy ( m_oWorld );
}

bool MercuryODEWorld::LoadFromINI( MercuryINI & pINI, const MString & sWorldName )
{
    //Set this the world's name
    SetName( sWorldName );

    unsigned NumElements = pINI.GetValueI( sWorldName, "NumElements" );
    SetGravity( -pINI.GetValueF( sWorldName, "Gravity", 32 ) );

    for ( unsigned i = 0; i < NumElements; i++ )
    {
        MString sInName = pINI.GetValueS( sWorldName, ssprintf( "Piece%d", i+1 ) );
        if ( sInName.length() == 0 )
        {
            LOG.Warn( ssprintf( "Cannot load object #%d in world.", i + 1 ) );
            continue;
        }

        MString sName = pINI.GetValueS( sWorldName, ssprintf( "Piece%dName", i+1 ), sInName );
        MString sClass = pINI.GetValueS( sWorldName, ssprintf( "Piece%dClass", i+1 ), "MercuryODEObjectLoadable" );

        if ( ToMakeODEs->find( sClass ) == ToMakeODEs->end() )
        {
            LOG.Warn( ssprintf( "Could not find class name %s on object #%d", sName.c_str(), i+1) );
            continue;
        }

        MercuryODEObjectLoadable * c = (*ToMakeODEs)[sClass]( sName );
        //Set up all info and send it in to the ODEObjectLoadable before it is loaded
        c->m_pWorld = this;
        c->m_bBodied = pINI.GetValueB( sWorldName, ssprintf( "Piece%dBodied", i + 1 ) );
        c->m_oSpace = m_oSpace;

        c->m_pPrePosition = MercuryPoint( 
                pINI.GetValueF( sWorldName, ssprintf( "Piece%dX", i + 1 ) ),
                pINI.GetValueF( sWorldName, ssprintf( "Piece%dY", i + 1 ) ),
                pINI.GetValueF( sWorldName, ssprintf( "Piece%dZ", i + 1 ) ) );
        
        c->m_pPreRotation = MercuryPoint( 
                pINI.GetValueF( sWorldName, ssprintf( "Piece%dRotX", i + 1 ) ),
                pINI.GetValueF( sWorldName, ssprintf( "Piece%dRotY", i + 1 ) ),
                pINI.GetValueF( sWorldName, ssprintf( "Piece%dRotZ", i + 1) ) );

        //Actually load the object
        c->m_oWorldSpace = m_oSpace;
        c->SetName( sWorldName + sInName );
        c->Init();
        c->LoadFromINI( pINI, sInName, m_oWorld );

        m_mObjects[sName] = c;

        c->SetPosition( c->m_pPrePosition );
        AddObject( c, true );
    }
    return true;
}
MercuryODEObject * MercuryODEWorld::GenAndAddToWorld( MercuryINI & pINI,
    const MString & sItemName, const MString & sItemType, const MString & sClass,
    bool bBodied, const MercuryPoint & pInitialPosition )
{
    MercuryODEObjectLoadable * c = (*ToMakeODEs)[sClass]( sItemName );
    c->m_bBodied = bBodied;
    c->m_oSpace = m_oSpace;
    c->m_pPrePosition = pInitialPosition;
    c->m_pPreRotation = gpZero;

    //Actually load the object
    c->m_oWorldSpace = m_oSpace;
    c->SetName( sItemName );
    c->Init();
    c->LoadFromINI( pINI, sItemType, m_oWorld );
    m_mObjects[sItemName] = c;
    c->SetPosition( c->m_pPrePosition );
    AddObject( c, true );
    return c;
}

void MercuryODEWorld::AddToWorld( MercuryODEObject * toAdd )
{
    m_mObjects[toAdd->GetName()] = toAdd;
    AddObject( toAdd );
}

bool MercuryODEWorld::RemoveObject( MercuryObject * object, bool bAllowDelete )
{
    if ( bAllowDelete )
    {
        PStack ret;
        PStack args;

        object->Command( ret, "RemoveODE", args );
        MercuryObject::RemoveObject( object, bAllowDelete );
        return true;
    }   
    return MercuryObject::RemoveObject( object, bAllowDelete );
}

/**************CONTACT STUFF************************************************/
void nearCallback (void *data, dGeomID o1, dGeomID o2)
{
    dBodyID b1,b2;
    b1 = dGeomGetBody(o1);
    b2 = dGeomGetBody(o2);
    //If we don't actually have a collision, then break out
    if (b1 && b2 && dAreConnectedExcluding (b1,b2,dJointTypeContact)) return;

    MercuryODEWorld * inthis =(MercuryODEWorld*) data;
    dContact contact[16];

    //Initialize all of our contacts
    int i;
    for ( i = 0; i <16; i++ )
    {
        contact[i].surface.mode = 0;
        contact[i].surface.mu = 5000;
        contact[i].surface.bounce = 0;
    }

    //Do the object actually collide?
    int numcol;
    if ( (numcol = dCollide (o1,o2,16,&contact[0].geom,sizeof(dContact)))) 
    {
        //Process the collisions
        for ( i = 0; i < numcol; i++ )
        {
            //Make sure we should collide
            MercuryODEObject * m1 = (MercuryODEObject*)dGeomGetData( o1 );
            MercuryODEObject * m2 = (MercuryODEObject*)dGeomGetData( o2 );

            if ( m1 && m2 )     //If shouldn't collide, bail out.
                if ( ( !m1->Collide( m2, contact[i], inthis ) ) || ( !m2->Collide( m1, contact[i], inthis ) ) )
                    continue;

            dJointID c = dJointCreateContact (inthis->m_oWorld,
                inthis->m_oJointGroup, &contact[i]);
            dJointAttach (c,b1,b2);
        }
    }
}


void MercuryODEWorld::Update( const float fDeltaTime )
{
    if ( fDeltaTime != 0 )
    {
        for( MDequeIterator<ParentHoldPair> child = m_objects.begin(); child != m_objects.end(); ++child )
            ((MercuryODEObject*)child->pObject)->PreCycleUpdate( fDeltaTime );


        //Do the collisions
        dSpaceCollide( m_oSpace, this, &nearCallback );

        //Step the world (quickstep is better at not crashing)
        //dWorldStep( m_oWorld, Clamp(fDeltaTime, 0.0f, 0.2f) );
        dWorldQuickStep( m_oWorld, Clamp(fDeltaTime,0.0f,0.2f) );

        //Empty all collisions and joints
        dJointGroupEmpty (m_oJointGroup);
    }

    //Run the update on the world
    MercuryObject::Update( fDeltaTime );
}

void MercuryODEWorld::SetGravity( const float fGravity )
{
    dWorldSetGravity( m_oWorld, 0, 0, fGravity );
}

std::map< MString, NewODEObjectFunction >  *ToMakeODEs = NULL;

void RegisterODEType( const MString& sClassName, NewODEObjectFunction pfn )
{
    if ( !ToMakeODEs )
        ToMakeODEs = new std::map< MString, NewODEObjectFunction >;

    (*ToMakeODEs)[sClassName] = pfn;
}

/* 
 * Copyright (c) 2005-2006, Charles Lohr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by