/// <summary> /// Update the contact manifold and touching status. /// Note: do not assume the fixture AABBs are overlapping or are valid. /// </summary> /// <param name="contactManager">The contact manager.</param> internal void Update(ContactManager contactManager) { Body bodyA = FixtureA.Body; Body bodyB = FixtureB.Body; if (FixtureA == null || FixtureB == null) { return; } if (!ContactManager.CheckCollisionConditions(FixtureA, FixtureB)) { Enabled = false; return; } Manifold oldManifold = Manifold; // Re-enable this contact. Enabled = true; bool touching; bool wasTouching = IsTouching; bool sensor = FixtureA.IsSensor || FixtureB.IsSensor; // Is this contact a sensor? if (sensor) { Shape shapeA = FixtureA.Shape; Shape shapeB = FixtureB.Shape; touching = Collision.TestOverlap(shapeA, ChildIndexA, shapeB, ChildIndexB, ref bodyA._xf, ref bodyB._xf); // Sensors don't generate manifolds. Manifold.PointCount = 0; } else { Evaluate(ref Manifold, ref bodyA._xf, ref bodyB._xf); touching = Manifold.PointCount > 0; // Match old contact ids to new contact ids and copy the // stored impulses to warm start the solver. for (int i = 0; i < Manifold.PointCount; ++i) { ManifoldPoint mp2 = Manifold.Points[i]; mp2.NormalImpulse = 0.0f; mp2.TangentImpulse = 0.0f; ContactID id2 = mp2.Id; for (int j = 0; j < oldManifold.PointCount; ++j) { ManifoldPoint mp1 = oldManifold.Points[j]; if (mp1.Id.Key == id2.Key) { mp2.NormalImpulse = mp1.NormalImpulse; mp2.TangentImpulse = mp1.TangentImpulse; break; } } Manifold.Points[i] = mp2; } if (touching != wasTouching) { bodyA.Awake = true; bodyB.Awake = true; } } IsTouching = touching; if (wasTouching == false) { if (touching) { if (Settings.AllCollisionCallbacksAgree) { bool enabledA = true, enabledB = true; // Report the collision to both participants. Track which ones returned true so we can // later call OnSeparation if the contact is disabled for a different reason. if (FixtureA.OnCollision != null) { foreach (OnCollisionEventHandler handler in FixtureA.OnCollision.GetInvocationList()) { enabledA = handler(FixtureA, FixtureB, this) && enabledA; } } // Reverse the order of the reported fixtures. The first fixture is always the one that the // user subscribed to. if (FixtureB.OnCollision != null) { foreach (OnCollisionEventHandler handler in FixtureB.OnCollision.GetInvocationList()) { enabledB = handler(FixtureB, FixtureA, this) && enabledB; } } Enabled = enabledA && enabledB; // BeginContact can also return false and disable the contact if (enabledA && enabledB && contactManager.BeginContact != null) { Enabled = contactManager.BeginContact(this); } } else { //Report the collision to both participants: if (FixtureA.OnCollision != null) { foreach (OnCollisionEventHandler handler in FixtureA.OnCollision.GetInvocationList()) { Enabled = handler(FixtureA, FixtureB, this); } } //Reverse the order of the reported fixtures. The first fixture is always the one that the //user subscribed to. if (FixtureB.OnCollision != null) { foreach (OnCollisionEventHandler handler in FixtureB.OnCollision.GetInvocationList()) { Enabled = handler(FixtureB, FixtureA, this); } } //BeginContact can also return false and disable the contact if (contactManager.BeginContact != null) { Enabled = contactManager.BeginContact(this); } } // If the user disabled the contact (needed to exclude it in TOI solver) at any point by // any of the callbacks, we need to mark it as not touching and call any separation // callbacks for fixtures that didn't explicitly disable the collision. if (!Enabled) { IsTouching = false; } } } else { if (touching == false) { //Report the separation to both participants: if (FixtureA != null && FixtureA.OnSeparation != null) { FixtureA.OnSeparation(FixtureA, FixtureB); } //Reverse the order of the reported fixtures. The first fixture is always the one that the //user subscribed to. if (FixtureB != null && FixtureB.OnSeparation != null) { FixtureB.OnSeparation(FixtureB, FixtureA); } if (contactManager.EndContact != null) { contactManager.EndContact(this); } } else { if (contactManager.StayContact != null) { contactManager.StayContact(this); } } } if (sensor) { return; } if (contactManager.PreSolve != null) { contactManager.PreSolve(this, ref oldManifold); } }
internal void Collide() { for (int i = 0; i < this.ContactList.Count; i++) { Contact contact = this.ContactList[i]; Fixture fixtureA = contact.FixtureA; Fixture fixtureB = contact.FixtureB; int childIndexA = contact.ChildIndexA; int childIndexB = contact.ChildIndexB; Body body = fixtureA.Body; Body body2 = fixtureB.Body; bool flag = !body.Enabled || !body2.Enabled; if (!flag) { bool filterFlag = contact.FilterFlag; if (filterFlag) { bool flag2 = !body2.ShouldCollide(body); if (flag2) { Contact contact2 = contact; this.Destroy(contact2); goto IL_198; } bool flag3 = !ContactManager.ShouldCollide(fixtureA, fixtureB); if (flag3) { Contact contact3 = contact; this.Destroy(contact3); goto IL_198; } bool flag4 = this.ContactFilter != null && !this.ContactFilter(fixtureA, fixtureB); if (flag4) { Contact contact4 = contact; this.Destroy(contact4); goto IL_198; } contact.FilterFlag = false; } bool flag5 = body.Awake && body.BodyType > BodyType.Static; bool flag6 = body2.Awake && body2.BodyType > BodyType.Static; bool flag7 = !flag5 && !flag6; if (!flag7) { int proxyId = fixtureA.Proxies[childIndexA].ProxyId; int proxyId2 = fixtureB.Proxies[childIndexB].ProxyId; bool flag8 = this.BroadPhase.TestOverlap(proxyId, proxyId2); bool flag9 = !flag8; if (flag9) { Contact contact5 = contact; this.Destroy(contact5); } else { contact.Update(this); } } } IL_198 :; } }
private void AddPair(ref FixtureProxy proxyA, ref FixtureProxy proxyB) { Fixture fixture = proxyA.Fixture; Fixture fixture2 = proxyB.Fixture; int childIndex = proxyA.ChildIndex; int childIndex2 = proxyB.ChildIndex; Body body = fixture.Body; Body body2 = fixture2.Body; bool flag = body == body2; if (!flag) { for (ContactEdge contactEdge = body2.ContactList; contactEdge != null; contactEdge = contactEdge.Next) { bool flag2 = contactEdge.Other == body; if (flag2) { Fixture fixtureA = contactEdge.Contact.FixtureA; Fixture fixtureB = contactEdge.Contact.FixtureB; int childIndexA = contactEdge.Contact.ChildIndexA; int childIndexB = contactEdge.Contact.ChildIndexB; bool flag3 = fixtureA == fixture && fixtureB == fixture2 && childIndexA == childIndex && childIndexB == childIndex2; if (flag3) { return; } bool flag4 = fixtureA == fixture2 && fixtureB == fixture && childIndexA == childIndex2 && childIndexB == childIndex; if (flag4) { return; } } } bool flag5 = !body2.ShouldCollide(body); if (!flag5) { bool flag6 = !ContactManager.ShouldCollide(fixture, fixture2); if (!flag6) { bool flag7 = this.ContactFilter != null && !this.ContactFilter(fixture, fixture2); if (!flag7) { bool flag8 = fixture.BeforeCollision != null && !fixture.BeforeCollision(fixture, fixture2); if (!flag8) { bool flag9 = fixture2.BeforeCollision != null && !fixture2.BeforeCollision(fixture2, fixture); if (!flag9) { Body body3 = null; Body item = null; bool flag10 = body.SpecialSensor > BodySpecialSensor.None; if (flag10) { body3 = body; item = body2; } else { bool flag11 = body2.SpecialSensor > BodySpecialSensor.None; if (flag11) { body3 = body2; item = body; } } bool flag12 = body3 != null; if (flag12) { bool flag13 = Collision.TestOverlap(body.FixtureList[0].Shape, childIndex, body2.FixtureList[0].Shape, childIndex2, ref body._xf, ref body2._xf); if (!flag13) { return; } body3._specialSensorResults.Add(item); bool flag14 = body3.SpecialSensor == BodySpecialSensor.ActiveOnce; if (flag14) { body3.disabled = true; return; } } Contact contact = Contact.Create(fixture, childIndex, fixture2, childIndex2); bool flag15 = contact == null; if (!flag15) { fixture = contact.FixtureA; fixture2 = contact.FixtureB; body = fixture.Body; body2 = fixture2.Body; this.ContactList.Add(contact); contact._nodeA.Contact = contact; contact._nodeA.Other = body2; contact._nodeA.Prev = null; contact._nodeA.Next = body.ContactList; bool flag16 = body.ContactList != null; if (flag16) { body.ContactList.Prev = contact._nodeA; } body.ContactList = contact._nodeA; contact._nodeB.Contact = contact; contact._nodeB.Other = body; contact._nodeB.Prev = null; contact._nodeB.Next = body2.ContactList; bool flag17 = body2.ContactList != null; if (flag17) { body2.ContactList.Prev = contact._nodeB; } body2.ContactList = contact._nodeB; bool flag18 = !fixture.IsSensor && !fixture2.IsSensor; if (flag18) { body.Awake = true; body2.Awake = true; } } } } } } } } }
internal void Update(ContactManager contactManager) { Body body = this.FixtureA.Body; Body body2 = this.FixtureB.Body; bool flag = this.FixtureA == null || this.FixtureB == null; if (!flag) { bool flag2 = !ContactManager.CheckCollisionConditions(this.FixtureA, this.FixtureB); if (flag2) { this.Enabled = false; } else { Manifold manifold = this.Manifold; this.Enabled = true; bool isTouching = this.IsTouching; bool flag3 = this.FixtureA.IsSensor || this.FixtureB.IsSensor; bool flag4 = flag3; bool flag5; if (flag4) { Shape shape = this.FixtureA.Shape; Shape shape2 = this.FixtureB.Shape; flag5 = Collision.TestOverlap(shape, this.ChildIndexA, shape2, this.ChildIndexB, ref body._xf, ref body2._xf); this.Manifold.PointCount = 0; } else { this.Evaluate(ref this.Manifold, ref body._xf, ref body2._xf); flag5 = (this.Manifold.PointCount > 0); for (int i = 0; i < this.Manifold.PointCount; i++) { ManifoldPoint manifoldPoint = this.Manifold.Points[i]; manifoldPoint.NormalImpulse = 0f; manifoldPoint.TangentImpulse = 0f; ContactID id = manifoldPoint.Id; for (int j = 0; j < manifold.PointCount; j++) { ManifoldPoint manifoldPoint2 = manifold.Points[j]; bool flag6 = manifoldPoint2.Id.Key == id.Key; if (flag6) { manifoldPoint.NormalImpulse = manifoldPoint2.NormalImpulse; manifoldPoint.TangentImpulse = manifoldPoint2.TangentImpulse; break; } } this.Manifold.Points[i] = manifoldPoint; } bool flag7 = flag5 != isTouching; if (flag7) { body.Awake = true; body2.Awake = true; } } this.IsTouching = flag5; bool flag8 = !isTouching; if (flag8) { bool flag9 = flag5; if (flag9) { bool flag10 = true; bool flag11 = true; bool flag12 = this.FixtureA.OnCollision != null; if (flag12) { Delegate[] invocationList = this.FixtureA.OnCollision.GetInvocationList(); for (int k = 0; k < invocationList.Length; k++) { OnCollisionEventHandler onCollisionEventHandler = (OnCollisionEventHandler)invocationList[k]; flag10 = (onCollisionEventHandler(this.FixtureA, this.FixtureB, this) & flag10); } } bool flag13 = this.FixtureB.OnCollision != null; if (flag13) { Delegate[] invocationList2 = this.FixtureB.OnCollision.GetInvocationList(); for (int l = 0; l < invocationList2.Length; l++) { OnCollisionEventHandler onCollisionEventHandler2 = (OnCollisionEventHandler)invocationList2[l]; flag11 = (onCollisionEventHandler2(this.FixtureB, this.FixtureA, this) & flag11); } } this.Enabled = (flag10 & flag11); bool flag14 = (flag10 & flag11) && contactManager.BeginContact != null; if (flag14) { this.Enabled = contactManager.BeginContact(this); } bool flag15 = !this.Enabled; if (flag15) { this.IsTouching = false; } } } else { bool flag16 = !flag5; if (flag16) { bool flag17 = this.FixtureA != null && this.FixtureA.OnSeparation != null; if (flag17) { this.FixtureA.OnSeparation(this.FixtureA, this.FixtureB); } bool flag18 = this.FixtureB != null && this.FixtureB.OnSeparation != null; if (flag18) { this.FixtureB.OnSeparation(this.FixtureB, this.FixtureA); } bool flag19 = contactManager.EndContact != null; if (flag19) { contactManager.EndContact(this); } } else { bool flag20 = contactManager.StayContact != null; if (flag20) { contactManager.StayContact(this); } } } bool flag21 = flag3; if (!flag21) { bool flag22 = contactManager.PreSolve != null; if (flag22) { contactManager.PreSolve(this, ref manifold); } } } } }