//by default, Bullet will use this near callback public static void DefaultNearCallback(ref BroadphasePair collisionPair, CollisionDispatcher dispatcher, DispatcherInfo dispatchInfo) { CollisionObject collisionObjectA = collisionPair.ProxyA.ClientData as CollisionObject; CollisionObject collisionObjectB = collisionPair.ProxyB.ClientData as CollisionObject; if (dispatcher.NeedsCollision(collisionObjectA, collisionObjectB)) { //dispatcher will keep algorithms persistent in the collision pair if (collisionPair.CollisionAlgorithm == null) { collisionPair.CollisionAlgorithm = dispatcher.FindAlgorithm(collisionObjectA, collisionObjectB); } if (collisionPair.CollisionAlgorithm != null) { ManifoldResult contactPointResult = new ManifoldResult(collisionObjectA, collisionObjectB); if (dispatchInfo.DispatchFunction == DispatchFunction.Discrete) { //discrete collision detection query collisionPair.CollisionAlgorithm.ProcessCollision(collisionObjectA, collisionObjectB, dispatchInfo, contactPointResult); } else { //continuous collision detection query, time of impact (toi) float timeOfImpact = collisionPair.CollisionAlgorithm.CalculateTimeOfImpact(collisionObjectA, collisionObjectB, dispatchInfo, contactPointResult); if (dispatchInfo.TimeOfImpact > timeOfImpact) { dispatchInfo.TimeOfImpact = timeOfImpact; } } } } }
public BroadphasePair(BroadphasePair other) { _proxyA = other._proxyA; _proxyB = other._proxyB; _algorithm = other._algorithm; _userInfo = null; }
public void RemoveOverlappingPair(BroadphasePair pair) { if (!_overlappingPairs.Contains(pair)) return; CleanOverlappingPair(ref pair); _overlappingPairs.Remove(pair); }
public override void ProcessAllOverlappingPairs(IOverlapCallback callback) { OverlappingPairs.Sort(new Comparison <BroadphasePair>(BroadphasePair.ComparisonSort)); if (_invalidPair != 0) { OverlappingPairs.RemoveRange(OverlappingPairs.Count - _invalidPair, _invalidPair); } _invalidPair = 0; BroadphasePair previousPair = new BroadphasePair(); previousPair.ProxyA = null; previousPair.ProxyB = null; previousPair.CollisionAlgorithm = null; List <BroadphasePair> removal = new List <BroadphasePair>(); for (int i = 0; i < OverlappingPairs.Count; i++) { bool isDuplicate = (OverlappingPairs[i] == previousPair); previousPair = OverlappingPairs[i]; bool needsRemoval; if (!isDuplicate) { bool hasOverlap = TestOverlap(previousPair.ProxyA, previousPair.ProxyB); if (hasOverlap) { needsRemoval = callback.ProcessOverlap(ref previousPair); } else { needsRemoval = true; } } else { needsRemoval = true; BulletDebug.Assert(previousPair.CollisionAlgorithm == null); } if (needsRemoval) { removal.Add(previousPair); } } for (int i = 0; i < removal.Count; i++) { BroadphasePair pair = removal[i]; CleanOverlappingPair(ref pair); pair.ProxyA = null; pair.ProxyB = null; _invalidPair++; OverlappingPairCount--; } }
public void CleanOverlappingPair(ref BroadphasePair pair) { if (pair.CollisionAlgorithm != null) { if (pair.CollisionAlgorithm is IDisposable) (pair.CollisionAlgorithm as IDisposable).Dispose(); pair.CollisionAlgorithm = null; } }
public void RemoveOverlappingPair(BroadphasePair pair) { if (!_overlappingPairs.Contains(pair)) { return; } CleanOverlappingPair(ref pair); _overlappingPairs.Remove(pair); }
public void CleanOverlappingPair(ref BroadphasePair pair) { if (pair.CollisionAlgorithm != null) { if (pair.CollisionAlgorithm is IDisposable) { (pair.CollisionAlgorithm as IDisposable).Dispose(); } pair.CollisionAlgorithm = null; } }
public void RemoveOverlappingPairsContainingProxy(BroadphaseProxy proxy) { for (int i = _overlappingPairs.Count - 1; i >= 0; i--) { BroadphasePair pair = _overlappingPairs[i]; if (pair.ProxyA == proxy || pair.ProxyB == proxy) { RemoveOverlappingPair(pair); i++; } } }
public void CleanProxyFromPairs(BroadphaseProxy proxy) { for (int i = 0; i < _overlappingPairs.Count; i++) { BroadphasePair pair = _overlappingPairs[i]; if (pair.ProxyA == proxy || pair.ProxyB == proxy) { CleanOverlappingPair(ref pair); _overlappingPairs[i] = pair; } } }
public void AddOverlappingPair(BroadphaseProxy proxyA, BroadphaseProxy proxyB) { //don't add overlap with own bool test = proxyA != proxyB; BulletDebug.Assert(proxyA != proxyB); if (!NeedsBroadphaseCollision(proxyA, proxyB)) return; BroadphasePair pair = new BroadphasePair(proxyA, proxyB); _overlappingPairs.Add(pair); _overlappingPairCount++; }
public static int ComparisonSort(BroadphasePair a, BroadphasePair b) { int aAId = a.ProxyA != null ? a.ProxyA.ComparisonID : -1; int aBId = a.ProxyB != null ? a.ProxyB.ComparisonID : -1; int aCId = a.CollisionAlgorithm != null ? a.CollisionAlgorithm.ComparisonID : -1; int bAId = b.ProxyA != null ? b.ProxyA.ComparisonID : -1; int bBId = b.ProxyB != null ? b.ProxyB.ComparisonID : -1; int bCId = b.CollisionAlgorithm != null ? b.CollisionAlgorithm.ComparisonID : -1; if (aAId > bAId || (a.ProxyA == b.ProxyA && aBId > bBId) || (a.ProxyA == b.ProxyA && a.ProxyB == b.ProxyB && aCId > bCId)) return -1; else return 1; }
//this FindPair becomes really slow. Either sort the list to speedup the query, or //use a different solution. It is mainly used for Removing overlapping pairs. Removal could be delayed. //we could keep a linked list in each proxy, and store pair in one of the proxies (with lowest memory address) //Also we can use a 2D bitmap, which can be useful for a future GPU implementation public BroadphasePair FindPair(BroadphaseProxy proxyA, BroadphaseProxy proxyB) { if (!NeedsBroadphaseCollision(proxyA, proxyB)) return null; BroadphasePair pair = new BroadphasePair(proxyA, proxyB); for (int i = 0; i < _overlappingPairs.Count; i++) { if (_overlappingPairs[i] == pair) { return _overlappingPairs[i]; } } return null; }
public void AddOverlappingPair(BroadphaseProxy proxyA, BroadphaseProxy proxyB) { //don't add overlap with own bool test = proxyA != proxyB; BulletDebug.Assert(proxyA != proxyB); if (!NeedsBroadphaseCollision(proxyA, proxyB)) { return; } BroadphasePair pair = new BroadphasePair(proxyA, proxyB); _overlappingPairs.Add(pair); _overlappingPairCount++; }
//this FindPair becomes really slow. Either sort the list to speedup the query, or //use a different solution. It is mainly used for Removing overlapping pairs. Removal could be delayed. //we could keep a linked list in each proxy, and store pair in one of the proxies (with lowest memory address) //Also we can use a 2D bitmap, which can be useful for a future GPU implementation public BroadphasePair FindPair(BroadphaseProxy proxyA, BroadphaseProxy proxyB) { if (!NeedsBroadphaseCollision(proxyA, proxyB)) { return(null); } BroadphasePair pair = new BroadphasePair(proxyA, proxyB); for (int i = 0; i < _overlappingPairs.Count; i++) { if (_overlappingPairs[i] == pair) { return(_overlappingPairs[i]); } } return(null); }
public virtual void ProcessAllOverlappingPairs(IOverlapCallback callback) { List <BroadphasePair> deleting = new List <BroadphasePair>(); for (int i = 0; i < _overlappingPairs.Count; i++) { BroadphasePair p = _overlappingPairs[i]; if (callback.ProcessOverlap(ref p)) { CleanOverlappingPair(ref p); deleting.Add(p); _overlappingPairCount--; } } for (int i = 0; i < deleting.Count; i++) { _overlappingPairs.Remove(deleting[i]); } }
public static int ComparisonSort(BroadphasePair a, BroadphasePair b) { int aAId = a.ProxyA != null ? a.ProxyA.ComparisonID : -1; int aBId = a.ProxyB != null ? a.ProxyB.ComparisonID : -1; int aCId = a.CollisionAlgorithm != null ? a.CollisionAlgorithm.ComparisonID : -1; int bAId = b.ProxyA != null ? b.ProxyA.ComparisonID : -1; int bBId = b.ProxyB != null ? b.ProxyB.ComparisonID : -1; int bCId = b.CollisionAlgorithm != null ? b.CollisionAlgorithm.ComparisonID : -1; if (aAId > bAId || (a.ProxyA == b.ProxyA && aBId > bBId) || (a.ProxyA == b.ProxyA && a.ProxyB == b.ProxyB && aCId > bCId)) { return(-1); } else { return(1); } }
//by default, Bullet will use this near callback public static void DefaultNearCallback(ref BroadphasePair collisionPair, CollisionDispatcher dispatcher, DispatcherInfo dispatchInfo) { CollisionObject collisionObjectA = collisionPair.ProxyA.ClientData as CollisionObject; CollisionObject collisionObjectB = collisionPair.ProxyB.ClientData as CollisionObject; if (dispatcher.NeedsCollision(collisionObjectA, collisionObjectB)) { //dispatcher will keep algorithms persistent in the collision pair if (collisionPair.CollisionAlgorithm == null) { collisionPair.CollisionAlgorithm = dispatcher.FindAlgorithm(collisionObjectA, collisionObjectB); } if (collisionPair.CollisionAlgorithm != null) { ManifoldResult contactPointResult = new ManifoldResult(collisionObjectA, collisionObjectB); if (dispatchInfo.DispatchFunction == DispatchFunction.Discrete) { //discrete collision detection query collisionPair.CollisionAlgorithm.ProcessCollision(collisionObjectA, collisionObjectB, dispatchInfo, contactPointResult); } else { //continuous collision detection query, time of impact (toi) float timeOfImpact = collisionPair.CollisionAlgorithm.CalculateTimeOfImpact(collisionObjectA, collisionObjectB, dispatchInfo, contactPointResult); if (dispatchInfo.TimeOfImpact > timeOfImpact) dispatchInfo.TimeOfImpact = timeOfImpact; } } } }
public bool ProcessOverlap(ref BroadphasePair pair) { _dispatcher.NearCallback(ref pair, _dispatcher, _dispatchInfo); return false; }
public override void ProcessAllOverlappingPairs(IOverlapCallback callback) { OverlappingPairs.Sort(new Comparison<BroadphasePair>(BroadphasePair.ComparisonSort)); if (_invalidPair != 0) OverlappingPairs.RemoveRange(OverlappingPairs.Count - _invalidPair, _invalidPair); _invalidPair = 0; BroadphasePair previousPair = new BroadphasePair(); previousPair.ProxyA = null; previousPair.ProxyB = null; previousPair.CollisionAlgorithm = null; List<BroadphasePair> removal = new List<BroadphasePair>(); for (int i = 0; i < OverlappingPairs.Count; i++) { bool isDuplicate = (OverlappingPairs[i] == previousPair); previousPair = OverlappingPairs[i]; bool needsRemoval; if (!isDuplicate) { bool hasOverlap = TestOverlap(previousPair.ProxyA, previousPair.ProxyB); if (hasOverlap) { needsRemoval = callback.ProcessOverlap(ref previousPair); } else { needsRemoval = true; } } else { needsRemoval = true; BulletDebug.Assert(previousPair.CollisionAlgorithm == null); } if (needsRemoval) { removal.Add(previousPair); } } for (int i = 0; i < removal.Count; i++) { BroadphasePair pair = removal[i]; CleanOverlappingPair(ref pair); pair.ProxyA = null; pair.ProxyB = null; _invalidPair++; OverlappingPairCount--; } }
public bool ProcessOverlap(ref BroadphasePair pair) { return (!SimpleBroadphase.AabbOverlap(pair.ProxyA as SimpleBroadphaseProxy, pair.ProxyB as SimpleBroadphaseProxy)); }
public bool ProcessOverlap(ref BroadphasePair pair) { _dispatcher.NearCallback(ref pair, _dispatcher, _dispatchInfo); return(false); }
public bool ProcessOverlap(ref BroadphasePair pair) { return(!SimpleBroadphase.AabbOverlap(pair.ProxyA as SimpleBroadphaseProxy, pair.ProxyB as SimpleBroadphaseProxy)); }