Differential D8762 Diff 28333 extern/bullet2/src/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.cpp

Changeset View

Standalone View

extern/bullet2/src/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.cpp

	Show All 17 Lines
	#include "btSoftBodyConcaveCollisionAlgorithm.h"			#include "btSoftBodyConcaveCollisionAlgorithm.h"
	#include "btSoftSoftCollisionAlgorithm.h"			#include "btSoftSoftCollisionAlgorithm.h"

	#include "LinearMath/btPoolAllocator.h"			#include "LinearMath/btPoolAllocator.h"

	#define ENABLE_SOFTBODY_CONCAVE_COLLISIONS 1			#define ENABLE_SOFTBODY_CONCAVE_COLLISIONS 1

	btSoftBodyRigidBodyCollisionConfiguration::btSoftBodyRigidBodyCollisionConfiguration(const btDefaultCollisionConstructionInfo& constructionInfo)			btSoftBodyRigidBodyCollisionConfiguration::btSoftBodyRigidBodyCollisionConfiguration(const btDefaultCollisionConstructionInfo& constructionInfo)
	:btDefaultCollisionConfiguration(constructionInfo)			: btDefaultCollisionConfiguration(constructionInfo)
	{			{
	void* mem;			void* mem;

	mem = btAlignedAlloc(sizeof(btSoftSoftCollisionAlgorithm::CreateFunc),16);			mem = btAlignedAlloc(sizeof(btSoftSoftCollisionAlgorithm::CreateFunc), 16);
	m_softSoftCreateFunc = new(mem) btSoftSoftCollisionAlgorithm::CreateFunc;			m_softSoftCreateFunc = new (mem) btSoftSoftCollisionAlgorithm::CreateFunc;

	mem = btAlignedAlloc(sizeof(btSoftRigidCollisionAlgorithm::CreateFunc),16);			mem = btAlignedAlloc(sizeof(btSoftRigidCollisionAlgorithm::CreateFunc), 16);
	m_softRigidConvexCreateFunc = new(mem) btSoftRigidCollisionAlgorithm::CreateFunc;			m_softRigidConvexCreateFunc = new (mem) btSoftRigidCollisionAlgorithm::CreateFunc;

	mem = btAlignedAlloc(sizeof(btSoftRigidCollisionAlgorithm::CreateFunc),16);			mem = btAlignedAlloc(sizeof(btSoftRigidCollisionAlgorithm::CreateFunc), 16);
	m_swappedSoftRigidConvexCreateFunc = new(mem) btSoftRigidCollisionAlgorithm::CreateFunc;			m_swappedSoftRigidConvexCreateFunc = new (mem) btSoftRigidCollisionAlgorithm::CreateFunc;
	m_swappedSoftRigidConvexCreateFunc->m_swapped=true;			m_swappedSoftRigidConvexCreateFunc->m_swapped = true;

	#ifdef ENABLE_SOFTBODY_CONCAVE_COLLISIONS			#ifdef ENABLE_SOFTBODY_CONCAVE_COLLISIONS
	mem = btAlignedAlloc(sizeof(btSoftBodyConcaveCollisionAlgorithm::CreateFunc),16);			mem = btAlignedAlloc(sizeof(btSoftBodyConcaveCollisionAlgorithm::CreateFunc), 16);
	m_softRigidConcaveCreateFunc = new(mem) btSoftBodyConcaveCollisionAlgorithm::CreateFunc;			m_softRigidConcaveCreateFunc = new (mem) btSoftBodyConcaveCollisionAlgorithm::CreateFunc;

	mem = btAlignedAlloc(sizeof(btSoftBodyConcaveCollisionAlgorithm::CreateFunc),16);			mem = btAlignedAlloc(sizeof(btSoftBodyConcaveCollisionAlgorithm::CreateFunc), 16);
	m_swappedSoftRigidConcaveCreateFunc = new(mem) btSoftBodyConcaveCollisionAlgorithm::SwappedCreateFunc;			m_swappedSoftRigidConcaveCreateFunc = new (mem) btSoftBodyConcaveCollisionAlgorithm::SwappedCreateFunc;
	m_swappedSoftRigidConcaveCreateFunc->m_swapped=true;			m_swappedSoftRigidConcaveCreateFunc->m_swapped = true;
	#endif			#endif

	//replace pool by a new one, with potential larger size			//replace pool by a new one, with potential larger size

	if (m_ownsCollisionAlgorithmPool && m_collisionAlgorithmPool)			if (m_ownsCollisionAlgorithmPool && m_collisionAlgorithmPool)
	{			{
	int curElemSize = m_collisionAlgorithmPool->getElementSize();			int curElemSize = m_collisionAlgorithmPool->getElementSize();
	///calculate maximum element size, big enough to fit any collision algorithm in the memory pool			///calculate maximum element size, big enough to fit any collision algorithm in the memory pool


	int maxSize0 = sizeof(btSoftSoftCollisionAlgorithm);			int maxSize0 = sizeof(btSoftSoftCollisionAlgorithm);
	int maxSize1 = sizeof(btSoftRigidCollisionAlgorithm);			int maxSize1 = sizeof(btSoftRigidCollisionAlgorithm);
	int maxSize2 = sizeof(btSoftBodyConcaveCollisionAlgorithm);			int maxSize2 = sizeof(btSoftBodyConcaveCollisionAlgorithm);

	int collisionAlgorithmMaxElementSize = btMax(maxSize0,maxSize1);			int collisionAlgorithmMaxElementSize = btMax(maxSize0, maxSize1);
	collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize,maxSize2);			collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize, maxSize2);

	if (collisionAlgorithmMaxElementSize > curElemSize)			if (collisionAlgorithmMaxElementSize > curElemSize)
	{			{
	m_collisionAlgorithmPool->~btPoolAllocator();			m_collisionAlgorithmPool->~btPoolAllocator();
	btAlignedFree(m_collisionAlgorithmPool);			btAlignedFree(m_collisionAlgorithmPool);
	void* mem = btAlignedAlloc(sizeof(btPoolAllocator),16);			void* mem = btAlignedAlloc(sizeof(btPoolAllocator), 16);
	m_collisionAlgorithmPool = new(mem) btPoolAllocator(collisionAlgorithmMaxElementSize,constructionInfo.m_defaultMaxCollisionAlgorithmPoolSize);			m_collisionAlgorithmPool = new (mem) btPoolAllocator(collisionAlgorithmMaxElementSize, constructionInfo.m_defaultMaxCollisionAlgorithmPoolSize);
	}			}
	}			}

	}			}

	btSoftBodyRigidBodyCollisionConfiguration::~btSoftBodyRigidBodyCollisionConfiguration()			btSoftBodyRigidBodyCollisionConfiguration::~btSoftBodyRigidBodyCollisionConfiguration()
	{			{
	m_softSoftCreateFunc->~btCollisionAlgorithmCreateFunc();			m_softSoftCreateFunc->~btCollisionAlgorithmCreateFunc();
	btAlignedFree( m_softSoftCreateFunc);			btAlignedFree(m_softSoftCreateFunc);

	m_softRigidConvexCreateFunc->~btCollisionAlgorithmCreateFunc();			m_softRigidConvexCreateFunc->~btCollisionAlgorithmCreateFunc();
	btAlignedFree( m_softRigidConvexCreateFunc);			btAlignedFree(m_softRigidConvexCreateFunc);

	m_swappedSoftRigidConvexCreateFunc->~btCollisionAlgorithmCreateFunc();			m_swappedSoftRigidConvexCreateFunc->~btCollisionAlgorithmCreateFunc();
	btAlignedFree( m_swappedSoftRigidConvexCreateFunc);			btAlignedFree(m_swappedSoftRigidConvexCreateFunc);

	#ifdef ENABLE_SOFTBODY_CONCAVE_COLLISIONS			#ifdef ENABLE_SOFTBODY_CONCAVE_COLLISIONS
	m_softRigidConcaveCreateFunc->~btCollisionAlgorithmCreateFunc();			m_softRigidConcaveCreateFunc->~btCollisionAlgorithmCreateFunc();
	btAlignedFree( m_softRigidConcaveCreateFunc);			btAlignedFree(m_softRigidConcaveCreateFunc);

	m_swappedSoftRigidConcaveCreateFunc->~btCollisionAlgorithmCreateFunc();			m_swappedSoftRigidConcaveCreateFunc->~btCollisionAlgorithmCreateFunc();
	btAlignedFree( m_swappedSoftRigidConcaveCreateFunc);			btAlignedFree(m_swappedSoftRigidConcaveCreateFunc);
	#endif			#endif
	}			}

	///creation of soft-soft and soft-rigid, and otherwise fallback to base class implementation			///creation of soft-soft and soft-rigid, and otherwise fallback to base class implementation
	btCollisionAlgorithmCreateFunc* btSoftBodyRigidBodyCollisionConfiguration::getCollisionAlgorithmCreateFunc(int proxyType0,int proxyType1)			btCollisionAlgorithmCreateFunc* btSoftBodyRigidBodyCollisionConfiguration::getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1)
	{			{

	///try to handle the softbody interactions first			///try to handle the softbody interactions first

	if ((proxyType0 == SOFTBODY_SHAPE_PROXYTYPE ) && (proxyType1==SOFTBODY_SHAPE_PROXYTYPE))			if ((proxyType0 == SOFTBODY_SHAPE_PROXYTYPE) && (proxyType1 == SOFTBODY_SHAPE_PROXYTYPE))
	{			{
	return m_softSoftCreateFunc;			return m_softSoftCreateFunc;
	}			}

	///softbody versus convex			///softbody versus convex
	if (proxyType0 == SOFTBODY_SHAPE_PROXYTYPE && btBroadphaseProxy::isConvex(proxyType1))			if (proxyType0 == SOFTBODY_SHAPE_PROXYTYPE && btBroadphaseProxy::isConvex(proxyType1))
	{			{
	return m_softRigidConvexCreateFunc;			return m_softRigidConvexCreateFunc;
	}			}

	///convex versus soft body			///convex versus soft body
	if (btBroadphaseProxy::isConvex(proxyType0) && proxyType1 == SOFTBODY_SHAPE_PROXYTYPE )			if (btBroadphaseProxy::isConvex(proxyType0) && proxyType1 == SOFTBODY_SHAPE_PROXYTYPE)
	{			{
	return m_swappedSoftRigidConvexCreateFunc;			return m_swappedSoftRigidConvexCreateFunc;
	}			}

	#ifdef ENABLE_SOFTBODY_CONCAVE_COLLISIONS			#ifdef ENABLE_SOFTBODY_CONCAVE_COLLISIONS
	///softbody versus convex			///softbody versus convex
	if (proxyType0 == SOFTBODY_SHAPE_PROXYTYPE && btBroadphaseProxy::isConcave(proxyType1))			if (proxyType0 == SOFTBODY_SHAPE_PROXYTYPE && btBroadphaseProxy::isConcave(proxyType1))
	{			{
	return m_softRigidConcaveCreateFunc;			return m_softRigidConcaveCreateFunc;
	}			}

	///convex versus soft body			///convex versus soft body
	if (btBroadphaseProxy::isConcave(proxyType0) && proxyType1 == SOFTBODY_SHAPE_PROXYTYPE )			if (btBroadphaseProxy::isConcave(proxyType0) && proxyType1 == SOFTBODY_SHAPE_PROXYTYPE)
	{			{
	return m_swappedSoftRigidConcaveCreateFunc;			return m_swappedSoftRigidConcaveCreateFunc;
	}			}
	#endif			#endif

	///fallback to the regular rigid collision shape			///fallback to the regular rigid collision shape
	return btDefaultCollisionConfiguration::getCollisionAlgorithmCreateFunc(proxyType0,proxyType1);			return btDefaultCollisionConfiguration::getCollisionAlgorithmCreateFunc(proxyType0, proxyType1);
	}			}