OgreNewt_World.h

Go to the documentation of this file.

/* 
    OgreNewt Library
 
    Ogre implementation of Newton Game Dynamics SDK
 
    OgreNewt basically has no license, you may use any or all of the library however you desire... I hope it can help you in any way.
 
        by Walaber
        some changes by melven
*/
#ifndef _INCLUDE_OGRENEWT_WORLD
#define _INCLUDE_OGRENEWT_WORLD
 
#include "OgreNewt_Prerequisites.h"
#include "OgreNewt_BodyInAABBIterator.h"
#include "OgreNewt_Debugger.h"
#include "CustomTriggerManager.h"
 
#include <map>
 
 
namespace OgreNewt
{
 
class World;
class _OgreNewtExport WorldTriggerManager: public CustomTriggerManager
{
        public:
  typedef std::function<void(NewtonBody* const visitor)> WorldTriggerEnterCallback;
  typedef std::function<void(NewtonBody* const visitor)> WorldTriggerInsideCallback;
  typedef std::function<void(NewtonBody* const visitor)> WorldTriggerExitCallback;
 
        class TriggerCallback
        {
                public:
                TriggerCallback(CustomTriggerController* const controller) :m_controller(controller)
                   , m_EnterCallback(0)
                   , m_InsideCallback(0)
                   , m_ExitCallback(0)
                {
                }
 
                virtual ~TriggerCallback()
                {
                }
 
                virtual void OnEnter(NewtonBody* const visitor)
                {
      if (m_EnterCallback)
        m_EnterCallback(visitor);
                }
 
                virtual void OnInside(NewtonBody* const visitor)
                {
      if (m_InsideCallback)
        m_InsideCallback(visitor);
                }
 
                virtual void OnExit(NewtonBody* const visitor)
                {
      if (m_ExitCallback)
        m_ExitCallback(visitor);
                }
 
    void setTriggerEnterCallback(WorldTriggerEnterCallback callback);
    template<class c> void setTriggerEnterCallback( std::function<void(c*, NewtonBody* const)> callback, c *instancedClassPointer )
    {
      setTriggerEnterCallback(std::bind(callback, instancedClassPointer, std::placeholders::_1));
    }
 
    void setTriggerInsideCallback(WorldTriggerInsideCallback callback);
    template<class c> void setTriggerInsideCallback( std::function<void(c*, NewtonBody* const)> callback, c *instancedClassPointer )
    {
      setTriggerInsideCallback(std::bind(callback, instancedClassPointer, std::placeholders::_1));
    }
 
    void setTriggerExitCallback(WorldTriggerExitCallback callback);
    template<class c> void setTriggerExitCallback( std::function<void(c*, NewtonBody* const)> callback, c *instancedClassPointer )
    {
      setTriggerExitCallback(std::bind(callback, instancedClassPointer, std::placeholders::_1));
    }
 
                CustomTriggerController* m_controller;
 
    private:
    WorldTriggerEnterCallback m_EnterCallback;
    WorldTriggerInsideCallback m_InsideCallback;
    WorldTriggerExitCallback m_ExitCallback;
        };
 
  WorldTriggerManager(World* const world);
 
        CustomTriggerController* CreateController(const dMatrix& matrix, NewtonCollision* const convexShape)
        {
                CustomTriggerController* const controller = CreateTrigger (matrix, convexShape, NULL);
                TriggerCallback* const forceCallback = new TriggerCallback (controller);
                controller->SetUserData(forceCallback);
    return controller;
        }
 
        void DestroyController(CustomTriggerController* const controller)
        {
                TriggerCallback* const userData = (TriggerCallback*) controller->GetUserData();
                delete userData;
                CustomTriggerManager::DestroyController(controller);
        }       
 
        virtual void EventCallback(const CustomTriggerController* const me, TriggerEventType event, NewtonBody* const visitor) const
        {
                TriggerCallback* const callback = (TriggerCallback*) me->GetUserData();
                switch (event) 
                {
                        case m_enterTrigger:
                        {
                                callback->OnEnter(visitor);
                                break;
                        }
 
                        case m_exitTrigger:
                        {
                                callback->OnExit(visitor);
                                break;
                        }
 
                        case m_inTrigger:
                        {
                                callback->OnInside(visitor);
                                break;
                        }
                }
        }
};
 
 
class _OgreNewtExport World
{
 
public:
 
 
    enum SolverModelMode 
    { 
        SM_EXACT = 0,   
        SM_FASTEST = 1, 
                SM_MEDIUM = 4, 
                SM_SLOW = 8, 
                SM_RIDICULUS = 16 
    };
 
 
    enum FrictionModelMode 
    { 
        FM_EXACT = 0,   
        FM_ADAPTIVE = 1 
    };
 
 
        enum PlatformArchitecture
        {
                PF_DETERMINISTIC_UNOPTIMIZED = 0,
                PF_COMMON_OPTIMIZED = 1,
                PF_BEST_POSSIBLE = 2
        };
 
 
    typedef std::function<void(OgreNewt::Body*, int threadIndex)> LeaveWorldCallback;
 
public:
 
        World(Ogre::Real desiredFps = 100.0f, int maxUpdatesPerFrames = 5, Ogre::String name = "main");
 
  ~World();
 
  CustomTriggerController* CreateController(const dMatrix& matrix, NewtonCollision* const convexShape);
  void DestroyController(CustomTriggerController* const controller);
 
  void setPreListener(std::string name, void* const listenerUserData, NewtonWorldUpdateListenerCallback update);
  void setpostListener(std::string name, void* const listenerUserData, NewtonWorldUpdateListenerCallback update);
 
 
        static void setAllocators (NewtonAllocMemory newtonAlloc, NewtonFreeMemory newtonFree);
        
 
  int update( Ogre::Real t_step );   
 
 
  void invalidateCache() { NewtonInvalidateCache( m_world ); }
 
 
  void setUpdateFPS(Ogre::Real desiredFps, int maxUpdatesPerFrames);
 
 
        Ogre::Real getUpdateFPS() const { return m_updateFPS; }
 
 
        void setDefaultLinearDamping(Ogre::Real defaultLinearDamping) { m_defaultLinearDamping = defaultLinearDamping; }
 
 
        Ogre::Real getDefaultLinearDamping() const { return m_defaultLinearDamping; }
 
 
        void setDefaultAngularDamping(Ogre::Vector3 defaultAngularDamping) { m_defaultAngularDamping = defaultAngularDamping; }
 
 
        Ogre::Vector3 getDefaultAngularDamping() const { return m_defaultAngularDamping; }
 
 
    NewtonWorld* getNewtonWorld() const { return m_world; }
 
 
    const MaterialID* getDefaultMaterialID() const { return m_defaultMatID; }   // get pointer to default material ID object.
 
 
    void destroyAllBodies() { NewtonDestroyAllBodies( m_world ); }
 
 
    void setSolverModel(int model);
 
 
    void setFrictionModel( int model) { NewtonSetFrictionModel( m_world, model ); }
 
 
    void setPlatformArchitecture( int mode )
    {
      NewtonSetCurrentDevice (m_world, mode);      //int platformsCount = NewtonEnumrateDevices (m_world);
      //char platform[256];
      //NewtonGetDeviceString (m_world, mode, platform, sizeof (platform));
    }
 
 
    int getPlatformArchitecture(Ogre::String& description) { char desc[265]; int mode = NewtonGetCurrentDevice(m_world); NewtonGetDeviceString(m_world, mode, desc, sizeof(desc)); description = desc; return mode;}
 
 
    int getBodyCount() const { return NewtonWorldGetBodyCount( m_world ); }
 
    int getConstraintCount() const {return NewtonWorldGetConstraintCount( m_world ); }
 
    void setMultithreadSolverOnSingleIsland( int mode ) { NewtonSetMultiThreadSolverOnSingleIsland( m_world, mode ); }
 
    int getMultithreadSolverOnSingleIsland( ) const { return NewtonGetMultiThreadSolverOnSingleIsland( m_world ); }
 
    void setThreadCount(int threads);
 
    int getThreadCount() const { return NewtonGetThreadsCount( m_world ); }
 
    void criticalSectionLock() const { NewtonWorldCriticalSectionLock( m_world, 0); }
 
    void criticalSectionUnlock() const { NewtonWorldCriticalSectionUnlock( m_world ); }
 
    void waitForUpdateToFinish() const { NewtonWaitForUpdateToFinish(m_world); }
 
    void setMinimumFrameRate( Ogre::Real frame ) { NewtonSetMinimumFrameRate( m_world, frame ); }
 
    // Newton >= 2.30 remove m_world
    int getVersion() const { return NewtonWorldGetVersion(); }
 
    Body* getFirstBody() const;
 
    /*
    MaterialGroupID* getFirstMaterialGroupID();
    */
 
    const BodyInAABBIterator& getBodyInAABBIterator() const {return m_bodyInAABBIterator;}
 
 
    Debugger& getDebugger() const {return *m_debugger;}
 
        /*
        void addBodyUpdateNodeRequest( int threadIndex, OgreNewt::Body* body ) const ;
        */
 
protected:
    
        int m_maxTicksPerFrames;
        Ogre::Real m_timestep;
        Ogre::Real m_invTimestep;
        Ogre::Real m_timeAcumulator;
        Ogre::Real m_updateFPS;
 
        Ogre::Vector3 m_defaultAngularDamping;
        Ogre::Real m_defaultLinearDamping;
 
  NewtonWorld* m_world;
  MaterialID* m_defaultMatID;
 
  BodyInAABBIterator m_bodyInAABBIterator;
 
  typedef std::vector< OgreNewt::Body* > BodyVector;
  typedef std::vector< BodyVector > BodyVectorVector;
//mutable BodyVectorVector m_bodyUpdateNodeRequests;
  WorldTriggerManager* m_triggerManager;
  mutable Debugger* m_debugger;
 
};
 
}
 
    
#endif
// _INCLUDE_OGRENEWT_WORLD