← Back to branch summary

~ubuntu-branches/ubuntu/maverick/blender/maverick

« back to all changes in this revision

Viewing changes to extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionWorld.h

  • Committer: Bazaar Package Importer
  • Author(s): Khashayar Naderehvandi, Khashayar Naderehvandi, Alessio Treglia
  • Date: 2009-01-22 16:53:59 UTC
  • mfrom: (14.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20090122165359-v0996tn7fbit64ni
Tags: 2.48a+dfsg-1ubuntu1
https://launchpad.net/bugs/320045
[ Khashayar Naderehvandi ]
* Merge from debian experimental (LP: #320045), Ubuntu remaining changes:
  - Add patch correcting header file locations.
  - Add libvorbis-dev and libgsm1-dev to Build-Depends.
  - Use avcodec_decode_audio2() in source/blender/src/hddaudio.c

[ Alessio Treglia ]
* Add missing previous changelog entries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionWorld.h
68
68
class btCollisionShape;
69
69
class btConvexShape;
70
70
class btBroadphaseInterface;
71
 
#include "../../LinearMath/btVector3.h"
72
 
#include "../../LinearMath/btTransform.h"
 
71
#include "LinearMath/btVector3.h"
 
72
#include "LinearMath/btTransform.h"
73
73
#include "btCollisionObject.h"
74
74
#include "btCollisionDispatcher.h" //for definition of btCollisionObjectArray
75
 
#include "../BroadphaseCollision/btOverlappingPairCache.h"
76
 
#include "../../LinearMath/btAlignedObjectArray.h"
 
75
#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"
 
76
#include "LinearMath/btAlignedObjectArray.h"
77
77
 
78
78
///CollisionWorld is interface and container for the collision detection
79
79
class btCollisionWorld
90
90
 
91
91
        btStackAlloc*   m_stackAlloc;
92
92
 
93
 
        btOverlappingPairCache* m_broadphasePairCache;
 
93
        btBroadphaseInterface*  m_broadphasePairCache;
 
94
 
 
95
        btIDebugDraw*   m_debugDrawer;
 
96
 
94
97
        
95
 
        bool    m_ownsDispatcher;
96
 
        bool    m_ownsBroadphasePairCache;
97
 
 
98
98
public:
99
99
 
100
100
        //this constructor doesn't own the dispatcher and paircache/broadphase
101
 
        btCollisionWorld(btDispatcher* dispatcher,btOverlappingPairCache* pairCache, int stackSize = 2*1024*1024);
 
101
        btCollisionWorld(btDispatcher* dispatcher,btBroadphaseInterface* broadphasePairCache, btCollisionConfiguration* collisionConfiguration);
102
102
 
103
103
        virtual ~btCollisionWorld();
104
104
 
 
105
        void    setBroadphase(btBroadphaseInterface*    pairCache)
 
106
        {
 
107
                m_broadphasePairCache = pairCache;
 
108
        }
105
109
 
106
110
        btBroadphaseInterface*  getBroadphase()
107
111
        {
110
114
 
111
115
        btOverlappingPairCache* getPairCache()
112
116
        {
113
 
                return m_broadphasePairCache;
 
117
                return m_broadphasePairCache->getOverlappingPairCache();
114
118
        }
115
119
 
116
120
 
119
123
                return m_dispatcher1;
120
124
        }
121
125
 
 
126
        const btDispatcher*     getDispatcher() const
 
127
        {
 
128
                return m_dispatcher1;
 
129
        }
 
130
 
 
131
        virtual void    updateAabbs();
 
132
 
 
133
        virtual void    setDebugDrawer(btIDebugDraw*    debugDrawer)
 
134
        {
 
135
                        m_debugDrawer = debugDrawer;
 
136
        }
 
137
 
 
138
        virtual btIDebugDraw*   getDebugDrawer()
 
139
        {
 
140
                return m_debugDrawer;
 
141
        }
 
142
 
 
143
 
122
144
        ///LocalShapeInfo gives extra information for complex shapes
123
145
        ///Currently, only btTriangleMeshShape is available, so it just contains triangleIndex and subpart
124
146
        struct  LocalShapeInfo
153
175
        ///RayResultCallback is used to report new raycast results
154
176
        struct  RayResultCallback
155
177
        {
 
178
                btScalar        m_closestHitFraction;
 
179
                btCollisionObject*              m_collisionObject;
 
180
                short int       m_collisionFilterGroup;
 
181
                short int       m_collisionFilterMask;
 
182
 
156
183
                virtual ~RayResultCallback()
157
184
                {
158
185
                }
159
 
                btScalar        m_closestHitFraction;
160
 
                bool    HasHit()
 
186
                bool    hasHit() const
161
187
                {
162
 
                        return (m_closestHitFraction < btScalar(1.));
 
188
                        return (m_collisionObject != 0);
163
189
                }
164
190
 
165
191
                RayResultCallback()
166
 
                        :m_closestHitFraction(btScalar(1.))
167
 
                {
168
 
                }
169
 
                virtual btScalar        AddSingleResult(LocalRayResult& rayResult) = 0;
 
192
                        :m_closestHitFraction(btScalar(1.)),
 
193
                        m_collisionObject(0),
 
194
                        m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
 
195
                        m_collisionFilterMask(btBroadphaseProxy::AllFilter)
 
196
                {
 
197
                }
 
198
 
 
199
                virtual bool needsCollision(btBroadphaseProxy* proxy0) const
 
200
                {
 
201
                        bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
 
202
                        collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
 
203
                        return collides;
 
204
                }
 
205
 
 
206
 
 
207
                virtual btScalar        addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace) = 0;
170
208
        };
171
209
 
172
210
        struct  ClosestRayResultCallback : public RayResultCallback
173
211
        {
174
212
                ClosestRayResultCallback(const btVector3&       rayFromWorld,const btVector3&   rayToWorld)
175
213
                :m_rayFromWorld(rayFromWorld),
176
 
                m_rayToWorld(rayToWorld),
177
 
                m_collisionObject(0)
 
214
                m_rayToWorld(rayToWorld)
178
215
                {
179
216
                }
180
217
 
183
220
 
184
221
                btVector3       m_hitNormalWorld;
185
222
                btVector3       m_hitPointWorld;
186
 
                btCollisionObject*      m_collisionObject;
187
 
                
188
 
                virtual btScalar        AddSingleResult(LocalRayResult& rayResult)
 
223
                        
 
224
                virtual btScalar        addSingleResult(LocalRayResult& rayResult,bool normalInWorldSpace)
189
225
                {
190
 
 
191
 
//caller already does the filter on the m_closestHitFraction
192
 
                        assert(rayResult.m_hitFraction <= m_closestHitFraction);
 
226
                        //caller already does the filter on the m_closestHitFraction
 
227
                        btAssert(rayResult.m_hitFraction <= m_closestHitFraction);
193
228
                        
194
229
                        m_closestHitFraction = rayResult.m_hitFraction;
195
230
                        m_collisionObject = rayResult.m_collisionObject;
196
 
                        m_hitNormalWorld = m_collisionObject->getWorldTransform().getBasis()*rayResult.m_hitNormalLocal;
 
231
                        if (normalInWorldSpace)
 
232
                        {
 
233
                                m_hitNormalWorld = rayResult.m_hitNormalLocal;
 
234
                        } else
 
235
                        {
 
236
                                ///need to transform normal into worldspace
 
237
                                m_hitNormalWorld = m_collisionObject->getWorldTransform().getBasis()*rayResult.m_hitNormalLocal;
 
238
                        }
197
239
                        m_hitPointWorld.setInterpolate3(m_rayFromWorld,m_rayToWorld,rayResult.m_hitFraction);
198
240
                        return rayResult.m_hitFraction;
199
241
                }
200
242
        };
201
243
 
202
244
 
203
 
        
 
245
        struct LocalConvexResult
 
246
        {
 
247
                LocalConvexResult(btCollisionObject*    hitCollisionObject, 
 
248
                        LocalShapeInfo* localShapeInfo,
 
249
                        const btVector3&                hitNormalLocal,
 
250
                        const btVector3&                hitPointLocal,
 
251
                        btScalar hitFraction
 
252
                        )
 
253
                :m_hitCollisionObject(hitCollisionObject),
 
254
                m_localShapeInfo(localShapeInfo),
 
255
                m_hitNormalLocal(hitNormalLocal),
 
256
                m_hitPointLocal(hitPointLocal),
 
257
                m_hitFraction(hitFraction)
 
258
                {
 
259
                }
 
260
 
 
261
                btCollisionObject*              m_hitCollisionObject;
 
262
                LocalShapeInfo*                 m_localShapeInfo;
 
263
                btVector3                               m_hitNormalLocal;
 
264
                btVector3                               m_hitPointLocal;
 
265
                btScalar                                m_hitFraction;
 
266
        };
 
267
 
 
268
        ///RayResultCallback is used to report new raycast results
 
269
        struct  ConvexResultCallback
 
270
        {
 
271
                btScalar        m_closestHitFraction;
 
272
                short int       m_collisionFilterGroup;
 
273
                short int       m_collisionFilterMask;
 
274
                
 
275
                ConvexResultCallback()
 
276
                        :m_closestHitFraction(btScalar(1.)),
 
277
                        m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
 
278
                        m_collisionFilterMask(btBroadphaseProxy::AllFilter)
 
279
                {
 
280
                }
 
281
 
 
282
                virtual ~ConvexResultCallback()
 
283
                {
 
284
                }
 
285
                
 
286
                bool    hasHit() const
 
287
                {
 
288
                        return (m_closestHitFraction < btScalar(1.));
 
289
                }
 
290
 
 
291
                
 
292
 
 
293
                virtual bool needsCollision(btBroadphaseProxy* proxy0) const
 
294
                {
 
295
                        bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
 
296
                        collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
 
297
                        return collides;
 
298
                }
 
299
 
 
300
                virtual btScalar        addSingleResult(LocalConvexResult& convexResult,bool normalInWorldSpace) = 0;
 
301
        };
 
302
 
 
303
        struct  ClosestConvexResultCallback : public ConvexResultCallback
 
304
        {
 
305
                ClosestConvexResultCallback(const btVector3&    convexFromWorld,const btVector3&        convexToWorld)
 
306
                :m_convexFromWorld(convexFromWorld),
 
307
                m_convexToWorld(convexToWorld),
 
308
                m_hitCollisionObject(0)
 
309
                {
 
310
                }
 
311
 
 
312
                btVector3       m_convexFromWorld;//used to calculate hitPointWorld from hitFraction
 
313
                btVector3       m_convexToWorld;
 
314
 
 
315
                btVector3       m_hitNormalWorld;
 
316
                btVector3       m_hitPointWorld;
 
317
                btCollisionObject*      m_hitCollisionObject;
 
318
                
 
319
                virtual btScalar        addSingleResult(LocalConvexResult& convexResult,bool normalInWorldSpace)
 
320
                {
 
321
//caller already does the filter on the m_closestHitFraction
 
322
                        btAssert(convexResult.m_hitFraction <= m_closestHitFraction);
 
323
                                                
 
324
                        m_closestHitFraction = convexResult.m_hitFraction;
 
325
                        m_hitCollisionObject = convexResult.m_hitCollisionObject;
 
326
                        if (normalInWorldSpace)
 
327
                        {
 
328
                                m_hitNormalWorld = convexResult.m_hitNormalLocal;
 
329
                        } else
 
330
                        {
 
331
                                ///need to transform normal into worldspace
 
332
                                m_hitNormalWorld = m_hitCollisionObject->getWorldTransform().getBasis()*convexResult.m_hitNormalLocal;
 
333
                        }
 
334
                        m_hitPointWorld = convexResult.m_hitPointLocal;
 
335
                        return convexResult.m_hitFraction;
 
336
                }
 
337
        };
204
338
 
205
339
        int     getNumCollisionObjects() const
206
340
        {
209
343
 
210
344
        /// rayTest performs a raycast on all objects in the btCollisionWorld, and calls the resultCallback
211
345
        /// This allows for several queries: first hit, all hits, any hit, dependent on the value returned by the callback.
212
 
        void    rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback, short int collisionFilterMask=-1);
 
346
        void    rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const; 
 
347
 
 
348
        // convexTest performs a swept convex cast on all objects in the btCollisionWorld, and calls the resultCallback
 
349
        // This allows for several queries: first hit, all hits, any hit, dependent on the value return by the callback.
 
350
        void    convexSweepTest (const btConvexShape* castShape, const btTransform& from, const btTransform& to, ConvexResultCallback& resultCallback) const;
 
351
 
213
352
 
214
353
        /// rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest.
215
354
        /// In a future implementation, we consider moving the ray test as a virtual method in btCollisionShape.
218
357
                                          btCollisionObject* collisionObject,
219
358
                                          const btCollisionShape* collisionShape,
220
359
                                          const btTransform& colObjWorldTransform,
221
 
                                          RayResultCallback& resultCallback, short int collisionFilterMask=-1);
 
360
                                          RayResultCallback& resultCallback);
222
361
 
223
362
        /// objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest.
224
363
        static void     objectQuerySingle(const btConvexShape* castShape, const btTransform& rayFromTrans,const btTransform& rayToTrans,
225
364
                                          btCollisionObject* collisionObject,
226
365
                                          const btCollisionShape* collisionShape,
227
366
                                          const btTransform& colObjWorldTransform,
228
 
                                          RayResultCallback& resultCallback, short int collisionFilterMask=-1);
 
367
                                          ConvexResultCallback& resultCallback, btScalar        allowedPenetration);
229
368
 
230
 
        void    addCollisionObject(btCollisionObject* collisionObject,short int collisionFilterGroup=1,short int collisionFilterMask=1);
 
369
        void    addCollisionObject(btCollisionObject* collisionObject,short int collisionFilterGroup=btBroadphaseProxy::DefaultFilter,short int collisionFilterMask=btBroadphaseProxy::AllFilter);
231
370
 
232
371
        btCollisionObjectArray& getCollisionObjectArray()
233
372
        {
249
388
                return m_dispatchInfo;
250
389
        }
251
390
 
 
391
        const btDispatcherInfo& getDispatchInfo() const
 
392
        {
 
393
                return m_dispatchInfo;
 
394
        }
 
395
 
252
396
};
253
397
 
254
398