/*
* Java port of Bullet (c) 2008 Martin Dvorak <jezek2@advel.cz>
*
* Bullet Continuous Collision Detection and Physics Library
* Copyright (c) 2003-2008 Erwin Coumans http://www.bulletphysics.com/
*
* 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.
*/
package com.bulletphysics.collision.dispatch;
import com.bulletphysics.collision.broadphase.BroadphaseNativeType;
import com.bulletphysics.collision.narrowphase.ConvexPenetrationDepthSolver;
import com.bulletphysics.collision.narrowphase.GjkEpaPenetrationDepthSolver;
import com.bulletphysics.collision.narrowphase.VoronoiSimplexSolver;
import com.bulletphysics.extras.gimpact.GImpactCollisionAlgorithm;
import static com.bulletphysics.collision.broadphase.BroadphaseNativeType.*;
/**
* Default implementation of {@link CollisionConfiguration}. Provides all core
* collision algorithms. Some extra algorithms (like {@link GImpactCollisionAlgorithm GImpact})
* must be registered manually by calling appropriate register method.
*
* @author jezek2
*/
public class DefaultCollisionConfiguration extends CollisionConfiguration {
//default simplex/penetration depth solvers
protected VoronoiSimplexSolver simplexSolver;
protected ConvexPenetrationDepthSolver pdSolver;
//default CreationFunctions, filling the m_doubleDispatch table
protected CollisionAlgorithmCreateFunc convexConvexCreateFunc;
protected CollisionAlgorithmCreateFunc convexConcaveCreateFunc;
protected CollisionAlgorithmCreateFunc swappedConvexConcaveCreateFunc;
protected CollisionAlgorithmCreateFunc compoundCreateFunc;
protected CollisionAlgorithmCreateFunc swappedCompoundCreateFunc;
protected CollisionAlgorithmCreateFunc emptyCreateFunc;
protected CollisionAlgorithmCreateFunc sphereSphereCF;
protected CollisionAlgorithmCreateFunc sphereBoxCF;
protected CollisionAlgorithmCreateFunc boxSphereCF;
protected CollisionAlgorithmCreateFunc boxBoxCF;
protected CollisionAlgorithmCreateFunc sphereTriangleCF;
protected CollisionAlgorithmCreateFunc triangleSphereCF;
protected CollisionAlgorithmCreateFunc planeConvexCF;
protected CollisionAlgorithmCreateFunc convexPlaneCF;
public DefaultCollisionConfiguration() {
simplexSolver = new VoronoiSimplexSolver();
//#define USE_EPA 1
//#ifdef USE_EPA
pdSolver = new GjkEpaPenetrationDepthSolver();
//#else
//pdSolver = new MinkowskiPenetrationDepthSolver();
//#endif//USE_EPA
/*
//default CreationFunctions, filling the m_doubleDispatch table
*/
convexConvexCreateFunc = new ConvexConvexAlgorithm.CreateFunc(simplexSolver, pdSolver);
convexConcaveCreateFunc = new ConvexConcaveCollisionAlgorithm.CreateFunc();
swappedConvexConcaveCreateFunc = new ConvexConcaveCollisionAlgorithm.SwappedCreateFunc();
compoundCreateFunc = new CompoundCollisionAlgorithm.CreateFunc();
swappedCompoundCreateFunc = new CompoundCollisionAlgorithm.SwappedCreateFunc();
emptyCreateFunc = new EmptyAlgorithm.CreateFunc();
sphereSphereCF = new SphereSphereCollisionAlgorithm.CreateFunc();
/*
m_sphereBoxCF = new(mem) btSphereBoxCollisionAlgorithm::CreateFunc;
m_boxSphereCF = new (mem)btSphereBoxCollisionAlgorithm::CreateFunc;
m_boxSphereCF->m_swapped = true;
m_sphereTriangleCF = new (mem)btSphereTriangleCollisionAlgorithm::CreateFunc;
m_triangleSphereCF = new (mem)btSphereTriangleCollisionAlgorithm::CreateFunc;
m_triangleSphereCF->m_swapped = true;
mem = btAlignedAlloc(sizeof(btBoxBoxCollisionAlgorithm::CreateFunc),16);
m_boxBoxCF = new(mem)btBoxBoxCollisionAlgorithm::CreateFunc;
*/
// convex versus plane
convexPlaneCF = new ConvexPlaneCollisionAlgorithm.CreateFunc();
planeConvexCF = new ConvexPlaneCollisionAlgorithm.CreateFunc();
planeConvexCF.swapped = true;
/*
///calculate maximum element size, big enough to fit any collision algorithm in the memory pool
int maxSize = sizeof(btConvexConvexAlgorithm);
int maxSize2 = sizeof(btConvexConcaveCollisionAlgorithm);
int maxSize3 = sizeof(btCompoundCollisionAlgorithm);
int maxSize4 = sizeof(btEmptyAlgorithm);
int collisionAlgorithmMaxElementSize = btMax(maxSize,maxSize2);
collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize,maxSize3);
collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize,maxSize4);
if (stackAlloc)
{
m_ownsStackAllocator = false;
this->m_stackAlloc = stackAlloc;
} else
{
m_ownsStackAllocator = true;
void* mem = btAlignedAlloc(sizeof(btStackAlloc),16);
m_stackAlloc = new(mem)btStackAlloc(DEFAULT_STACK_ALLOCATOR_SIZE);
}
if (persistentManifoldPool)
{
m_ownsPersistentManifoldPool = false;
m_persistentManifoldPool = persistentManifoldPool;
} else
{
m_ownsPersistentManifoldPool = true;
void* mem = btAlignedAlloc(sizeof(btPoolAllocator),16);
m_persistentManifoldPool = new (mem) btPoolAllocator(sizeof(btPersistentManifold),DEFAULT_MAX_OVERLAPPING_PAIRS);
}
if (collisionAlgorithmPool)
{
m_ownsCollisionAlgorithmPool = false;
m_collisionAlgorithmPool = collisionAlgorithmPool;
} else
{
m_ownsCollisionAlgorithmPool = true;
void* mem = btAlignedAlloc(sizeof(btPoolAllocator),16);
m_collisionAlgorithmPool = new(mem) btPoolAllocator(collisionAlgorithmMaxElementSize,DEFAULT_MAX_OVERLAPPING_PAIRS);
}
*/
}
@Override
public CollisionAlgorithmCreateFunc getCollisionAlgorithmCreateFunc(BroadphaseNativeType proxyType0, BroadphaseNativeType proxyType1) {
if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1 == SPHERE_SHAPE_PROXYTYPE)) {
return sphereSphereCF;
}
/*
if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1==BOX_SHAPE_PROXYTYPE))
{
return m_sphereBoxCF;
}
if ((proxyType0 == BOX_SHAPE_PROXYTYPE ) && (proxyType1==SPHERE_SHAPE_PROXYTYPE))
{
return m_boxSphereCF;
}
if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE ) && (proxyType1==TRIANGLE_SHAPE_PROXYTYPE))
{
return m_sphereTriangleCF;
}
if ((proxyType0 == TRIANGLE_SHAPE_PROXYTYPE ) && (proxyType1==SPHERE_SHAPE_PROXYTYPE))
{
return m_triangleSphereCF;
}
if ((proxyType0 == BOX_SHAPE_PROXYTYPE) && (proxyType1 == BOX_SHAPE_PROXYTYPE)) {
return boxBoxCF;
}
*/
if (proxyType0.isConvex() && (proxyType1 == STATIC_PLANE_PROXYTYPE))
{
return convexPlaneCF;
}
if (proxyType1.isConvex() && (proxyType0 == STATIC_PLANE_PROXYTYPE))
{
return planeConvexCF;
}
if (proxyType0.isConvex() && proxyType1.isConvex()) {
return convexConvexCreateFunc;
}
if (proxyType0.isConvex() && proxyType1.isConcave()) {
return convexConcaveCreateFunc;
}
if (proxyType1.isConvex() && proxyType0.isConcave()) {
return swappedConvexConcaveCreateFunc;
}
if (proxyType0.isCompound()) {
return compoundCreateFunc;
}
else {
if (proxyType1.isCompound()) {
return swappedCompoundCreateFunc;
}
}
// failed to find an algorithm
return emptyCreateFunc;
}
}