Bullet Collision Detection & Physics Library
btGImpactCollisionAlgorithm.h
Go to the documentation of this file.
1 
4 /*
5 This source file is part of GIMPACT Library.
6 
7 For the latest info, see http://gimpact.sourceforge.net/
8 
9 Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
10 email: projectileman@yahoo.com
11 
12 
13 This software is provided 'as-is', without any express or implied warranty.
14 In no event will the authors be held liable for any damages arising from the use of this software.
15 Permission is granted to anyone to use this software for any purpose,
16 including commercial applications, and to alter it and redistribute it freely,
17 subject to the following restrictions:
18 
19 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.
20 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
21 3. This notice may not be removed or altered from any source distribution.
22 */
23 
24 #ifndef BT_GIMPACT_BVH_CONCAVE_COLLISION_ALGORITHM_H
25 #define BT_GIMPACT_BVH_CONCAVE_COLLISION_ALGORITHM_H
26 
31 class btDispatcher;
35 
37 
38 #include "btGImpactShape.h"
44 
45 
47 
55 {
56 protected:
62  int m_part0;
64  int m_part1;
65 
66 
69  {
71  return m_manifoldPtr;
72  }
73 
75  {
77  {
80  m_convex_algorithm = NULL;
81  }
82  }
83 
85  {
86  if(m_manifoldPtr == NULL) return;
88  m_manifoldPtr = NULL;
89  }
90 
92  {
95 
96  m_triface0 = -1;
97  m_part0 = -1;
98  m_triface1 = -1;
99  m_part1 = -1;
100  }
101 
103  {
104  return m_manifoldPtr;
105  }
106 
107 
108  // Call before process collision
110  {
111  if(getLastManifold() == 0)
112  {
113  newContactManifold(body0Wrap->getCollisionObject(),body1Wrap->getCollisionObject());
114  }
115 
117  }
118 
119  // Call before process collision
121  {
122  checkManifold(body0Wrap,body1Wrap);
123 
124  btCollisionAlgorithm * convex_algorithm = m_dispatcher->findAlgorithm(
125  body0Wrap,body1Wrap,getLastManifold());
126  return convex_algorithm ;
127  }
128 
129  // Call before process collision
131  {
132  if(m_convex_algorithm) return;
133  m_convex_algorithm = newAlgorithm(body0Wrap,body1Wrap);
134  }
135 
136 
137 
138 
139  void addContactPoint(const btCollisionObjectWrapper * body0Wrap,
140  const btCollisionObjectWrapper * body1Wrap,
141  const btVector3 & point,
142  const btVector3 & normal,
143  btScalar distance);
144 
147 
148  void collide_gjk_triangles(const btCollisionObjectWrapper* body0Wrap,
149  const btCollisionObjectWrapper* body1Wrap,
150  const btGImpactMeshShapePart * shape0,
151  const btGImpactMeshShapePart * shape1,
152  const int * pairs, int pair_count);
153 
154  void collide_sat_triangles(const btCollisionObjectWrapper* body0Wrap,
155  const btCollisionObjectWrapper* body1Wrap,
156  const btGImpactMeshShapePart * shape0,
157  const btGImpactMeshShapePart * shape1,
158  const int * pairs, int pair_count);
159 
160 
161 
162 
164  const btCollisionObjectWrapper* body0,
165  const btCollisionObjectWrapper* body1,
166  const btCollisionShape * shape0,
167  const btCollisionShape * shape1);
168 
170  const btCollisionObjectWrapper* body1Wrap,
171  const btCollisionShape* shape0,
172  const btCollisionShape* shape1);
173 
174 
175 
177  const btTransform & trans0,
178  const btTransform & trans1,
179  const btGImpactShapeInterface * shape0,
180  const btGImpactShapeInterface * shape1,btPairSet & pairset);
181 
183  const btTransform & trans0,
184  const btTransform & trans1,
185  const btGImpactShapeInterface * shape0,
186  const btCollisionShape * shape1,
187  btAlignedObjectArray<int> & collided_primitives);
188 
189 
191  const btCollisionObjectWrapper * body0Wrap,
192  const btCollisionObjectWrapper * body1Wrap,
193  const btGImpactMeshShapePart * shape0,
194  const btStaticPlaneShape * shape1,bool swapped);
195 
196 
197 public:
198 
200 
202 
203  virtual void processCollision (const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
204 
206 
207  virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
208  {
209  if (m_manifoldPtr)
210  manifoldArray.push_back(m_manifoldPtr);
211  }
212 
214  {
215  return m_resultOut;
216  }
217 
219  {
221  {
223  return new(mem) btGImpactCollisionAlgorithm(ci,body0Wrap,body1Wrap);
224  }
225  };
226 
228  static void registerAlgorithm(btCollisionDispatcher * dispatcher);
229 #ifdef TRI_COLLISION_PROFILING
230  static float getAverageTreeCollisionTime();
232 
234  static float getAverageTriangleCollisionTime();
235 #endif //TRI_COLLISION_PROFILING
236 
238 
243  void gimpact_vs_gimpact(const btCollisionObjectWrapper* body0Wrap,
244  const btCollisionObjectWrapper * body1Wrap,
245  const btGImpactShapeInterface * shape0,
246  const btGImpactShapeInterface * shape1);
247 
248  void gimpact_vs_shape(const btCollisionObjectWrapper* body0Wrap,
249  const btCollisionObjectWrapper* body1Wrap,
250  const btGImpactShapeInterface * shape0,
251  const btCollisionShape * shape1,bool swapped);
252 
253  void gimpact_vs_compoundshape(const btCollisionObjectWrapper * body0Wrap,
254  const btCollisionObjectWrapper * body1Wrap,
255  const btGImpactShapeInterface * shape0,
256  const btCompoundShape * shape1,bool swapped);
257 
258  void gimpact_vs_concave(
259  const btCollisionObjectWrapper * body0Wrap,
260  const btCollisionObjectWrapper * body1Wrap,
261  const btGImpactShapeInterface * shape0,
262  const btConcaveShape * shape1,bool swapped);
263 
264 
265 
266 
268  void setFace0(int value)
269  {
270  m_triface0 = value;
271  }
272  int getFace0()
273  {
274  return m_triface0;
275  }
276  void setFace1(int value)
277  {
278  m_triface1 = value;
279  }
280  int getFace1()
281  {
282  return m_triface1;
283  }
284  void setPart0(int value)
285  {
286  m_part0 = value;
287  }
288  int getPart0()
289  {
290  return m_part0;
291  }
292  void setPart1(int value)
293  {
294  m_part1 = value;
295  }
296  int getPart1()
297  {
298  return m_part1;
299  }
300 
301 };
302 
303 
304 //algorithm details
305 //#define BULLET_TRIANGLE_COLLISION 1
306 #define GIMPACT_VS_PLANE_COLLISION 1
307 
308 
309 
310 #endif //BT_GIMPACT_BVH_CONCAVE_COLLISION_ALGORITHM_H
virtual void releaseManifold(btPersistentManifold *manifold)=0
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
btPersistentManifold * newContactManifold(const btCollisionObject *body0, const btCollisionObject *body1)
Creates a new contact point.
void push_back(const T &_Val)
virtual btCollisionAlgorithm * findAlgorithm(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, btPersistentManifold *sharedManifold=0)=0
void collide_gjk_triangles(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btGImpactMeshShapePart *shape0, const btGImpactMeshShapePart *shape1, const int *pairs, int pair_count)
Collision routines.
btPersistentManifold * getLastManifold()
void setPersistentManifold(btPersistentManifold *manifoldPtr)
This class is not enabled yet (work-in-progress) to more aggressively activate objects.
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
void checkManifold(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap)
#define SIMD_FORCE_INLINE
Definition: btScalar.h:58
btCollisionDispatcher supports algorithms that handle ConvexConvex and ConvexConcave collision pairs...
btManifoldResult is a helper class to manage contact results.
void gimpact_vs_shape_find_pairs(const btTransform &trans0, const btTransform &trans1, const btGImpactShapeInterface *shape0, const btCollisionShape *shape1, btAlignedObjectArray< int > &collided_primitives)
void gimpact_vs_concave(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btGImpactShapeInterface *shape0, const btConcaveShape *shape1, bool swapped)
void gimpact_vs_gimpact(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btGImpactShapeInterface *shape0, const btGImpactShapeInterface *shape1)
Collides two gimpact shapes.
void gimpact_vs_compoundshape(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btGImpactShapeInterface *shape0, const btCompoundShape *shape1, bool swapped)
A pairset array.
Definition: btGImpactBvh.h:59
virtual btCollisionAlgorithm * CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo &ci, const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap)
Base class for gimpact shapes.
This class manages a sub part of a mesh supplied by the btStridingMeshInterface interface.
virtual void * allocateCollisionAlgorithm(int size)=0
btGImpactCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo &ci, const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap)
void convex_vs_convex_collision(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btCollisionShape *shape0, const btCollisionShape *shape1)
Used by the btCollisionDispatcher to register and create instances for btCollisionAlgorithm.
btCollisionObject can be used to manage collision detection objects.
virtual void freeCollisionAlgorithm(void *ptr)=0
virtual btPersistentManifold * getNewManifold(const btCollisionObject *b0, const btCollisionObject *b1)=0
void gimpacttrimeshpart_vs_plane_collision(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btGImpactMeshShapePart *shape0, const btStaticPlaneShape *shape1, bool swapped)
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
static void registerAlgorithm(btCollisionDispatcher *dispatcher)
Use this function for register the algorithm externally.
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
void gimpact_vs_gimpact_find_pairs(const btTransform &trans0, const btTransform &trans1, const btGImpactShapeInterface *shape0, const btGImpactShapeInterface *shape1, btPairSet &pairset)
The btConcaveShape class provides an interface for non-moving (static) concave shapes.
btScalar calculateTimeOfImpact(btCollisionObject *body0, btCollisionObject *body1, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)
btCollisionAlgorithm * m_convex_algorithm
void setFace0(int value)
Accessor/Mutator pairs for Part and triangleID.
btCollisionAlgorithm * newAlgorithm(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap)
const btDispatcherInfo * m_dispatchInfo
The btCompoundShape allows to store multiple other btCollisionShapes This allows for moving concave c...
void shape_vs_shape_collision(const btCollisionObjectWrapper *body0, const btCollisionObjectWrapper *body1, const btCollisionShape *shape0, const btCollisionShape *shape1)
The btStaticPlaneShape simulates an infinite non-moving (static) collision plane. ...
virtual void getAllContactManifolds(btManifoldArray &manifoldArray)
void collide_sat_triangles(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btGImpactMeshShapePart *shape0, const btGImpactMeshShapePart *shape1, const int *pairs, int pair_count)
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:69
btCollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatche...
Collision Algorithm for GImpact Shapes.
void addContactPoint(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btVector3 &point, const btVector3 &normal, btScalar distance)
virtual void processCollision(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:266
void gimpact_vs_shape(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btGImpactShapeInterface *shape0, const btCollisionShape *shape1, bool swapped)
void checkConvexAlgorithm(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap)
const btCollisionObject * getCollisionObject() const