ODESimulator.h

Go to the documentation of this file.

/*************************************************************************
*                                                                       *
* Open Physics Abstraction Layer                                        *
* Copyright (C) 2004-2005                                               *
* Alan Fischer  alan.fischer@gmail.com                                  *
* Andres Reinot  andres@reinot.com                                      *
* Tyler Streeter  tylerstreeter@gmail.com                               *
* All rights reserved.                                                  *
* Web: opal.sourceforge.net                                             *
*                                                                       *
* This library is free software; you can redistribute it and/or         *
* modify it under the terms of EITHER:                                  *
*   (1) The GNU Lesser General Public License as published by the Free  *
*       Software Foundation; either version 2.1 of the License, or (at  *
*       your option) any later version. The text of the GNU Lesser      *
*       General Public License is included with this library in the     *
*       file license-LGPL.txt.                                          *
*   (2) The BSD-style license that is included with this library in     *
*       the file license-BSD.txt.                                       *
*                                                                       *
* This library is distributed in the hope that it will be useful,       *
* but WITHOUT ANY WARRANTY; without even the implied warranty of        *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files    *
* license-LGPL.txt and license-BSD.txt for more details.                *
*                                                                       *
*************************************************************************/

#ifndef OPAL_ODE_SIMULATOR_H
#define OPAL_ODE_SIMULATOR_H

// project headers
#include "../Defines.h"
#include "../Simulator.h"
#include "../AccelerationSensor.h"
#include "../InclineSensor.h"
#include "../RaycastSensor.h"
#include "../VolumeSensor.h"
#include "ODESolid.h"
#include "ODEJoint.h"
#include "ODESpace.h"

// system headers
#include <ode/ode.h>
#include <vector>

namespace opal
{
    class ODESimulator : public Simulator
    {
        public:
            enum SolverType
            {
                SOLVER_WORLDSTEP,

                SOLVER_QUICKSTEP };

            ODESimulator( );

            void initData( SimulatorData data );

            virtual ~ODESimulator();

            virtual void OPAL_CALL destroy();

            virtual void OPAL_CALL setMaxCorrectingVel( real vel );

            // SOLIDS

            virtual Solid* OPAL_CALL createSolid();

            // JOINTS

            virtual Joint* OPAL_CALL createJoint();

            // MOTORS

            // No ODE-specific Motor implementations at this time.

            // SENSORS

            // No ODE-specific Sensor implementations at this time.

            // SPACES

            virtual Space* OPAL_CALL createSpace();

            virtual void OPAL_CALL setGravity( const Vec3r& gravity );

            virtual Vec3r OPAL_CALL getGravity() const;

            virtual void OPAL_CALL setSolverAccuracy( SolverAccuracyLevel level );

            virtual dWorldID OPAL_CALL internal_getWorldID() const;

            virtual dSpaceID OPAL_CALL internal_getSpaceID() const;

            virtual dJointGroupID OPAL_CALL internal_getJointGroupID() const;

            virtual std::vector<RaycastResult> & OPAL_CALL internal_fireRay(
                const Rayr& r, real length, const Solid* attachedSolid,
                unsigned int rayContactGroup );

            virtual const VolumeQueryResult& OPAL_CALL internal_queryVolume(
                const Solid* volume, const Solid* attachedSolid );


            void internal_addRaycastResult( Solid* solid,
                    const Point3r& intersection, const Vec3r& normal, real depth );

            void internal_addCollidedSolid( Solid* solid );

            virtual unsigned int OPAL_CALL internal_getRayContactGroup();

        protected:
            virtual void stepPhysics();

            dWorldID mWorldID;

            dSpaceID mRootSpaceID;

            dJointGroupID mContactJointGroupID;

            SolverType mSolverType;

            long int mCollisionCount;

            VolumeQueryResult mVolumeQueryResult;

            const Solid* mSensorSolid;

            unsigned int mRayContactGroup;

            std::vector<RaycastResult> mRaycastResults;
    };

    namespace ode_hidden
    {
        // These function don't use the OPAL_CALL calling convention
        // because they are functors passed to ODE, which expects a different
        // calling convention.

        void internal_collisionCallback( void* data, dGeomID o0, dGeomID o1 );

        Joint* internal_getCommonJoint( dBodyID body0, dBodyID body1 );

        void internal_volumeCollisionCallback( void* data, dGeomID o0,
                        dGeomID o1 );

        void internal_raycastCollisionCallback( void* data, dGeomID o0,
                        dGeomID o1 );

        //helper function for collision callback
        //void createOneSidedContact(dJointID contactJoint,
        //      dBodyID movingObject, dBodyID staticObject, dVector3 pos);
    }
}

#endif

---