Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #281 from erwincoumans/master

Browse Source 
comment-out the memset in DEBUG mode in btVector3.cpp and b3Vector3.cpp
This commit is contained in:
erwincoumans
2014-11-05 12:27:55 -08:00
parent c64377b76c eafbf817c3
commit dc731280b8
9 changed files with 675 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Demos/VoronoiFractureDemo/CMakeLists.txt
View File

@@ -29,6 +29,8 @@ ADD_EXECUTABLE(AppVoronoiFractureDemo
main.cpp
VoronoiFractureDemo.cpp
VoronoiFractureDemo.h
btConvexConvexMprAlgorithm.cpp
btConvexConvexMprAlgorithm.h
${BULLET_PHYSICS_SOURCE_DIR}/build3/bullet.rc
)
ELSE()
@@ -36,6 +38,8 @@ ELSE()
main.cpp
VoronoiFractureDemo.cpp
VoronoiFractureDemo.h
btConvexConvexMprAlgorithm.cpp
btConvexConvexMprAlgorithm.h
)
ENDIF()
@@ -57,6 +61,8 @@ ELSE (USE_GLUT)
Win32VoronoiFractureDemo.cpp
VoronoiFractureDemo.cpp
VoronoiFractureDemo.h
btConvexConvexMprAlgorithm.cpp
btConvexConvexMprAlgorithm.h
${BULLET_PHYSICS_SOURCE_DIR}/build3/bullet.rc
)

47
Demos/VoronoiFractureDemo/VoronoiFractureDemo.cpp
View File

@@ -25,20 +25,23 @@ Voronoi fracture and shatter code and demo copyright (c) 2011 Alain Ducharme
//maximum number of objects (and allow user to shoot additional boxes)
#define MAX_PROXIES (2048)
#define BREAKING_THRESHOLD 2
#define BREAKING_THRESHOLD 3
#define CONVEX_MARGIN 0.04
static int useMpr = 0;
#include "VoronoiFractureDemo.h"
#include "GlutStuff.h"
///btBulletDynamicsCommon.h is the main Bullet include file, contains most common include files.
#include "btBulletDynamicsCommon.h"
#include "GLDebugFont.h"
#include <stdio.h> //printf debugging
#include "GLDebugDrawer.h"
static GLDebugDrawer sDebugDraw;
static bool useGenericConstraint = false;
#include "btConvexConvexMprAlgorithm.h"
void VoronoiFractureDemo::attachFixedConstraints()
{
@@ -493,13 +496,13 @@ void VoronoiFractureDemo::clientMoveAndDisplay()
///step the simulation
if (m_dynamicsWorld)
{
m_dynamicsWorld->stepSimulation(ms / 1000000.f);
m_dynamicsWorld->stepSimulation(1. / 60., 0);// ms / 1000000.f);
//optional but useful: debug drawing
m_dynamicsWorld->debugDrawWorld();
}
renderme();
glFlush();
swapBuffers();
@@ -520,9 +523,30 @@ void VoronoiFractureDemo::displayCallback(void) {
swapBuffers();
}
void VoronoiFractureDemo::renderme()
{
DemoApplication::renderme();
char buf[124];
int lineWidth = 200;
int xStart = m_glutScreenWidth - lineWidth;
if (useMpr)
{
sprintf(buf, "Using GJK+MPR");
}
else
{
sprintf(buf, "Using GJK+EPA");
}
GLDebugDrawString(xStart, 20, buf);
}
void VoronoiFractureDemo::initPhysics()
{
srand(13);
useGenericConstraint = !useGenericConstraint;
printf("useGenericConstraint = %d\n", useGenericConstraint);
@@ -538,7 +562,22 @@ void VoronoiFractureDemo::initPhysics()
///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration);
useMpr = 1 - useMpr;
if (useMpr)
{
printf("using GJK+MPR convex-convex collision detection\n");
btConvexConvexMprAlgorithm::CreateFunc* cf = new btConvexConvexMprAlgorithm::CreateFunc;
m_dispatcher->registerCollisionCreateFunc(CONVEX_HULL_SHAPE_PROXYTYPE, CONVEX_HULL_SHAPE_PROXYTYPE, cf);
m_dispatcher->registerCollisionCreateFunc(CONVEX_HULL_SHAPE_PROXYTYPE, BOX_SHAPE_PROXYTYPE, cf);
m_dispatcher->registerCollisionCreateFunc(BOX_SHAPE_PROXYTYPE, CONVEX_HULL_SHAPE_PROXYTYPE, cf);
}
else
{
printf("using default (GJK+EPA) convex-convex collision detection\n");
}
m_broadphase = new btDbvtBroadphase();
///the default constraint solver. For parallel processing you can use a different solver (see Extras/BulletMultiThreaded)

2
Demos/VoronoiFractureDemo/VoronoiFractureDemo.h
View File

@@ -68,6 +68,8 @@ class VoronoiFractureDemo : public PlatformDemoApplication
void exitPhysics();
virtual void renderme();
void getVerticesInsidePlanes(const btAlignedObjectArray<btVector3>& planes, btAlignedObjectArray<btVector3>& verticesOut, std::set<int>& planeIndicesOut);
void voronoiBBShatter(const btAlignedObjectArray<btVector3>& points, const btVector3& bbmin, const btVector3& bbmax, const btQuaternion& bbq, const btVector3& bbt, btScalar matDensity);
void voronoiConvexHullShatter(const btAlignedObjectArray<btVector3>& points, const btAlignedObjectArray<btVector3>& verts, const btQuaternion& bbq, const btVector3& bbt, btScalar matDensity);

288
Demos/VoronoiFractureDemo/btConvexConvexMprAlgorithm.cpp Normal file
View File

@@ -0,0 +1,288 @@
/*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2014 Erwin Coumans http://continuousphysics.com/Bullet/
This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions:
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.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "btConvexConvexMprAlgorithm.h"
//#include <stdio.h>
#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
#include "BulletCollision/CollisionShapes/btConvexShape.h"
#include "BulletCollision/CollisionShapes/btTriangleShape.h"
#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h"
#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
#include "BulletCollision/CollisionShapes/btBoxShape.h"
#include "BulletCollision/CollisionDispatch/btManifoldResult.h"
#include "BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h"
#include "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h"
#include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h"
#include "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h"
#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h"
#include "BulletCollision/CollisionShapes/btSphereShape.h"
#include "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h"
#include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h"
#include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h"
#include "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h"
#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h"
#include "BulletCollision/NarrowPhaseCollision/btComputeGjkEpaPenetration.h"
#include "BulletCollision/NarrowPhaseCollision/btGjkEpa3.h"
#include "BulletCollision/NarrowPhaseCollision/btMprPenetration.h"
//this is just an internal debug variable to switch between GJK+MPR or GJK+EPA
bool gUseMprCollisionFunction = true;
btConvexConvexMprAlgorithm::CreateFunc::CreateFunc()
{
}
btConvexConvexMprAlgorithm::CreateFunc::~CreateFunc()
{
}
btConvexConvexMprAlgorithm::btConvexConvexMprAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap)
: btActivatingCollisionAlgorithm(ci,body0Wrap,body1Wrap),
m_ownManifold (false),
m_manifoldPtr(mf)
{
(void)body0Wrap;
(void)body1Wrap;
}
btConvexConvexMprAlgorithm::~btConvexConvexMprAlgorithm()
{
if (m_ownManifold)
{
if (m_manifoldPtr)
m_dispatcher->releaseManifold(m_manifoldPtr);
}
}
btVector3 btBulletShapeSupportFunc(const void* shapeAptr, const btVector3& dir, bool includeMargin)
{
btConvexShape* shape = (btConvexShape*) shapeAptr;
if (includeMargin)
{
return shape->localGetSupportingVertex(dir);
}
return shape->localGetSupportingVertexWithoutMargin(dir);
}
btVector3 btBulletShapeCenterFunc(const void* shapeAptr)
{
return btVector3(0,0,0);
}
struct btMprConvexWrap
{
const btConvexShape* m_convex;
btTransform m_worldTrans;
inline btScalar getMargin() const
{
return m_convex->getMargin();
}
inline btVector3 getObjectCenterInWorld() const
{
return m_worldTrans.getOrigin();
}
inline const btTransform& getWorldTransform() const
{
return m_worldTrans;
}
inline btVector3 getLocalSupportWithMargin(const btVector3& dir) const
{
return m_convex->localGetSupportingVertex(dir);
}
inline btVector3 getLocalSupportWithoutMargin(const btVector3& dir) const
{
return m_convex->localGetSupportingVertexWithoutMargin(dir);
}
};
struct btMyDistanceInfo
{
btVector3 m_pointOnA;
btVector3 m_pointOnB;
btVector3 m_normalBtoA;
btScalar m_distance;
};
//
// Convex-Convex collision algorithm
//
void btConvexConvexMprAlgorithm ::processCollision (const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
{
if (!m_manifoldPtr)
{
//swapped?
m_manifoldPtr = m_dispatcher->getNewManifold(body0Wrap->getCollisionObject(),body1Wrap->getCollisionObject());
m_ownManifold = true;
}
resultOut->setPersistentManifold(m_manifoldPtr);
//comment-out next line to test multi-contact generation
//resultOut->getPersistentManifold()->clearManifold();
const btConvexShape* min0 = static_cast<const btConvexShape*>(body0Wrap->getCollisionShape());
const btConvexShape* min1 = static_cast<const btConvexShape*>(body1Wrap->getCollisionShape());
btVector3 normalOnB;
btVector3 pointOnBWorld;
btGjkPairDetector::ClosestPointInput input;
btVoronoiSimplexSolver vs;
btGjkEpaPenetrationDepthSolver epa;
if (gUseMprCollisionFunction)
{
btMprConvexWrap a,b;
a.m_worldTrans = body0Wrap->getWorldTransform();
b.m_worldTrans = body1Wrap->getWorldTransform();
a.m_convex = (const btConvexShape*)body0Wrap->getCollisionShape();
b.m_convex = (const btConvexShape*)body1Wrap->getCollisionShape();
btVoronoiSimplexSolver simplexSolver;
simplexSolver.reset();
btGjkCollisionDescription colDesc;
btMyDistanceInfo distInfo;
int res = btComputeGjkDistance(a,b,colDesc,&distInfo);
if (res==0)
{
//printf("use GJK results in distance %f\n",distInfo.m_distance);
} else
{
btMprCollisionDescription mprDesc;
res = btComputeMprPenetration(a,b,mprDesc, &distInfo);
//printf("use MPR results in distance %f\n",distInfo.m_distance);
}
if (res == 0)
{
#if 0
printf("Dist=%f,normalOnB[%f,%f,%f],pA=[%f,%f,%f],pB[%f,%f,%f]\n",
distInfo.m_distance, distInfo.m_normalBtoA[0], distInfo.m_normalBtoA[1], distInfo.m_normalBtoA[2],
distInfo.m_pointOnA[0], distInfo.m_pointOnA[1], distInfo.m_pointOnA[2],
distInfo.m_pointOnB[0], distInfo.m_pointOnB[1], distInfo.m_pointOnB[2]);
#endif
if (distInfo.m_distance<=0)
{
resultOut->addContactPoint(distInfo.m_normalBtoA, distInfo.m_pointOnB, distInfo.m_distance);
}
//ASSERT_EQ(0,result);
//ASSERT_NEAR(btFabs(btScalar(i-z))-btScalar(j)-ssd.m_radiusB, distInfo.m_distance, abs_error);
//btVector3 computedA = distInfo.m_pointOnB+distInfo.m_distance*distInfo.m_normalBtoA;
//ASSERT_NEAR(computedA.x(),distInfo.m_pointOnA.x(),abs_error);
//ASSERT_NEAR(computedA.y(),distInfo.m_pointOnA.y(),abs_error);
//ASSERT_NEAR(computedA.z(),distInfo.m_pointOnA.z(),abs_error);
}
#if 0
btCollisionDescription colDesc;
colDesc.m_objA = min0;
colDesc.m_objB = min1;
colDesc.m_localSupportFuncA = &btBulletShapeSupportFunc;
colDesc.m_localSupportFuncB = &btBulletShapeSupportFunc;
colDesc.m_localOriginFuncA = &btBulletShapeCenterFunc;
colDesc.m_localOriginFuncB = &btBulletShapeCenterFunc;
colDesc.m_transformA = body0Wrap->getWorldTransform();
colDesc.m_transformB = body1Wrap->getWorldTransform();
colDesc.m_marginA = body0Wrap->getCollisionShape()->getMargin();
colDesc.m_marginB = body1Wrap->getCollisionShape()->getMargin();
btDistanceInfo distInfo;
//int result = btComputeGjkEpaPenetration(colDesc, &distInfo);
//int result = btComputeGjkEpaPenetration2(colDesc, &distInfo);
int result = btComputeMprPenetration(colDesc, &distInfo);
if (result==0)
{
resultOut->addContactPoint(distInfo.m_normalBtoA,distInfo.m_pointOnB,distInfo.m_distance);
}
//bool res = b3MprPenetration(pairIndex,bodyIndexA,bodyIndexB,cpuBodyBuf,convexData,collidable2,cpuVertices,sepAxis,hasSepAxis,depthOut,dirOut,posOut);
/*btCollisionDescription colDesc;
btDistanceInfo distInfo;
int btComputeGjkEpaPenetration(min0, min1, &colDesc, &distInfo);
*/
#endif
} else
{
btGjkPairDetector gjkPairDetector(min0,min1,&vs,&epa);//m_simplexSolver,m_pdSolver);
//TODO: if (dispatchInfo.m_useContinuous)
gjkPairDetector.setMinkowskiA(min0);
gjkPairDetector.setMinkowskiB(min1);
{
//if (dispatchInfo.m_convexMaxDistanceUseCPT)
//{
// input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactProcessingThreshold();
//} else
//{
input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactBreakingThreshold();
// }
input.m_maximumDistanceSquared*= input.m_maximumDistanceSquared;
}
input.m_transformA = body0Wrap->getWorldTransform();
input.m_transformB = body1Wrap->getWorldTransform();
gjkPairDetector.getClosestPoints(input,*resultOut,dispatchInfo.m_debugDraw);
}
if (m_ownManifold)
{
resultOut->refreshContactPoints();
}
}
btScalar btConvexConvexMprAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
{
(void)resultOut;
(void)dispatchInfo;
btAssert(0);
return 0;
}

87
Demos/VoronoiFractureDemo/btConvexConvexMprAlgorithm.h Normal file
View File

@@ -0,0 +1,87 @@
/*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions:
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.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#ifndef BT_CONVEX_CONVEX_MPR_ALGORITHM_H
#define BT_CONVEX_CONVEX_MPR_ALGORITHM_H
#include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h"
#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h"
#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h"
#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
#include "LinearMath/btTransformUtil.h" //for btConvexSeparatingDistanceUtil
class btConvexPenetrationDepthSolver;
///Enabling USE_SEPDISTANCE_UTIL2 requires 100% reliable distance computation. However, when using large size ratios GJK can be imprecise
///so the distance is not conservative. In that case, enabling this USE_SEPDISTANCE_UTIL2 would result in failing/missing collisions.
///Either improve GJK for large size ratios (testing a 100 units versus a 0.1 unit object) or only enable the util
///for certain pairs that have a small size ratio
///The convexConvexAlgorithm collision algorithm implements time of impact, convex closest points and penetration depth calculations between two convex objects.
///Multiple contact points are calculated by perturbing the orientation of the smallest object orthogonal to the separating normal.
///This idea was described by Gino van den Bergen in this forum topic http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=4&t=288&p=888#p888
class btConvexConvexMprAlgorithm : public btActivatingCollisionAlgorithm
{
bool m_ownManifold;
btPersistentManifold* m_manifoldPtr;
///cache separating vector to speedup collision detection
public:
btConvexConvexMprAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap);
virtual ~btConvexConvexMprAlgorithm();
virtual void processCollision (const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
{
///should we use m_ownManifold to avoid adding duplicates?
if (m_manifoldPtr && m_ownManifold)
manifoldArray.push_back(m_manifoldPtr);
}
const btPersistentManifold* getManifold()
{
return m_manifoldPtr;
}
struct CreateFunc :public btCollisionAlgorithmCreateFunc
{
CreateFunc();
virtual ~CreateFunc();
virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap)
{
void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btConvexConvexMprAlgorithm));
return new(mem) btConvexConvexMprAlgorithm(ci.m_manifold,ci,body0Wrap,body1Wrap);
}
};
};
#endif //BT_CONVEX_CONVEX_MPR_ALGORITHM_H

2
Demos/VoronoiFractureDemo/main.cpp
View File

@@ -25,7 +25,7 @@ subject to the following restrictions:
int main(int argc,char** argv)
{
VoronoiFractureDemo ccdDemo;
ccdDemo.initPhysics();

4
Demos3/FiniteElementMethod/OpenTissue/dynamics/fem/fem_add_plasticity_force.h
View File

@@ -8,7 +8,7 @@
// OTTL is licensed under zlib: http://opensource.org/licenses/zlib-license.php
//
#include <OpenTissue/configuration.h>
#include <algorithm> //std::min
namespace OpenTissue
{
namespace fem
@@ -22,7 +22,7 @@ namespace OpenTissue
{
using std::min;
using std::sqrt;
using std::sqrt;
typedef typename tetrahedron_type::vector3_type vector3_type;

488
src/Bullet3Common/b3Vector3.cpp
View File

File diff suppressed because it is too large Load Diff

4
src/LinearMath/btVector3.cpp
View File

@@ -63,7 +63,7 @@ long _maxdot_large( const float *vv, const float *vec, unsigned long count, floa
float4 stack_array[ STACK_ARRAY_COUNT ];
#if DEBUG
memset( stack_array, -1, STACK_ARRAY_COUNT * sizeof(stack_array[0]) );
//memset( stack_array, -1, STACK_ARRAY_COUNT * sizeof(stack_array[0]) );
#endif
size_t index;
@@ -448,7 +448,7 @@ long _mindot_large( const float *vv, const float *vec, unsigned long count, floa
float4 stack_array[ STACK_ARRAY_COUNT ];
#if DEBUG
memset( stack_array, -1, STACK_ARRAY_COUNT * sizeof(stack_array[0]) );
//memset( stack_array, -1, STACK_ARRAY_COUNT * sizeof(stack_array[0]) );
#endif
size_t index;