Simulator.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_SIMULATOR_H
#define OPAL_SIMULATOR_H

// project headers
#include "Defines.h"
#include "Motor.h"
#include "Joint.h"
#include "Solid.h"
#include "Space.h"
#include "Blueprint.h"
#include "Sensor.h"
#include "Vec3r.h"

namespace opal
{
        class AttractorMotor;
        class GearedMotor;
        class ServoMotor;
        class SpringMotor;
        class ThrusterMotor;
        class VelocityMotor;
        class AccelerationSensor;
        class InclineSensor;
        class RaycastSensor;
        class VolumeSensor;
        class BlueprintInstance;
        class PostStepEventHandler;
        struct RaycastResult;
        struct VolumeQueryResult;

        class SimulatorData
        {
                public:
                        SimulatorData()
                        {
                                useOctreeInsteadHash = false;

                                // octree defaults
                                worldSize = Vec3r( 1000, 1000, 1000 );
                                octreeDepth = 7;
                                worldCenter = Vec3r( 0, 0, 0 );

                                // hash defaults
                                hashMinLevel = -5;
                                hashMaxLevel = 9;
                        }

                        /*
                        SimulatorData( SimulatorData & copy )
                        {
                            useOctreeInsteadHash = copy.useOctreeInsteadHash;

                            // octree defaults
                            worldSize = copy.worldSize;
                            octreeDepth = copy.octreeDepth;
                            worldCenter = copy.worldCenter;

                            // hash defaults
                            hashMinLevel = copy.hashMinLevel;
                            hashMaxLevel = copy.hashMaxLevel;
                        }*/

                        bool useOctreeInsteadHash;

                        Vec3r worldSize;

                        Vec3r worldCenter;

                        int octreeDepth;

                        int hashMinLevel;

                        int hashMaxLevel;
        };

        class Simulator
        {
                public:
                        Simulator();

                        virtual void initData( SimulatorData data );

                        virtual void OPAL_CALL destroy() = 0;

                        virtual bool OPAL_CALL simulate( real dt );

                        virtual void OPAL_CALL setStepSize( real stepSize );

                        virtual real OPAL_CALL getStepSize();

                        // post events


                        virtual void OPAL_CALL addPostStepEventHandler(
                            PostStepEventHandler * eventHandler );

                        virtual void OPAL_CALL removePostStepEventHandler(
                            PostStepEventHandler * eventHandler );

                        virtual size_t OPAL_CALL getNumPostStepEventHandlers() const;

                        virtual PostStepEventHandler* OPAL_CALL
                        getPostStepEventHandler( unsigned int id ) const;

                        // global collision events


                        virtual void OPAL_CALL addGlobalCollisionEventHandler(
                            CollisionEventHandler * eventHandler );

                        virtual void OPAL_CALL removeGlobalCollisionEventHandler(
                            CollisionEventHandler * eventHandler );

                        virtual size_t OPAL_CALL getNumGlobalCollisionEventHandlers() const;

                        virtual CollisionEventHandler* OPAL_CALL
                        getGlobalCollisionEventHandler( unsigned int id ) const;

                        virtual void OPAL_CALL instantiateBlueprint(
                            BlueprintInstance& instance, const Blueprint& bp,
                            const Matrix44r& offset = Matrix44r(), real scale = 1 );

                        virtual void OPAL_CALL setGravity( const Vec3r& gravity ) = 0;

                        virtual Vec3r OPAL_CALL getGravity() const = 0;

                        virtual void OPAL_CALL setSolverAccuracy( SolverAccuracyLevel level );

                        virtual SolverAccuracyLevel OPAL_CALL getSolverAccuracy() const;

                        virtual void OPAL_CALL setMaxCorrectingVel( real vel );

                        virtual real OPAL_CALL getMaxCorrectingVel() const;

                        virtual void OPAL_CALL setMaxContacts( unsigned int mc );

                        virtual unsigned int OPAL_CALL getMaxContacts() const;

                        //virtual void OPAL_CALL setMaxLinearVel(real max);

                        //virtual real OPAL_CALL getMaxLinearVel()const;

                        //virtual void OPAL_CALL setMaxAngularVel(real max);

                        //virtual real OPAL_CALL getMaxAngularVel()const;

                        virtual void OPAL_CALL setUserData( void* data );

                        virtual void* OPAL_CALL getUserData();

                        virtual void OPAL_CALL setupContactGroups( unsigned int group0,
                                unsigned int group1, bool makeContacts );

                        virtual void OPAL_CALL setupContactGroup( unsigned int group,
                                bool makeContacts );

                        virtual bool OPAL_CALL groupsMakeContacts( unsigned int group0,
                                unsigned int group1 );

                        virtual void OPAL_CALL setStaticSleepingContactsEnabled( bool enable );

                        virtual bool OPAL_CALL areStaticSleepingContactsEnabled();

                        // SOLIDS

                        virtual Solid* OPAL_CALL createSolid() = 0;

                        virtual Solid* OPAL_CALL createPlane( real a, real b, real c, real d,
                                                              const Material& m = defaults::shape::material );

                        virtual unsigned int OPAL_CALL getNumSolids() const;

                        virtual Solid* OPAL_CALL getSolid( unsigned int i ) const;

                        virtual void OPAL_CALL destroySolid( Solid* s );

                        virtual void OPAL_CALL destroyAllSolids();

                        // JOINTS

                        virtual Joint* OPAL_CALL createJoint() = 0;

                        virtual void OPAL_CALL destroyJoint( Joint* j );

                        virtual void OPAL_CALL destroyAllJoints();

                        // MOTORS

                        virtual ThrusterMotor* OPAL_CALL createThrusterMotor();

                        virtual VelocityMotor* OPAL_CALL createVelocityMotor();

                        virtual GearedMotor* OPAL_CALL createGearedMotor();

                        virtual ServoMotor* OPAL_CALL createServoMotor();

                        virtual AttractorMotor* OPAL_CALL createAttractorMotor();

                        virtual SpringMotor* OPAL_CALL createSpringMotor();

                        //virtual void OPAL_CALL registerCustomMotor(Motor* m);

                        virtual void OPAL_CALL destroyMotor( Motor* m );

                        virtual void OPAL_CALL destroyAllMotors();

                        // SENSORS

                        virtual AccelerationSensor* OPAL_CALL createAccelerationSensor();

                        virtual InclineSensor* OPAL_CALL createInclineSensor();

                        virtual RaycastSensor* OPAL_CALL createRaycastSensor();

                        virtual VolumeSensor* OPAL_CALL createVolumeSensor();

                        virtual void OPAL_CALL destroySensor( Sensor* s );

                        virtual void OPAL_CALL destroyAllSensors();

                        // SPACES

                        virtual Space* OPAL_CALL createSpace() = 0;

                        virtual Space* OPAL_CALL getRootSpace();

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

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

                        virtual unsigned long int OPAL_CALL
                        internal_getContactGroupFlags( unsigned int groupNum ) const;

                        virtual void OPAL_CALL internal_recordCollision( const CollisionEvent & event );

                protected:
                        virtual ~Simulator();

                        virtual void stepPhysics() = 0;

                        void addSolid( Solid* s );

                        void removeSolid( Solid* s );

                        void addJoint( Joint* j );

                        void removeJoint( Joint* j );

                        void addMotor( Motor* m );

                        void removeMotor( Motor* m );

                        void addSensor( Sensor* s );

                        void removeSensor( Sensor* s );

                        void addSpace( Space* s );

                        void destroyGarbage();

                        real mStepSize;

                        real mTimeBuffer;

                        SolverAccuracyLevel mSolverAccuracyLevel;

                        void* mUserData;

                        //real mMaxLinearVel;

                        //real mMaxAngularVel;

                        std::vector<Solid*> mSolidList;

                        std::vector<Joint*> mJointList;

                        std::vector<Motor*> mMotorList;

                        std::vector<Sensor*> mSensorList;

                        bool mIsSolidDestructionSafe;

                        bool mIsJointDestructionSafe;

                        std::vector<Solid*> mSolidGarbageList;

                        std::vector<Joint*> mJointGarbageList;

                        std::vector<Space*> mSpaceList;

                        Space * mRootSpace;

                        unsigned long int mContactGroupFlags[ 32 ];

                        bool mStaticSleepingContactsEnabled;

                        std::vector<PostStepEventHandler *> mPostStepEventHandlers;

                        std::vector<CollisionEventHandler *> mCollisionEventHandlers;

                        real mMaxCorrectingVel;

                        unsigned int mMaxContacts;

                        SimulatorData mData;

                private:
        };
}

#endif

---