← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty-proposed

« back to all changes in this revision

Viewing changes to extern/bullet2/src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2013-08-14 10:43:49 UTC
  • mfrom: (14.2.19 sid)
  • Revision ID: package-import@ubuntu.com-20130814104349-t1d5mtwkphp12dyj
Tags: 2.68a-3
* Upload to unstable
* debian/: python3.3 Depends simplified
  - debian/control: python3.3 Depends dropped
    for blender-data package
  - 0001-blender_thumbnailer.patch refreshed
* debian/control: libavcodec b-dep versioning dropped

Show diffs side-by-side

added added

removed removed

Lines of Context:
extern/bullet2/src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp
25
25
#include "BulletCollision/CollisionShapes/btSphereShape.h"
26
26
#include "LinearMath/btIDebugDraw.h"
27
27
#include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h"
 
28
#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h"
28
29
 
29
 
btConvexConcaveCollisionAlgorithm::btConvexConcaveCollisionAlgorithm( const btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionObject* body1,bool isSwapped)
30
 
: btActivatingCollisionAlgorithm(ci,body0,body1),
 
30
btConvexConcaveCollisionAlgorithm::btConvexConcaveCollisionAlgorithm( const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap,bool isSwapped)
 
31
: btActivatingCollisionAlgorithm(ci,body0Wrap,body1Wrap),
31
32
m_isSwapped(isSwapped),
32
 
m_btConvexTriangleCallback(ci.m_dispatcher1,body0,body1,isSwapped)
 
33
m_btConvexTriangleCallback(ci.m_dispatcher1,body0Wrap,body1Wrap,isSwapped)
33
34
{
34
35
}
35
36
 
46
47
}
47
48
 
48
49
 
49
 
btConvexTriangleCallback::btConvexTriangleCallback(btDispatcher*  dispatcher,btCollisionObject* body0,btCollisionObject* body1,bool isSwapped):
 
50
btConvexTriangleCallback::btConvexTriangleCallback(btDispatcher*  dispatcher,const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap,bool isSwapped):
50
51
          m_dispatcher(dispatcher),
51
52
        m_dispatchInfoPtr(0)
52
53
{
53
 
        m_convexBody = isSwapped? body1:body0;
54
 
        m_triBody = isSwapped? body0:body1;
 
54
        m_convexBodyWrap = isSwapped? body1Wrap:body0Wrap;
 
55
        m_triBodyWrap = isSwapped? body0Wrap:body1Wrap;
55
56
        
56
57
          //
57
58
          // create the manifold from the dispatcher 'manifold pool'
58
59
          //
59
 
          m_manifoldPtr = m_dispatcher->getNewManifold(m_convexBody,m_triBody);
 
60
          m_manifoldPtr = m_dispatcher->getNewManifold(m_convexBodyWrap->getCollisionObject(),m_triBodyWrap->getCollisionObject());
60
61
 
61
62
          clearCache();
62
63
}
88
89
        btCollisionAlgorithmConstructionInfo ci;
89
90
        ci.m_dispatcher1 = m_dispatcher;
90
91
 
91
 
        btCollisionObject* ob = static_cast<btCollisionObject*>(m_triBody);
 
92
        //const btCollisionObject* ob = static_cast<btCollisionObject*>(m_triBodyWrap->getCollisionObject());
92
93
 
93
94
 
94
95
#if 0   
103
104
        }
104
105
#endif
105
106
        
106
 
        if (m_convexBody->getCollisionShape()->isConvex())
 
107
        if (m_convexBodyWrap->getCollisionShape()->isConvex())
107
108
        {
108
109
                btTriangleShape tm(triangle[0],triangle[1],triangle[2]);        
109
110
                tm.setMargin(m_collisionMarginTriangle);
110
111
                
111
 
                btCollisionShape* tmpShape = ob->getCollisionShape();
112
 
                ob->internalSetTemporaryCollisionShape( &tm );
113
 
 
114
 
                btCollisionAlgorithm* colAlgo = ci.m_dispatcher1->findAlgorithm(m_convexBody,m_triBody,m_manifoldPtr);
115
 
 
116
 
                if (m_resultOut->getBody0Internal() == m_triBody)
 
112
                
 
113
                btCollisionObjectWrapper triObWrap(m_triBodyWrap,&tm,m_triBodyWrap->getCollisionObject(),m_triBodyWrap->getWorldTransform(),partId,triangleIndex);//correct transform?
 
114
                btCollisionAlgorithm* colAlgo = ci.m_dispatcher1->findAlgorithm(m_convexBodyWrap,&triObWrap,m_manifoldPtr);
 
115
 
 
116
                const btCollisionObjectWrapper* tmpWrap = 0;
 
117
 
 
118
                if (m_resultOut->getBody0Internal() == m_triBodyWrap->getCollisionObject())
117
119
                {
 
120
                        tmpWrap = m_resultOut->getBody0Wrap();
 
121
                        m_resultOut->setBody0Wrap(&triObWrap);
118
122
                        m_resultOut->setShapeIdentifiersA(partId,triangleIndex);
119
123
                }
120
124
                else
121
125
                {
 
126
                        tmpWrap = m_resultOut->getBody1Wrap();
 
127
                        m_resultOut->setBody1Wrap(&triObWrap);
122
128
                        m_resultOut->setShapeIdentifiersB(partId,triangleIndex);
123
129
                }
124
130
        
125
 
                colAlgo->processCollision(m_convexBody,m_triBody,*m_dispatchInfoPtr,m_resultOut);
 
131
                colAlgo->processCollision(m_convexBodyWrap,&triObWrap,*m_dispatchInfoPtr,m_resultOut);
 
132
 
 
133
                if (m_resultOut->getBody0Internal() == m_triBodyWrap->getCollisionObject())
 
134
                {
 
135
                        m_resultOut->setBody0Wrap(tmpWrap);
 
136
                } else
 
137
                {
 
138
                        m_resultOut->setBody1Wrap(tmpWrap);
 
139
                }
 
140
                
 
141
 
 
142
 
126
143
                colAlgo->~btCollisionAlgorithm();
127
144
                ci.m_dispatcher1->freeCollisionAlgorithm(colAlgo);
128
 
                ob->internalSetTemporaryCollisionShape( tmpShape);
129
145
        }
130
146
 
131
 
 
132
147
}
133
148
 
134
149
 
135
150
 
136
 
void    btConvexTriangleCallback::setTimeStepAndCounters(btScalar collisionMarginTriangle,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 
151
void    btConvexTriangleCallback::setTimeStepAndCounters(btScalar collisionMarginTriangle,const btDispatcherInfo& dispatchInfo,const btCollisionObjectWrapper* convexBodyWrap, const btCollisionObjectWrapper* triBodyWrap, btManifoldResult* resultOut)
137
152
{
 
153
        m_convexBodyWrap = convexBodyWrap;
 
154
        m_triBodyWrap = triBodyWrap;
 
155
 
138
156
        m_dispatchInfoPtr = &dispatchInfo;
139
157
        m_collisionMarginTriangle = collisionMarginTriangle;
140
158
        m_resultOut = resultOut;
141
159
 
142
160
        //recalc aabbs
143
161
        btTransform convexInTriangleSpace;
144
 
        convexInTriangleSpace = m_triBody->getWorldTransform().inverse() * m_convexBody->getWorldTransform();
145
 
        btCollisionShape* convexShape = static_cast<btCollisionShape*>(m_convexBody->getCollisionShape());
 
162
        convexInTriangleSpace = m_triBodyWrap->getWorldTransform().inverse() * m_convexBodyWrap->getWorldTransform();
 
163
        const btCollisionShape* convexShape = static_cast<const btCollisionShape*>(m_convexBodyWrap->getCollisionShape());
146
164
        //CollisionShape* triangleShape = static_cast<btCollisionShape*>(triBody->m_collisionShape);
147
165
        convexShape->getAabb(convexInTriangleSpace,m_aabbMin,m_aabbMax);
148
166
        btScalar extraMargin = collisionMarginTriangle;
159
177
 
160
178
}
161
179
 
162
 
void btConvexConcaveCollisionAlgorithm::processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 
180
void btConvexConcaveCollisionAlgorithm::processCollision (const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
163
181
{
164
182
        
165
183
        
166
 
        btCollisionObject* convexBody = m_isSwapped ? body1 : body0;
167
 
        btCollisionObject* triBody = m_isSwapped ? body0 : body1;
 
184
        const btCollisionObjectWrapper* convexBodyWrap = m_isSwapped ? body1Wrap : body0Wrap;
 
185
        const btCollisionObjectWrapper* triBodyWrap = m_isSwapped ? body0Wrap : body1Wrap;
168
186
 
169
 
        if (triBody->getCollisionShape()->isConcave())
 
187
        if (triBodyWrap->getCollisionShape()->isConcave())
170
188
        {
171
189
 
172
190
 
173
 
                btCollisionObject*      triOb = triBody;
174
 
                btConcaveShape* concaveShape = static_cast<btConcaveShape*>( triOb->getCollisionShape());
175
 
                
176
 
                if (convexBody->getCollisionShape()->isConvex())
 
191
                
 
192
                const btConcaveShape* concaveShape = static_cast<const btConcaveShape*>( triBodyWrap->getCollisionShape());
 
193
                
 
194
                if (convexBodyWrap->getCollisionShape()->isConvex())
177
195
                {
178
196
                        btScalar collisionMarginTriangle = concaveShape->getMargin();
179
197
                                        
180
198
                        resultOut->setPersistentManifold(m_btConvexTriangleCallback.m_manifoldPtr);
181
 
                        m_btConvexTriangleCallback.setTimeStepAndCounters(collisionMarginTriangle,dispatchInfo,resultOut);
182
 
 
183
 
                        //Disable persistency. previously, some older algorithm calculated all contacts in one go, so you can clear it here.
184
 
                        //m_dispatcher->clearManifold(m_btConvexTriangleCallback.m_manifoldPtr);
185
 
 
186
 
                        m_btConvexTriangleCallback.m_manifoldPtr->setBodies(convexBody,triBody);
 
199
                        m_btConvexTriangleCallback.setTimeStepAndCounters(collisionMarginTriangle,dispatchInfo,convexBodyWrap,triBodyWrap,resultOut);
 
200
 
 
201
                        m_btConvexTriangleCallback.m_manifoldPtr->setBodies(convexBodyWrap->getCollisionObject(),triBodyWrap->getCollisionObject());
187
202
 
188
203
                        concaveShape->processAllTriangles( &m_btConvexTriangleCallback,m_btConvexTriangleCallback.getAabbMin(),m_btConvexTriangleCallback.getAabbMax());
189
204
                        
190
205
                        resultOut->refreshContactPoints();
 
206
 
 
207
                        m_btConvexTriangleCallback.clearWrapperData();
191
208
        
192
209
                }
193
210