Added refactored Bullet 2.x library. Important: these files are not part of the Blend...
[blender.git] / extern / bullet2 / src / BulletCollision / CollisionDispatch / btCollisionObject.h
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
4
5 This software is provided 'as-is', without any express or implied warranty.
6 In no event will the authors be held liable for any damages arising from the use of this software.
7 Permission is granted to anyone to use this software for any purpose, 
8 including commercial applications, and to alter it and redistribute it freely, 
9 subject to the following restrictions:
10
11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
13 3. This notice may not be removed or altered from any source distribution.
14 */
15
16 #ifndef COLLISION_OBJECT_H
17 #define COLLISION_OBJECT_H
18
19 #include "LinearMath/btTransform.h"
20
21 //island management, m_activationState1
22 #define ACTIVE_TAG 1
23 #define ISLAND_SLEEPING 2
24 #define WANTS_DEACTIVATION 3
25 #define DISABLE_DEACTIVATION 4
26 #define DISABLE_SIMULATION 5
27
28 struct  btBroadphaseProxy;
29 class   btCollisionShape;
30 #include "LinearMath/btMotionState.h"
31
32
33
34 /// btCollisionObject can be used to manage collision detection objects. 
35 /// btCollisionObject maintains all information that is needed for a collision detection: Shape, Transform and AABB proxy.
36 /// They can be added to the btCollisionWorld.
37 struct  btCollisionObject
38 {
39         btTransform     m_worldTransform;
40         btBroadphaseProxy*      m_broadphaseHandle;
41         btCollisionShape*               m_collisionShape;
42
43         ///m_interpolationWorldTransform is used for CCD and interpolation
44         ///it can be either previous or future (predicted) transform
45         btTransform     m_interpolationWorldTransform;
46
47         enum CollisionFlags
48         {
49                 CF_STATIC_OBJECT= 1,
50                 CF_KINEMATIC_OJBECT= 2,
51                 CF_NO_CONTACT_RESPONSE = 4,
52                 CF_CUSTOM_MATERIAL_CALLBACK = 8,//this allows per-triangle material (friction/restitution)
53         };
54
55         int                             m_collisionFlags;
56
57         int                             m_islandTag1;
58         int                             m_activationState1;
59         float                   m_deactivationTime;
60
61         btScalar                m_friction;
62         btScalar                m_restitution;
63
64         ///users can point to their objects, m_userPointer is not used by Bullet
65         void*                   m_userObjectPointer;
66
67         ///m_internalOwner is reserved to point to Bullet's btRigidBody. Don't use this, use m_userObjectPointer instead.
68         void*                   m_internalOwner;
69
70         ///time of impact calculation
71         float                   m_hitFraction; 
72         
73         ///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
74         float                   m_ccdSweptSphereRadius;
75
76         /// Don't do continuous collision detection if square motion (in one step) is less then m_ccdSquareMotionTreshold
77         float                   m_ccdSquareMotionTreshold;
78
79         inline bool mergesSimulationIslands() const
80         {
81                 ///static objects, kinematic and object without contact response don't merge islands
82                 return  !(m_collisionFlags & (CF_STATIC_OBJECT | CF_KINEMATIC_OJBECT | CF_NO_CONTACT_RESPONSE) );
83         }
84
85
86         inline bool             isStaticObject() const {
87                 return m_collisionFlags & CF_STATIC_OBJECT;
88         }
89
90         inline bool             isKinematicObject() const
91         {
92                 return m_collisionFlags & CF_KINEMATIC_OJBECT;
93         }
94
95         inline bool             isStaticOrKinematicObject() const
96         {
97                 return m_collisionFlags & (CF_KINEMATIC_OJBECT | CF_STATIC_OBJECT);
98         }
99
100         inline bool             hasContactResponse() const {
101                 return !(m_collisionFlags & CF_NO_CONTACT_RESPONSE);
102         }
103
104         
105
106
107         btCollisionObject();
108
109
110         void    SetCollisionShape(btCollisionShape* collisionShape)
111         {
112                 m_collisionShape = collisionShape;
113         }
114
115         int     GetActivationState() const { return m_activationState1;}
116         
117         void SetActivationState(int newState);
118
119         void ForceActivationState(int newState);
120
121         void    activate();
122
123         inline bool IsActive() const
124         {
125                 return ((GetActivationState() != ISLAND_SLEEPING) && (GetActivationState() != DISABLE_SIMULATION));
126         }
127
128                 void    setRestitution(float rest)
129         {
130                 m_restitution = rest;
131         }
132         float   getRestitution() const
133         {
134                 return m_restitution;
135         }
136         void    setFriction(float frict)
137         {
138                 m_friction = frict;
139         }
140         float   getFriction() const
141         {
142                 return m_friction;
143         }
144
145
146 };
147
148 #endif //COLLISION_OBJECT_H