Server job assigning logic, submarine movement syncing, submarine collision improvements, spawnpoints in levels
This commit is contained in:
Regalis
@@ -0,0 +1,273 @@
|
||||
/*
|
||||
* Farseer Physics Engine:
|
||||
* Copyright (c) 2012 Ian Qvist
|
||||
*
|
||||
* Original source Box2D:
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* This software is provided 'as-is', without any express or implied
|
||||
* warranty. In no event will the authors be held liable for any damages
|
||||
* arising from the use of this software.
|
||||
* Permission is granted to anyone to use this software for any purpose,
|
||||
* including commercial applications, and to alter it and redistribute it
|
||||
* freely, subject to the following restrictions:
|
||||
* 1. The origin of this software must not be misrepresented; you must not
|
||||
* claim that you wrote the original software. If you use this software
|
||||
* in a product, an acknowledgment in the product documentation would be
|
||||
* appreciated but is not required.
|
||||
* 2. Altered source versions must be plainly marked as such, and must not be
|
||||
* misrepresented as being the original software.
|
||||
* 3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
using System.Diagnostics;
|
||||
using FarseerPhysics.Common;
|
||||
using Microsoft.Xna.Framework;
|
||||
|
||||
namespace FarseerPhysics.Collision.Shapes
|
||||
{
|
||||
/// <summary>
|
||||
/// A chain shape is a free form sequence of line segments.
|
||||
/// The chain has two-sided collision, so you can use inside and outside collision.
|
||||
/// Therefore, you may use any winding order.
|
||||
/// Connectivity information is used to create smooth collisions.
|
||||
/// WARNING: The chain will not collide properly if there are self-intersections.
|
||||
/// </summary>
|
||||
public class ChainShape : Shape
|
||||
{
|
||||
/// <summary>
|
||||
/// The vertices. These are not owned/freed by the chain Shape.
|
||||
/// </summary>
|
||||
public Vertices Vertices;
|
||||
private Vector2 _prevVertex, _nextVertex;
|
||||
private bool _hasPrevVertex, _hasNextVertex;
|
||||
private static EdgeShape _edgeShape = new EdgeShape();
|
||||
|
||||
/// <summary>
|
||||
/// Constructor for ChainShape. By default have 0 in density.
|
||||
/// </summary>
|
||||
public ChainShape()
|
||||
: base(0)
|
||||
{
|
||||
ShapeType = ShapeType.Chain;
|
||||
_radius = Settings.PolygonRadius;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a new chainshape from the vertices.
|
||||
/// </summary>
|
||||
/// <param name="vertices">The vertices to use. Must contain 2 or more vertices.</param>
|
||||
/// <param name="createLoop">Set to true to create a closed loop. It connects the first vertice to the last, and automatically adjusts connectivity to create smooth collisions along the chain.</param>
|
||||
public ChainShape(Vertices vertices, bool createLoop = false)
|
||||
: base(0)
|
||||
{
|
||||
ShapeType = ShapeType.Chain;
|
||||
_radius = Settings.PolygonRadius;
|
||||
|
||||
if (!(vertices != null && vertices.Count >= 2))
|
||||
{
|
||||
int lkmsdgkldf = 1;
|
||||
}
|
||||
|
||||
Debug.Assert(vertices != null && vertices.Count >= 2);
|
||||
Debug.Assert(vertices[0] != vertices[vertices.Count - 1]); // FPE. See http://www.box2d.org/forum/viewtopic.php?f=4&t=7973&p=35363
|
||||
|
||||
for (int i = 1; i < vertices.Count; ++i)
|
||||
{
|
||||
Vector2 v1 = vertices[i - 1];
|
||||
Vector2 v2 = vertices[i];
|
||||
|
||||
// If the code crashes here, it means your vertices are too close together.
|
||||
|
||||
if (Vector2.DistanceSquared(v1, v2) < Settings.LinearSlop * Settings.LinearSlop)
|
||||
{
|
||||
int asldmfk = 1;
|
||||
}
|
||||
|
||||
Debug.Assert(Vector2.DistanceSquared(v1, v2) > Settings.LinearSlop * Settings.LinearSlop);
|
||||
}
|
||||
|
||||
Vertices = new Vertices(vertices);
|
||||
|
||||
if (createLoop)
|
||||
{
|
||||
Vertices.Add(vertices[0]);
|
||||
PrevVertex = Vertices[Vertices.Count - 2]; //FPE: We use the properties instead of the private fields here.
|
||||
NextVertex = Vertices[1]; //FPE: We use the properties instead of the private fields here.
|
||||
}
|
||||
}
|
||||
|
||||
public override int ChildCount
|
||||
{
|
||||
// edge count = vertex count - 1
|
||||
get { return Vertices.Count - 1; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Establish connectivity to a vertex that precedes the first vertex.
|
||||
/// Don't call this for loops.
|
||||
/// </summary>
|
||||
public Vector2 PrevVertex
|
||||
{
|
||||
get { return _prevVertex; }
|
||||
set
|
||||
{
|
||||
Debug.Assert(value != null);
|
||||
|
||||
_prevVertex = value;
|
||||
_hasPrevVertex = true;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Establish connectivity to a vertex that follows the last vertex.
|
||||
/// Don't call this for loops.
|
||||
/// </summary>
|
||||
public Vector2 NextVertex
|
||||
{
|
||||
get { return _nextVertex; }
|
||||
set
|
||||
{
|
||||
Debug.Assert(value != null);
|
||||
|
||||
_nextVertex = value;
|
||||
_hasNextVertex = true;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// This method has been optimized to reduce garbage.
|
||||
/// </summary>
|
||||
/// <param name="edge">The cached edge to set properties on.</param>
|
||||
/// <param name="index">The index.</param>
|
||||
internal void GetChildEdge(EdgeShape edge, int index)
|
||||
{
|
||||
Debug.Assert(0 <= index && index < Vertices.Count - 1);
|
||||
Debug.Assert(edge != null);
|
||||
|
||||
edge.ShapeType = ShapeType.Edge;
|
||||
edge._radius = _radius;
|
||||
|
||||
edge.Vertex1 = Vertices[index + 0];
|
||||
edge.Vertex2 = Vertices[index + 1];
|
||||
|
||||
if (index > 0)
|
||||
{
|
||||
edge.Vertex0 = Vertices[index - 1];
|
||||
edge.HasVertex0 = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
edge.Vertex0 = _prevVertex;
|
||||
edge.HasVertex0 = _hasPrevVertex;
|
||||
}
|
||||
|
||||
if (index < Vertices.Count - 2)
|
||||
{
|
||||
edge.Vertex3 = Vertices[index + 2];
|
||||
edge.HasVertex3 = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
edge.Vertex3 = _nextVertex;
|
||||
edge.HasVertex3 = _hasNextVertex;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Get a child edge.
|
||||
/// </summary>
|
||||
/// <param name="index">The index.</param>
|
||||
public EdgeShape GetChildEdge(int index)
|
||||
{
|
||||
EdgeShape edgeShape = new EdgeShape();
|
||||
GetChildEdge(edgeShape, index);
|
||||
return edgeShape;
|
||||
}
|
||||
|
||||
public override bool TestPoint(ref Transform transform, ref Vector2 point)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
public override bool RayCast(out RayCastOutput output, ref RayCastInput input, ref Transform transform, int childIndex)
|
||||
{
|
||||
Debug.Assert(childIndex < Vertices.Count);
|
||||
|
||||
int i1 = childIndex;
|
||||
int i2 = childIndex + 1;
|
||||
if (i2 == Vertices.Count)
|
||||
{
|
||||
i2 = 0;
|
||||
}
|
||||
|
||||
_edgeShape.Vertex1 = Vertices[i1];
|
||||
_edgeShape.Vertex2 = Vertices[i2];
|
||||
|
||||
return _edgeShape.RayCast(out output, ref input, ref transform, 0);
|
||||
}
|
||||
|
||||
public override void ComputeAABB(out AABB aabb, ref Transform transform, int childIndex)
|
||||
{
|
||||
Debug.Assert(childIndex < Vertices.Count);
|
||||
|
||||
int i1 = childIndex;
|
||||
int i2 = childIndex + 1;
|
||||
if (i2 == Vertices.Count)
|
||||
{
|
||||
i2 = 0;
|
||||
}
|
||||
|
||||
Vector2 v1 = MathUtils.Mul(ref transform, Vertices[i1]);
|
||||
Vector2 v2 = MathUtils.Mul(ref transform, Vertices[i2]);
|
||||
|
||||
aabb.LowerBound = Vector2.Min(v1, v2);
|
||||
aabb.UpperBound = Vector2.Max(v1, v2);
|
||||
}
|
||||
|
||||
protected override void ComputeProperties()
|
||||
{
|
||||
//Does nothing. Chain shapes don't have properties.
|
||||
}
|
||||
|
||||
public override float ComputeSubmergedArea(ref Vector2 normal, float offset, ref Transform xf, out Vector2 sc)
|
||||
{
|
||||
sc = Vector2.Zero;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Compare the chain to another chain
|
||||
/// </summary>
|
||||
/// <param name="shape">The other chain</param>
|
||||
/// <returns>True if the two chain shapes are the same</returns>
|
||||
public bool CompareTo(ChainShape shape)
|
||||
{
|
||||
if (Vertices.Count != shape.Vertices.Count)
|
||||
return false;
|
||||
|
||||
for (int i = 0; i < Vertices.Count; i++)
|
||||
{
|
||||
if (Vertices[i] != shape.Vertices[i])
|
||||
return false;
|
||||
}
|
||||
|
||||
return PrevVertex == shape.PrevVertex && NextVertex == shape.NextVertex;
|
||||
}
|
||||
|
||||
public override Shape Clone()
|
||||
{
|
||||
ChainShape clone = new ChainShape();
|
||||
clone.ShapeType = ShapeType;
|
||||
clone._density = _density;
|
||||
clone._radius = _radius;
|
||||
clone.PrevVertex = _prevVertex;
|
||||
clone.NextVertex = _nextVertex;
|
||||
clone._hasNextVertex = _hasNextVertex;
|
||||
clone._hasPrevVertex = _hasPrevVertex;
|
||||
clone.Vertices = new Vertices(Vertices);
|
||||
clone.MassData = MassData;
|
||||
return clone;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,198 @@
|
||||
/*
|
||||
* Farseer Physics Engine:
|
||||
* Copyright (c) 2012 Ian Qvist
|
||||
*
|
||||
* Original source Box2D:
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* This software is provided 'as-is', without any express or implied
|
||||
* warranty. In no event will the authors be held liable for any damages
|
||||
* arising from the use of this software.
|
||||
* Permission is granted to anyone to use this software for any purpose,
|
||||
* including commercial applications, and to alter it and redistribute it
|
||||
* freely, subject to the following restrictions:
|
||||
* 1. The origin of this software must not be misrepresented; you must not
|
||||
* claim that you wrote the original software. If you use this software
|
||||
* in a product, an acknowledgment in the product documentation would be
|
||||
* appreciated but is not required.
|
||||
* 2. Altered source versions must be plainly marked as such, and must not be
|
||||
* misrepresented as being the original software.
|
||||
* 3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
using System;
|
||||
using System.Diagnostics;
|
||||
using FarseerPhysics.Common;
|
||||
using Microsoft.Xna.Framework;
|
||||
|
||||
namespace FarseerPhysics.Collision.Shapes
|
||||
{
|
||||
/// <summary>
|
||||
/// A circle shape.
|
||||
/// </summary>
|
||||
public class CircleShape : Shape
|
||||
{
|
||||
internal Vector2 _position;
|
||||
|
||||
/// <summary>
|
||||
/// Create a new circle with the desired radius and density.
|
||||
/// </summary>
|
||||
/// <param name="radius">The radius of the circle.</param>
|
||||
/// <param name="density">The density of the circle.</param>
|
||||
public CircleShape(float radius, float density)
|
||||
: base(density)
|
||||
{
|
||||
Debug.Assert(radius >= 0);
|
||||
Debug.Assert(density >= 0);
|
||||
|
||||
ShapeType = ShapeType.Circle;
|
||||
_position = Vector2.Zero;
|
||||
Radius = radius; // The Radius property cache 2radius and calls ComputeProperties(). So no need to call ComputeProperties() here.
|
||||
}
|
||||
|
||||
internal CircleShape()
|
||||
: base(0)
|
||||
{
|
||||
ShapeType = ShapeType.Circle;
|
||||
_radius = 0.0f;
|
||||
_position = Vector2.Zero;
|
||||
}
|
||||
|
||||
public override int ChildCount
|
||||
{
|
||||
get { return 1; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Get or set the position of the circle
|
||||
/// </summary>
|
||||
public Vector2 Position
|
||||
{
|
||||
get { return _position; }
|
||||
set
|
||||
{
|
||||
_position = value;
|
||||
ComputeProperties(); //TODO: Optimize here
|
||||
}
|
||||
}
|
||||
|
||||
public override bool TestPoint(ref Transform transform, ref Vector2 point)
|
||||
{
|
||||
Vector2 center = transform.p + MathUtils.Mul(transform.q, Position);
|
||||
Vector2 d = point - center;
|
||||
return Vector2.Dot(d, d) <= _2radius;
|
||||
}
|
||||
|
||||
public override bool RayCast(out RayCastOutput output, ref RayCastInput input, ref Transform transform, int childIndex)
|
||||
{
|
||||
// Collision Detection in Interactive 3D Environments by Gino van den Bergen
|
||||
// From Section 3.1.2
|
||||
// x = s + a * r
|
||||
// norm(x) = radius
|
||||
|
||||
output = new RayCastOutput();
|
||||
|
||||
Vector2 position = transform.p + MathUtils.Mul(transform.q, Position);
|
||||
Vector2 s = input.Point1 - position;
|
||||
float b = Vector2.Dot(s, s) - _2radius;
|
||||
|
||||
// Solve quadratic equation.
|
||||
Vector2 r = input.Point2 - input.Point1;
|
||||
float c = Vector2.Dot(s, r);
|
||||
float rr = Vector2.Dot(r, r);
|
||||
float sigma = c * c - rr * b;
|
||||
|
||||
// Check for negative discriminant and short segment.
|
||||
if (sigma < 0.0f || rr < Settings.Epsilon)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// Find the point of intersection of the line with the circle.
|
||||
float a = -(c + (float)Math.Sqrt(sigma));
|
||||
|
||||
// Is the intersection point on the segment?
|
||||
if (0.0f <= a && a <= input.MaxFraction * rr)
|
||||
{
|
||||
a /= rr;
|
||||
output.Fraction = a;
|
||||
|
||||
//TODO: Check results here
|
||||
output.Normal = s + a * r;
|
||||
output.Normal.Normalize();
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public override void ComputeAABB(out AABB aabb, ref Transform transform, int childIndex)
|
||||
{
|
||||
Vector2 p = transform.p + MathUtils.Mul(transform.q, Position);
|
||||
aabb.LowerBound = new Vector2(p.X - Radius, p.Y - Radius);
|
||||
aabb.UpperBound = new Vector2(p.X + Radius, p.Y + Radius);
|
||||
}
|
||||
|
||||
protected override sealed void ComputeProperties()
|
||||
{
|
||||
float area = Settings.Pi * _2radius;
|
||||
MassData.Area = area;
|
||||
MassData.Mass = Density * area;
|
||||
MassData.Centroid = Position;
|
||||
|
||||
// inertia about the local origin
|
||||
MassData.Inertia = MassData.Mass * (0.5f * _2radius + Vector2.Dot(Position, Position));
|
||||
}
|
||||
|
||||
public override float ComputeSubmergedArea(ref Vector2 normal, float offset, ref Transform xf, out Vector2 sc)
|
||||
{
|
||||
sc = Vector2.Zero;
|
||||
|
||||
Vector2 p = MathUtils.Mul(ref xf, Position);
|
||||
float l = -(Vector2.Dot(normal, p) - offset);
|
||||
if (l < -Radius + Settings.Epsilon)
|
||||
{
|
||||
//Completely dry
|
||||
return 0;
|
||||
}
|
||||
if (l > Radius)
|
||||
{
|
||||
//Completely wet
|
||||
sc = p;
|
||||
return Settings.Pi * _2radius;
|
||||
}
|
||||
|
||||
//Magic
|
||||
float l2 = l * l;
|
||||
float area = _2radius * (float)((Math.Asin(l / Radius) + Settings.Pi / 2) + l * Math.Sqrt(_2radius - l2));
|
||||
float com = -2.0f / 3.0f * (float)Math.Pow(_2radius - l2, 1.5f) / area;
|
||||
|
||||
sc.X = p.X + normal.X * com;
|
||||
sc.Y = p.Y + normal.Y * com;
|
||||
|
||||
return area;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Compare the circle to another circle
|
||||
/// </summary>
|
||||
/// <param name="shape">The other circle</param>
|
||||
/// <returns>True if the two circles are the same size and have the same position</returns>
|
||||
public bool CompareTo(CircleShape shape)
|
||||
{
|
||||
return (Radius == shape.Radius && Position == shape.Position);
|
||||
}
|
||||
|
||||
public override Shape Clone()
|
||||
{
|
||||
CircleShape clone = new CircleShape();
|
||||
clone.ShapeType = ShapeType;
|
||||
clone._radius = Radius;
|
||||
clone._2radius = _2radius; //FPE note: We also copy the cache
|
||||
clone._density = _density;
|
||||
clone._position = _position;
|
||||
clone.MassData = MassData;
|
||||
return clone;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,252 @@
|
||||
/*
|
||||
* Farseer Physics Engine:
|
||||
* Copyright (c) 2012 Ian Qvist
|
||||
*
|
||||
* Original source Box2D:
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* This software is provided 'as-is', without any express or implied
|
||||
* warranty. In no event will the authors be held liable for any damages
|
||||
* arising from the use of this software.
|
||||
* Permission is granted to anyone to use this software for any purpose,
|
||||
* including commercial applications, and to alter it and redistribute it
|
||||
* freely, subject to the following restrictions:
|
||||
* 1. The origin of this software must not be misrepresented; you must not
|
||||
* claim that you wrote the original software. If you use this software
|
||||
* in a product, an acknowledgment in the product documentation would be
|
||||
* appreciated but is not required.
|
||||
* 2. Altered source versions must be plainly marked as such, and must not be
|
||||
* misrepresented as being the original software.
|
||||
* 3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
using FarseerPhysics.Common;
|
||||
using Microsoft.Xna.Framework;
|
||||
|
||||
namespace FarseerPhysics.Collision.Shapes
|
||||
{
|
||||
/// <summary>
|
||||
/// A line segment (edge) shape. These can be connected in chains or loops
|
||||
/// to other edge shapes.
|
||||
/// The connectivity information is used to ensure correct contact normals.
|
||||
/// </summary>
|
||||
public class EdgeShape : Shape
|
||||
{
|
||||
/// <summary>
|
||||
/// Edge start vertex
|
||||
/// </summary>
|
||||
internal Vector2 _vertex1;
|
||||
|
||||
/// <summary>
|
||||
/// Edge end vertex
|
||||
/// </summary>
|
||||
internal Vector2 _vertex2;
|
||||
|
||||
internal EdgeShape()
|
||||
: base(0)
|
||||
{
|
||||
ShapeType = ShapeType.Edge;
|
||||
_radius = Settings.PolygonRadius;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a new EdgeShape with the specified start and end.
|
||||
/// </summary>
|
||||
/// <param name="start">The start of the edge.</param>
|
||||
/// <param name="end">The end of the edge.</param>
|
||||
public EdgeShape(Vector2 start, Vector2 end)
|
||||
: base(0)
|
||||
{
|
||||
ShapeType = ShapeType.Edge;
|
||||
_radius = Settings.PolygonRadius;
|
||||
Set(start, end);
|
||||
}
|
||||
|
||||
public override int ChildCount
|
||||
{
|
||||
get { return 1; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Is true if the edge is connected to an adjacent vertex before vertex 1.
|
||||
/// </summary>
|
||||
public bool HasVertex0 { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Is true if the edge is connected to an adjacent vertex after vertex2.
|
||||
/// </summary>
|
||||
public bool HasVertex3 { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Optional adjacent vertices. These are used for smooth collision.
|
||||
/// </summary>
|
||||
public Vector2 Vertex0 { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Optional adjacent vertices. These are used for smooth collision.
|
||||
/// </summary>
|
||||
public Vector2 Vertex3 { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// These are the edge vertices
|
||||
/// </summary>
|
||||
public Vector2 Vertex1
|
||||
{
|
||||
get { return _vertex1; }
|
||||
set
|
||||
{
|
||||
_vertex1 = value;
|
||||
ComputeProperties();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// These are the edge vertices
|
||||
/// </summary>
|
||||
public Vector2 Vertex2
|
||||
{
|
||||
get { return _vertex2; }
|
||||
set
|
||||
{
|
||||
_vertex2 = value;
|
||||
ComputeProperties();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Set this as an isolated edge.
|
||||
/// </summary>
|
||||
/// <param name="start">The start.</param>
|
||||
/// <param name="end">The end.</param>
|
||||
public void Set(Vector2 start, Vector2 end)
|
||||
{
|
||||
_vertex1 = start;
|
||||
_vertex2 = end;
|
||||
HasVertex0 = false;
|
||||
HasVertex3 = false;
|
||||
|
||||
ComputeProperties();
|
||||
}
|
||||
|
||||
public override bool TestPoint(ref Transform transform, ref Vector2 point)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
public override bool RayCast(out RayCastOutput output, ref RayCastInput input, ref Transform transform, int childIndex)
|
||||
{
|
||||
// p = p1 + t * d
|
||||
// v = v1 + s * e
|
||||
// p1 + t * d = v1 + s * e
|
||||
// s * e - t * d = p1 - v1
|
||||
|
||||
output = new RayCastOutput();
|
||||
|
||||
// Put the ray into the edge's frame of reference.
|
||||
Vector2 p1 = MathUtils.MulT(transform.q, input.Point1 - transform.p);
|
||||
Vector2 p2 = MathUtils.MulT(transform.q, input.Point2 - transform.p);
|
||||
Vector2 d = p2 - p1;
|
||||
|
||||
Vector2 v1 = _vertex1;
|
||||
Vector2 v2 = _vertex2;
|
||||
Vector2 e = v2 - v1;
|
||||
Vector2 normal = new Vector2(e.Y, -e.X); //TODO: Could possibly cache the normal.
|
||||
normal.Normalize();
|
||||
|
||||
// q = p1 + t * d
|
||||
// dot(normal, q - v1) = 0
|
||||
// dot(normal, p1 - v1) + t * dot(normal, d) = 0
|
||||
float numerator = Vector2.Dot(normal, v1 - p1);
|
||||
float denominator = Vector2.Dot(normal, d);
|
||||
|
||||
if (denominator == 0.0f)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
float t = numerator / denominator;
|
||||
if (t < 0.0f || input.MaxFraction < t)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
Vector2 q = p1 + t * d;
|
||||
|
||||
// q = v1 + s * r
|
||||
// s = dot(q - v1, r) / dot(r, r)
|
||||
Vector2 r = v2 - v1;
|
||||
float rr = Vector2.Dot(r, r);
|
||||
if (rr == 0.0f)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
float s = Vector2.Dot(q - v1, r) / rr;
|
||||
if (s < 0.0f || 1.0f < s)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
output.Fraction = t;
|
||||
if (numerator > 0.0f)
|
||||
{
|
||||
output.Normal = -normal;
|
||||
}
|
||||
else
|
||||
{
|
||||
output.Normal = normal;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public override void ComputeAABB(out AABB aabb, ref Transform transform, int childIndex)
|
||||
{
|
||||
Vector2 v1 = MathUtils.Mul(ref transform, _vertex1);
|
||||
Vector2 v2 = MathUtils.Mul(ref transform, _vertex2);
|
||||
|
||||
Vector2 lower = Vector2.Min(v1, v2);
|
||||
Vector2 upper = Vector2.Max(v1, v2);
|
||||
|
||||
Vector2 r = new Vector2(Radius, Radius);
|
||||
aabb.LowerBound = lower - r;
|
||||
aabb.UpperBound = upper + r;
|
||||
}
|
||||
|
||||
protected override void ComputeProperties()
|
||||
{
|
||||
MassData.Centroid = 0.5f * (_vertex1 + _vertex2);
|
||||
}
|
||||
|
||||
public override float ComputeSubmergedArea(ref Vector2 normal, float offset, ref Transform xf, out Vector2 sc)
|
||||
{
|
||||
sc = Vector2.Zero;
|
||||
return 0;
|
||||
}
|
||||
|
||||
public bool CompareTo(EdgeShape shape)
|
||||
{
|
||||
return (HasVertex0 == shape.HasVertex0 &&
|
||||
HasVertex3 == shape.HasVertex3 &&
|
||||
Vertex0 == shape.Vertex0 &&
|
||||
Vertex1 == shape.Vertex1 &&
|
||||
Vertex2 == shape.Vertex2 &&
|
||||
Vertex3 == shape.Vertex3);
|
||||
}
|
||||
|
||||
public override Shape Clone()
|
||||
{
|
||||
EdgeShape clone = new EdgeShape();
|
||||
clone.ShapeType = ShapeType;
|
||||
clone._radius = _radius;
|
||||
clone._density = _density;
|
||||
clone.HasVertex0 = HasVertex0;
|
||||
clone.HasVertex3 = HasVertex3;
|
||||
clone.Vertex0 = Vertex0;
|
||||
clone._vertex1 = _vertex1;
|
||||
clone._vertex2 = _vertex2;
|
||||
clone.Vertex3 = Vertex3;
|
||||
clone.MassData = MassData;
|
||||
return clone;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,471 @@
|
||||
/*
|
||||
* Farseer Physics Engine:
|
||||
* Copyright (c) 2012 Ian Qvist
|
||||
*
|
||||
* Original source Box2D:
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* This software is provided 'as-is', without any express or implied
|
||||
* warranty. In no event will the authors be held liable for any damages
|
||||
* arising from the use of this software.
|
||||
* Permission is granted to anyone to use this software for any purpose,
|
||||
* including commercial applications, and to alter it and redistribute it
|
||||
* freely, subject to the following restrictions:
|
||||
* 1. The origin of this software must not be misrepresented; you must not
|
||||
* claim that you wrote the original software. If you use this software
|
||||
* in a product, an acknowledgment in the product documentation would be
|
||||
* appreciated but is not required.
|
||||
* 2. Altered source versions must be plainly marked as such, and must not be
|
||||
* misrepresented as being the original software.
|
||||
* 3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
using System.Diagnostics;
|
||||
using FarseerPhysics.Common;
|
||||
using FarseerPhysics.Common.ConvexHull;
|
||||
using Microsoft.Xna.Framework;
|
||||
|
||||
namespace FarseerPhysics.Collision.Shapes
|
||||
{
|
||||
/// <summary>
|
||||
/// Represents a simple non-selfintersecting convex polygon.
|
||||
/// Create a convex hull from the given array of points.
|
||||
/// </summary>
|
||||
public class PolygonShape : Shape
|
||||
{
|
||||
private Vertices _vertices;
|
||||
private Vertices _normals;
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the <see cref="PolygonShape"/> class.
|
||||
/// </summary>
|
||||
/// <param name="vertices">The vertices.</param>
|
||||
/// <param name="density">The density.</param>
|
||||
public PolygonShape(Vertices vertices, float density)
|
||||
: base(density)
|
||||
{
|
||||
ShapeType = ShapeType.Polygon;
|
||||
_radius = Settings.PolygonRadius;
|
||||
|
||||
Vertices = vertices;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a new PolygonShape with the specified density.
|
||||
/// </summary>
|
||||
/// <param name="density">The density.</param>
|
||||
public PolygonShape(float density)
|
||||
: base(density)
|
||||
{
|
||||
Debug.Assert(density >= 0f);
|
||||
|
||||
ShapeType = ShapeType.Polygon;
|
||||
_radius = Settings.PolygonRadius;
|
||||
_vertices = new Vertices(Settings.MaxPolygonVertices);
|
||||
_normals = new Vertices(Settings.MaxPolygonVertices);
|
||||
}
|
||||
|
||||
internal PolygonShape()
|
||||
: base(0)
|
||||
{
|
||||
ShapeType = ShapeType.Polygon;
|
||||
_radius = Settings.PolygonRadius;
|
||||
_vertices = new Vertices(Settings.MaxPolygonVertices);
|
||||
_normals = new Vertices(Settings.MaxPolygonVertices);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a convex hull from the given array of local points.
|
||||
/// The number of vertices must be in the range [3, Settings.MaxPolygonVertices].
|
||||
/// Warning: the points may be re-ordered, even if they form a convex polygon
|
||||
/// Warning: collinear points are handled but not removed. Collinear points may lead to poor stacking behavior.
|
||||
/// </summary>
|
||||
public Vertices Vertices
|
||||
{
|
||||
get { return _vertices; }
|
||||
set
|
||||
{
|
||||
_vertices = new Vertices(value);
|
||||
|
||||
//Debug.Assert(_vertices.Count >= 3 && _vertices.Count <= Settings.MaxPolygonVertices);
|
||||
|
||||
if (Settings.UseConvexHullPolygons)
|
||||
{
|
||||
//FPE note: This check is required as the GiftWrap algorithm early exits on triangles
|
||||
//So instead of giftwrapping a triangle, we just force it to be clock wise.
|
||||
if (_vertices.Count <= 3)
|
||||
_vertices.ForceCounterClockWise();
|
||||
else
|
||||
_vertices = GiftWrap.GetConvexHull(_vertices);
|
||||
}
|
||||
|
||||
_normals = new Vertices(_vertices.Count);
|
||||
|
||||
// Compute normals. Ensure the edges have non-zero length.
|
||||
for (int i = 0; i < _vertices.Count; ++i)
|
||||
{
|
||||
int next = i + 1 < _vertices.Count ? i + 1 : 0;
|
||||
Vector2 edge = _vertices[next] - _vertices[i];
|
||||
Debug.Assert(edge.LengthSquared() > Settings.Epsilon * Settings.Epsilon);
|
||||
|
||||
//FPE optimization: Normals.Add(MathHelper.Cross(edge, 1.0f));
|
||||
Vector2 temp = new Vector2(edge.Y, -edge.X);
|
||||
temp.Normalize();
|
||||
_normals.Add(temp);
|
||||
}
|
||||
|
||||
// Compute the polygon mass data
|
||||
ComputeProperties();
|
||||
}
|
||||
}
|
||||
|
||||
public Vertices Normals { get { return _normals; } }
|
||||
|
||||
public override int ChildCount { get { return 1; } }
|
||||
|
||||
protected override void ComputeProperties()
|
||||
{
|
||||
// Polygon mass, centroid, and inertia.
|
||||
// Let rho be the polygon density in mass per unit area.
|
||||
// Then:
|
||||
// mass = rho * int(dA)
|
||||
// centroid.X = (1/mass) * rho * int(x * dA)
|
||||
// centroid.Y = (1/mass) * rho * int(y * dA)
|
||||
// I = rho * int((x*x + y*y) * dA)
|
||||
//
|
||||
// We can compute these integrals by summing all the integrals
|
||||
// for each triangle of the polygon. To evaluate the integral
|
||||
// for a single triangle, we make a change of variables to
|
||||
// the (u,v) coordinates of the triangle:
|
||||
// x = x0 + e1x * u + e2x * v
|
||||
// y = y0 + e1y * u + e2y * v
|
||||
// where 0 <= u && 0 <= v && u + v <= 1.
|
||||
//
|
||||
// We integrate u from [0,1-v] and then v from [0,1].
|
||||
// We also need to use the Jacobian of the transformation:
|
||||
// D = cross(e1, e2)
|
||||
//
|
||||
// Simplification: triangle centroid = (1/3) * (p1 + p2 + p3)
|
||||
//
|
||||
// The rest of the derivation is handled by computer algebra.
|
||||
|
||||
Debug.Assert(Vertices.Count >= 3);
|
||||
|
||||
//FPE optimization: Early exit as polygons with 0 density does not have any properties.
|
||||
if (_density <= 0)
|
||||
return;
|
||||
|
||||
//FPE optimization: Consolidated the calculate centroid and mass code to a single method.
|
||||
Vector2 center = Vector2.Zero;
|
||||
float area = 0.0f;
|
||||
float I = 0.0f;
|
||||
|
||||
// pRef is the reference point for forming triangles.
|
||||
// It's location doesn't change the result (except for rounding error).
|
||||
Vector2 s = Vector2.Zero;
|
||||
|
||||
// This code would put the reference point inside the polygon.
|
||||
for (int i = 0; i < Vertices.Count; ++i)
|
||||
{
|
||||
s += Vertices[i];
|
||||
}
|
||||
s *= 1.0f / Vertices.Count;
|
||||
|
||||
const float k_inv3 = 1.0f / 3.0f;
|
||||
|
||||
for (int i = 0; i < Vertices.Count; ++i)
|
||||
{
|
||||
// Triangle vertices.
|
||||
Vector2 e1 = Vertices[i] - s;
|
||||
Vector2 e2 = i + 1 < Vertices.Count ? Vertices[i + 1] - s : Vertices[0] - s;
|
||||
|
||||
float D = MathUtils.Cross(e1, e2);
|
||||
|
||||
float triangleArea = 0.5f * D;
|
||||
area += triangleArea;
|
||||
|
||||
// Area weighted centroid
|
||||
center += triangleArea * k_inv3 * (e1 + e2);
|
||||
|
||||
float ex1 = e1.X, ey1 = e1.Y;
|
||||
float ex2 = e2.X, ey2 = e2.Y;
|
||||
|
||||
float intx2 = ex1 * ex1 + ex2 * ex1 + ex2 * ex2;
|
||||
float inty2 = ey1 * ey1 + ey2 * ey1 + ey2 * ey2;
|
||||
|
||||
I += (0.25f * k_inv3 * D) * (intx2 + inty2);
|
||||
}
|
||||
|
||||
//The area is too small for the engine to handle.
|
||||
Debug.Assert(area > Settings.Epsilon);
|
||||
|
||||
// We save the area
|
||||
MassData.Area = area;
|
||||
|
||||
// Total mass
|
||||
MassData.Mass = _density * area;
|
||||
|
||||
// Center of mass
|
||||
center *= 1.0f / area;
|
||||
MassData.Centroid = center + s;
|
||||
|
||||
// Inertia tensor relative to the local origin (point s).
|
||||
MassData.Inertia = _density * I;
|
||||
|
||||
// Shift to center of mass then to original body origin.
|
||||
MassData.Inertia += MassData.Mass * (Vector2.Dot(MassData.Centroid, MassData.Centroid) - Vector2.Dot(center, center));
|
||||
}
|
||||
|
||||
public override bool TestPoint(ref Transform transform, ref Vector2 point)
|
||||
{
|
||||
Vector2 pLocal = MathUtils.MulT(transform.q, point - transform.p);
|
||||
|
||||
for (int i = 0; i < Vertices.Count; ++i)
|
||||
{
|
||||
float dot = Vector2.Dot(Normals[i], pLocal - Vertices[i]);
|
||||
if (dot > 0.0f)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
public override bool RayCast(out RayCastOutput output, ref RayCastInput input, ref Transform transform, int childIndex)
|
||||
{
|
||||
output = new RayCastOutput();
|
||||
|
||||
// Put the ray into the polygon's frame of reference.
|
||||
Vector2 p1 = MathUtils.MulT(transform.q, input.Point1 - transform.p);
|
||||
Vector2 p2 = MathUtils.MulT(transform.q, input.Point2 - transform.p);
|
||||
Vector2 d = p2 - p1;
|
||||
|
||||
float lower = 0.0f, upper = input.MaxFraction;
|
||||
|
||||
int index = -1;
|
||||
|
||||
for (int i = 0; i < Vertices.Count; ++i)
|
||||
{
|
||||
// p = p1 + a * d
|
||||
// dot(normal, p - v) = 0
|
||||
// dot(normal, p1 - v) + a * dot(normal, d) = 0
|
||||
float numerator = Vector2.Dot(Normals[i], Vertices[i] - p1);
|
||||
float denominator = Vector2.Dot(Normals[i], d);
|
||||
|
||||
if (denominator == 0.0f)
|
||||
{
|
||||
if (numerator < 0.0f)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Note: we want this predicate without division:
|
||||
// lower < numerator / denominator, where denominator < 0
|
||||
// Since denominator < 0, we have to flip the inequality:
|
||||
// lower < numerator / denominator <==> denominator * lower > numerator.
|
||||
if (denominator < 0.0f && numerator < lower * denominator)
|
||||
{
|
||||
// Increase lower.
|
||||
// The segment enters this half-space.
|
||||
lower = numerator / denominator;
|
||||
index = i;
|
||||
}
|
||||
else if (denominator > 0.0f && numerator < upper * denominator)
|
||||
{
|
||||
// Decrease upper.
|
||||
// The segment exits this half-space.
|
||||
upper = numerator / denominator;
|
||||
}
|
||||
}
|
||||
|
||||
// The use of epsilon here causes the assert on lower to trip
|
||||
// in some cases. Apparently the use of epsilon was to make edge
|
||||
// shapes work, but now those are handled separately.
|
||||
//if (upper < lower - b2_epsilon)
|
||||
if (upper < lower)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
Debug.Assert(0.0f <= lower && lower <= input.MaxFraction);
|
||||
|
||||
if (index >= 0)
|
||||
{
|
||||
output.Fraction = lower;
|
||||
output.Normal = MathUtils.Mul(transform.q, Normals[index]);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Given a transform, compute the associated axis aligned bounding box for a child shape.
|
||||
/// </summary>
|
||||
/// <param name="aabb">The aabb results.</param>
|
||||
/// <param name="transform">The world transform of the shape.</param>
|
||||
/// <param name="childIndex">The child shape index.</param>
|
||||
public override void ComputeAABB(out AABB aabb, ref Transform transform, int childIndex)
|
||||
{
|
||||
Vector2 lower = MathUtils.Mul(ref transform, Vertices[0]);
|
||||
Vector2 upper = lower;
|
||||
|
||||
for (int i = 1; i < Vertices.Count; ++i)
|
||||
{
|
||||
Vector2 v = MathUtils.Mul(ref transform, Vertices[i]);
|
||||
lower = Vector2.Min(lower, v);
|
||||
upper = Vector2.Max(upper, v);
|
||||
}
|
||||
|
||||
Vector2 r = new Vector2(Radius, Radius);
|
||||
aabb.LowerBound = lower - r;
|
||||
aabb.UpperBound = upper + r;
|
||||
}
|
||||
|
||||
public override float ComputeSubmergedArea(ref Vector2 normal, float offset, ref Transform xf, out Vector2 sc)
|
||||
{
|
||||
sc = Vector2.Zero;
|
||||
|
||||
//Transform plane into shape co-ordinates
|
||||
Vector2 normalL = MathUtils.MulT(xf.q, normal);
|
||||
float offsetL = offset - Vector2.Dot(normal, xf.p);
|
||||
|
||||
float[] depths = new float[Settings.MaxPolygonVertices];
|
||||
int diveCount = 0;
|
||||
int intoIndex = -1;
|
||||
int outoIndex = -1;
|
||||
|
||||
bool lastSubmerged = false;
|
||||
int i;
|
||||
for (i = 0; i < Vertices.Count; i++)
|
||||
{
|
||||
depths[i] = Vector2.Dot(normalL, Vertices[i]) - offsetL;
|
||||
bool isSubmerged = depths[i] < -Settings.Epsilon;
|
||||
if (i > 0)
|
||||
{
|
||||
if (isSubmerged)
|
||||
{
|
||||
if (!lastSubmerged)
|
||||
{
|
||||
intoIndex = i - 1;
|
||||
diveCount++;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (lastSubmerged)
|
||||
{
|
||||
outoIndex = i - 1;
|
||||
diveCount++;
|
||||
}
|
||||
}
|
||||
}
|
||||
lastSubmerged = isSubmerged;
|
||||
}
|
||||
switch (diveCount)
|
||||
{
|
||||
case 0:
|
||||
if (lastSubmerged)
|
||||
{
|
||||
//Completely submerged
|
||||
sc = MathUtils.Mul(ref xf, MassData.Centroid);
|
||||
return MassData.Mass / Density;
|
||||
}
|
||||
|
||||
//Completely dry
|
||||
return 0;
|
||||
case 1:
|
||||
if (intoIndex == -1)
|
||||
{
|
||||
intoIndex = Vertices.Count - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
outoIndex = Vertices.Count - 1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
int intoIndex2 = (intoIndex + 1) % Vertices.Count;
|
||||
int outoIndex2 = (outoIndex + 1) % Vertices.Count;
|
||||
|
||||
float intoLambda = (0 - depths[intoIndex]) / (depths[intoIndex2] - depths[intoIndex]);
|
||||
float outoLambda = (0 - depths[outoIndex]) / (depths[outoIndex2] - depths[outoIndex]);
|
||||
|
||||
Vector2 intoVec = new Vector2(Vertices[intoIndex].X * (1 - intoLambda) + Vertices[intoIndex2].X * intoLambda, Vertices[intoIndex].Y * (1 - intoLambda) + Vertices[intoIndex2].Y * intoLambda);
|
||||
Vector2 outoVec = new Vector2(Vertices[outoIndex].X * (1 - outoLambda) + Vertices[outoIndex2].X * outoLambda, Vertices[outoIndex].Y * (1 - outoLambda) + Vertices[outoIndex2].Y * outoLambda);
|
||||
|
||||
//Initialize accumulator
|
||||
float area = 0;
|
||||
Vector2 center = new Vector2(0, 0);
|
||||
Vector2 p2 = Vertices[intoIndex2];
|
||||
|
||||
const float k_inv3 = 1.0f / 3.0f;
|
||||
|
||||
//An awkward loop from intoIndex2+1 to outIndex2
|
||||
i = intoIndex2;
|
||||
while (i != outoIndex2)
|
||||
{
|
||||
i = (i + 1) % Vertices.Count;
|
||||
Vector2 p3;
|
||||
if (i == outoIndex2)
|
||||
p3 = outoVec;
|
||||
else
|
||||
p3 = Vertices[i];
|
||||
//Add the triangle formed by intoVec,p2,p3
|
||||
{
|
||||
Vector2 e1 = p2 - intoVec;
|
||||
Vector2 e2 = p3 - intoVec;
|
||||
|
||||
float D = MathUtils.Cross(e1, e2);
|
||||
|
||||
float triangleArea = 0.5f * D;
|
||||
|
||||
area += triangleArea;
|
||||
|
||||
// Area weighted centroid
|
||||
center += triangleArea * k_inv3 * (intoVec + p2 + p3);
|
||||
}
|
||||
|
||||
p2 = p3;
|
||||
}
|
||||
|
||||
//Normalize and transform centroid
|
||||
center *= 1.0f / area;
|
||||
|
||||
sc = MathUtils.Mul(ref xf, center);
|
||||
|
||||
return area;
|
||||
}
|
||||
|
||||
public bool CompareTo(PolygonShape shape)
|
||||
{
|
||||
if (Vertices.Count != shape.Vertices.Count)
|
||||
return false;
|
||||
|
||||
for (int i = 0; i < Vertices.Count; i++)
|
||||
{
|
||||
if (Vertices[i] != shape.Vertices[i])
|
||||
return false;
|
||||
}
|
||||
|
||||
return (Radius == shape.Radius && MassData == shape.MassData);
|
||||
}
|
||||
|
||||
public override Shape Clone()
|
||||
{
|
||||
PolygonShape clone = new PolygonShape();
|
||||
clone.ShapeType = ShapeType;
|
||||
clone._radius = _radius;
|
||||
clone._density = _density;
|
||||
clone._vertices = new Vertices(_vertices);
|
||||
clone._normals = new Vertices(_normals);
|
||||
clone.MassData = MassData;
|
||||
return clone;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,255 @@
|
||||
/*
|
||||
* Farseer Physics Engine:
|
||||
* Copyright (c) 2012 Ian Qvist
|
||||
*
|
||||
* Original source Box2D:
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* This software is provided 'as-is', without any express or implied
|
||||
* warranty. In no event will the authors be held liable for any damages
|
||||
* arising from the use of this software.
|
||||
* Permission is granted to anyone to use this software for any purpose,
|
||||
* including commercial applications, and to alter it and redistribute it
|
||||
* freely, subject to the following restrictions:
|
||||
* 1. The origin of this software must not be misrepresented; you must not
|
||||
* claim that you wrote the original software. If you use this software
|
||||
* in a product, an acknowledgment in the product documentation would be
|
||||
* appreciated but is not required.
|
||||
* 2. Altered source versions must be plainly marked as such, and must not be
|
||||
* misrepresented as being the original software.
|
||||
* 3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
using System;
|
||||
using System.Diagnostics;
|
||||
using FarseerPhysics.Common;
|
||||
using Microsoft.Xna.Framework;
|
||||
|
||||
namespace FarseerPhysics.Collision.Shapes
|
||||
{
|
||||
/// <summary>
|
||||
/// This holds the mass data computed for a shape.
|
||||
/// </summary>
|
||||
public struct MassData : IEquatable<MassData>
|
||||
{
|
||||
/// <summary>
|
||||
/// The area of the shape
|
||||
/// </summary>
|
||||
public float Area { get; internal set; }
|
||||
|
||||
/// <summary>
|
||||
/// The position of the shape's centroid relative to the shape's origin.
|
||||
/// </summary>
|
||||
public Vector2 Centroid { get; internal set; }
|
||||
|
||||
/// <summary>
|
||||
/// The rotational inertia of the shape about the local origin.
|
||||
/// </summary>
|
||||
public float Inertia { get; internal set; }
|
||||
|
||||
/// <summary>
|
||||
/// The mass of the shape, usually in kilograms.
|
||||
/// </summary>
|
||||
public float Mass { get; internal set; }
|
||||
|
||||
/// <summary>
|
||||
/// The equal operator
|
||||
/// </summary>
|
||||
/// <param name="left"></param>
|
||||
/// <param name="right"></param>
|
||||
/// <returns></returns>
|
||||
public static bool operator ==(MassData left, MassData right)
|
||||
{
|
||||
return (left.Area == right.Area && left.Mass == right.Mass && left.Centroid == right.Centroid && left.Inertia == right.Inertia);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The not equal operator
|
||||
/// </summary>
|
||||
/// <param name="left"></param>
|
||||
/// <param name="right"></param>
|
||||
/// <returns></returns>
|
||||
public static bool operator !=(MassData left, MassData right)
|
||||
{
|
||||
return !(left == right);
|
||||
}
|
||||
|
||||
public bool Equals(MassData other)
|
||||
{
|
||||
return this == other;
|
||||
}
|
||||
|
||||
public override bool Equals(object obj)
|
||||
{
|
||||
if (ReferenceEquals(null, obj))
|
||||
return false;
|
||||
|
||||
if (obj.GetType() != typeof(MassData))
|
||||
return false;
|
||||
|
||||
return Equals((MassData)obj);
|
||||
}
|
||||
|
||||
public override int GetHashCode()
|
||||
{
|
||||
unchecked
|
||||
{
|
||||
int result = Area.GetHashCode();
|
||||
result = (result * 397) ^ Centroid.GetHashCode();
|
||||
result = (result * 397) ^ Inertia.GetHashCode();
|
||||
result = (result * 397) ^ Mass.GetHashCode();
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public enum ShapeType
|
||||
{
|
||||
Unknown = -1,
|
||||
Circle = 0,
|
||||
Edge = 1,
|
||||
Polygon = 2,
|
||||
Chain = 3,
|
||||
TypeCount = 4,
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A shape is used for collision detection. You can create a shape however you like.
|
||||
/// Shapes used for simulation in World are created automatically when a Fixture
|
||||
/// is created. Shapes may encapsulate a one or more child shapes.
|
||||
/// </summary>
|
||||
public abstract class Shape
|
||||
{
|
||||
internal float _density;
|
||||
internal float _radius;
|
||||
internal float _2radius;
|
||||
|
||||
protected Shape(float density)
|
||||
{
|
||||
_density = density;
|
||||
ShapeType = ShapeType.Unknown;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Contains the properties of the shape such as:
|
||||
/// - Area of the shape
|
||||
/// - Centroid
|
||||
/// - Inertia
|
||||
/// - Mass
|
||||
/// </summary>
|
||||
public MassData MassData;
|
||||
|
||||
/// <summary>
|
||||
/// Get the type of this shape.
|
||||
/// </summary>
|
||||
/// <value>The type of the shape.</value>
|
||||
public ShapeType ShapeType { get; internal set; }
|
||||
|
||||
/// <summary>
|
||||
/// Get the number of child primitives.
|
||||
/// </summary>
|
||||
/// <value></value>
|
||||
public abstract int ChildCount { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Gets or sets the density.
|
||||
/// Changing the density causes a recalculation of shape properties.
|
||||
/// </summary>
|
||||
/// <value>The density.</value>
|
||||
public float Density
|
||||
{
|
||||
get { return _density; }
|
||||
set
|
||||
{
|
||||
Debug.Assert(value >= 0);
|
||||
|
||||
_density = value;
|
||||
ComputeProperties();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Radius of the Shape
|
||||
/// Changing the radius causes a recalculation of shape properties.
|
||||
/// </summary>
|
||||
public float Radius
|
||||
{
|
||||
get { return _radius; }
|
||||
set
|
||||
{
|
||||
Debug.Assert(value >= 0);
|
||||
|
||||
_radius = value;
|
||||
_2radius = _radius * _radius;
|
||||
|
||||
ComputeProperties();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Clone the concrete shape
|
||||
/// </summary>
|
||||
/// <returns>A clone of the shape</returns>
|
||||
public abstract Shape Clone();
|
||||
|
||||
/// <summary>
|
||||
/// Test a point for containment in this shape.
|
||||
/// Note: This only works for convex shapes.
|
||||
/// </summary>
|
||||
/// <param name="transform">The shape world transform.</param>
|
||||
/// <param name="point">A point in world coordinates.</param>
|
||||
/// <returns>True if the point is inside the shape</returns>
|
||||
public abstract bool TestPoint(ref Transform transform, ref Vector2 point);
|
||||
|
||||
/// <summary>
|
||||
/// Cast a ray against a child shape.
|
||||
/// </summary>
|
||||
/// <param name="output">The ray-cast results.</param>
|
||||
/// <param name="input">The ray-cast input parameters.</param>
|
||||
/// <param name="transform">The transform to be applied to the shape.</param>
|
||||
/// <param name="childIndex">The child shape index.</param>
|
||||
/// <returns>True if the ray-cast hits the shape</returns>
|
||||
public abstract bool RayCast(out RayCastOutput output, ref RayCastInput input, ref Transform transform, int childIndex);
|
||||
|
||||
/// <summary>
|
||||
/// Given a transform, compute the associated axis aligned bounding box for a child shape.
|
||||
/// </summary>
|
||||
/// <param name="aabb">The aabb results.</param>
|
||||
/// <param name="transform">The world transform of the shape.</param>
|
||||
/// <param name="childIndex">The child shape index.</param>
|
||||
public abstract void ComputeAABB(out AABB aabb, ref Transform transform, int childIndex);
|
||||
|
||||
/// <summary>
|
||||
/// Compute the mass properties of this shape using its dimensions and density.
|
||||
/// The inertia tensor is computed about the local origin, not the centroid.
|
||||
/// </summary>
|
||||
protected abstract void ComputeProperties();
|
||||
|
||||
/// <summary>
|
||||
/// Compare this shape to another shape based on type and properties.
|
||||
/// </summary>
|
||||
/// <param name="shape">The other shape</param>
|
||||
/// <returns>True if the two shapes are the same.</returns>
|
||||
public bool CompareTo(Shape shape)
|
||||
{
|
||||
if (shape is PolygonShape && this is PolygonShape)
|
||||
return ((PolygonShape)this).CompareTo((PolygonShape)shape);
|
||||
|
||||
if (shape is CircleShape && this is CircleShape)
|
||||
return ((CircleShape)this).CompareTo((CircleShape)shape);
|
||||
|
||||
if (shape is EdgeShape && this is EdgeShape)
|
||||
return ((EdgeShape)this).CompareTo((EdgeShape)shape);
|
||||
|
||||
if (shape is ChainShape && this is ChainShape)
|
||||
return ((ChainShape)this).CompareTo((ChainShape)shape);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Used for the buoyancy controller
|
||||
/// </summary>
|
||||
public abstract float ComputeSubmergedArea(ref Vector2 normal, float offset, ref Transform xf, out Vector2 sc);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user