bullet: Update to current svn, r2636
[blender.git] / extern / bullet2 / src / BulletCollision / CollisionShapes / btConvexInternalShape.h
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
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 BT_CONVEX_INTERNAL_SHAPE_H
17 #define BT_CONVEX_INTERNAL_SHAPE_H
18
19 #include "btConvexShape.h"
20 #include "LinearMath/btAabbUtil2.h"
21
22
23 ///The btConvexInternalShape is an internal base class, shared by most convex shape implementations.
24 ///The btConvexInternalShape uses a default collision margin set to CONVEX_DISTANCE_MARGIN.
25 ///This collision margin used by Gjk and some other algorithms, see also btCollisionMargin.h
26 ///Note that when creating small shapes (derived from btConvexInternalShape), 
27 ///you need to make sure to set a smaller collision margin, using the 'setMargin' API
28 ///There is a automatic mechanism 'setSafeMargin' used by btBoxShape and btCylinderShape
29 ATTRIBUTE_ALIGNED16(class) btConvexInternalShape : public btConvexShape
30 {
31
32         protected:
33
34         //local scaling. collisionMargin is not scaled !
35         btVector3       m_localScaling;
36
37         btVector3       m_implicitShapeDimensions;
38         
39         btScalar        m_collisionMargin;
40
41         btScalar        m_padding;
42
43         btConvexInternalShape();
44
45 public:
46
47         BT_DECLARE_ALIGNED_ALLOCATOR();
48
49         virtual ~btConvexInternalShape()
50         {
51
52         }
53
54         virtual btVector3       localGetSupportingVertex(const btVector3& vec)const;
55
56         const btVector3& getImplicitShapeDimensions() const
57         {
58                 return m_implicitShapeDimensions;
59         }
60
61         ///warning: use setImplicitShapeDimensions with care
62         ///changing a collision shape while the body is in the world is not recommended,
63         ///it is best to remove the body from the world, then make the change, and re-add it
64         ///alternatively flush the contact points, see documentation for 'cleanProxyFromPairs'
65         void    setImplicitShapeDimensions(const btVector3& dimensions)
66         {
67                 m_implicitShapeDimensions = dimensions;
68         }
69
70         void    setSafeMargin(btScalar minDimension, btScalar defaultMarginMultiplier = 0.1f)
71         {
72                 btScalar safeMargin = defaultMarginMultiplier*minDimension;
73                 if (safeMargin < getMargin())
74                 {
75                         setMargin(safeMargin);
76                 }
77         }
78         void    setSafeMargin(const btVector3& halfExtents, btScalar defaultMarginMultiplier = 0.1f)
79         {
80                 //see http://code.google.com/p/bullet/issues/detail?id=349
81                 //this margin check could could be added to other collision shapes too,
82                 //or add some assert/warning somewhere
83                 btScalar minDimension=halfExtents[halfExtents.minAxis()];               
84                 setSafeMargin(minDimension, defaultMarginMultiplier);
85         }
86
87         ///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
88         void getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
89         {
90                 getAabbSlow(t,aabbMin,aabbMax);
91         }
92
93
94         
95         virtual void getAabbSlow(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const;
96
97
98         virtual void    setLocalScaling(const btVector3& scaling);
99         virtual const btVector3& getLocalScaling() const 
100         {
101                 return m_localScaling;
102         }
103
104         const btVector3& getLocalScalingNV() const 
105         {
106                 return m_localScaling;
107         }
108
109         virtual void    setMargin(btScalar margin)
110         {
111                 m_collisionMargin = margin;
112         }
113         virtual btScalar        getMargin() const
114         {
115                 return m_collisionMargin;
116         }
117
118         btScalar        getMarginNV() const
119         {
120                 return m_collisionMargin;
121         }
122
123         virtual int             getNumPreferredPenetrationDirections() const
124         {
125                 return 0;
126         }
127         
128         virtual void    getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const
129         {
130                 (void)penetrationVector;
131                 (void)index;
132                 btAssert(0);
133         }
134
135         virtual int     calculateSerializeBufferSize() const;
136
137         ///fills the dataBuffer and returns the struct name (and 0 on failure)
138         virtual const char*     serialize(void* dataBuffer, btSerializer* serializer) const;
139
140         
141 };
142
143 ///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
144 struct  btConvexInternalShapeData
145 {
146         btCollisionShapeData    m_collisionShapeData;
147
148         btVector3FloatData      m_localScaling;
149
150         btVector3FloatData      m_implicitShapeDimensions;
151         
152         float                   m_collisionMargin;
153
154         int     m_padding;
155
156 };
157
158
159
160 SIMD_FORCE_INLINE       int     btConvexInternalShape::calculateSerializeBufferSize() const
161 {
162         return sizeof(btConvexInternalShapeData);
163 }
164
165 ///fills the dataBuffer and returns the struct name (and 0 on failure)
166 SIMD_FORCE_INLINE       const char*     btConvexInternalShape::serialize(void* dataBuffer, btSerializer* serializer) const
167 {
168         btConvexInternalShapeData* shapeData = (btConvexInternalShapeData*) dataBuffer;
169         btCollisionShape::serialize(&shapeData->m_collisionShapeData, serializer);
170
171         m_implicitShapeDimensions.serializeFloat(shapeData->m_implicitShapeDimensions);
172         m_localScaling.serializeFloat(shapeData->m_localScaling);
173         shapeData->m_collisionMargin = float(m_collisionMargin);
174
175         return "btConvexInternalShapeData";
176 }
177
178
179
180
181 ///btConvexInternalAabbCachingShape adds local aabb caching for convex shapes, to avoid expensive bounding box calculations
182 class btConvexInternalAabbCachingShape : public btConvexInternalShape
183 {
184         btVector3       m_localAabbMin;
185         btVector3       m_localAabbMax;
186         bool            m_isLocalAabbValid;
187         
188 protected:
189                                         
190         btConvexInternalAabbCachingShape();
191         
192         void setCachedLocalAabb (const btVector3& aabbMin, const btVector3& aabbMax)
193         {
194                 m_isLocalAabbValid = true;
195                 m_localAabbMin = aabbMin;
196                 m_localAabbMax = aabbMax;
197         }
198
199         inline void getCachedLocalAabb (btVector3& aabbMin, btVector3& aabbMax) const
200         {
201                 btAssert(m_isLocalAabbValid);
202                 aabbMin = m_localAabbMin;
203                 aabbMax = m_localAabbMax;
204         }
205
206         inline void getNonvirtualAabb(const btTransform& trans,btVector3& aabbMin,btVector3& aabbMax, btScalar margin) const
207         {
208
209                 //lazy evaluation of local aabb
210                 btAssert(m_isLocalAabbValid);
211                 btTransformAabb(m_localAabbMin,m_localAabbMax,margin,trans,aabbMin,aabbMax);
212         }
213                 
214 public:
215                 
216         virtual void    setLocalScaling(const btVector3& scaling);
217
218         virtual void getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const;
219
220         void    recalcLocalAabb();
221
222 };
223
224 #endif //BT_CONVEX_INTERNAL_SHAPE_H