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