void DrawShape(Fixture fixture, Transform xf, Color color)
{
switch (fixture.ShapeType)
{
case ShapeType.Circle:
{
CircleShape circle = (CircleShape)fixture.GetShape();
Vector2 center = MathUtils.Multiply(ref xf, circle._p);
float radius = circle._radius;
Vector2 axis = xf.R.col1;
DebugDraw.DrawSolidCircle(center, radius, axis, color);
}
break;
case ShapeType.Polygon:
{
PolygonShape poly = (PolygonShape)fixture.GetShape();
int vertexCount = poly._vertexCount;
//Debug.Assert(vertexCount <= Settings.b2_maxPolygonVertices);
FixedArray8 <Vector2> vertices = new FixedArray8 <Vector2>();
for (int i = 0; i < vertexCount; ++i)
{
vertices[i] = MathUtils.Multiply(ref xf, poly._vertices[i]);
}
DebugDraw.DrawSolidPolygon(ref vertices, vertexCount, color);
}
break;
case ShapeType.Edge:
{
EdgeShape edge = (EdgeShape)fixture.GetShape();
Vector2 v1 = MathUtils.Multiply(ref xf, edge._vertex1);
Vector2 v2 = MathUtils.Multiply(ref xf, edge._vertex2);
DebugDraw.DrawSegment(v1, v2, color);
}
break;
case ShapeType.Loop:
{
LoopShape loop = (LoopShape)fixture.GetShape();
int count = loop._count;
Vector2 v1 = MathUtils.Multiply(ref xf, loop._vertices[count - 1]);
for (int i = 0; i < count; ++i)
{
Vector2 v2 = MathUtils.Multiply(ref xf, loop._vertices[i]);
DebugDraw.DrawSegment(v1, v2, color);
v1 = v2;
}
}
break;
}
}
public void DrawFixture(Fixture fixture)
{
Color color = Color.FromArgb(245, 245, 150);
Transform xf = fixture.GetBody().GetTransform();
switch (fixture.GetShapeType())
{
case ShapeType.Circle:
{
CircleShape circle = (CircleShape)fixture.GetShape();
Vec2 center = Utilities.Mul(xf, circle.m_p);
float radius = circle.m_radius;
m_debugDraw.DrawCircle(center, radius, color);
}
break;
case ShapeType.Polygon:
{
PolygonShape poly = (PolygonShape)fixture.GetShape();
int vertexCount = poly.m_count;
Utilities.Assert(vertexCount <= Settings._maxPolygonVertices);
Vec2[] vertices = new Vec2[Settings._maxPolygonVertices];
for (int i = 0; i < vertexCount; ++i)
{
vertices[i] = Utilities.Mul(xf, poly.m_vertices[i]);
}
m_debugDraw.DrawPolygon(vertices, vertexCount, color);
}
break;
default:
break;
}
}
public void Initialize(Contact[] contacts, int count, Body toiBody)
{
_count = count;
_toiBody = toiBody;
if (_constraints.Length < _count)
{
_constraints = new TOIConstraint[Math.Max(_constraints.Length * 2, _count)];
}
for (int i = 0; i < _count; ++i)
{
Contact contact = contacts[i];
Fixture fixtureA = contact.GetFixtureA();
Fixture fixtureB = contact.GetFixtureB();
Shape shapeA = fixtureA.GetShape();
Shape shapeB = fixtureB.GetShape();
float radiusA = shapeA._radius;
float radiusB = shapeB._radius;
Body bodyA = fixtureA.GetBody();
Body bodyB = fixtureB.GetBody();
Manifold manifold;
contact.GetManifold(out manifold);
//Debug.Assert(manifold._pointCount > 0);
TOIConstraint constraint = _constraints[i];
constraint.bodyA = bodyA;
constraint.bodyB = bodyB;
constraint.localNormal = manifold._localNormal;
constraint.localPoint = manifold._localPoint;
constraint.type = manifold._type;
constraint.pointCount = manifold._pointCount;
constraint.radius = radiusA + radiusB;
for (int j = 0; j < constraint.pointCount; ++j)
{
constraint.localPoints[j] = manifold._points[j].LocalPoint;
}
_constraints[i] = constraint;
}
}
/// Called for each fixture found in the query AABB.
/// @return false to terminate the query.
public override bool ReportFixture(Fixture fixture)
{
if (m_count == e_maxCount)
{
return false;
}
Body body = fixture.GetBody();
Shape shape = fixture.GetShape();
bool overlap = Collision.TestOverlap(shape, 0, m_circle, 0, body.GetTransform(), m_transform);
if (overlap)
{
DrawFixture(fixture);
++m_count;
}
return true;
}
public void Reset(Contact[] contacts, int contactCount, float impulseRatio)
{
_contacts = contacts;
_constraintCount = contactCount;
// grow the array
if (_constraints == null || _constraints.Length < _constraintCount)
{
_constraints = new ContactConstraint[_constraintCount * 2];
}
for (int i = 0; i < _constraintCount; ++i)
{
Contact contact = contacts[i];
Fixture fixtureA = contact._fixtureA;
Fixture fixtureB = contact._fixtureB;
Shape shapeA = fixtureA.GetShape();
Shape shapeB = fixtureB.GetShape();
float radiusA = shapeA._radius;
float radiusB = shapeB._radius;
Body bodyA = fixtureA.GetBody();
Body bodyB = fixtureB.GetBody();
Manifold manifold;
contact.GetManifold(out manifold);
float friction = Settings.b2MixFriction(fixtureA.GetFriction(), fixtureB.GetFriction());
float restitution = Settings.b2MixRestitution(fixtureA.GetRestitution(), fixtureB.GetRestitution());
Vector2 vA = bodyA._linearVelocity;
Vector2 vB = bodyB._linearVelocity;
float wA = bodyA._angularVelocity;
float wB = bodyB._angularVelocity;
//Debug.Assert(manifold._pointCount > 0);
WorldManifold worldManifold = new WorldManifold(ref manifold, ref bodyA._xf, radiusA, ref bodyB._xf, radiusB);
ContactConstraint cc = _constraints[i];
cc.bodyA = bodyA;
cc.bodyB = bodyB;
cc.manifold = manifold;
cc.normal = worldManifold._normal;
cc.pointCount = manifold._pointCount;
cc.friction = friction;
cc.localNormal = manifold._localNormal;
cc.localPoint = manifold._localPoint;
cc.radius = radiusA + radiusB;
cc.type = manifold._type;
for (int j = 0; j < cc.pointCount; ++j)
{
ManifoldPoint cp = manifold._points[j];
ContactConstraintPoint ccp = cc.points[j];
ccp.normalImpulse = impulseRatio * cp.NormalImpulse;
ccp.tangentImpulse = impulseRatio * cp.TangentImpulse;
ccp.localPoint = cp.LocalPoint;
ccp.rA = worldManifold._points[j] - bodyA._sweep.c;
ccp.rB = worldManifold._points[j] - bodyB._sweep.c;
#if MATH_OVERLOADS
float rnA = MathUtils.Cross(ccp.rA, cc.normal);
float rnB = MathUtils.Cross(ccp.rB, cc.normal);
#else
float rnA = ccp.rA.x * cc.normal.y - ccp.rA.y * cc.normal.x;
float rnB = ccp.rB.x * cc.normal.y - ccp.rB.y * cc.normal.x;
#endif
rnA *= rnA;
rnB *= rnB;
float kNormal = bodyA._invMass + bodyB._invMass + bodyA._invI * rnA + bodyB._invI * rnB;
//Debug.Assert(kNormal > Settings.b2_epsilon);
ccp.normalMass = 1.0f / kNormal;
#if MATH_OVERLOADS
Vector2 tangent = MathUtils.Cross(cc.normal, 1.0f);
float rtA = MathUtils.Cross(ccp.rA, tangent);
float rtB = MathUtils.Cross(ccp.rB, tangent);
#else
Vector2 tangent = new Vector2(cc.normal.y, -cc.normal.x);
float rtA = ccp.rA.x * tangent.y - ccp.rA.y * tangent.x;
float rtB = ccp.rB.x * tangent.y - ccp.rB.y * tangent.x;
#endif
rtA *= rtA;
rtB *= rtB;
float kTangent = bodyA._invMass + bodyB._invMass + bodyA._invI * rtA + bodyB._invI * rtB;
//Debug.Assert(kTangent > Settings.b2_epsilon);
ccp.tangentMass = 1.0f / kTangent;
// Setup a velocity bias for restitution.
ccp.velocityBias = 0.0f;
float vRel = Vector2.Dot(cc.normal, vB + MathUtils.Cross(wB, ccp.rB) - vA - MathUtils.Cross(wA, ccp.rA));
if (vRel < -Settings.b2_velocityThreshold)
{
ccp.velocityBias = -restitution * vRel;
}
cc.points[j] = ccp;
}
// If we have two points, then prepare the block solver.
if (cc.pointCount == 2)
{
ContactConstraintPoint ccp1 = cc.points[0];
ContactConstraintPoint ccp2 = cc.points[1];
float invMassA = bodyA._invMass;
float invIA = bodyA._invI;
float invMassB = bodyB._invMass;
float invIB = bodyB._invI;
float rn1A = MathUtils.Cross(ccp1.rA, cc.normal);
float rn1B = MathUtils.Cross(ccp1.rB, cc.normal);
float rn2A = MathUtils.Cross(ccp2.rA, cc.normal);
float rn2B = MathUtils.Cross(ccp2.rB, cc.normal);
float k11 = invMassA + invMassB + invIA * rn1A * rn1A + invIB * rn1B * rn1B;
float k22 = invMassA + invMassB + invIA * rn2A * rn2A + invIB * rn2B * rn2B;
float k12 = invMassA + invMassB + invIA * rn1A * rn2A + invIB * rn1B * rn2B;
// Ensure a reasonable condition number.
const float k_maxConditionNumber = 100.0f;
if (k11 * k11 < k_maxConditionNumber * (k11 * k22 - k12 * k12))
{
// K is safe to invert.
cc.K = new Mat22(new Vector2(k11, k12), new Vector2(k12, k22));
cc.normalMass = cc.K.GetInverse();
}
else
{
// The constraints are redundant, just use one.
// TODO_ERIN use deepest?
cc.pointCount = 1;
}
}
_constraints[i] = cc;
}
}
private void DrawShape(Fixture fixture, Transform xf, Color color){
switch (fixture.GetShapeType())
{
case ShapeType.Circle:
{
CircleShape circle = (CircleShape)fixture.GetShape();
Vec2 center = Utilities.Mul(xf, circle.m_p);
float radius = circle.m_radius;
Vec2 axis = Utilities.Mul(xf.q, new Vec2(1.0f, 0.0f));
m_debugDraw.DrawSolidCircle(center, radius, axis, color);
}
break;
case ShapeType.Edge:
{
EdgeShape edge = (EdgeShape)fixture.GetShape();
Vec2 v1 = Utilities.Mul(xf, edge.m_vertex1);
Vec2 v2 = Utilities.Mul(xf, edge.m_vertex2);
m_debugDraw.DrawSegment(v1, v2, color);
}
break;
case ShapeType.Chain:
{
ChainShape chain = (ChainShape)fixture.GetShape();
int count = chain.m_count;
List<Vec2> vertices = chain.m_vertices;
Vec2 v1 = Utilities.Mul(xf, vertices[0]);
for (int i = 1; i < count; ++i)
{
Vec2 v2 = Utilities.Mul(xf, vertices[i]);
m_debugDraw.DrawSegment(v1, v2, color);
m_debugDraw.DrawCircle(v1, 0.05f, color);
v1 = v2;
}
}
break;
case ShapeType.Polygon:
{
PolygonShape poly = (PolygonShape)fixture.GetShape();
int vertexCount = poly.m_count;
Utilities.Assert(vertexCount <= Settings._maxPolygonVertices);
Vec2[] vertices = new Vec2[Settings._maxPolygonVertices];
for (int i = 0; i < vertexCount; ++i)
{
vertices[i] = Utilities.Mul(xf, poly.m_vertices[i]);
}
m_debugDraw.DrawSolidPolygon(vertices, vertexCount, color);
}
break;
default:
break;
}
}
// Advance a dynamic body to its first time of contact
// and adjust the position to ensure clearance.
void SolveTOI(Body body)
{
// Find the minimum contact.
Contact toiContact = null;
float toi = 1.0f;
Body toiOther = null;
bool found;
int count;
int iter = 0;
bool bullet = body.IsBullet;
// Iterate until all contacts agree on the minimum TOI. We have
// to iterate because the TOI algorithm may skip some intermediate
// collisions when objects rotate through each other.
do
{
count = 0;
found = false;
for (ContactEdge ce = body._contactList; ce != null; ce = ce.Next)
{
if (ce.Contact == toiContact)
{
continue;
}
Body other = ce.Other;
BodyType type = other.GetType();
// Only bullets perform TOI with dynamic bodies.
if (bullet == true)
{
// Bullets only perform TOI with bodies that have their TOI resolved.
if ((other._flags & BodyFlags.Toi) == 0)
{
continue;
}
// No repeated hits on non-static bodies
if (type != BodyType.Static && (ce.Contact._flags & ContactFlags.BulletHit) != 0)
{
continue;
}
}
else if (type == BodyType.Dynamic)
{
continue;
}
// Check for a disabled contact.
Contact contact = ce.Contact;
if (contact.IsEnabled() == false)
{
continue;
}
// Prevent infinite looping.
if (contact._toiCount > 10)
{
continue;
}
Fixture fixtureA = contact._fixtureA;
Fixture fixtureB = contact._fixtureB;
int indexA = contact._indexA;
int indexB = contact._indexB;
// Cull sensors.
if (fixtureA.IsSensor() || fixtureB.IsSensor())
{
continue;
}
Body bodyA = fixtureA._body;
Body bodyB = fixtureB._body;
// Compute the time of impact in interval [0, minTOI]
TOIInput input = new TOIInput();
input.proxyA.Set(fixtureA.GetShape(), indexA);
input.proxyB.Set(fixtureB.GetShape(), indexB);
input.sweepA = bodyA._sweep;
input.sweepB = bodyB._sweep;
input.tMax = toi;
TOIOutput output;
TimeOfImpact.CalculateTimeOfImpact(out output, ref input);
if (output.State == TOIOutputState.Touching && output.t < toi)
{
toiContact = contact;
toi = output.t;
toiOther = other;
found = true;
}
++count;
}
++iter;
} while (found && count > 1 && iter < 50);
if (toiContact == null)
{
body.Advance(1.0f);
return;
}
Sweep backup = body._sweep;
body.Advance(toi);
toiContact.Update(_contactManager.ContactListener);
if (toiContact.IsEnabled() == false)
{
// Contact disabled. Backup and recurse.
body._sweep = backup;
SolveTOI(body);
}
++toiContact._toiCount;
// Update all the valid contacts on this body and build a contact island.
count = 0;
for (ContactEdge ce = body._contactList; (ce != null) && (count < Settings.b2_maxTOIContacts); ce = ce.Next)
{
Body other = ce.Other;
BodyType type = other.GetType();
// Only perform correction with static bodies, so the
// body won't get pushed out of the world.
if (type == BodyType.Dynamic)
{
continue;
}
// Check for a disabled contact.
Contact contact = ce.Contact;
if (contact.IsEnabled() == false)
{
continue;
}
Fixture fixtureA = contact._fixtureA;
Fixture fixtureB = contact._fixtureB;
// Cull sensors.
if (fixtureA.IsSensor() || fixtureB.IsSensor())
{
continue;
}
// The contact likely has some new contact points. The listener
// gives the user a chance to disable the contact.
if (contact != toiContact)
{
contact.Update(_contactManager.ContactListener);
}
// Did the user disable the contact?
if (contact.IsEnabled() == false)
{
// Skip this contact.
continue;
}
if (contact.IsTouching() == false)
{
continue;
}
_toiContacts[count] = contact;
++count;
}
// Reduce the TOI body's overlap with the contact island.
_toiSolver.Initialize(_toiContacts, count, body);
float k_toiBaumgarte = 0.75f;
//bool solved = false;
for (int i = 0; i < 20; ++i)
{
bool contactsOkay = _toiSolver.Solve(k_toiBaumgarte);
if (contactsOkay)
{
//solved = true;
break;
}
}
if (toiOther.GetType() != BodyType.Static)
{
toiContact._flags |= ContactFlags.BulletHit;
}
}
private void DrawShape(Fixture fixture, Transform xf, Color color)
{
switch (fixture.GetShapeType())
{
case ShapeType.Circle:
{
CircleShape circle = (CircleShape)fixture.GetShape();
Vec2 center = Utilities.Mul(xf, circle.m_p);
float radius = circle.m_radius;
Vec2 axis = Utilities.Mul(xf.q, new Vec2(1.0f, 0.0f));
m_debugDraw.DrawSolidCircle(center, radius, axis, color);
}
break;
case ShapeType.Edge:
{
EdgeShape edge = (EdgeShape)fixture.GetShape();
Vec2 v1 = Utilities.Mul(xf, edge.m_vertex1);
Vec2 v2 = Utilities.Mul(xf, edge.m_vertex2);
m_debugDraw.DrawSegment(v1, v2, color);
}
break;
case ShapeType.Chain:
{
ChainShape chain = (ChainShape)fixture.GetShape();
int count = chain.m_count;
List <Vec2> vertices = chain.m_vertices;
Vec2 v1 = Utilities.Mul(xf, vertices[0]);
for (int i = 1; i < count; ++i)
{
Vec2 v2 = Utilities.Mul(xf, vertices[i]);
m_debugDraw.DrawSegment(v1, v2, color);
m_debugDraw.DrawCircle(v1, 0.05f, color);
v1 = v2;
}
}
break;
case ShapeType.Polygon:
{
PolygonShape poly = (PolygonShape)fixture.GetShape();
int vertexCount = poly.m_count;
Utilities.Assert(vertexCount <= Settings._maxPolygonVertices);
Vec2[] vertices = new Vec2[Settings._maxPolygonVertices];
for (int i = 0; i < vertexCount; ++i)
{
vertices[i] = Utilities.Mul(xf, poly.m_vertices[i]);
}
m_debugDraw.DrawSolidPolygon(vertices, vertexCount, color);
}
break;
default:
break;
}
}
private void SolveTOI(TimeStep step)
{
Island island = new Island(m_contactManager.m_contactListener);
if (m_stepComplete)
{
foreach (Body b in m_bodyList)
{
b.m_flags &= ~Body.BodyFlags.e_islandFlag;
b.m_sweep.alpha0 = 0.0f;
}
foreach (Contact c in m_contactManager.m_contactList)
{
// Invalidate TOI
c.m_flags &= ~(ContactFlags.e_toiFlag | ContactFlags.e_islandFlag);
c.m_toiCount = 0;
c.m_toi = 1.0f;
}
}
Fixture fA = null;
Fixture fB = null;
Body bA = null;
Body bB = null;
// Find TOI events and solve them.
for (;;)
{
// Find the first TOI.
Contact minContact = null;
float minAlpha = 1.0f;
foreach (Contact c in m_contactManager.m_contactList)
{
// Is this contact disabled?
if (c.IsEnabled() == false)
{
continue;
}
// Prevent excessive sub-stepping.
if (c.m_toiCount > Settings._maxSubSteps)
{
continue;
}
float alpha = 1.0f;
if (c.m_flags.HasFlag(ContactFlags.e_toiFlag))
{
// This contact has a valid cached TOI.
alpha = c.m_toi;
}
else
{
fA = c.FixtureA;
fB = c.FixtureB;
// Is there a sensor?
if (fA.IsSensor || fB.IsSensor)
{
continue;
}
bA = fA.GetBody();
bB = fB.GetBody();
BodyType typeA = bA.m_type;
BodyType typeB = bB.m_type;
Utilities.Assert(typeA == BodyType._dynamicBody || typeB == BodyType._dynamicBody);
bool activeA = bA.IsAwake() && typeA != BodyType._staticBody;
bool activeB = bB.IsAwake() && typeB != BodyType._staticBody;
// Is at least one body active (awake and dynamic or kinematic)?
if (activeA == false && activeB == false)
{
continue;
}
bool collideA = bA.IsBullet() || typeA != BodyType._dynamicBody;
bool collideB = bB.IsBullet() || typeB != BodyType._dynamicBody;
// Are these two non-bullet dynamic bodies?
if (collideA == false && collideB == false)
{
continue;
}
// Compute the TOI for this contact.
// Put the sweeps onto the same time interval.
float alpha0 = bA.m_sweep.alpha0;
if (bA.m_sweep.alpha0 < bB.m_sweep.alpha0)
{
alpha0 = bB.m_sweep.alpha0;
bA.m_sweep.Advance(alpha0);
}
else if (bB.m_sweep.alpha0 < bA.m_sweep.alpha0)
{
alpha0 = bA.m_sweep.alpha0;
bB.m_sweep.Advance(alpha0);
}
Utilities.Assert(alpha0 < 1.0f);
int indexA = c.GetChildIndexA();
int indexB = c.GetChildIndexB();
// Compute the time of impact in interval [0, minTOI]
TOIInput input = new TOIInput();
input.proxyA.Set(fA.GetShape(), indexA);
input.proxyB.Set(fB.GetShape(), indexB);
input.sweepA = bA.m_sweep;
input.sweepB = bB.m_sweep;
input.tMax = 1.0f;
TOIOutput output;
Utilities.TimeOfImpact(out output, input);
// Beta is the fraction of the remaining portion of the .
float beta = output.t;
if (output.state == TOIOutput.State.e_touching)
{
alpha = Math.Min(alpha0 + (1.0f - alpha0) * beta, 1.0f);
}
else
{
alpha = 1.0f;
}
c.m_toi = alpha;
c.m_flags |= ContactFlags.e_toiFlag;
}
if (alpha < minAlpha)
{
// This is the minimum TOI found so far.
minContact = c;
minAlpha = alpha;
}
}
if (minContact == null || 1.0f - 10.0f * Single.Epsilon < minAlpha)
{
// No more TOI events. Done!
m_stepComplete = true;
break;
}
// Advance the bodies to the TOI.
fA = minContact.FixtureA;
fB = minContact.FixtureB;
bA = fA.GetBody();
bB = fB.GetBody();
Sweep backup1 = bA.m_sweep;
Sweep backup2 = bB.m_sweep;
bA.Advance(minAlpha);
bB.Advance(minAlpha);
// The TOI contact likely has some new contact points.
minContact.Update(m_contactManager.m_contactListener);
minContact.m_flags &= ~ContactFlags.e_toiFlag;
++minContact.m_toiCount;
// Is the contact solid?
if (minContact.IsEnabled() == false || minContact.IsTouching() == false)
{
// Restore the sweeps.
minContact.SetEnabled(false);
bA.m_sweep = backup1;
bB.m_sweep = backup2;
bA.SynchronizeTransform();
bB.SynchronizeTransform();
continue;
}
bA.SetAwake(true);
bB.SetAwake(true);
// Build the island
island.Clear();
island.Add(bA);
island.Add(bB);
island.Add(minContact);
bA.m_flags |= Body.BodyFlags.e_islandFlag;
bB.m_flags |= Body.BodyFlags.e_islandFlag;
minContact.m_flags |= ContactFlags.e_islandFlag;
// Get contacts on bodyA and bodyB.
Body[] bodies = { bA, bB };
for (int i = 0; i < 2; ++i)
{
Body body = bodies[i];
if (body.m_type == BodyType._dynamicBody)
{
foreach (ContactEdge ce in body.m_contactList)
{
throw new NotImplementedException();
//if (island.m_bodies.Count() == island.m_bodyCapacity)
//{
// break;
//}
//if (island.m_bodies.Count() == island.m_contactCapacity)
//{
// break;
//}
//Contact* contact = ce.contact;
//// Has this contact already been added to the island?
//if (contact.m_flags & ContactFlags.e_islandFlag)
//{
// continue;
//}
//// Only add static, kinematic, or bullet bodies.
//Body* other = ce.other;
//if (other.m_type == _dynamicBody &&
// body.IsBullet() == false && other.IsBullet() == false)
//{
// continue;
//}
//// Skip sensors.
//bool sensorA = contact.m_fixtureA.m_isSensor;
//bool sensorB = contact.m_fixtureB.m_isSensor;
//if (sensorA || sensorB)
//{
// continue;
//}
//// Tentatively advance the body to the TOI.
//Sweep backup = other.m_sweep;
//if ((other.m_flags & Body.BodyFlags.e_islandFlag) == 0)
//{
// other.Advance(minAlpha);
//}
//// Update the contact points
//contact.Update(m_contactManager.m_contactListener);
//// Was the contact disabled by the user?
//if (contact.IsEnabled() == false)
//{
// other.m_sweep = backup;
// other.SynchronizeTransform();
// continue;
//}
//// Are there contact points?
//if (contact.IsTouching() == false)
//{
// other.m_sweep = backup;
// other.SynchronizeTransform();
// continue;
//}
//// Add the contact to the island
//contact.m_flags |= ContactFlags.e_islandFlag;
//island.Add(contact);
//// Has the other body already been added to the island?
//if (other.m_flags & Body.BodyFlags.e_islandFlag)
//{
// continue;
//}
//// Add the other body to the island.
//other.m_flags |= Body.BodyFlags.e_islandFlag;
//if (other.m_type != _staticBody)
//{
// other.SetAwake(true);
//}
//island.Add(other);
}
}
}
TimeStep subStep;
subStep.dt = (1.0f - minAlpha) * step.dt;
subStep.inv_dt = 1.0f / subStep.dt;
subStep.dtRatio = 1.0f;
subStep.positionIterations = 20;
subStep.velocityIterations = step.velocityIterations;
subStep.warmStarting = false;
island.SolveTOI(subStep, bA.m_islandIndex, bB.m_islandIndex);
// Reset island flags and synchronize broad-phase proxies.
for (int i = 0; i < island.m_bodies.Count(); ++i)
{
throw new NotImplementedException();
//Body* body = island.m_bodies[i];
//body.m_flags &= ~Body.BodyFlags.e_islandFlag;
//if (body.m_type != _dynamicBody)
//{
// continue;
//}
//body.SynchronizeFixtures();
//// Invalidate all contact TOIs on this displaced body.
//for (ContactEdge* ce = body.m_contactList; ce; ce = ce.next)
//{
// ce.contact.m_flags &= ~(ContactFlags.e_toiFlag | ContactFlags.e_islandFlag);
//}
}
// Commit fixture proxy movements to the broad-phase so that new contacts are created.
// Also, some contacts can be destroyed.
m_contactManager.FindNewContacts();
if (m_subStepping)
{
m_stepComplete = false;
break;
}
}
}
// Update the contact manifold and touching status.
// Note: do not assume the fixture AABBs are overlapping or are valid.
internal void Update(ContactListener listener)
{
Manifold oldManifold = m_manifold;
// Re-enable this contact.
m_flags |= ContactFlags.e_enabledFlag;
bool touching = false;
bool wasTouching = (m_flags & ContactFlags.e_touchingFlag) == ContactFlags.e_touchingFlag;
bool sensorA = m_fixtureA.IsSensor;
bool sensorB = m_fixtureB.IsSensor;
bool sensor = sensorA || sensorB;
Body bodyA = m_fixtureA.GetBody();
Body bodyB = m_fixtureB.GetBody();
Transform xfA = bodyA.GetTransform();
Transform xfB = bodyB.GetTransform();
// Is this contact a sensor?
if (sensor)
{
Shape shapeA = m_fixtureA.GetShape();
Shape shapeB = m_fixtureB.GetShape();
touching = Collision.TestOverlap(shapeA, m_indexA, shapeB, m_indexB, xfA, xfB);
// Sensors don't generate manifolds.
m_manifold.points.Clear();
}
else
{
Evaluate(out m_manifold, xfA, xfB);
touching = m_manifold.points.Count() > 0;
// Match old contact ids to new contact ids and copy the
// stored impulses to warm start the solver.
for (int i = 0; i < m_manifold.points.Count(); ++i)
{
ManifoldPoint mp2 = m_manifold.points[i];
mp2.normalImpulse = 0.0f;
mp2.tangentImpulse = 0.0f;
ContactID id2 = mp2.id;
for (int j = 0; j < oldManifold.points.Count(); ++j)
{
ManifoldPoint mp1 = oldManifold.points[j];
if (mp1.id.key == id2.key)
{
mp2.normalImpulse = mp1.normalImpulse;
mp2.tangentImpulse = mp1.tangentImpulse;
break;
}
}
}
if (touching != wasTouching)
{
bodyA.SetAwake(true);
bodyB.SetAwake(true);
}
}
if (touching)
{
m_flags |= ContactFlags.e_touchingFlag;
}
else
{
m_flags &= ~ContactFlags.e_touchingFlag;
}
if (wasTouching == false && touching == true && listener != null)
{
listener.BeginContact(this);
}
if (wasTouching == true && touching == false && listener != null)
{
listener.EndContact(this);
}
if (sensor == false && touching && listener != null)
{
listener.PreSolve(this, oldManifold);
}
}
public ContactSolver(ContactSolverDef def)
{
m_step = def.step;
m_positionConstraints = new List <ContactPositionConstraint>();
m_velocityConstraints = new List <ContactVelocityConstraint>();
m_positions = def.positions;
m_velocities = def.velocities;
m_contacts = def.contacts;
// Initialize position independent portions of the constraints.
for (int i = 0; i < def.contacts.Count(); ++i)
{
Contact contact = m_contacts[i];
Fixture fixtureA = contact.m_fixtureA;
Fixture fixtureB = contact.m_fixtureB;
Shape shapeA = fixtureA.GetShape();
Shape shapeB = fixtureB.GetShape();
float radiusA = shapeA.m_radius;
float radiusB = shapeB.m_radius;
Body bodyA = fixtureA.GetBody();
Body bodyB = fixtureB.GetBody();
Manifold manifold = contact.GetManifold();
int pointCount = manifold.points.Count();
Utilities.Assert(pointCount > 0);
ContactVelocityConstraint vc = new ContactVelocityConstraint();
vc.friction = contact.m_friction;
vc.restitution = contact.m_restitution;
vc.tangentSpeed = contact.m_tangentSpeed;
vc.indexA = bodyA.m_islandIndex;
vc.indexB = bodyB.m_islandIndex;
vc.invMassA = bodyA.m_invMass;
vc.invMassB = bodyB.m_invMass;
vc.invIA = bodyA.m_invI;
vc.invIB = bodyB.m_invI;
vc.contactIndex = i;
//vc.points.Count() = pointCount;
vc.K.SetZero();
vc.normalMass.SetZero();
ContactPositionConstraint pc = new ContactPositionConstraint();
pc.indexA = bodyA.m_islandIndex;
pc.indexB = bodyB.m_islandIndex;
pc.invMassA = bodyA.m_invMass;
pc.invMassB = bodyB.m_invMass;
pc.localCenterA = bodyA.m_sweep.localCenter;
pc.localCenterB = bodyB.m_sweep.localCenter;
pc.invIA = bodyA.m_invI;
pc.invIB = bodyB.m_invI;
pc.localNormal = manifold.localNormal;
pc.localPoint = manifold.localPoint;
pc.pointCount = pointCount;
pc.radiusA = radiusA;
pc.radiusB = radiusB;
pc.type = manifold.type;
for (int j = 0; j < pointCount; ++j)
{
ManifoldPoint cp = manifold.points[j];
VelocityConstraintPoint vcp = new VelocityConstraintPoint();
if (m_step.warmStarting)
{
vcp.normalImpulse = m_step.dtRatio * cp.normalImpulse;
vcp.tangentImpulse = m_step.dtRatio * cp.tangentImpulse;
}
else
{
vcp.normalImpulse = 0.0f;
vcp.tangentImpulse = 0.0f;
}
vcp.rA.SetZero();
vcp.rB.SetZero();
vcp.normalMass = 0.0f;
vcp.tangentMass = 0.0f;
vcp.velocityBias = 0.0f;
vc.points.Add(vcp);
pc.localPoints[j] = cp.localPoint;
}
m_velocityConstraints.Add(vc);
m_positionConstraints.Add(pc);
}
}
