vrsode/include/vrsode/PhysicsManager.h

Go to the documentation of this file.

#ifndef _VRSODE_PHYSICS_MANAGER_H_
#define _VRSODE_PHYSICS_MANAGER_H_

#include "CollisionBody.h"
#include "PhysicsBody.h"

#include "PhysicsJoint.h"
#include "PhysicsJointBall.h"
#include "PhysicsJointHinge.h"
#include "PhysicsJointHinge2.h"
#include "PhysicsJointSlider.h"
#include "PhysicsJointUniversal.h"

#include "CollisionSpace.h"
#include "CollisionSpaceSimple.h"

// #include "random_utils/SleepyObject.h"
#include "random_utils/ThreadSafeObject.h"
#include "random_utils/ThreadSafeCanvas.h"

#include <ode/ode.h>
#include <vrs/container/array.h>
#include <vrs/so.h>
#include <vrs/matrix.h>
#include <vrs/sg/scenething.h>

#include "SDL.h"

namespace vrsode
{

#define Infinity dInfinity;

// class PhysicsManager : public random_utils::SleepyObject
class PhysicsManager : public random_utils::ThreadSafeObject
{
    dWorldID m_worldId;
    dSpaceID m_spaceId;
    dJointGroupID m_collisionContactGroupId;

    unsigned int m_maxCollisionContacts;

    // in how many steps is one update cycle split
    static unsigned int m_updateResolution;
    static double m_stepSize;
    static double m_stepTime;
    static bool m_keepRunning;
    static bool m_runningMultiThreaded;

    bool m_performanceAutoAdjust;

    static PhysicsManager* m_instance;
    bool m_initialised;

    std::vector<VRS::SO<PhysicsBody> > m_physicsBodies;
    std::vector<VRS::SO<CollisionBody> > m_collisionBodies;

    static SDL_Thread* m_thread;

    void applyTransformations();

    std::vector<VRS::SO<PhysicsBody> >::iterator findPhysicsBody(
        VRS::SO<PhysicsBody>);
    std::vector<VRS::SO<CollisionBody> >::iterator findCollisionBody(
        VRS::SO<CollisionBody>);

    double currentTime();

protected:
    void update();

public:
    PhysicsManager();

    ~PhysicsManager();

    static void startThread()
    {
        PhysicsManager* pm = PhysicsManager::get();
        assert(pm->isInitialised());
        m_runningMultiThreaded = true;
        m_thread = SDL_CreateThread(&PhysicsManager::updateWorker, pm);
    }

    static void terminate()
    {
        assert(m_runningMultiThreaded);
        PhysicsManager* pm = PhysicsManager::get();
        pm->stop();
        random_utils::ThreadSafeCanvas::get()->breakOut();
        pm->release();
        SDL_WaitThread(m_thread, 0);
        // SDL_KillThread(m_thread);
    }

    bool runningMultiThreaded();

    void registerCollisionBody(VRS::SO<CollisionBody>);

    void registerPhysicsBody(VRS::SO<PhysicsBody>);

    void unregisterCollisionBody(VRS::SO<CollisionBody>);

    void unregisterPhysicsBody(VRS::SO<PhysicsBody>);

    const std::vector<VRS::SO<PhysicsBody> >& physicsBodies() const;

    const std::vector<VRS::SO<CollisionBody> >& collisionBodies() const;

    unsigned int physicsBodyCount() const;

    unsigned int collisionBodyCount() const;

    static PhysicsManager* get()
    {
        if(!m_instance)
            m_instance = new PhysicsManager();

        return m_instance;
    }

    void setDebugNodesGlobal(bool p_debugNodes = true);

    const dWorldID worldId() const;

    const dSpaceID spaceId() const;

    const dJointGroupID collisionContactGroupId() const;

    const unsigned int maxCollisionContacts() const;

    void setMaxCollisionContacts(unsigned int);

    const bool isInitialised() const;

    void init();

    void tick(double);

    void update(double);

    void release();

    void setStepTime(double);

    double stepTime();

    void setStepSize(double);

    double stepSize();

    void setUpdateSpeed(double);

    double updateSpeed();

    void setUpdateResolution(unsigned int);

    unsigned int updateResolution();

    static int updateWorker(void*);

    bool keepRunning();

    void stop();

    void setPerformanceAutoAdjust(bool);

    bool performanceAutoAdjust();

    std::string odeVersionString();
};

}

#endif

---