documentation/html/_ogre_newt___body_8h_source.html

/*

    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.


    please note that the "boost" library files included here are not of my creation, refer to those files and boost.org for information.


    by Walaber

    some changes by melven


    */


#ifndef _INCLUDE_OGRENEWT_BODY

#define _INCLUDE_OGRENEWT_BODY


#include "OgreNewt_Prerequisites.h"

#include "OgreNewt_MaterialID.h"

#include "OgreNewt_Collision.h"

#include "CustomTriggerManager.h"


// OgreNewt namespace.  all functions and classes use this namespace.

namespace OgreNewt

{

  /*

      CLASS DEFINITION:


      Body


      USE:

      this class represents a NewtonBody rigid body!

      */


  class _OgreNewtExport Body : public _DestructorCallback<Body>

  {

  public:


    typedef std::function<void(OgreNewt::Body*, Ogre::Real timeStep, int threadIndex)> ForceCallback;


    typedef std::function<void(OgreNewt::Body*)> TriggerEnterCallback;

    typedef std::function<void(OgreNewt::Body*)> TriggerInsideCallback;

    typedef std::function<void(OgreNewt::Body*)> TriggerExitCallback;


    /*

    this function pointer, when set, is called from updateNode to notify the application

    the this node the function is controlling has being modified.

    The application can use this function to re calculate relative position of child nodes, or any other depended transform.


    You can set this as the by using the setnNodeUpdateNotify() function.

    Using std::function means OgreNewt can now accept pointers to member functions of specific classes.

    */

    typedef std::function<void(OgreNewt::Body*)> NodeUpdateNotifyCallback;


#if 0


    //typedef std::function<void(OgreNewt::Body*, const Ogre::Quaternion&, const Ogre::Vector3&, int threadIndex)> TransformCallback;

    //typedef std::function<void(OgreNewt::Body*, int threadIndex)> TransformCallback;

#endif


    typedef std::function<bool(dLong, OgreNewt::Body*, const Ogre::Quaternion&, const Ogre::Vector3&, Ogre::Plane&)> buoyancyPlaneCallback;


    Body(World* const W, const OgreNewt::CollisionPtr& col, int bodytype = 0, bool trigger = false);


    ~Body();


#ifndef OGRENEWT_NO_OGRE_ANY

    void setUserData(const Ogre::Any& data) { m_userdata = data; }

#else

    void setUserData( void* data ) { m_userdata = data; }

#endif


#ifndef OGRENEWT_NO_OGRE_ANY

    const Ogre::Any& getUserData() const { return m_userdata; }

#else

    void* getUserData() const { return m_userdata; }

#endif


    NewtonBody* getNewtonBody() const { return m_body; }


    Ogre::Node* getOgreNode() const { return m_node; }


    OgreNewt::World* const getWorld() const { return m_world; }


    void setType(int type) { m_type = type; }


    int getType() const { return m_type; }


    void attachNode(Ogre::Node* node);


    void enableSimulation(bool state);


    void setStandardForceCallback();


    /*

        This specifies a custom callback to use for applying forces to a body.  if you are using a standard non-member function, or a static member function, you can simply pass a pointer to the function here.. like this:

        setCustomForceAndTorqueCallback( &myCallbackFunction );


        If you want to bind to a class member, you also need to pass a pointer to the class itself, using the std::bind system, like so:

        setCustomForceAndTorqueCallback( std::bind( &MyClass::myCallback, (MyClass*)classInstance, std::placeholders::_1 ) );  (from outside the class) or:

        setCustomForceAndTorqueCallback( std::bind( &MyClass::myCallback, this, std::placeholders::_1 ) );  (from inside the class).


        You can also use:

        setCustomForceAndTorqueCallback<>( &MyClass::myCallback, (MyClass*)classInstance );  (from outside the class) or:

        setCustomForceAndTorqueCallback<>( &MyClass::myCallback, this );  (from inside the class).

        Note: Notice the "<>" after the function name.

        */

    void setCustomForceAndTorqueCallback(ForceCallback callback);


    template<class c> void setCustomForceAndTorqueCallback(std::function<void(c*, Body*, float, int)> callback, c *instancedClassPointer)

    {

      setCustomForceAndTorqueCallback(std::bind(callback, instancedClassPointer, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));

    }


    void setTriggerEnterCallback(TriggerEnterCallback callback);


    template<class c> void setTriggerEnterCallback(std::function<void(c*, Body*)> callback, c *instancedClassPointer)

    {

      setTriggerEnterCallback(std::bind(callback, instancedClassPointer, std::placeholders::_1));

    }


    void setTriggerInsideCallback(TriggerInsideCallback callback);


    template<class c> void setTriggerInsideCallback(std::function<void(c*, Body*)> callback, c *instancedClassPointer)

    {

      setTriggerInsideCallback(std::bind(callback, instancedClassPointer, std::placeholders::_1));

    }


    void setTriggerExitCallback(TriggerExitCallback callback);


    template<class c> void setTriggerExitCallback(std::function<void(c*, Body*)> callback, c *instancedClassPointer)

    {

      setTriggerExitCallback(std::bind(callback, instancedClassPointer, std::placeholders::_1));

    }


    void removeForceAndTorqueCallback() { NewtonBodySetForceAndTorqueCallback(m_body, NULL);  m_forcecallback = NULL; }


    ForceCallback getForceTorqueCallback()

    {

      return m_forcecallback;

    }


    /*

    set a function pointer to be called for function nodeUpdate when the application desires to be notified that this node is bing updated.

    Control joints like the vehicle an drag dolls use the function to calculate the correct matrix of wheels and body parts.

    */

    void setNodeUpdateNotify(NodeUpdateNotifyCallback callback);


    template<class c> void setNodeUpdateNotify(std::function<void(c*, OgreNewt::Body*)> callback, c *instancedClassPointer)

    {

      setNodeUpdateNotify(std::bind(callback, instancedClassPointer, std::placeholders::_1));

    }


    void removeNodeUpdateNotify() { m_nodeupdatenotifycallback = NULL; }


    void setNodeUpdateJointNotify(NodeUpdateNotifyCallback callback);


    template<class c> void setNodeUpdateJointNotify(std::function<void(c*, OgreNewt::Body*)> callback, c *instancedClassPointer)

    {

      setNodeUpdateJointNotify(std::bind(callback, instancedClassPointer, std::placeholders::_1));

    }


    void removeNodeUpdateJointNotify() { m_nodeupdatejointnotifycallback = NULL; }


    void setPositionOrientation(const Ogre::Vector3& pos, const Ogre::Quaternion& orient, int threadIndex = -1);


    void setPositionOrientationFromNode(int threadIndex = -1);


    void updatePositionOrientation(const Ogre::Vector3& pos, const Ogre::Quaternion& orient, int threadIndex = -1);


    void setVisualPosition(Ogre::Vector3 pos, Ogre::Quaternion quat);


    void setMassMatrix(Ogre::Real mass, const Ogre::Vector3& inertia);


    void setMass(Ogre::Real mass);


    void setCenterOfMass(const Ogre::Vector3& centerOfMass)

    {

      dVector fvec;

      fvec.m_x = dFloat(centerOfMass.x);

      fvec.m_y = dFloat(centerOfMass.y);

      fvec.m_z = dFloat(centerOfMass.z);

      NewtonBodySetCentreOfMass(m_body, &fvec.m_x);

    }


    Ogre::Vector3 getCenterOfMass() const;


    Ogre::Vector3 calculateOffset() const;


    Ogre::Vector3 calculateInertialMatrix() const;


    void freeze() { NewtonBodySetFreezeState(m_body, 1); }


    void unFreeze() { NewtonBodySetFreezeState(m_body, 0); }


    bool isFreezed() { return NewtonBodyGetFreezeState(m_body) != 0; }


    void setMaterialGroupID(const MaterialID* ID)

    {

      m_matid = ID;

      NewtonBodySetMaterialGroupID(m_body, m_matid->getID());

    }


    void setContinuousCollisionMode(unsigned state) { NewtonBodySetContinuousCollisionMode(m_body, state); }


    void setJointRecursiveCollision(unsigned state) { NewtonBodySetJointRecursiveCollision(m_body, state); }


    void setOmega(const Ogre::Vector3& omega)

    {

      dVector fvec;

      fvec.m_x = dFloat(omega.x);

      fvec.m_y = dFloat(omega.y);

      fvec.m_z = dFloat(omega.z);

      NewtonBodySetOmega(m_body, &fvec.m_x);

    }


    void setVelocity(const Ogre::Vector3& vel);


    void setLinearDamping(Ogre::Real damp) { NewtonBodySetLinearDamping(m_body, dFloat(damp)); }


    void setAngularDamping(const Ogre::Vector3& damp)

    {

      dVector fvec;

      fvec.m_x = dFloat(damp.x);

      fvec.m_y = dFloat(damp.y);

      fvec.m_z = dFloat(damp.z);

      NewtonBodySetAngularDamping(m_body, &fvec.m_x);

    }


    void setCollision(const OgreNewt::CollisionPtr& col);


    void setAutoSleep(int flag) { NewtonBodySetAutoSleep(m_body, flag); }


    int getAutoSleep() { return NewtonBodyGetAutoSleep(m_body); }


    bool isSleeping() { return NewtonBodyGetSleepState(m_body) != 0; }


    void setSleep()

    {

      setVelocity(Ogre::Vector3::ZERO);

      setOmega(Ogre::Vector3::ZERO);

      NewtonBodySetSleepState(m_body, 1);

    }


    void wakeUp()

    {

      NewtonBodySetSleepState(m_body, 0);


      // hack to wakeup the bodies

      dVector fvec;

      fvec.m_x = dFloat(0.0);

      fvec.m_y = dFloat(0.0);

      fvec.m_z = dFloat(0.0);

      NewtonBodyAddImpulse(m_body, &fvec.m_x, &fvec.m_x);

    }


    //void setFreezeThreshold( Ogre::Real speed, Ogre::Real omega, int framecount ) { NewtonBodySetFreezeTreshold( m_body, (float)speed, (float)omega, framecount ); }


    const OgreNewt::CollisionPtr& getCollision() const;


    void setScale(const Ogre::Vector3& scale, const Ogre::Quaternion& orient, Ogre::Vector3& pos);


    const OgreNewt::MaterialID* getMaterialGroupID() const;


    int getContinuousCollisionMode() const { return NewtonBodyGetContinuousCollisionMode(m_body); }


    int getJointRecursiveCollision() const { return NewtonBodyGetJointRecursiveCollision(m_body); }


    void getPositionOrientation(Ogre::Vector3& pos, Ogre::Quaternion& orient) const;


    Ogre::Vector3 getPosition() const;


    Ogre::Quaternion getOrientation() const;


    void getVisualPositionOrientation(Ogre::Vector3& pos, Ogre::Quaternion& orient) const;


    Ogre::Vector3 getVisualPosition() const;


    Ogre::Quaternion getVisualOrientation() const;


    Ogre::AxisAlignedBox getAABB() const;


    void getMassMatrix(Ogre::Real& mass, Ogre::Vector3& inertia) const;


    Ogre::Real getMass() const;


    Ogre::Vector3 getInertia() const;


    void getInvMass(Ogre::Real& mass, Ogre::Vector3& inertia) const;


    Ogre::Vector3 getOmega() const;


    Ogre::Vector3 getVelocity() const;


    Ogre::Vector3 getForce() const;


    Ogre::Vector3 getTorque() const;


    Ogre::Vector3 getForceAcceleration() const;


    Ogre::Vector3 getTorqueAcceleration() const;


    Ogre::Real getLinearDamping() const { return (Ogre::Real)NewtonBodyGetLinearDamping(m_body); }


    Ogre::Vector3 getAngularDamping() const;


    Ogre::Vector3 calculateInverseDynamicsForce(Ogre::Real timestep, Ogre::Vector3 desiredVelocity);


    //void getFreezeThreshold( Ogre::Real& speed, Ogre::Real& omega ) const { NewtonBodyGetFreezeTreshold( m_body, &speed, &omega ); }


    void addImpulse(const Ogre::Vector3& deltav, const Ogre::Vector3& posit)

    {

      dVector fdvec;

      fdvec.m_x = dFloat(deltav.x);

      fdvec.m_y = dFloat(deltav.y);

      fdvec.m_z = dFloat(deltav.z);


      dVector fpvec;

      fpvec.m_x = dFloat(posit.x);

      fpvec.m_y = dFloat(posit.y);

      fpvec.m_z = dFloat(posit.z);

      NewtonBodyAddImpulse(m_body, &fdvec.m_x, &fpvec.m_x);

    }


    void addForce(const Ogre::Vector3& force)

    {

      dVector fvec;

      fvec.m_x = dFloat(force.x);

      fvec.m_y = dFloat(force.y);

      fvec.m_z = dFloat(force.z);


      NewtonBodyAddForce(m_body, &fvec.m_x);

    }


    void addTorque(const Ogre::Vector3& torque)

    {

      dVector fvec;

      fvec.m_x = dFloat(torque.x);

      fvec.m_y = dFloat(torque.y);

      fvec.m_z = dFloat(torque.z);


      NewtonBodyAddTorque(m_body, &fvec.m_x);

    }


    void setForce(const Ogre::Vector3& force)

    {

      dVector fvec;

      fvec.m_x = dFloat(force.x);

      fvec.m_y = dFloat(force.y);

      fvec.m_z = dFloat(force.z);


      NewtonBodySetForce(m_body, &fvec.m_x);

    }


    void setTorque(const Ogre::Vector3& torque)

    {

      dVector fvec;

      fvec.m_x = dFloat(torque.x);

      fvec.m_y = dFloat(torque.y);

      fvec.m_z = dFloat(torque.z);


      NewtonBodySetTorque(m_body, &fvec.m_x);

    }


    Body* getNext() const;


    void addGlobalForce(const Ogre::Vector3& force, const Ogre::Vector3& pos);


    void addGlobalForceAccumulate(const Ogre::Vector3& force, const Ogre::Vector3& pos);


    // helper function that adds a force (and resulting torque) to an object in local coordinates.

    void addLocalForce(const Ogre::Vector3& force, const Ogre::Vector3& pos);


    CollisionPrimitiveType getCollisionPrimitiveType() const { return Collision::getCollisionPrimitiveType(getNewtonCollision()); }


    NewtonCollision *getNewtonCollision() const { return NewtonBodyGetCollision(m_body); }


#if 0


    void requestNodeUpdate(int threadIndex, bool forceNodeUpdate = false);


    bool isNodeUpdateNeeded() const {return m_nodeupdateneeded;}

#endif


    /*

    bool isNodeUpdateNeeded() const {return m_nodeupdateneeded;}


    void setNodeUpdateNeeded(bool state) {m_nodeupdateneeded = state;}

    */


    void updateNode(Ogre::Real interpolatParam);


    void MoveToPosition(const Ogre::Vector3 &destPos, const Ogre::Real &stiffness, Ogre::Real timestep);

    void RotateToOrientation(const Ogre::Quaternion &destquat, const Ogre::Real &stiffness, Ogre::Real timestep);


  protected:


    NewtonBody*                     m_body;

    OgreNewt::CollisionPtr          m_collision;

    const MaterialID*               m_matid;

    World* const                    m_world;


    std::vector<std::pair<Ogre::Vector3, Ogre::Vector3> > m_accumulatedGlobalForces;

    Ogre::Vector3                                       m_nodePosit;

    Ogre::Vector3                                       m_curPosit;

    Ogre::Vector3                                       m_prevPosit;

    Ogre::Vector3                                       m_scale;

    Ogre::Quaternion                    m_nodeRotation;

    Ogre::Quaternion                    m_curRotation;

    Ogre::Quaternion                    m_prevRotation;


#ifndef OGRENEWT_NO_OGRE_ANY

    Ogre::Any                       m_userdata;

#else

    void*                           m_userdata;

#endif


    int                             m_type;

    Ogre::Node*                     m_node;

    //bool                            m_nodeupdateneeded;


    ForceCallback                  m_forcecallback;

    TriggerEnterCallback           m_triggerEnterCallback;

    TriggerInsideCallback          m_triggerInsideCallback;

    TriggerExitCallback            m_triggerExitCallback;


    NodeUpdateNotifyCallback        m_nodeupdatenotifycallback;

    NodeUpdateNotifyCallback        m_nodeupdatejointnotifycallback;


  private:

    CustomTriggerController* m_triggerController;

    static void _CDECL newtonDestructor(const NewtonBody* body);


    static void _CDECL newtonTransformCallback(const NewtonBody* body, const dFloat* matrix, int threadIndex);

    static void _CDECL newtonForceTorqueCallback(const NewtonBody* body, dFloat timestep, int threadIndex);

    void newtonTriggerEnterCallback(NewtonBody* const visitor);

    void newtonTriggerInsideCallback(NewtonBody* const visitor);

    void newtonTriggerExitCallback(NewtonBody* const visitor);


    // standard gravity force callback.

    static void standardForceCallback(Body* me, dFloat timeStep, int threadIndex);


  };


}


#endif

// _INCLUDE_OGRENEWT_BODY


OgreNewt_Collision.h

OgreNewt_MaterialID.h

OgreNewt_Prerequisites.h

OgreNewt::_DestructorCallback
helper class: OgreNewt-classes can derive from this class to implement a destructor-callback
Definition OgreNewt_Prerequisites.h:94

OgreNewt::Body
main class for all Rigid Bodies in the system.
Definition OgreNewt_Body.h:39

OgreNewt::Body::getCollisionPrimitiveType
CollisionPrimitiveType getCollisionPrimitiveType() const
Returns the Collisiontype for the Collision from this Body.
Definition OgreNewt_Body.h:589

OgreNewt::Body::setTriggerEnterCallback
void setTriggerEnterCallback(std::function< void(c *, Body *)> callback, c *instancedClassPointer)
Definition OgreNewt_Body.h:184

OgreNewt::Body::m_nodePosit
Ogre::Vector3 m_nodePosit
Definition OgreNewt_Body.h:633

OgreNewt::Body::getUserData
const Ogre::Any & getUserData() const
retrieve pointer to previously set user data.
Definition OgreNewt_Body.h:118

OgreNewt::Body::setContinuousCollisionMode
void setContinuousCollisionMode(unsigned state)
prevents fast moving bodies from "tunneling" through other bodies.
Definition OgreNewt_Body.h:325

OgreNewt::Body::setUserData
void setUserData(const Ogre::Any &data)
set user data to connect this class to another.
Definition OgreNewt_Body.h:111

OgreNewt::Body::setSleep
void setSleep()
Definition OgreNewt_Body.h:383

OgreNewt::Body::m_userdata
Ogre::Any m_userdata
Definition OgreNewt_Body.h:643

OgreNewt::Body::isFreezed
bool isFreezed()
is the body freezed?
Definition OgreNewt_Body.h:304

OgreNewt::Body::setCustomForceAndTorqueCallback
void setCustomForceAndTorqueCallback(std::function< void(c *, Body *, float, int)> callback, c *instancedClassPointer)
Definition OgreNewt_Body.h:178

OgreNewt::Body::removeForceAndTorqueCallback
void removeForceAndTorqueCallback()
remove any force callbacks.
Definition OgreNewt_Body.h:202

OgreNewt::Body::getWorld
OgreNewt::World *const getWorld() const
get a pointer to the OgreNewt::World this body belongs to.
Definition OgreNewt_Body.h:136

OgreNewt::Body::setAngularDamping
void setAngularDamping(const Ogre::Vector3 &damp)
set the angular damping for the body.
Definition OgreNewt_Body.h:355

OgreNewt::Body::isSleeping
bool isSleeping()
Definition OgreNewt_Body.h:381

OgreNewt::Body::setMaterialGroupID
void setMaterialGroupID(const MaterialID *ID)
set the material for the body
Definition OgreNewt_Body.h:312

OgreNewt::Body::addImpulse
void addImpulse(const Ogre::Vector3 &deltav, const Ogre::Vector3 &posit)
get the freeze threshold
Definition OgreNewt_Body.h:487

OgreNewt::Body::getAutoSleep
int getAutoSleep()
get whether the body should "sleep" when equilibrium is reached.
Definition OgreNewt_Body.h:378

OgreNewt::Body::m_triggerInsideCallback
TriggerInsideCallback m_triggerInsideCallback
Definition OgreNewt_Body.h:654

OgreNewt::Body::freeze
void freeze()
freeze the rigid body.
Definition OgreNewt_Body.h:295

OgreNewt::Body::setNodeUpdateJointNotify
void setNodeUpdateJointNotify(std::function< void(c *, OgreNewt::Body *)> callback, c *instancedClassPointer)
Definition OgreNewt_Body.h:226

OgreNewt::Body::TriggerEnterCallback
std::function< void(OgreNewt::Body *)> TriggerEnterCallback
Definition OgreNewt_Body.h:51

OgreNewt::Body::requestNodeUpdate
void requestNodeUpdate(int threadIndex, bool forceNodeUpdate=false)
Call this to signify that the position/orientation of the attached node needs to be updated.

OgreNewt::Body::setTriggerInsideCallback
void setTriggerInsideCallback(std::function< void(c *, Body *)> callback, c *instancedClassPointer)
Definition OgreNewt_Body.h:190

OgreNewt::Body::setForce
void setForce(const Ogre::Vector3 &force)
set the force for a body.
Definition OgreNewt_Body.h:533

OgreNewt::Body::m_forcecallback
ForceCallback m_forcecallback
Definition OgreNewt_Body.h:652

OgreNewt::Body::m_triggerEnterCallback
TriggerEnterCallback m_triggerEnterCallback
Definition OgreNewt_Body.h:653

OgreNewt::Body::m_scale
Ogre::Vector3 m_scale
Definition OgreNewt_Body.h:636

OgreNewt::Body::m_prevPosit
Ogre::Vector3 m_prevPosit
Definition OgreNewt_Body.h:635

OgreNewt::Body::addTorque
void addTorque(const Ogre::Vector3 &torque)
add torque to the body.
Definition OgreNewt_Body.h:519

OgreNewt::Body::setTriggerExitCallback
void setTriggerExitCallback(std::function< void(c *, Body *)> callback, c *instancedClassPointer)
Definition OgreNewt_Body.h:196

OgreNewt::Body::TriggerExitCallback
std::function< void(OgreNewt::Body *)> TriggerExitCallback
Definition OgreNewt_Body.h:53

OgreNewt::Body::addForce
void addForce(const Ogre::Vector3 &force)
add force to the body.
Definition OgreNewt_Body.h:505

OgreNewt::Body::wakeUp
void wakeUp()
Definition OgreNewt_Body.h:390

OgreNewt::Body::m_body
NewtonBody * m_body
Definition OgreNewt_Body.h:627

OgreNewt::Body::m_nodeupdatejointnotifycallback
NodeUpdateNotifyCallback m_nodeupdatejointnotifycallback
Definition OgreNewt_Body.h:658

OgreNewt::Body::m_node
Ogre::Node * m_node
Definition OgreNewt_Body.h:649

OgreNewt::Body::getType
int getType() const
get the type set for this body.
Definition OgreNewt_Body.h:146

OgreNewt::Body::NodeUpdateNotifyCallback
std::function< void(OgreNewt::Body *)> NodeUpdateNotifyCallback
node update notify.
Definition OgreNewt_Body.h:65

OgreNewt::Body::m_curRotation
Ogre::Quaternion m_curRotation
Definition OgreNewt_Body.h:638

OgreNewt::Body::ForceCallback
std::function< void(OgreNewt::Body *, Ogre::Real timeStep, int threadIndex)> ForceCallback
custom force callback.
Definition OgreNewt_Body.h:49

OgreNewt::Body::getJointRecursiveCollision
int getJointRecursiveCollision() const
returns current setting for this body.
Definition OgreNewt_Body.h:418

OgreNewt::Body::setUserData
void setUserData(void *data)
Definition OgreNewt_Body.h:113

OgreNewt::Body::m_accumulatedGlobalForces
std::vector< std::pair< Ogre::Vector3, Ogre::Vector3 > > m_accumulatedGlobalForces
Definition OgreNewt_Body.h:632

OgreNewt::Body::m_userdata
void * m_userdata
Definition OgreNewt_Body.h:645

OgreNewt::Body::m_world
World *const m_world
Definition OgreNewt_Body.h:630

OgreNewt::Body::getLinearDamping
Ogre::Real getLinearDamping() const
get linear damping
Definition OgreNewt_Body.h:475

OgreNewt::Body::setType
void setType(int type)
set the type for this body.
Definition OgreNewt_Body.h:143

OgreNewt::Body::getNewtonBody
NewtonBody * getNewtonBody() const
get a pointer to the NewtonBody object
Definition OgreNewt_Body.h:127

OgreNewt::Body::m_type
int m_type
Definition OgreNewt_Body.h:648

OgreNewt::Body::getUserData
void * getUserData() const
Definition OgreNewt_Body.h:120

OgreNewt::Body::m_matid
const MaterialID * m_matid
Definition OgreNewt_Body.h:629

OgreNewt::Body::m_triggerExitCallback
TriggerExitCallback m_triggerExitCallback
Definition OgreNewt_Body.h:655

OgreNewt::Body::setNodeUpdateNotify
void setNodeUpdateNotify(std::function< void(c *, OgreNewt::Body *)> callback, c *instancedClassPointer)
Definition OgreNewt_Body.h:217

OgreNewt::Body::m_nodeupdatenotifycallback
NodeUpdateNotifyCallback m_nodeupdatenotifycallback
Definition OgreNewt_Body.h:657

OgreNewt::Body::setTorque
void setTorque(const Ogre::Vector3 &torque)
set the torque for a body.
Definition OgreNewt_Body.h:547

OgreNewt::Body::removeNodeUpdateNotify
void removeNodeUpdateNotify()
remove any transform callbacks.
Definition OgreNewt_Body.h:223

OgreNewt::Body::m_curPosit
Ogre::Vector3 m_curPosit
Definition OgreNewt_Body.h:634

OgreNewt::Body::getContinuousCollisionMode
int getContinuousCollisionMode() const
returns current setting for this body.
Definition OgreNewt_Body.h:415

OgreNewt::Body::isNodeUpdateNeeded
bool isNodeUpdateNeeded() const
Return if an node update was requested.
Definition OgreNewt_Body.h:608

OgreNewt::Body::removeNodeUpdateJointNotify
void removeNodeUpdateJointNotify()
remove any transform callbacks.
Definition OgreNewt_Body.h:232

OgreNewt::Body::setOmega
void setOmega(const Ogre::Vector3 &omega)
set an arbitrary omega for the body.
Definition OgreNewt_Body.h:335

OgreNewt::Body::getOgreNode
Ogre::Node * getOgreNode() const
get a pointer to the attached Node.
Definition OgreNewt_Body.h:133

OgreNewt::Body::setLinearDamping
void setLinearDamping(Ogre::Real damp)
set the linear damping for the body.
Definition OgreNewt_Body.h:352

OgreNewt::Body::setJointRecursiveCollision
void setJointRecursiveCollision(unsigned state)
set whether all parent/children pairs connected to this body should be allowed to collide.
Definition OgreNewt_Body.h:328

OgreNewt::Body::m_collision
OgreNewt::CollisionPtr m_collision
Definition OgreNewt_Body.h:628

OgreNewt::Body::buoyancyPlaneCallback
std::function< bool(dLong, OgreNewt::Body *, const Ogre::Quaternion &, const Ogre::Vector3 &, Ogre::Plane &)> buoyancyPlaneCallback
custom transform callback.
Definition OgreNewt_Body.h:91

OgreNewt::Body::m_prevRotation
Ogre::Quaternion m_prevRotation
Definition OgreNewt_Body.h:639

OgreNewt::Body::getForceTorqueCallback
ForceCallback getForceTorqueCallback()
returns correct force-torque callback
Definition OgreNewt_Body.h:205

OgreNewt::Body::TriggerInsideCallback
std::function< void(OgreNewt::Body *)> TriggerInsideCallback
Definition OgreNewt_Body.h:52

OgreNewt::Body::getNewtonCollision
NewtonCollision * getNewtonCollision() const
Returns the Newton Collision for this Body.
Definition OgreNewt_Body.h:595

OgreNewt::Body::setAutoSleep
void setAutoSleep(int flag)
set whether the body should "sleep" when equilibruim is reached.
Definition OgreNewt_Body.h:375

OgreNewt::Body::m_nodeRotation
Ogre::Quaternion m_nodeRotation
Definition OgreNewt_Body.h:637

OgreNewt::Body::setCenterOfMass
void setCenterOfMass(const Ogre::Vector3 &centerOfMass)
set the body's center of mass
Definition OgreNewt_Body.h:271

OgreNewt::Body::unFreeze
void unFreeze()
unfreeze the rigid body.
Definition OgreNewt_Body.h:301

OgreNewt::Collision
represents a shape for collision detection
Definition OgreNewt_Collision.h:51

OgreNewt::MaterialID
represents a material
Definition OgreNewt_MaterialID.h:25

OgreNewt::World
represents a physics world.
Definition OgreNewt_World.h:142

OgreNewt
main namespace.
Definition OgreNewt_BasicFrameListener.h:30

OgreNewt::CollisionPrimitiveType
CollisionPrimitiveType
Definition OgreNewt_Collision.h:25