public int GetCurrentIndex(Body body)
{
if(bodies.ContainsKey(body))
return bodies[body].GetCurrentIndex();
return -1;
}
public PhysicsState(Body body)
{
this.body = body;
this.time = 0;
this.pointmass_list_positions = new Vector2[body.count];
this.pointmass_list_velocities = new Vector2[body.count];
this.pointmass_list_forces = new Vector2[body.count];
this.curr_shape_positions = new Vector2[body.count];
}
public void Clear()
{
body_a = body_b = null;
pointmass_a = pointmass_b = pointmass_c = new PointMass();
edge_distance = 0f;
point = Vector2.Zero;
normal = Vector2.Zero;
penetration = 0f;
}
public PhysicsHistory(Body body)
{
this.capacity = 512;
this.curr_index = 0;
this.body = body;
this.states = new PhysicsState[capacity];
for (int i = 0; i < states.Length; i++)
states[i] = new PhysicsState(body);
}
public static List<CollisionInfo> Intersects(Body body_a, Body body_b)
{
List<CollisionInfo> data = new List<CollisionInfo>();
int bApmCount = body_a.count;
int bBpmCount = body_b.count;
AxisAlignedBoundingBox boxB = body_b.aabb;
// check all PointMasses on bodyA for collision against bodyB. if there is a collision, return detailed info.
CollisionInfo infoAway = new CollisionInfo();
CollisionInfo infoSame = new CollisionInfo();
for (int i = 0; i < bApmCount; i++)
{
Vector2 pt = body_a.pointmass_list[i].position;
// early out - if this point is outside the bounding box for bodyB, skip it!
if (!boxB.Contains(pt.X, pt.Y))
continue;
// early out - if this point is not inside bodyB, skip it!
if (!body_b.Contains(ref pt))
continue;
int prevPt = (i > 0) ? i - 1 : bApmCount - 1;
int nextPt = (i < bApmCount - 1) ? i + 1 : 0;
Vector2 prev = body_a.pointmass_list[prevPt].position;
Vector2 next = body_a.pointmass_list[nextPt].position;
// now get the normal for this point. (NOT A UNIT VECTOR)
Vector2 fromPrev = new Vector2();
fromPrev.X = pt.X - prev.X;
fromPrev.Y = pt.Y - prev.Y;
Vector2 toNext = new Vector2();
toNext.X = next.X - pt.X;
toNext.Y = next.Y - pt.Y;
Vector2 ptNorm = new Vector2();
ptNorm.X = fromPrev.X + toNext.X;
ptNorm.Y = fromPrev.Y + toNext.Y;
VectorHelper.Perpendicular(ref ptNorm);
// this point is inside the other body. now check if the edges on either side intersect with and edges on bodyB.
float closestAway = 100000.0f;
float closestSame = 100000.0f;
infoAway.Clear();
infoAway.body_a = body_a;
infoAway.pointmass_a = body_a.pointmass_list[i];
infoAway.body_b = body_b;
infoSame.Clear();
infoSame.body_a = body_a;
infoSame.pointmass_a = body_a.pointmass_list[i];
infoSame.body_b = body_b;
bool found = false;
int b1 = 0;
int b2 = 1;
for (int j = 0; j < bBpmCount; j++)
{
Vector2 hitPt;
Vector2 norm;
float edgeD;
b1 = j;
if (j < bBpmCount - 1)
b2 = j + 1;
else
b2 = 0;
Vector2 pt1 = body_b.pointmass_list[b1].position;
Vector2 pt2 = body_b.pointmass_list[b2].position;
// quick test of distance to each point on the edge, if both are greater than current mins, we can skip!
float distToA = ((pt1.X - pt.X) * (pt1.X - pt.X)) + ((pt1.Y - pt.Y) * (pt1.Y - pt.Y));
float distToB = ((pt2.X - pt.X) * (pt2.X - pt.X)) + ((pt2.Y - pt.Y) * (pt2.Y - pt.Y));
if ((distToA > closestAway) && (distToA > closestSame) && (distToB > closestAway) && (distToB > closestSame))
continue;
// test against this edge.
float dist = body_b.GetClosestPointOnEdgeSquared(pt, j, out hitPt, out norm, out edgeD);
// only perform the check if the normal for this edge is facing AWAY from the point normal.
float dot;
Vector2.Dot(ref ptNorm, ref norm, out dot);
if (dot <= 0f)
{
if (dist < closestAway)
{
closestAway = dist;
infoAway.pointmass_b = body_b.pointmass_list[b1];
infoAway.pointmass_c = body_b.pointmass_list[b2];
infoAway.edge_distance = edgeD;
infoAway.point = hitPt;
infoAway.normal = norm;
infoAway.penetration = dist;
found = true;
}
}
else
{
if (dist < closestSame)
{
closestSame = dist;
infoSame.pointmass_b = body_b.pointmass_list[b1];
infoSame.pointmass_c = body_b.pointmass_list[b2];
infoSame.edge_distance = edgeD;
infoSame.point = hitPt;
infoSame.normal = norm;
infoSame.penetration = dist;
}
}
}
// we've checked all edges on BodyB.
if ((found) && (closestAway > 0.3f) && (closestSame < closestAway))
{
infoSame.penetration = (float)Math.Sqrt(infoSame.penetration);
data.Add(infoSame);
}
else
{
infoAway.penetration = (float)Math.Sqrt(infoAway.penetration);
data.Add(infoAway);
}
}
return data;
}
public void Add(Body body)
{
if (!body_list.Contains(body))
body_list.Add(body);
}
public void UpdateBitmask(Body body)
{
AxisAlignedBoundingBox box = body.aabb;
int minX = (int)Math.Floor((box.min.X - aabb.min.X) / cell.X);
int maxX = (int)Math.Floor((box.max.X - aabb.min.X) / cell.X);
if (minX < 0) { minX = 0; } else if (minX > 32) { minX = 32; }
if (maxX < 0) { maxX = 0; } else if (maxX > 32) { maxX = 32; }
int minY = (int)Math.Floor((box.min.Y - aabb.min.Y) / cell.Y);
int maxY = (int)Math.Floor((box.max.Y - aabb.min.Y) / cell.Y);
if (minY < 0) { minY = 0; } else if (minY > 32) { minY = 32; }
if (maxY < 0) { maxY = 0; } else if (maxY > 32) { maxY = 32; }
body.bitmaskx.clear();
for (int i = minX; i <= maxX; i++)
body.bitmaskx.setOn(i);
body.bitmasky.clear();
for (int i = minY; i <= maxY; i++)
body.bitmasky.setOn(i);
}
public void Remove(Body body)
{
if (body_list.Contains(body))
body_list.Remove(body);
}
public void RenderBody(Body body)
{
// RenderAABB(body.aabb);
//RenderShape(body.curr_shape);
RenderOutlines(body.pointmass_list);
// RenderNormals(body.pointmass_list);
}