protected void ConvexVsConvexCollision(CollisionObject body0,
CollisionObject body1,
CollisionShape shape0,
CollisionShape shape1)
{
CollisionShape tmpShape0 = body0.GetCollisionShape();
CollisionShape tmpShape1 = body1.GetCollisionShape();
body0.InternalSetTemporaryCollisionShape(shape0);
body1.InternalSetTemporaryCollisionShape(shape1);
if (BulletGlobals.g_streamWriter != null && BulletGlobals.debugGimpactAlgo)
{
BulletGlobals.g_streamWriter.WriteLine("GImpactAglo::ConvexVsConvex");
}
m_resultOut.SetShapeIdentifiersA(m_part0, m_triface0);
m_resultOut.SetShapeIdentifiersB(m_part1, m_triface1);
CheckConvexAlgorithm(body0, body1);
m_convex_algorithm.ProcessCollision(body0, body1, m_dispatchInfo, m_resultOut);
body0.InternalSetTemporaryCollisionShape(tmpShape0);
body1.InternalSetTemporaryCollisionShape(tmpShape1);
}
protected void ShapeVsShapeCollision(
CollisionObject body0,
CollisionObject body1,
CollisionShape shape0,
CollisionShape shape1)
{
CollisionShape tmpShape0 = body0.GetCollisionShape();
CollisionShape tmpShape1 = body1.GetCollisionShape();
body0.InternalSetTemporaryCollisionShape(shape0);
body1.InternalSetTemporaryCollisionShape(shape1);
if (BulletGlobals.g_streamWriter != null && BulletGlobals.debugGimpactAlgo)
{
BulletGlobals.g_streamWriter.WriteLine("GImpactAglo::ShapeVsShape");
}
{
CollisionAlgorithm algor = NewAlgorithm(body0, body1);
// post : checkManifold is called
m_resultOut.SetShapeIdentifiersA(m_part0, m_triface0);
m_resultOut.SetShapeIdentifiersB(m_part1, m_triface1);
algor.ProcessCollision(body0, body1, m_dispatchInfo, m_resultOut);
m_dispatcher.FreeCollisionAlgorithm(algor);
}
body0.InternalSetTemporaryCollisionShape(tmpShape0);
body1.InternalSetTemporaryCollisionShape(tmpShape1);
}
private void PreallocateChildAlgorithms(CollisionObject body0, CollisionObject body1)
{
CollisionObject colObj = m_isSwapped ? body1 : body0;
CollisionObject otherObj = m_isSwapped ? body0 : body1;
Debug.Assert(colObj.GetCollisionShape().IsCompound());
CompoundShape compoundShape = (CompoundShape)(colObj.GetCollisionShape());
int numChildren = compoundShape.GetNumChildShapes();
int i;
//m_childCollisionAlgorithms.resize(numChildren);
m_childCollisionAlgorithms.Clear();
for (i = 0; i < numChildren; i++)
{
if (compoundShape.GetDynamicAabbTree() != null)
{
m_childCollisionAlgorithms.Add(null);
}
else
{
CollisionShape tmpShape = colObj.GetCollisionShape();
CollisionShape childShape = compoundShape.GetChildShape(i);
colObj.InternalSetTemporaryCollisionShape(childShape);
CollisionAlgorithm ca = m_dispatcher.FindAlgorithm(colObj, otherObj, m_sharedManifold);
m_childCollisionAlgorithms.Add(ca);
colObj.InternalSetTemporaryCollisionShape(tmpShape);
}
}
}
public virtual void ProcessTriangle(IndexedVector3[] triangle, int partId, int triangleIndex)
{
//aabb filter is already applied!
CollisionAlgorithmConstructionInfo ci = new CollisionAlgorithmConstructionInfo();
ci.SetDispatcher(m_dispatcher);
CollisionObject ob = m_triBody as CollisionObject;
///debug drawing of the overlapping triangles
///
#if false
if (m_dispatchInfoPtr != null && m_dispatchInfoPtr.getDebugDraw() != null && ((m_dispatchInfoPtr.getDebugDraw().GetDebugMode() & DebugDrawModes.DBG_DrawWireframe) > 0))
{
IndexedVector3 color = new IndexedVector3(1, 1, 0);
IndexedMatrix tr = ob.GetWorldTransform();
IndexedVector3[] transformedTriangles = new IndexedVector3[3];
IndexedVector3.Transform(triangle, ref tr, transformedTriangles);
m_dispatchInfoPtr.getDebugDraw().DrawLine(ref transformedTriangles[0], ref transformedTriangles[1], ref color);
m_dispatchInfoPtr.getDebugDraw().DrawLine(ref transformedTriangles[1], ref transformedTriangles[2], ref color);
m_dispatchInfoPtr.getDebugDraw().DrawLine(ref transformedTriangles[2], ref transformedTriangles[0], ref color);
}
#endif
if (m_convexBody.GetCollisionShape().IsConvex())
{
using (TriangleShape tm = BulletGlobals.TriangleShapePool.Get())
{
tm.Initialize(ref triangle[0], ref triangle[1], ref triangle[2]);
tm.SetMargin(m_collisionMarginTriangle);
CollisionShape tmpShape = ob.GetCollisionShape();
ob.InternalSetTemporaryCollisionShape(tm);
CollisionAlgorithm colAlgo = ci.GetDispatcher().FindAlgorithm(m_convexBody, m_triBody, m_manifoldPtr);
///this should use the btDispatcher, so the actual registered algorithm is used
// btConvexConvexAlgorithm cvxcvxalgo(m_manifoldPtr,ci,m_convexBody,m_triBody);
if (m_resultOut.GetBody0Internal() == m_triBody)
{
m_resultOut.SetShapeIdentifiersA(partId, triangleIndex);
}
else
{
m_resultOut.SetShapeIdentifiersB(partId, triangleIndex);
}
colAlgo.ProcessCollision(m_convexBody, m_triBody, m_dispatchInfoPtr, m_resultOut);
ci.GetDispatcher().FreeCollisionAlgorithm(colAlgo);
colAlgo = null;
ob.InternalSetTemporaryCollisionShape(tmpShape);
}
}
}
public override float CalculateTimeOfImpact(CollisionObject body0, CollisionObject body1, DispatcherInfo dispatchInfo, ManifoldResult resultOut)
{
resultOut = null;
CollisionObject colObj = m_isSwapped ? body1 : body0;
CollisionObject otherObj = m_isSwapped ? body0 : body1;
Debug.Assert(colObj.GetCollisionShape().IsCompound());
CompoundShape compoundShape = (CompoundShape)(colObj.GetCollisionShape());
//We will use the OptimizedBVH, AABB tree to cull potential child-overlaps
//If both proxies are Compound, we will deal with that directly, by performing sequential/parallel tree traversals
//given Proxy0 and Proxy1, if both have a tree, Tree0 and Tree1, this means:
//determine overlapping nodes of Proxy1 using Proxy0 AABB against Tree1
//then use each overlapping node AABB against Tree0
//and vise versa.
float hitFraction = 1f;
int numChildren = m_childCollisionAlgorithms.Count;
IndexedMatrix orgTrans;
float frac;
for (int i = 0; i < numChildren; i++)
{
//temporarily exchange parent btCollisionShape with childShape, and recurse
CollisionShape childShape = compoundShape.GetChildShape(i);
//backup
orgTrans = colObj.GetWorldTransform();
IndexedMatrix childTrans = compoundShape.GetChildTransform(i);
IndexedMatrix newChildWorldTrans = orgTrans * childTrans;
colObj.SetWorldTransform(ref newChildWorldTrans);
CollisionShape tmpShape = colObj.GetCollisionShape();
colObj.InternalSetTemporaryCollisionShape(childShape);
frac = m_childCollisionAlgorithms[i].CalculateTimeOfImpact(colObj, otherObj, dispatchInfo, resultOut);
if (frac < hitFraction)
{
hitFraction = frac;
}
//revert back
colObj.InternalSetTemporaryCollisionShape(tmpShape);
colObj.SetWorldTransform(ref orgTrans);
}
return(hitFraction);
}
/// objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest.
public static void ObjectQuerySingle(ConvexShape castShape, ref IndexedMatrix convexFromTrans, ref IndexedMatrix convexToTrans,
CollisionObject collisionObject, CollisionShape collisionShape,
ref IndexedMatrix colObjWorldTransform,
ConvexResultCallback resultCallback, float allowedPenetration)
{
if (collisionShape.IsConvex())
{
BulletGlobals.StartProfile("convexSweepConvex");
CastResult castResult = BulletGlobals.CastResultPool.Get();
castResult.m_allowedPenetration = allowedPenetration;
castResult.m_fraction = resultCallback.m_closestHitFraction;//float(1.);//??
ConvexShape convexShape = collisionShape as ConvexShape;
VoronoiSimplexSolver simplexSolver = BulletGlobals.VoronoiSimplexSolverPool.Get();
GjkEpaPenetrationDepthSolver gjkEpaPenetrationSolver = BulletGlobals.GjkEpaPenetrationDepthSolverPool.Get();
ContinuousConvexCollision convexCaster1 = BulletGlobals.ContinuousConvexCollisionPool.Get();
convexCaster1.Initialize(castShape, convexShape, simplexSolver, gjkEpaPenetrationSolver);
//btGjkConvexCast convexCaster2(castShape,convexShape,&simplexSolver);
//btSubsimplexConvexCast convexCaster3(castShape,convexShape,&simplexSolver);
IConvexCast castPtr = convexCaster1;
if (castPtr.CalcTimeOfImpact(ref convexFromTrans, ref convexToTrans, ref colObjWorldTransform, ref colObjWorldTransform, castResult))
{
//add hit
if (castResult.m_normal.LengthSquared() > 0.0001f)
{
if (castResult.m_fraction < resultCallback.m_closestHitFraction)
{
castResult.m_normal.Normalize();
LocalConvexResult localConvexResult = new LocalConvexResult
(
collisionObject,
//null, // updated to allow different ctor on struct
ref castResult.m_normal,
ref castResult.m_hitPoint,
castResult.m_fraction
);
bool normalInWorldSpace = true;
resultCallback.AddSingleResult(ref localConvexResult, normalInWorldSpace);
}
}
}
BulletGlobals.ContinuousConvexCollisionPool.Free(convexCaster1);
BulletGlobals.GjkEpaPenetrationDepthSolverPool.Free(gjkEpaPenetrationSolver);
BulletGlobals.VoronoiSimplexSolverPool.Free(simplexSolver);
castResult.Cleanup();
BulletGlobals.StopProfile();
}
else
{
if (collisionShape.IsConcave())
{
if (collisionShape.GetShapeType() == BroadphaseNativeTypes.TRIANGLE_MESH_SHAPE_PROXYTYPE)
{
BulletGlobals.StartProfile("convexSweepbtBvhTriangleMesh");
BvhTriangleMeshShape triangleMesh = (BvhTriangleMeshShape)collisionShape;
IndexedMatrix worldTocollisionObject = colObjWorldTransform.Inverse();
IndexedVector3 convexFromLocal = worldTocollisionObject * convexFromTrans._origin;
IndexedVector3 convexToLocal = worldTocollisionObject * convexToTrans._origin;
// rotation of box in local mesh space = MeshRotation^-1 * ConvexToRotation
IndexedMatrix rotationXform = new IndexedMatrix(worldTocollisionObject._basis * convexToTrans._basis,new IndexedVector3(0));
using (BridgeTriangleConvexcastCallback tccb = BulletGlobals.BridgeTriangleConvexcastCallbackPool.Get())
{
tccb.Initialize(castShape, ref convexFromTrans, ref convexToTrans, resultCallback, collisionObject, triangleMesh, ref colObjWorldTransform);
tccb.m_hitFraction = resultCallback.m_closestHitFraction;
tccb.m_allowedPenetration = allowedPenetration;
IndexedVector3 boxMinLocal;
IndexedVector3 boxMaxLocal;
castShape.GetAabb(ref rotationXform, out boxMinLocal, out boxMaxLocal);
triangleMesh.PerformConvexCast(tccb, ref convexFromLocal, ref convexToLocal, ref boxMinLocal, ref boxMaxLocal);
}
BulletGlobals.StopProfile();
}
else
{
if (collisionShape.GetShapeType() == BroadphaseNativeTypes.STATIC_PLANE_PROXYTYPE)
{
CastResult castResult = BulletGlobals.CastResultPool.Get();
castResult.m_allowedPenetration = allowedPenetration;
castResult.m_fraction = resultCallback.m_closestHitFraction;
StaticPlaneShape planeShape = collisionShape as StaticPlaneShape;
ContinuousConvexCollision convexCaster1 = new ContinuousConvexCollision(castShape, planeShape);
if (convexCaster1.CalcTimeOfImpact(ref convexFromTrans, ref convexToTrans, ref colObjWorldTransform, ref colObjWorldTransform, castResult))
{
//add hit
if (castResult.m_normal.LengthSquared() > 0.0001f)
{
if (castResult.m_fraction < resultCallback.m_closestHitFraction)
{
castResult.m_normal.Normalize();
LocalConvexResult localConvexResult = new LocalConvexResult
(
collisionObject,
//null, // updated to allow different ctor on struct
ref castResult.m_normal,
ref castResult.m_hitPoint,
castResult.m_fraction
);
bool normalInWorldSpace = true;
resultCallback.AddSingleResult(ref localConvexResult, normalInWorldSpace);
}
}
}
castResult.Cleanup();
}
else
{
BulletGlobals.StartProfile("convexSweepConcave");
ConcaveShape concaveShape = (ConcaveShape)collisionShape;
IndexedMatrix worldTocollisionObject = colObjWorldTransform.Inverse();
IndexedVector3 convexFromLocal = worldTocollisionObject * convexFromTrans._origin;
IndexedVector3 convexToLocal = worldTocollisionObject * convexToTrans._origin;
// rotation of box in local mesh space = MeshRotation^-1 * ConvexToRotation
IndexedMatrix rotationXform = new IndexedMatrix(worldTocollisionObject._basis * convexToTrans._basis, new IndexedVector3(0));
using (BridgeTriangleConvexcastCallback tccb = BulletGlobals.BridgeTriangleConvexcastCallbackPool.Get())
{
tccb.Initialize(castShape, ref convexFromTrans, ref convexToTrans, resultCallback, collisionObject, concaveShape, ref colObjWorldTransform);
tccb.m_hitFraction = resultCallback.m_closestHitFraction;
tccb.m_allowedPenetration = allowedPenetration;
IndexedVector3 boxMinLocal;
IndexedVector3 boxMaxLocal;
castShape.GetAabb(ref rotationXform, out boxMinLocal, out boxMaxLocal);
IndexedVector3 rayAabbMinLocal = convexFromLocal;
MathUtil.VectorMin(ref convexToLocal, ref rayAabbMinLocal);
//rayAabbMinLocal.setMin(convexToLocal);
IndexedVector3 rayAabbMaxLocal = convexFromLocal;
//rayAabbMaxLocal.setMax(convexToLocal);
MathUtil.VectorMax(ref convexToLocal, ref rayAabbMaxLocal);
rayAabbMinLocal += boxMinLocal;
rayAabbMaxLocal += boxMaxLocal;
concaveShape.ProcessAllTriangles(tccb, ref rayAabbMinLocal, ref rayAabbMaxLocal);
BulletGlobals.StopProfile();
}
}
}
}
else
{
///@todo : use AABB tree or other BVH acceleration structure!
if (collisionShape.IsCompound())
{
BulletGlobals.StartProfile("convexSweepCompound");
CompoundShape compoundShape = (CompoundShape)collisionShape;
for (int i = 0; i < compoundShape.GetNumChildShapes(); i++)
{
IndexedMatrix childTrans = compoundShape.GetChildTransform(i);
CollisionShape childCollisionShape = compoundShape.GetChildShape(i);
IndexedMatrix childWorldTrans = colObjWorldTransform * childTrans;
// replace collision shape so that callback can determine the triangle
CollisionShape saveCollisionShape = collisionObject.GetCollisionShape();
collisionObject.InternalSetTemporaryCollisionShape(childCollisionShape);
LocalInfoAdder my_cb = new LocalInfoAdder(i, resultCallback);
my_cb.m_closestHitFraction = resultCallback.m_closestHitFraction;
ObjectQuerySingle(castShape, ref convexFromTrans, ref convexToTrans,
collisionObject,
childCollisionShape,
ref childWorldTrans,
my_cb, allowedPenetration);
// restore
collisionObject.InternalSetTemporaryCollisionShape(saveCollisionShape);
}
BulletGlobals.StopProfile();
}
}
}
}
protected void ConvexVsConvexCollision(CollisionObject body0,
CollisionObject body1,
CollisionShape shape0,
CollisionShape shape1)
{
CollisionShape tmpShape0 = body0.GetCollisionShape();
CollisionShape tmpShape1 = body1.GetCollisionShape();
body0.InternalSetTemporaryCollisionShape(shape0);
body1.InternalSetTemporaryCollisionShape(shape1);
if (BulletGlobals.g_streamWriter != null && BulletGlobals.debugGimpactAlgo)
{
BulletGlobals.g_streamWriter.WriteLine("GImpactAglo::ConvexVsConvex");
}
m_resultOut.SetShapeIdentifiersA(m_part0, m_triface0);
m_resultOut.SetShapeIdentifiersB(m_part1, m_triface1);
CheckConvexAlgorithm(body0, body1);
m_convex_algorithm.ProcessCollision(body0, body1, m_dispatchInfo, m_resultOut);
body0.InternalSetTemporaryCollisionShape(tmpShape0);
body1.InternalSetTemporaryCollisionShape(tmpShape1);
}
protected void ShapeVsShapeCollision(
CollisionObject body0,
CollisionObject body1,
CollisionShape shape0,
CollisionShape shape1)
{
CollisionShape tmpShape0 = body0.GetCollisionShape();
CollisionShape tmpShape1 = body1.GetCollisionShape();
body0.InternalSetTemporaryCollisionShape(shape0);
body1.InternalSetTemporaryCollisionShape(shape1);
if (BulletGlobals.g_streamWriter != null && BulletGlobals.debugGimpactAlgo)
{
BulletGlobals.g_streamWriter.WriteLine("GImpactAglo::ShapeVsShape");
}
{
CollisionAlgorithm algor = NewAlgorithm(body0, body1);
// post : checkManifold is called
m_resultOut.SetShapeIdentifiersA(m_part0, m_triface0);
m_resultOut.SetShapeIdentifiersB(m_part1, m_triface1);
algor.ProcessCollision(body0, body1, m_dispatchInfo, m_resultOut);
m_dispatcher.FreeCollisionAlgorithm(algor);
}
body0.InternalSetTemporaryCollisionShape(tmpShape0);
body1.InternalSetTemporaryCollisionShape(tmpShape1);
}
public void ProcessChildShape(CollisionShape childShape, int index)
{
Debug.Assert(index >= 0);
CompoundShape compoundShape = (CompoundShape)(m_compoundColObj.GetCollisionShape());
Debug.Assert(index < compoundShape.GetNumChildShapes());
//backup
IndexedMatrix orgTrans = m_compoundColObj.GetWorldTransform();
IndexedMatrix orgInterpolationTrans = m_compoundColObj.GetInterpolationWorldTransform();
IndexedMatrix childTrans = compoundShape.GetChildTransform(index);
IndexedMatrix newChildWorldTrans = orgTrans * childTrans;
//perform an AABB check first
IndexedVector3 aabbMin0;
IndexedVector3 aabbMax0;
IndexedVector3 aabbMin1;
IndexedVector3 aabbMax1;
childShape.GetAabb(ref newChildWorldTrans, out aabbMin0, out aabbMax0);
m_otherObj.GetCollisionShape().GetAabb(m_otherObj.GetWorldTransform(), out aabbMin1, out aabbMax1);
if (AabbUtil2.TestAabbAgainstAabb2(ref aabbMin0, ref aabbMax0, ref aabbMin1, ref aabbMax1))
{
m_compoundColObj.SetWorldTransform(ref newChildWorldTrans);
m_compoundColObj.SetInterpolationWorldTransform(ref newChildWorldTrans);
//the contactpoint is still projected back using the original inverted worldtrans
CollisionShape tmpShape = m_compoundColObj.GetCollisionShape();
m_compoundColObj.InternalSetTemporaryCollisionShape(childShape);
if (m_childCollisionAlgorithms[index] == null)
{
m_childCollisionAlgorithms[index] = m_dispatcher.FindAlgorithm(m_compoundColObj, m_otherObj, m_sharedManifold);
if (m_childCollisionAlgorithms[index] == m_parent)
{
int ibreak = 0;
}
}
///detect swapping case
if (m_resultOut.GetBody0Internal() == m_compoundColObj)
{
m_resultOut.SetShapeIdentifiersA(-1, index);
}
else
{
m_resultOut.SetShapeIdentifiersB(-1, index);
}
m_childCollisionAlgorithms[index].ProcessCollision(m_compoundColObj, m_otherObj, m_dispatchInfo, m_resultOut);
if (m_dispatchInfo.getDebugDraw() != null && (((m_dispatchInfo.getDebugDraw().GetDebugMode() & DebugDrawModes.DBG_DrawAabb)) != 0))
{
IndexedVector3 worldAabbMin = IndexedVector3.Zero, worldAabbMax = IndexedVector3.Zero;
m_dispatchInfo.getDebugDraw().DrawAabb(aabbMin0, aabbMax0, new IndexedVector3(1, 1, 1));
m_dispatchInfo.getDebugDraw().DrawAabb(aabbMin1, aabbMax1, new IndexedVector3(1, 1, 1));
}
//revert back transform
m_compoundColObj.InternalSetTemporaryCollisionShape(tmpShape);
m_compoundColObj.SetWorldTransform(ref orgTrans);
m_compoundColObj.SetInterpolationWorldTransform(ref orgInterpolationTrans);
}
}