internal override void getAllContactManifolds( btManifoldArray manifoldArray)
{
if( m_manifoldPtr != null && m_ownManifold )
{
manifoldArray.Add( m_manifoldPtr );
}
}
virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
{
if (m_manifoldPtr && m_ownManifold)
{
manifoldArray.Add(m_manifoldPtr);
}
}
internal override void getAllContactManifolds( btManifoldArray manifoldArray )
{
int i;
for( i = 0; i < m_childCollisionAlgorithms.Count; i++ )
{
if( m_childCollisionAlgorithms[i] != null )
m_childCollisionAlgorithms[i].getAllContactManifolds( manifoldArray );
}
}
internal override void processCollision( btCollisionObjectWrapper body0Wrap
, ref btTransform body0Transform
, btCollisionObjectWrapper body1Wrap
, ref btTransform body1Transform
, btDispatcherInfo dispatchInfo, btManifoldResult resultOut )
{
btCollisionObjectWrapper colObjWrap = m_isSwapped ? body1Wrap : body0Wrap;
btCollisionObjectWrapper otherObjWrap = m_isSwapped ? body0Wrap : body1Wrap;
Debug.Assert( colObjWrap.getCollisionShape().isCompound() );
btCompoundShape compoundShape = (btCompoundShape)( colObjWrap.getCollisionShape() );
///btCompoundShape might have changed:
////make sure the internal child collision algorithm caches are still valid
if( compoundShape.getUpdateRevision() != m_compoundShapeRevision )
{
///clear and update all
removeChildAlgorithms();
preallocateChildAlgorithms( body0Wrap, body1Wrap );
m_compoundShapeRevision = compoundShape.getUpdateRevision();
}
if( m_childCollisionAlgorithms.Count == 0 )
return;
btDbvt tree = compoundShape.getDynamicAabbTree();
//use a dynamic aabb tree to cull potential child-overlaps
btCompoundLeafCallback callback = BulletGlobals.CompoundLeafCallbackPool.Get();
callback.Initialize( colObjWrap, otherObjWrap, m_dispatcher, dispatchInfo, resultOut, m_childCollisionAlgorithms.InternalArray, m_sharedManifold);
///we need to refresh all contact manifolds
///note that we should actually recursively traverse all children, btCompoundShape can nested more then 1 level deep
///so we should add a 'refreshManifolds' in the btCollisionAlgorithm
{
int i;
btManifoldArray manifoldArray = new btManifoldArray();
for( i = 0; i < m_childCollisionAlgorithms.Count; i++ )
{
if( m_childCollisionAlgorithms[i] != null )
{
m_childCollisionAlgorithms[i].getAllContactManifolds( manifoldArray );
for( int m = 0; m < manifoldArray.Count; m++ )
{
if( manifoldArray[m].m_cachedPoints > 0 )
{
resultOut.setPersistentManifold( manifoldArray[m] );
resultOut.refreshContactPoints();
resultOut.setPersistentManifold( null );//??necessary?
}
}
manifoldArray.Count = ( 0 );
}
}
}
if( tree != null )
{
btVector3 localAabbMin, localAabbMax;
btTransform otherInCompoundSpace;
if( m_isSwapped )
body1Transform.inverseTimes(ref body0Transform, out otherInCompoundSpace);
else
body0Transform.inverseTimes( ref body1Transform, out otherInCompoundSpace );
otherObjWrap.getCollisionShape().getAabb( ref otherInCompoundSpace, out localAabbMin, out localAabbMax );
btDbvt.btDbvtVolume bounds = btDbvt.btDbvtVolume.FromMM( ref localAabbMin, ref localAabbMax );
//process all children, that overlap with the given AABB bounds
btDbvt.CollideTV( tree.m_root, ref bounds, callback );
}
else
{
//iterate over all children, perform an AABB check inside ProcessChildShape
int numChildren = m_childCollisionAlgorithms.Count;
int i;
for( i = 0; i < numChildren; i++ )
{
callback.ProcessChildShape( compoundShape.getChildShape( i ), i );
}
}
{
//iterate over all children, perform an AABB check inside ProcessChildShape
int numChildren = m_childCollisionAlgorithms.Count;
int i;
//btManifoldArray manifoldArray;
btCollisionShape childShape = null;
//btITransform orgTrans;
btTransform newChildWorldTrans;
btVector3 aabbMin0, aabbMax0, aabbMin1, aabbMax1;
for( i = 0; i < numChildren; i++ )
{
if( m_childCollisionAlgorithms[i] != null )
{
childShape = compoundShape.getChildShape( i );
//if not longer overlapping, remove the algorithm
//orgTrans = colObjWrap.m_worldTransform;
//btTransform childTrans = compoundShape.getChildTransform( i );
( ( m_isSwapped ) ? body1Transform : body0Transform ).Apply( ref compoundShape.m_children.InternalArray[i].m_transform, out newChildWorldTrans );
//perform an AABB check first
childShape.getAabb( ref newChildWorldTrans, out aabbMin0, out aabbMax0 );
if( m_isSwapped )
otherObjWrap.m_shape.getAabb( ref body0Transform, out aabbMin1, out aabbMax1 );
else
otherObjWrap.m_shape.getAabb( ref body1Transform, out aabbMin1, out aabbMax1 );
if( !btAabbUtil.TestAabbAgainstAabb2( ref aabbMin0, ref aabbMax0, ref aabbMin1, ref aabbMax1 ) )
{
//m_childCollisionAlgorithms[i].~btCollisionAlgorithm();
m_dispatcher.freeCollisionAlgorithm( m_childCollisionAlgorithms[i] );
m_childCollisionAlgorithms[i] = null;
}
}
}
}
}
internal override void getAllContactManifolds( btManifoldArray manifoldArray )
{
}
internal override void getAllContactManifolds( btManifoldArray manifoldArray )
{
///should we use m_ownManifold to avoid adding duplicates?
if( m_manifoldPtr != null && m_ownManifold )
manifoldArray.Add( m_manifoldPtr );
}
internal override void processCollision( btCollisionObjectWrapper body0Wrap
, ref btTransform body0Transform
, btCollisionObjectWrapper body1Wrap
, ref btTransform body1Transform
, btDispatcherInfo dispatchInfo, btManifoldResult resultOut )
{
btCollisionObjectWrapper col0ObjWrap = body0Wrap;
btCollisionObjectWrapper col1ObjWrap = body1Wrap;
Debug.Assert( col0ObjWrap.getCollisionShape().isCompound() );
Debug.Assert( col1ObjWrap.getCollisionShape().isCompound() );
btCompoundShape compoundShape0 = (btCompoundShape)( col0ObjWrap.getCollisionShape() );
btCompoundShape compoundShape1 = (btCompoundShape)( col1ObjWrap.getCollisionShape() );
btDbvt tree0 = compoundShape0.getDynamicAabbTree();
btDbvt tree1 = compoundShape1.getDynamicAabbTree();
if( tree0 == null || tree1 == null )
{
base.processCollision( body0Wrap, ref body0Transform, body1Wrap, ref body1Transform, dispatchInfo, resultOut );
return;
}
///btCompoundShape might have changed:
////make sure the internal child collision algorithm caches are still valid
if( ( compoundShape0.getUpdateRevision() != m_compoundShapeRevision0 ) || ( compoundShape1.getUpdateRevision() != m_compoundShapeRevision1 ) )
{
///clear all
removeChildAlgorithms();
m_compoundShapeRevision0 = compoundShape0.getUpdateRevision();
m_compoundShapeRevision1 = compoundShape1.getUpdateRevision();
}
///we need to refresh all contact manifolds
///note that we should actually recursively traverse all children, btCompoundShape can nested more then 1 level deep
///so we should add a 'refreshManifolds' in the btCollisionAlgorithm
{
int i;
btManifoldArray manifoldArray = new btManifoldArray();
btSimplePairArray pairs = m_childCollisionAlgorithmCache.getOverlappingPairArray();
for( i = 0; i < pairs.Count; i++ )
{
if( pairs[i].m_userPointer != null )
{
btCollisionAlgorithm algo = (btCollisionAlgorithm)pairs[i].m_userPointer;
algo.getAllContactManifolds( manifoldArray );
for( int m = 0; m < manifoldArray.Count; m++ )
{
if( manifoldArray[m].m_cachedPoints != 0 )
{
resultOut.setPersistentManifold( manifoldArray[m] );
resultOut.refreshContactPoints();
resultOut.setPersistentManifold( null );
}
}
manifoldArray.Count =( 0 );
}
}
}
btCompoundCompoundLeafCallback callback = new btCompoundCompoundLeafCallback
( col0ObjWrap, col1ObjWrap,this.m_dispatcher, dispatchInfo, resultOut, this.m_childCollisionAlgorithmCache, m_sharedManifold);
btTransform xform; body0Transform.inverseTimes( ref body1Transform, out xform );
MycollideTT( tree0.m_root, tree1.m_root, ref xform, callback );
//Console.WriteLine("#compound-compound child/leaf overlap =%d \r",callback.m_numOverlapPairs);
//remove non-overlapping child pairs
{
Debug.Assert( m_removePairs.Count == 0 );
//iterate over all children, perform an AABB check inside ProcessChildShape
btSimplePairArray pairs = m_childCollisionAlgorithmCache.getOverlappingPairArray();
int i;
//btManifoldArray manifoldArray;
btVector3 aabbMin0, aabbMax0, aabbMin1, aabbMax1;
for( i = 0; i < pairs.Count; i++ )
{
if( pairs[i].m_userPointer != null )
{
btCollisionAlgorithm algo = (btCollisionAlgorithm)pairs[i].m_userPointer;
{
btCollisionShape childShape0 = null;
btTransform newChildWorldTrans0;
//btTransform orgInterpolationTrans0;
childShape0 = compoundShape0.getChildShape( pairs[i].m_indexA );
//orgInterpolationTrans0 = col0ObjWrap.m_worldTransform;
btTransform childTrans0 = compoundShape0.getChildTransform( pairs[i].m_indexA );
body0Transform.Apply( ref childTrans0, out newChildWorldTrans0 );
childShape0.getAabb( ref newChildWorldTrans0, out aabbMin0, out aabbMax0 );
}
{
btCollisionShape childShape1 = null;
btTransform newChildWorldTrans1;
childShape1 = compoundShape1.getChildShape( pairs[i].m_indexB );
btTransform childTrans1 = compoundShape1.getChildTransform( pairs[i].m_indexB );
body1Transform.Apply( ref childTrans1, out newChildWorldTrans1 );
childShape1.getAabb( ref newChildWorldTrans1, out aabbMin1, out aabbMax1 );
}
if( !btAabbUtil.TestAabbAgainstAabb2( ref aabbMin0, ref aabbMax0, ref aabbMin1, ref aabbMax1 ) )
{
//algo.~btCollisionAlgorithm();
m_dispatcher.freeCollisionAlgorithm( algo );
m_removePairs.Add( new btSimplePair( pairs[i].m_indexA, pairs[i].m_indexB ) );
}
}
}
for( i = 0; i < m_removePairs.Count; i++ )
{
m_childCollisionAlgorithmCache.removeOverlappingPair( m_removePairs[i].m_indexA, m_removePairs[i].m_indexB );
}
m_removePairs.Clear();
}
}
internal override void getAllContactManifolds( btManifoldArray manifoldArray )
{
int i;
btSimplePairArray pairs = m_childCollisionAlgorithmCache.getOverlappingPairArray();
for( i = 0; i < pairs.Count; i++ )
{
if( pairs[i].m_userPointer != null )
{
( (btCollisionAlgorithm)pairs[i].m_userPointer ).getAllContactManifolds( manifoldArray );
}
}
}
internal override void getAllContactManifolds( btManifoldArray manifoldArray )
{
if( m_btConvexTriangleCallback.m_manifoldPtr != null )
{
manifoldArray.Add( m_btConvexTriangleCallback.m_manifoldPtr );
}
}