public void Update(ContactListener listener)
{
int oldCount = GetManifoldCount();
Evaluate(listener);
int newCount = GetManifoldCount();
Body body1 = _shape1.GetBody();
Body body2 = _shape2.GetBody();
if (newCount == 0 && oldCount > 0)
{
body1.WakeUp();
body2.WakeUp();
}
// Slow contacts don't generate TOI events.
if (body1.IsStatic() || body1.IsBullet() || body2.IsStatic() || body2.IsBullet())
{
_flags &= ~CollisionFlags.Slow;
}
else
{
_flags |= CollisionFlags.Slow;
}
}
public Contact(Fixture fixtureA, Fixture fixtureB)
{
Flags = 0;
if (fixtureA.IsSensor || fixtureB.IsSensor)
{
Flags |= ContactFlag.SensorFlag;
}
Body bodyA = fixtureA.GetBody();
Body bodyB = fixtureB.GetBody();
if (bodyA.IsStatic() || bodyA.IsBullet() || bodyB.IsStatic() || bodyB.IsBullet())
{
Flags |= ContactFlag.ContinuousFlag;
}
else
{
Flags &= ~ContactFlag.ContinuousFlag;
}
_fixtureA = fixtureA;
_fixtureB = fixtureB;
Manifold = new Manifold();
Manifold.PointCount = 0;
Prev = null;
Next = null;
NodeA = new ContactEdge();
NodeA.Contact = null;
NodeA.Prev = null;
NodeA.Next = null;
NodeA.Other = null;
NodeB = new ContactEdge();
NodeB.Contact = null;
NodeB.Prev = null;
NodeB.Next = null;
NodeB.Other = null;
}
// Find TOI contacts and solve them.
private void SolveTOI(TimeStep step)
{
// Reserve an island and a queue for TOI island solution.
Island island = new Island(_bodyCount,
Settings.MaxTOIContactsPerIsland,
Settings.MaxTOIJointsPerIsland,
_contactManager._contactListener);
//Simple one pass queue
//Relies on the fact that we're only making one pass
//through and each body can only be pushed/popped once.
//To push:
// queue[queueStart+queueSize++] = newElement;
//To pop:
// poppedElement = queue[queueStart++];
// --queueSize;
int queueCapacity = _bodyCount;
Body[] queue = new Body[queueCapacity];
for (Body b = _bodyList; b != null; b = b._next)
{
b._flags &= ~Body.BodyFlags.Island;
b._sweep.T0 = 0.0f;
}
for (Contact c = _contactManager._contactList; c != null; c = c.Next)
{
// Invalidate TOI
c.Flags &= ~(ContactFlag.ToiFlag | ContactFlag.IslandFlag);
}
for (Joint j = _jointList; j != null; j = j._next)
{
j._islandFlag = false;
}
// Find TOI events and solve them.
for (; ;)
{
// Find the first TOI.
Contact minContact = null;
float minTOI = 1.0f;
for (Contact c = _contactManager._contactList; c != null; c = c.Next)
{
// Can this contact generate a solid TOI contact?
if (c.IsSolid() == false || c.IsContinuous() == false)
{
continue;
}
// TODO_ERIN keep a counter on the contact, only respond to M TOIs per contact.
float toi = 1.0f;
if ((c.Flags & ContactFlag.ToiFlag) != 0)
{
// This contact has a valid cached TOI.
toi = c.Toi;
}
else
{
// Compute the TOI for this contact.
Fixture s1 = c.GetFixtureA();
Fixture s2 = c.GetFixtureB();
Body b1 = s1.GetBody();
Body b2 = s2.GetBody();
if ((b1.IsStatic() || b1.IsSleeping()) && (b2.IsStatic() || b2.IsSleeping()))
{
continue;
}
// Put the sweeps onto the same time interval.
float t0 = b1._sweep.T0;
if (b1._sweep.T0 < b2._sweep.T0)
{
t0 = b2._sweep.T0;
b1._sweep.Advance(t0);
}
else if (b2._sweep.T0 < b1._sweep.T0)
{
t0 = b1._sweep.T0;
b2._sweep.Advance(t0);
}
Box2DXDebug.Assert(t0 < 1.0f);
// Compute the time of impact.
toi = c.ComputeTOI(b1._sweep, b2._sweep);
Box2DXDebug.Assert(0.0f <= toi && toi <= 1.0f);
// If the TOI is in range ...
if (0.0f < toi && toi < 1.0f)
{
// Interpolate on the actual range.
toi = Math.Min((1.0f - toi) * t0 + toi, 1.0f);
}
c.Toi = toi;
c.Flags |= ContactFlag.ToiFlag;
}
if (Settings.FLT_EPSILON < toi && toi < minTOI)
{
// This is the minimum TOI found so far.
minContact = c;
minTOI = toi;
}
}
if (minContact == null || 1.0f - 100.0f * Settings.FLT_EPSILON < minTOI)
{
// No more TOI events. Done!
break;
}
// Advance the bodies to the TOI.
Fixture f1 = minContact.GetFixtureA();
Fixture f2 = minContact.GetFixtureB();
Body b3 = f1.GetBody();
Body b4 = f2.GetBody();
Sweep backup1 = b3._sweep;
Sweep backup2 = b4._sweep;
b3.Advance(minTOI);
b4.Advance(minTOI);
// The TOI contact likely has some new contact points.
minContact.Update(_contactManager._contactListener);
minContact.Flags &= ~ContactFlag.ToiFlag;
// Is the contact solid?
if (minContact.IsSolid() == false)
{
// Restore the sweeps.
b3._sweep = backup1;
b4._sweep = backup2;
b3.SynchronizeTransform();
b4.SynchronizeTransform();
continue;
}
// Did numerical issues prevent a contact point from being generated?
if (minContact.IsTouching() == false)
{
// Give up on this TOI.
continue;
}
// Build the TOI island. We need a dynamic seed.
Body seed = b3;
if (seed.IsStatic())
{
seed = b4;
}
// Reset island and queue.
island.Clear();
int queueStart = 0; // starting index for queue
int queueSize = 0; // elements in queue
queue[queueStart + queueSize++] = seed;
seed._flags |= Body.BodyFlags.Island;
// Perform a breadth first search (BFS) on the contact/joint graph.
while (queueSize > 0)
{
// Grab the next body off the stack and add it to the island.
Body b = queue[queueStart++];
--queueSize;
island.Add(ref b);
// Make sure the body is awake.
b._flags &= ~Body.BodyFlags.Sleep;
// To keep islands as small as possible, we don't
// propagate islands across static bodies.
if (b.IsStatic())
{
continue;
}
// Search all contacts connected to this body.
for (ContactEdge cEdge = b._contactList; cEdge != null; cEdge = cEdge.Next)
{
// Does the TOI island still have space for contacts?
if (island.ContactCount == island.ContactCapacity)
{
break;
}
// Has this contact already been added to an island? Skip slow or non-solid contacts.
if ((cEdge.Contact.Flags & ContactFlag.IslandFlag) != 0)
{
continue;
}
// Is this contact touching? For performance we are not updating this contact.
if (cEdge.Contact.IsSolid() == false || cEdge.Contact.IsTouching() == false)
{
continue;
}
island.Add(ref cEdge.Contact);
cEdge.Contact.Flags |= ContactFlag.IslandFlag;
// Update other body.
Body other = cEdge.Other;
// Was the other body already added to this island?
if ((other._flags & Body.BodyFlags.Island) != 0)
{
continue;
}
// March forward, this can do no harm since this is the min TOI.
if (other.IsStatic() == false)
{
other.Advance(minTOI);
other.WakeUp();
}
Box2DXDebug.Assert(queueStart + queueSize < queueCapacity);
queue[queueStart + queueSize] = other;
++queueSize;
other._flags |= Body.BodyFlags.Island;
}
for (JointEdge jEdge = b._jointList; jEdge != null; jEdge = jEdge.Next)
{
if (island.JointCount == island.JointCapacity)
{
continue;
}
if (jEdge.Joint._islandFlag == true)
{
continue;
}
island.Add(jEdge.Joint);
jEdge.Joint._islandFlag = true;
Body other = jEdge.Other;
if ((other._flags & Body.BodyFlags.Island) != 0)
{
continue;
}
if (!other.IsStatic())
{
other.Advance(minTOI);
other.WakeUp();
}
Box2DXDebug.Assert(queueStart + queueSize < queueCapacity);
queue[queueStart + queueSize] = other;
++queueSize;
other._flags |= Body.BodyFlags.Island;
}
}
TimeStep subStep;
subStep.WarmStarting = false;
subStep.Dt = (1.0f - minTOI) * step.Dt;
subStep.Inv_Dt = 1.0f / subStep.Dt;
subStep.DtRatio = 0.0f;
subStep.VelocityIterations = step.VelocityIterations;
subStep.PositionIterations = step.PositionIterations;
island.SolveTOI(ref subStep);
// Post solve cleanup.
for (int i = 0; i < island.BodyCount; ++i)
{
// Allow bodies to participate in future TOI islands.
Body b = island.Bodies[i];
b._flags &= ~Body.BodyFlags.Island;
if ((b._flags & Body.BodyFlags.Sleep) != 0)
{
continue;
}
if (b.IsStatic())
{
continue;
}
b.SynchronizeFixtures();
// Invalidate all contact TOIs associated with this body. Some of these
// may not be in the island because they were not touching.
for (ContactEdge ce = b._contactList; ce != null; ce = ce.Next)
{
ce.Contact.Flags &= ~ContactFlag.ToiFlag;
}
}
for (int i = 0; i < island.ContactCount; ++i)
{
// Allow contacts to participate in future TOI islands.
Contact c = island.Contacts[i];
c.Flags &= ~(ContactFlag.ToiFlag | ContactFlag.IslandFlag);
}
for (int i = 0; i < island.JointCount; ++i)
{
// Allow joints to participate in future TOI islands.
Joint j = island.Joints[i];
j._islandFlag = false;
}
// Commit fixture proxy movements to the broad-phase so that new contacts are created.
// Also, some contacts can be destroyed.
_contactManager.FindNewContacts();
}
queue = null;
}
// Find islands, integrate and solve constraints, solve position constraints
private void Solve(TimeStep step)
{
// Size the island for the worst case.
Island island = new Island(_bodyCount,
_contactManager._contactCount,
_jointCount,
_contactManager._contactListener);
// Clear all the island flags.
for (Body b = _bodyList; b != null; b = b._next)
{
b._flags &= ~Body.BodyFlags.Island;
}
for (Contact c = _contactManager._contactList; c != null; c = c.Next)
{
c.Flags &= ~ContactFlag.IslandFlag;
}
for (Joint j = _jointList; j != null; j = j._next)
{
j._islandFlag = false;
}
// Build and simulate all awake islands.
int stackSize = _bodyCount;
Body[] stack = new Body[stackSize];
for (Body seed = _bodyList; seed != null; seed = seed._next)
{
if ((seed._flags & (Body.BodyFlags.Island | Body.BodyFlags.Sleep)) != 0)
{
continue;
}
if (seed.IsStatic())
{
continue;
}
// Reset island and stack.
island.Clear();
int stackCount = 0;
stack[stackCount++] = seed;
seed._flags |= Body.BodyFlags.Island;
// Perform a depth first search (DFS) on the constraint graph.
while (stackCount > 0)
{
// Grab the next body off the stack and add it to the island.
Body b = stack[--stackCount];
island.Add(ref b);
// Make sure the body is awake.
b._flags &= ~Body.BodyFlags.Sleep;
// To keep islands as small as possible, we don't
// propagate islands across static bodies.
if (b.IsStatic())
{
continue;
}
// Search all contacts connected to this body.
for (ContactEdge ce = b._contactList; ce != null; ce = ce.Next)
{
// Has this contact already been added to an island?
if ((ce.Contact.Flags & ContactFlag.IslandFlag) != 0)
{
continue;
}
// Is this contact touching?
if (ce.Contact.IsSolid() == false || ce.Contact.IsTouching() == false)
{
continue;
}
island.Add(ref ce.Contact);
ce.Contact.Flags |= ContactFlag.IslandFlag;
Body other = ce.Other;
// Was the other body already added to this island?
if ((other._flags & Body.BodyFlags.Island) != 0)
{
continue;
}
Box2DXDebug.Assert(stackCount < stackSize);
stack[stackCount++] = other;
other._flags |= Body.BodyFlags.Island;
}
// Search all joints connect to this body.
for (JointEdge je = b._jointList; je != null; je = je.Next)
{
if (je.Joint._islandFlag == true)
{
continue;
}
island.Add(je.Joint);
je.Joint._islandFlag = true;
Body other = je.Other;
if ((other._flags & Body.BodyFlags.Island) != 0)
{
continue;
}
Box2DXDebug.Assert(stackCount < stackSize);
stack[stackCount++] = other;
other._flags |= Body.BodyFlags.Island;
}
}
island.Solve(step, _gravity, _allowSleep);
// Post solve cleanup.
for (int i = 0; i < island.BodyCount; ++i)
{
// Allow static bodies to participate in other islands.
Body b = island.Bodies[i];
if (b.IsStatic())
{
b._flags &= ~Body.BodyFlags.Island;
}
}
}
stack = null;
// Synchronize shapes, check for out of range bodies.
for (Body b = _bodyList; b != null; b = b.GetNext())
{
if ((b._flags & Body.BodyFlags.Sleep) != 0)
{
continue;
}
if (b.IsStatic())
{
continue;
}
// Update fixtures (for broad-phase).
b.SynchronizeFixtures();
}
// Look for new contacts.
_contactManager.FindNewContacts();
}
public void DrawDebugData()
{
if (_debugDraw == null)
{
return;
}
DebugDraw.DrawFlags flags = _debugDraw.Flags;
if ((flags & DebugDraw.DrawFlags.Shape) != 0)
{
for (Body b = _bodyList; b != null; b = b.GetNext())
{
Transform xf = b.GetTransform();
for (Fixture f = b.GetFixtureList(); f != null; f = f.GetNext())
{
if (b.IsStatic())
{
DrawShape(f, xf, new Color(0.5f, 0.9f, 0.5f));
}
else if (b.IsSleeping())
{
DrawShape(f, xf, new Color(0.5f, 0.5f, 0.9f));
}
else
{
DrawShape(f, xf, new Color(0.9f, 0.9f, 0.9f));
}
}
}
}
if ((flags & DebugDraw.DrawFlags.Joint) != 0)
{
for (Joint j = _jointList; j != null; j = j.GetNext())
{
if (j.GetType() != JointType.MouseJoint)
{
DrawJoint(j);
}
}
}
if ((flags & DebugDraw.DrawFlags.Pair) != 0)
{
// TODO_ERIN
}
if ((flags & DebugDraw.DrawFlags.Aabb) != 0)
{
Color color = new Color(0.9f, 0.3f, 0.9f);
BroadPhase bp = _contactManager._broadPhase;
for (Body b = _bodyList; b != null; b = b.GetNext())
{
for (Fixture f = b.GetFixtureList(); f != null; f = f.GetNext())
{
AABB aabb = bp.GetFatAABB(f.ProxyId);
Vec2[] vs = new Vec2[4];
vs[0].Set(aabb.LowerBound.X, aabb.LowerBound.Y);
vs[1].Set(aabb.UpperBound.X, aabb.LowerBound.Y);
vs[2].Set(aabb.UpperBound.X, aabb.UpperBound.Y);
vs[3].Set(aabb.LowerBound.X, aabb.UpperBound.Y);
_debugDraw.DrawPolygon(vs, 4, color);
}
}
}
if ((flags & DebugDraw.DrawFlags.CenterOfMass) != 0)
{
for (Body b = _bodyList; b != null; b = b.GetNext())
{
Transform xf = b.GetTransform();
xf.Position = b.GetWorldCenter();
_debugDraw.DrawXForm(xf);
}
}
}
/// <summary>
/// Create a joint to constrain bodies together. No reference to the definition
/// is retained. This may cause the connected bodies to cease colliding.
/// @warning This function is locked during callbacks.
/// </summary>
/// <param name="def"></param>
/// <returns></returns>
public Joint CreateJoint(JointDef def)
{
Box2DXDebug.Assert(IsLocked() == false);
if (IsLocked())
{
return(null);
}
Joint j = Joint.Create(def);
// Connect to the world list.
j._prev = null;
j._next = _jointList;
if (_jointList != null)
{
_jointList._prev = j;
}
_jointList = j;
++_jointCount;
// Connect to the bodies' doubly linked lists.
j._edgeA.Joint = j;
j._edgeA.Other = j._bodyB;
j._edgeA.Prev = null;
j._edgeA.Next = j._bodyA._jointList;
if (j._bodyA._jointList != null)
{
j._bodyA._jointList.Prev = j._edgeA;
}
j._bodyA._jointList = j._edgeA;
j._edgeB.Joint = j;
j._edgeB.Other = j._bodyA;
j._edgeB.Prev = null;
j._edgeB.Next = j._bodyB._jointList;
if (j._bodyB._jointList != null)
{
j._bodyB._jointList.Prev = j._edgeB;
}
j._bodyB._jointList = j._edgeB;
Body bodyA = def.Body1;
Body bodyB = def.Body2;
bool staticA = bodyA.IsStatic();
bool staticB = bodyB.IsStatic();
// If the joint prevents collisions, then flag any contacts for filtering.
if (def.CollideConnected == false && (staticA == false || staticB == false))
{
// Ensure we iterate over contacts on a dynamic body (usually have less contacts
// than a static body). Ideally we will have a contact count on both bodies.
if (staticB)
{
Math.Swap(ref bodyA, ref bodyB);
}
ContactEdge edge = bodyB.GetContactList();
while (edge != null)
{
if (edge.Other == bodyA)
{
// Flag the contact for filtering at the next time step (where either
// body is awake).
edge.Contact.FlagForFiltering();
}
edge = edge.Next;
}
}
// Note: creating a joint doesn't wake the bodies.
return(j);
}
public void Solve(TimeStep step, Vec2 gravity, bool allowSleep)
{
// Integrate velocities and apply damping.
for (int i = 0; i < BodyCount; ++i)
{
Body b = Bodies[i];
if (b.IsStatic())
{
continue;
}
// Integrate velocities.
b._linearVelocity += step.Dt * (gravity + b._invMass * b._force);
b._angularVelocity += step.Dt * b._invI * b._torque;
// Reset forces.
b._force.Set(0.0f, 0.0f);
b._torque = 0.0f;
// Apply damping.
// ODE: dv/dt + c * v = 0
// Solution: v(t) = v0 * exp(-c * t)
// Time step: v(t + dt) = v0 * exp(-c * (t + dt)) = v0 * exp(-c * t) * exp(-c * dt) = v * exp(-c * dt)
// v2 = exp(-c * dt) * v1
// Taylor expansion:
// v2 = (1.0f - c * dt) * v1
b._linearVelocity *= Common.Math.Clamp(1.0f - step.Dt * b._linearDamping, 0.0f, 1.0f);
b._angularVelocity *= Common.Math.Clamp(1.0f - step.Dt * b._angularDamping, 0.0f, 1.0f);
}
ContactSolver contactSolver = new ContactSolver(step, Contacts, ContactCount);
// Initialize velocity constraints.
contactSolver.InitVelocityConstraints(step);
for (int i = 0; i < JointCount; ++i)
{
Joints[i].InitVelocityConstraints(step);
}
// Solve velocity constraints.
for (int i = 0; i < step.VelocityIterations; ++i)
{
for (int j = 0; j < JointCount; ++j)
{
Joints[j].SolveVelocityConstraints(step);
}
contactSolver.SolveVelocityConstraints();
}
// Post-solve (store impulses for warm starting).
contactSolver.FinalizeVelocityConstraints();
// Integrate positions.
for (int i = 0; i < BodyCount; ++i)
{
Body b = Bodies[i];
if (b.IsStatic())
{
continue;
}
// Check for large velocities.
Vec2 translation = step.Dt * b._linearVelocity;
if (Vec2.Dot(translation, translation) > Settings.MaxTranslationSquared)
{
translation.Normalize();
b._linearVelocity = (Settings.MaxTranslation * step.Inv_Dt) * translation;
}
float rotation = step.Dt * Bodies[i]._angularVelocity;
if (rotation * rotation > Settings.MaxRotationSquared)
{
if (rotation < 0.0)
{
b._angularVelocity = -step.Inv_Dt * Settings.MaxRotation;
}
else
{
b._angularVelocity = step.Inv_Dt * Settings.MaxRotation;
}
}
// Store positions for continuous collision.
b._sweep.C0 = b._sweep.C;
b._sweep.A0 = b._sweep.A;
// Integrate
b._sweep.C += step.Dt * b._linearVelocity;
b._sweep.A += step.Dt * b._angularVelocity;
// Compute new transform
b.SynchronizeTransform();
// Note: shapes are synchronized later.
}
// Iterate over constraints.
for (int i = 0; i < step.PositionIterations; ++i)
{
bool contactsOkay = contactSolver.SolvePositionConstraints(Settings.ContactBaumgarte);
bool jointsOkay = true;
for (int j = 0; j < JointCount; ++j)
{
bool jointOkay = Joints[j].SolvePositionConstraints(Settings.ContactBaumgarte);
jointsOkay = jointsOkay && jointOkay;
}
if (contactsOkay && jointsOkay)
{
// Exit early if the position errors are small.
break;
}
}
Report(contactSolver.Constraints);
if (allowSleep)
{
float minSleepTime = Settings.FLT_MAX;
#if !TARGET_FLOAT32_IS_FIXED
float linTolSqr = Settings.LinearSleepTolerance * Settings.LinearSleepTolerance;
float angTolSqr = Settings.AngularSleepTolerance * Settings.AngularSleepTolerance;
#endif
for (int i = 0; i < BodyCount; ++i)
{
Body b = Bodies[i];
if (b._invMass == 0.0f)
{
continue;
}
if ((b._flags & Body.BodyFlags.AllowSleep) == 0)
{
b._sleepTime = 0.0f;
minSleepTime = 0.0f;
}
if ((b._flags & Body.BodyFlags.AllowSleep) == 0 ||
#if TARGET_FLOAT32_IS_FIXED
Common.Math.Abs(b._angularVelocity) > Settings.AngularSleepTolerance ||
Common.Math.Abs(b._linearVelocity.X) > Settings.LinearSleepTolerance ||
Common.Math.Abs(b._linearVelocity.Y) > Settings.LinearSleepTolerance)
#else
b._angularVelocity *b._angularVelocity > angTolSqr ||
Vec2.Dot(b._linearVelocity, b._linearVelocity) > linTolSqr)
#endif
{
b._sleepTime = 0.0f;
minSleepTime = 0.0f;
}
else
{
b._sleepTime += step.Dt;
minSleepTime = Common.Math.Min(minSleepTime, b._sleepTime);
}
}
public override object PairAdded(object proxyUserData1, object proxyUserData2)
{
Shape shape = proxyUserData1 as Shape;
Shape shape2 = proxyUserData2 as Shape;
Body body = shape.GetBody();
Body body2 = shape2.GetBody();
object result;
if (body.IsStatic() && body2.IsStatic())
{
result = this._nullContact;
}
else
{
if (shape.GetBody() == shape2.GetBody())
{
result = this._nullContact;
}
else
{
if (body2.IsConnected(body))
{
result = this._nullContact;
}
else
{
if (this._world._contactFilter != null && !this._world._contactFilter.ShouldCollide(shape, shape2))
{
result = this._nullContact;
}
else
{
Contact contact = Contact.Create(shape, shape2);
if (contact == null)
{
result = this._nullContact;
}
else
{
shape = contact.GetShape1();
shape2 = contact.GetShape2();
body = shape.GetBody();
body2 = shape2.GetBody();
contact._prev = null;
contact._next = this._world._contactList;
if (this._world._contactList != null)
{
this._world._contactList._prev = contact;
}
this._world._contactList = contact;
contact._node1.Contact = contact;
contact._node1.Other = body2;
contact._node1.Prev = null;
contact._node1.Next = body._contactList;
if (body._contactList != null)
{
body._contactList.Prev = contact._node1;
}
body._contactList = contact._node1;
contact._node2.Contact = contact;
contact._node2.Other = body;
contact._node2.Prev = null;
contact._node2.Next = body2._contactList;
if (body2._contactList != null)
{
body2._contactList.Prev = contact._node2;
}
body2._contactList = contact._node2;
this._world._contactCount++;
result = contact;
}
}
}
}
}
return(result);
}
public void Update(ContactListener listener)
{
//Note: Manifold is a class, not a struct. It will reference the old manifest, not copy it - DONE
Manifold oldManifold = new Manifold();
oldManifold.LocalPlaneNormal = Manifold.LocalPlaneNormal;
oldManifold.LocalPoint = Manifold.LocalPoint;
oldManifold.PointCount = Manifold.PointCount;
oldManifold.Points = Manifold.Points;
oldManifold.Type = Manifold.Type;
// Re-enable this contact.
Flags &= ~ContactFlag.DisabledFlag;
if (Collision.Collision.TestOverlap(_fixtureA.Aabb, _fixtureB.Aabb))
{
Evaluate();
}
else
{
Manifold.PointCount = 0;
}
Body bodyA = _fixtureA.GetBody();
Body bodyB = _fixtureB.GetBody();
int oldCount = oldManifold.PointCount;
int newCount = Manifold.PointCount;
if (newCount == 0 && oldCount > 0)
{
bodyA.WakeUp();
bodyB.WakeUp();
}
// Slow contacts don't generate TOI events.
if (bodyA.IsStatic() || bodyA.IsBullet() || bodyB.IsStatic() || bodyB.IsBullet())
{
Flags |= ContactFlag.ContinuousFlag;
}
else
{
Flags &= ~ContactFlag.ContinuousFlag;
}
// 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;
}
}
}
if (newCount > 0)
{
Flags |= ContactFlag.TouchingFlag;
}
else
{
Flags &= ~ContactFlag.TouchingFlag;
}
if (oldCount == 0 && newCount > 0)
{
listener.BeginContact(this);
}
if (oldCount > 0 && newCount == 0)
{
listener.EndContact(this);
}
if ((Flags & ContactFlag.SensorFlag) == 0)
{
listener.PreSolve(this, oldManifold);
}
}
// This is a callback from the broadphase when two AABB proxies begin
// to overlap. We create a Contact to manage the narrow phase.
public override object PairAdded(object proxyUserDataA, object proxyUserDataB)
{
Fixture fixtureA = proxyUserDataA as Fixture;
Fixture fixtureB = proxyUserDataB as Fixture;
Body bodyA = fixtureA.Body;
Body bodyB = fixtureB.Body;
if (bodyA.IsStatic() && bodyB.IsStatic())
{
return(_nullContact);
}
if (fixtureA.Body == fixtureB.Body)
{
return(_nullContact);
}
if (bodyB.IsConnected(bodyA))
{
return(_nullContact);
}
if (_world._contactFilter != null && _world._contactFilter.ShouldCollide(fixtureA, fixtureB) == false)
{
return(_nullContact);
}
// Call the factory.
Contact c = Contact.Create(fixtureA, fixtureB);
if (c == null)
{
return(_nullContact);
}
// Contact creation may swap shapes.
fixtureA = c.FixtureA;
fixtureB = c.FixtureB;
bodyA = fixtureA.Body;
bodyB = fixtureB.Body;
// Insert into the world.
c._prev = null;
c._next = _world._contactList;
if (_world._contactList != null)
{
_world._contactList._prev = c;
}
_world._contactList = c;
// Connect to island graph.
// Connect to body 1
c._nodeA.Contact = c;
c._nodeA.Other = bodyB;
c._nodeA.Prev = null;
c._nodeA.Next = bodyA._contactList;
if (bodyA._contactList != null)
{
bodyA._contactList.Prev = c._nodeA;
}
bodyA._contactList = c._nodeA;
// Connect to body 2
c._nodeB.Contact = c;
c._nodeB.Other = bodyA;
c._nodeB.Prev = null;
c._nodeB.Next = bodyB._contactList;
if (bodyB._contactList != null)
{
bodyB._contactList.Prev = c._nodeB;
}
bodyB._contactList = c._nodeB;
++_world._contactCount;
return(c);
}
