Back to index

supertuxkart  0.5+dfsg1
Defines | Functions
btCollisionObject.h File Reference
#include "LinearMath/btTransform.h"
#include "LinearMath/btMotionState.h"
#include "LinearMath/btAlignedAllocator.h"
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines

#define ACTIVE_TAG   1
#define ISLAND_SLEEPING   2
#define WANTS_DEACTIVATION   3
#define DISABLE_DEACTIVATION   4
#define DISABLE_SIMULATION   5

Functions

 ATTRIBUTE_ALIGNED16 (class) btCollisionObject
 btCollisionObject can be used to manage collision detection objects. btCollisionObject maintains all information that is needed for a collision detection: Shape, Transform and AABB proxy. They can be added to the btCollisionWorld.

Define Documentation

#define ACTIVE_TAG   1

Definition at line 22 of file btCollisionObject.h.

#define DISABLE_DEACTIVATION   4

Definition at line 25 of file btCollisionObject.h.

#define DISABLE_SIMULATION   5

Definition at line 26 of file btCollisionObject.h.

#define ISLAND_SLEEPING   2

Definition at line 23 of file btCollisionObject.h.

#define WANTS_DEACTIVATION   3

Definition at line 24 of file btCollisionObject.h.


Function Documentation

ATTRIBUTE_ALIGNED16 ( class  )

btCollisionObject can be used to manage collision detection objects. btCollisionObject maintains all information that is needed for a collision detection: Shape, Transform and AABB proxy. They can be added to the btCollisionWorld.

OptimizedBvh store an AABB tree that can be quickly traversed on CPU (and SPU,GPU in future)

m_interpolationWorldTransform is used for CCD and interpolation it can be either previous or future (predicted) transform

users can point to their objects, m_userPointer is not used by Bullet, see setUserPointer/getUserPointer

m_internalType is reserved to distinguish Bullet's btCollisionObject, btRigidBody, btSoftBody etc. do not assign your own m_internalType unless you write a new dynamics object class.

time of impact calculation

Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::

Don't do continuous collision detection if square motion (in one step) is less then m_ccdSquareMotionThreshold

If some object should have elaborate collision filtering by sub-classes

static objects, kinematic and object without contact response don't merge islands

reserved for Bullet internal usage

Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::

Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::

Don't do continuous collision detection if square motion (in one step) is less then m_ccdSquareMotionThreshold

users can point to their objects, userPointer is not used by Bullet

users can point to their objects, userPointer is not used by Bullet

Definition at line 38 of file btCollisionObject.h.

{

protected:

       btTransform   m_worldTransform;

       btTransform   m_interpolationWorldTransform;
       //those two are experimental: just added for bullet time effect, so you can still apply impulses (directly modifying velocities) 
       //without destroying the continuous interpolated motion (which uses this interpolation velocities)
       btVector3     m_interpolationLinearVelocity;
       btVector3     m_interpolationAngularVelocity;
       btBroadphaseProxy*          m_broadphaseHandle;
       btCollisionShape*           m_collisionShape;

       int                         m_collisionFlags;

       int                         m_islandTag1;
       int                         m_companionId;

       int                         m_activationState1;
       btScalar                    m_deactivationTime;

       btScalar             m_friction;
       btScalar             m_restitution;

       void*                m_userObjectPointer;

       int                         m_internalType;

       btScalar             m_hitFraction; 
       
       btScalar             m_ccdSweptSphereRadius;

       btScalar             m_ccdSquareMotionThreshold;
       
       bool                 m_checkCollideWith;

       char   m_pad[7];

       virtual bool  checkCollideWithOverride(btCollisionObject* co)
       {
              return true;
       }

public:

       BT_DECLARE_ALIGNED_ALLOCATOR();

       enum CollisionFlags
       {
              CF_STATIC_OBJECT= 1,
              CF_KINEMATIC_OBJECT= 2,
              CF_NO_CONTACT_RESPONSE = 4,
              CF_CUSTOM_MATERIAL_CALLBACK = 8//this allows per-triangle material (friction/restitution)
       };

       enum   CollisionObjectTypes
       {
              CO_COLLISION_OBJECT =1,
              CO_RIGID_BODY,
              CO_SOFT_BODY
       };

       SIMD_FORCE_INLINE bool mergesSimulationIslands() const
       {
              return  ((m_collisionFlags & (CF_STATIC_OBJECT | CF_KINEMATIC_OBJECT | CF_NO_CONTACT_RESPONSE) )==0);
       }


       SIMD_FORCE_INLINE bool             isStaticObject() const {
              return (m_collisionFlags & CF_STATIC_OBJECT) != 0;
       }

       SIMD_FORCE_INLINE bool             isKinematicObject() const
       {
              return (m_collisionFlags & CF_KINEMATIC_OBJECT) != 0;
       }

       SIMD_FORCE_INLINE bool             isStaticOrKinematicObject() const
       {
              return (m_collisionFlags & (CF_KINEMATIC_OBJECT | CF_STATIC_OBJECT)) != 0 ;
       }

       SIMD_FORCE_INLINE bool             hasContactResponse() const {
              return (m_collisionFlags & CF_NO_CONTACT_RESPONSE)==0;
       }

       
       btCollisionObject();

       virtual ~btCollisionObject();

       void   setCollisionShape(btCollisionShape* collisionShape)
       {
              m_collisionShape = collisionShape;
       }

       SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const
       {
              return m_collisionShape;
       }

       SIMD_FORCE_INLINE btCollisionShape*       getCollisionShape()
       {
              return m_collisionShape;
       }

       


       int    getActivationState() const { return m_activationState1;}
       
       void setActivationState(int newState);

       void   setDeactivationTime(btScalar time)
       {
              m_deactivationTime = time;
       }
       btScalar      getDeactivationTime() const
       {
              return m_deactivationTime;
       }

       void forceActivationState(int newState);

       void   activate(bool forceActivation = false);

       inline bool isActive() const
       {
              return ((getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION));
       }

       void   setRestitution(btScalar rest)
       {
              m_restitution = rest;
       }
       btScalar      getRestitution() const
       {
              return m_restitution;
       }
       void   setFriction(btScalar frict)
       {
              m_friction = frict;
       }
       btScalar      getFriction() const
       {
              return m_friction;
       }

       int    getInternalType() const
       {
              return m_internalType;
       }

       btTransform&  getWorldTransform()
       {
              return m_worldTransform;
       }

       const btTransform&   getWorldTransform() const
       {
              return m_worldTransform;
       }

       void   setWorldTransform(const btTransform& worldTrans)
       {
              m_worldTransform = worldTrans;
       }


       btBroadphaseProxy*   getBroadphaseHandle()
       {
              return m_broadphaseHandle;
       }

       const btBroadphaseProxy*    getBroadphaseHandle() const
       {
              return m_broadphaseHandle;
       }

       void   setBroadphaseHandle(btBroadphaseProxy* handle)
       {
              m_broadphaseHandle = handle;
       }


       const btTransform&   getInterpolationWorldTransform() const
       {
              return m_interpolationWorldTransform;
       }

       btTransform&  getInterpolationWorldTransform()
       {
              return m_interpolationWorldTransform;
       }

       void   setInterpolationWorldTransform(const btTransform&       trans)
       {
              m_interpolationWorldTransform = trans;
       }


       const btVector3&     getInterpolationLinearVelocity() const
       {
              return m_interpolationLinearVelocity;
       }

       const btVector3&     getInterpolationAngularVelocity() const
       {
              return m_interpolationAngularVelocity;
       }

       const int getIslandTag() const
       {
              return m_islandTag1;
       }

       void   setIslandTag(int tag)
       {
              m_islandTag1 = tag;
       }

       const int getCompanionId() const
       {
              return m_companionId;
       }

       void   setCompanionId(int id)
       {
              m_companionId = id;
       }

       const btScalar                     getHitFraction() const
       {
              return m_hitFraction; 
       }

       void   setHitFraction(btScalar hitFraction)
       {
              m_hitFraction = hitFraction;
       }

       
       const int     getCollisionFlags() const
       {
              return m_collisionFlags;
       }

       void   setCollisionFlags(int flags)
       {
              m_collisionFlags = flags;
       }
       
       btScalar                    getCcdSweptSphereRadius() const
       {
              return m_ccdSweptSphereRadius;
       }

       void   setCcdSweptSphereRadius(btScalar radius)
       {
              m_ccdSweptSphereRadius = radius;
       }

       btScalar      getCcdSquareMotionThreshold() const
       {
              return m_ccdSquareMotionThreshold;
       }


       void   setCcdSquareMotionThreshold(btScalar ccdSquareMotionThreshold)
       {
              m_ccdSquareMotionThreshold = ccdSquareMotionThreshold;
       }

       void*  getUserPointer() const
       {
              return m_userObjectPointer;
       }
       
       void   setUserPointer(void* userPointer)
       {
              m_userObjectPointer = userPointer;
       }


       inline bool checkCollideWith(btCollisionObject* co)
       {
              if (m_checkCollideWith)
                     return checkCollideWithOverride(co);

              return true;
       }
};

Here is the call graph for this function: