MercuryODE.h

Go to the documentation of this file.

#ifndef _MercuryODE_H
#define _MercuryODE_H

#include <ode/ode.h>
#include "MercuryINI.h"
#include "MercuryObject.h"

class MercuryODEWorld;

class MercuryODEObject : public MercuryObject
{
public:
    MercuryODEObject();
    virtual ~MercuryODEObject();

    virtual bool Collide( MercuryODEObject * pHit, dContact & pContact, MercuryODEWorld * pWorld ) = 0;

    dMass               m_oAccumulatedMass;
    dBodyID             m_oBody;
    dSpaceID            m_oSpace;

    PSElement GetParameter( const MString & sName ) { return m_mParameters[sName]; }
    void SetParameter( const MString & sName, const PSElement & pSet ) { m_mParameters[sName] = pSet; }

    virtual void PreCycleUpdate( const float dTime ) { }
    CLASS_RTTI( MercuryODEObject, MercuryObject );

    virtual void RemoveODE();

    MercuryODEWorld *   m_pWorld;
protected:
    bool m_wasActive;
private:
    std::map< MString, PSElement > m_mParameters;
};

class MercuryODEObjectLoadable : public MercuryODEObject
{
public:
    MercuryODEObjectLoadable()
        :MercuryODEObject()
    { }
    MercuryODEObjectLoadable( const MString & sName )
        :MercuryODEObject()
    {
        SetName(sName);
    }

    virtual ~MercuryODEObjectLoadable();
    virtual void Update( const float dTime );
    virtual void RemoveODE();

    virtual bool Collide( MercuryODEObject * pHit, dContact & pContact, MercuryODEWorld * pCollide )  { return true; }

    virtual bool LoadFromINI( MercuryINI & pINI, const MString & sShapeName, const dWorldID &oWorld );

    bool                m_bBodied;

    MercuryPoint        m_pPrePosition;
    MercuryPoint        m_pPreRotation;

    MVector< dGeomID > m_vAllGeoms;
    MVector< dGeomID > m_vAllTransforms;

    dSpaceID            m_oWorldSpace;
    CLASS_RTTI( MercuryODEObjectLoadable, MercuryODEObject );

    MVector< MercuryObject * > m_vMercuryShapes;

protected:
    dWorldID            m_oParentWorld;
private:

    struct InternalTrimesh
    {
        //XXX: We HAVE to define this here, otherwise we get an
        //internal compiler error in VC6
        ~InternalTrimesh()
        {
            dGeomTriMeshDataDestroy( m_oTriData );
            delete [] m_aVerts;
            delete [] m_aIndices;
        }

        dTriMeshDataID      m_oTriData;

        dVector3        *   m_aVerts;
        int                 m_iVertexCount;

        int             *   m_aIndices;
        int                 m_iIndexCount;
    };

    MVector< InternalTrimesh * > m_vTrimeshes;
};


class MercuryODEWorld : public MercuryObject
{
public:
    MercuryODEWorld();
    virtual ~MercuryODEWorld();

    virtual void Init();

    bool LoadFromINI( MercuryINI & pINI, const MString & sWorldName );

    void AddToWorld( MercuryODEObject * toAdd );

    MercuryODEObject * GenAndAddToWorld( MercuryINI & pINI, const MString & sItemName, const MString & sItemType, const MString & sClass, bool bBodied, const MercuryPoint & pInitialPosition );

    virtual bool RemoveObject( MercuryObject * object, bool bAllowDelete = true );

    MercuryODEObject * GetODEObjectByName( const MString & name ) { return m_mObjects[name]; }

    dSpaceID GetWorldSpaceID() { return m_oSpace; }

    dWorldID GetWorldID() { return m_oWorld; }

    virtual void Update( const float fDeltaTime );

    void SetGravity( const float fGravity );

    CLASS_RTTI( MercuryODEWorld, MercuryObject );

    MHash<MercuryODEObject *> & GetAllObjectMap() { return m_mObjects; }

    dJointGroupID       m_oJointGroup;
protected:
    MHash< MercuryODEObject * > m_mObjects;

    dWorldID            m_oWorld;

    dSpaceID            m_oSpace;

    dGeomID             m_oGround;

    friend void nearCallback (void *data, dGeomID o1, dGeomID o2);
};

//NOTE: This type of self-registering screen system is almost an
//exact rip-off of the one in Rage (for StepMania). The following
//few lines are (c) MIT 2001-2005 Chris Danford, Glenn Maynard
typedef MercuryODEObjectLoadable* (*NewODEObjectFunction)(const MString& sClassName);
void RegisterODEType( const MString& sClassName, NewODEObjectFunction pfn );

#include "MercuryObjectFactory.h"

#define REGISTER_ODE_OBJECT_CLASS( className ) \
    static MercuryODEObjectLoadable* CreateODE##className( const MString &sName ) \
    { MercuryODEObjectLoadable *pRet = new className( sName ); return pRet; } \
    struct RegisterODE##className { \
        RegisterODE##className() { RegisterODEType( #className,CreateODE##className); } \
    }; \
    static RegisterODE##className register_ODE##className; \
    REGISTER_OBJECT_TYPE( className );

extern std::map< MString, NewODEObjectFunction >  *ToMakeODEs;

//End of Rage-based registering system.


#endif

/* 
 * 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