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 ); } }