OgreNewt_ContactJoint.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 melven
        some changes by melven
 
*/
#ifndef _INCLUDE_OGRENEWT_CONTACTJOINT
#define _INCLUDE_OGRENEWT_CONTACTJOINT
 
 
#include "OgreNewt_Prerequisites.h"
#include "OgreNewt_Body.h"
 
// OgreNewt namespace.  all functions and classes use this namespace.
namespace OgreNewt
{
 
 
 
class _OgreNewtExport ContactJoint
{
public:
 
    ContactJoint(const NewtonJoint* contactJoint);
 
    ~ContactJoint();
 
    int getContactCount() const { return NewtonContactJointGetContactCount( m_contactjoint ); }
 
    Contact getFirstContact();
 
    OgreNewt::Body* getBody0() { return (OgreNewt::Body*) NewtonBodyGetUserData(NewtonJointGetBody0(m_contactjoint)); }
 
    OgreNewt::Body* getBody1() { return (OgreNewt::Body*) NewtonBodyGetUserData(NewtonJointGetBody1(m_contactjoint)); }
 
    const NewtonJoint* _getNewtonContactJoint() { return m_contactjoint; }
 
 
    MaterialPair* getMaterialPair();
 
protected:
    const NewtonJoint* m_contactjoint;
};
 
 
 
 
class _OgreNewtExport Contact
{
public:
 
    Contact(void *contact, ContactJoint* parent);
 
    ~Contact();
 
    operator bool() const { return m_contact != NULL; }
 
    Contact getNext() const;
 
    // basic contact control commands... they can only be used, if this is a valid contact ( !contact == false )
 
    OgreNewt::Body* getBody0() const { return (OgreNewt::Body*) NewtonBodyGetUserData( NewtonJointGetBody0( m_parent->_getNewtonContactJoint() ) ); }
    OgreNewt::Body* getBody1() const { return (OgreNewt::Body*) NewtonBodyGetUserData( NewtonJointGetBody1( m_parent->_getNewtonContactJoint() ) ); }
 
    unsigned getFaceAttribute() const { return NewtonMaterialGetContactFaceAttribute( m_material ); }
 
    //unsigned getBodyCollisionID( OgreNewt::Body* body ) const { return NewtonMaterialGetBodyCollisionID( m_material, body->getNewtonBody() ); }
 
    Ogre::Real getNormalSpeed() const { return (Ogre::Real)NewtonMaterialGetContactNormalSpeed( m_material ); }
 
 
    Ogre::Vector3 getForce() const;
 
    void getPositionAndNormal( Ogre::Vector3& pos, Ogre::Vector3& norm, OgreNewt::Body* body ) const
    {
      dVector fPos;
      dVector fNorm;
      NewtonMaterialGetContactPositionAndNormal(m_material, body->getNewtonBody(), &fPos.m_x, &fNorm.m_x);
 
      pos.x = Ogre::Real(fPos.m_x);
      pos.y = Ogre::Real(fPos.m_y);
      pos.z = Ogre::Real(fPos.m_z);
 
      norm.x = Ogre::Real(fNorm.m_x);
      norm.y = Ogre::Real(fNorm.m_y);
      norm.z = Ogre::Real(fNorm.m_z);
    }
 
    void getTangentDirections( Ogre::Vector3& dir0, Ogre::Vector3& dir1, OgreNewt::Body* body ) const
    {
 
      dVector fDir0;
      dVector fDir1;
      NewtonMaterialGetContactTangentDirections(m_material, body->getNewtonBody(), &fDir0.m_x, &fDir1.m_x);
 
      dir0.x = Ogre::Real(fDir0.m_x);
      dir0.y = Ogre::Real(fDir0.m_y);
      dir0.z = Ogre::Real(fDir0.m_z);
 
      dir1.x = Ogre::Real(fDir1.m_x);
      dir1.y = Ogre::Real(fDir1.m_y);
      dir1.z = Ogre::Real(fDir1.m_z);
    }
 
    Ogre::Real getTangentSpeed( int index ) const
    {
      return (Ogre::Real)NewtonMaterialGetContactTangentSpeed( m_material, index );
    }
 
    void setSoftness( Ogre::Real softness ) { NewtonMaterialSetContactSoftness( m_material, dFloat(softness)); }
 
    void setElasticity( Ogre::Real elasticity ) { NewtonMaterialSetContactElasticity( m_material, dFloat(elasticity)); }
 
    void setFrictionState( int state, int index ) { NewtonMaterialSetContactFrictionState( m_material, state, index ); }
 
    void setFrictionCoef( Ogre::Real stat, Ogre::Real kinetic, int index ) { NewtonMaterialSetContactFrictionCoef( m_material, dFloat(stat), dFloat(kinetic), index ); }
 
    void setTangentAcceleration( Ogre::Real accel, int index ) { NewtonMaterialSetContactTangentAcceleration( m_material, dFloat(accel), index ); }
 
    void rotateTangentDirections( const Ogre::Vector3& dir )
    {
      dVector fdir;
      fdir.m_x = dFloat(dir.x);
      fdir.m_y = dFloat(dir.y);
      fdir.m_z = dFloat(dir.z);
      NewtonMaterialContactRotateTangentDirections( m_material, &fdir.m_x);
    }
 
    void setNormalDirection( const Ogre::Vector3& dir )
    {
      dVector fdir;
      fdir.m_x = dFloat(dir.x);
      fdir.m_y = dFloat(dir.y);
      fdir.m_z = dFloat(dir.z);
      NewtonMaterialSetContactNormalDirection( m_material, &fdir.m_x);
    }
 
    void setNormalAcceleration( Ogre::Real accel ) { NewtonMaterialSetContactNormalAcceleration( m_material, dFloat(accel)); }
 
 
    void remove();
 
    NewtonMaterial* _getNewtonMaterial() { return m_material; }
 
protected:
    NewtonMaterial* m_material;
    void* m_contact;
    OgreNewt::ContactJoint* m_parent;
};
 
 
}   // end NAMESPACE OgreNewt
 
#endif
// _INCLUDE_OGRENEWT_CONTACTJOINT