upgrade to latest Bullet 2.53. cross the fingers it doesn't break one of the exotic...
[blender-staging.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 ATTRIBUTE_ALIGNED16(class)      btCollisionObject
38 {
39
40 protected:
41
42         btTransform     m_worldTransform;
43
44         ///m_interpolationWorldTransform is used for CCD and interpolation
45         ///it can be either previous or future (predicted) transform
46         btTransform     m_interpolationWorldTransform;
47         //those two are experimental: just added for bullet time effect, so you can still apply impulses (directly modifying velocities) 
48         //without destroying the continuous interpolated motion (which uses this interpolation velocities)
49         btVector3       m_interpolationLinearVelocity;
50         btVector3       m_interpolationAngularVelocity;
51         btBroadphaseProxy*              m_broadphaseHandle;
52         btCollisionShape*               m_collisionShape;
53
54         int                             m_collisionFlags;
55
56         int                             m_islandTag1;
57         int                             m_companionId;
58
59         int                             m_activationState1;
60         btScalar                        m_deactivationTime;
61
62         btScalar                m_friction;
63         btScalar                m_restitution;
64
65         ///users can point to their objects, m_userPointer is not used by Bullet, see setUserPointer/getUserPointer
66         void*                   m_userObjectPointer;
67
68         ///m_internalOwner is reserved to point to Bullet's btRigidBody. Don't use this, use m_userObjectPointer instead.
69         void*                   m_internalOwner;
70
71         ///time of impact calculation
72         btScalar                        m_hitFraction; 
73         
74         ///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
75         btScalar                        m_ccdSweptSphereRadius;
76
77         /// Don't do continuous collision detection if square motion (in one step) is less then m_ccdSquareMotionThreshold
78         btScalar                        m_ccdSquareMotionThreshold;
79         
80         char    m_pad[8];
81
82 public:
83
84         enum CollisionFlags
85         {
86                 CF_STATIC_OBJECT= 1,
87                 CF_KINEMATIC_OBJECT= 2,
88                 CF_NO_CONTACT_RESPONSE = 4,
89                 CF_CUSTOM_MATERIAL_CALLBACK = 8//this allows per-triangle material (friction/restitution)
90         };
91
92
93         inline bool mergesSimulationIslands() const
94         {
95                 ///static objects, kinematic and object without contact response don't merge islands
96                 return  ((m_collisionFlags & (CF_STATIC_OBJECT | CF_KINEMATIC_OBJECT | CF_NO_CONTACT_RESPONSE) )==0);
97         }
98
99
100         inline bool             isStaticObject() const {
101                 return (m_collisionFlags & CF_STATIC_OBJECT) != 0;
102         }
103
104         inline bool             isKinematicObject() const
105         {
106                 return (m_collisionFlags & CF_KINEMATIC_OBJECT) != 0;
107         }
108
109         inline bool             isStaticOrKinematicObject() const
110         {
111                 return (m_collisionFlags & (CF_KINEMATIC_OBJECT | CF_STATIC_OBJECT)) != 0 ;
112         }
113
114         inline bool             hasContactResponse() const {
115                 return (m_collisionFlags & CF_NO_CONTACT_RESPONSE)==0;
116         }
117
118         
119         btCollisionObject();
120
121
122         void    setCollisionShape(btCollisionShape* collisionShape)
123         {
124                 m_collisionShape = collisionShape;
125         }
126
127         const btCollisionShape* getCollisionShape() const
128         {
129                 return m_collisionShape;
130         }
131
132         btCollisionShape*       getCollisionShape()
133         {
134                 return m_collisionShape;
135         }
136
137         
138
139
140         int     getActivationState() const { return m_activationState1;}
141         
142         void setActivationState(int newState);
143
144         void    setDeactivationTime(btScalar time)
145         {
146                 m_deactivationTime = time;
147         }
148         btScalar        getDeactivationTime() const
149         {
150                 return m_deactivationTime;
151         }
152
153         void forceActivationState(int newState);
154
155         void    activate(bool forceActivation = false);
156
157         inline bool isActive() const
158         {
159                 return ((getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION));
160         }
161
162                 void    setRestitution(btScalar rest)
163         {
164                 m_restitution = rest;
165         }
166         btScalar        getRestitution() const
167         {
168                 return m_restitution;
169         }
170         void    setFriction(btScalar frict)
171         {
172                 m_friction = frict;
173         }
174         btScalar        getFriction() const
175         {
176                 return m_friction;
177         }
178
179         ///reserved for Bullet internal usage
180         void*   getInternalOwner()
181         {
182                 return m_internalOwner;
183         }
184
185         const void*     getInternalOwner() const
186         {
187                 return m_internalOwner;
188         }
189
190         btTransform&    getWorldTransform()
191         {
192                 return m_worldTransform;
193         }
194
195         const btTransform&      getWorldTransform() const
196         {
197                 return m_worldTransform;
198         }
199
200         void    setWorldTransform(const btTransform& worldTrans)
201         {
202                 m_worldTransform = worldTrans;
203         }
204
205
206         btBroadphaseProxy*      getBroadphaseHandle()
207         {
208                 return m_broadphaseHandle;
209         }
210
211         const btBroadphaseProxy*        getBroadphaseHandle() const
212         {
213                 return m_broadphaseHandle;
214         }
215
216         void    setBroadphaseHandle(btBroadphaseProxy* handle)
217         {
218                 m_broadphaseHandle = handle;
219         }
220
221
222         const btTransform&      getInterpolationWorldTransform() const
223         {
224                 return m_interpolationWorldTransform;
225         }
226
227         btTransform&    getInterpolationWorldTransform()
228         {
229                 return m_interpolationWorldTransform;
230         }
231
232         void    setInterpolationWorldTransform(const btTransform&       trans)
233         {
234                 m_interpolationWorldTransform = trans;
235         }
236
237
238         const btVector3&        getInterpolationLinearVelocity() const
239         {
240                 return m_interpolationLinearVelocity;
241         }
242
243         const btVector3&        getInterpolationAngularVelocity() const
244         {
245                 return m_interpolationAngularVelocity;
246         }
247
248         const int getIslandTag() const
249         {
250                 return  m_islandTag1;
251         }
252
253         void    setIslandTag(int tag)
254         {
255                 m_islandTag1 = tag;
256         }
257
258         const int getCompanionId() const
259         {
260                 return  m_companionId;
261         }
262
263         void    setCompanionId(int id)
264         {
265                 m_companionId = id;
266         }
267
268         const btScalar                  getHitFraction() const
269         {
270                 return m_hitFraction; 
271         }
272
273         void    setHitFraction(btScalar hitFraction)
274         {
275                 m_hitFraction = hitFraction;
276         }
277
278         
279         const int       getCollisionFlags() const
280         {
281                 return m_collisionFlags;
282         }
283
284         void    setCollisionFlags(int flags)
285         {
286                 m_collisionFlags = flags;
287         }
288         
289         ///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
290         btScalar                        getCcdSweptSphereRadius() const
291         {
292                 return m_ccdSweptSphereRadius;
293         }
294
295         ///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
296         void    setCcdSweptSphereRadius(btScalar radius)
297         {
298                 m_ccdSweptSphereRadius = radius;
299         }
300
301         btScalar        getCcdSquareMotionThreshold() const
302         {
303                 return m_ccdSquareMotionThreshold;
304         }
305
306
307         /// Don't do continuous collision detection if square motion (in one step) is less then m_ccdSquareMotionThreshold
308         void    setCcdSquareMotionThreshold(btScalar ccdSquareMotionThreshold)
309         {
310                 m_ccdSquareMotionThreshold = ccdSquareMotionThreshold;
311         }
312
313         ///users can point to their objects, userPointer is not used by Bullet
314         void*   getUserPointer() const
315         {
316                 return m_userObjectPointer;
317         }
318         
319         ///users can point to their objects, userPointer is not used by Bullet
320         void    setUserPointer(void* userPointer)
321         {
322                 m_userObjectPointer = userPointer;
323         }
324
325 }
326 ;
327
328 #endif //COLLISION_OBJECT_H