public void drawSegment(Vector2 start, Vector2 end, Color color)
{
start = FSConvert.toDisplayUnits(start);
end = FSConvert.toDisplayUnits(end);
_primitiveBatch.addVertex(start, color, PrimitiveType.LineList);
_primitiveBatch.addVertex(end, color, PrimitiveType.LineList);
}
public void DrawSolidCircle(System.Numerics.Vector2 center, float radius, System.Numerics.Vector2 axis, Color color)
{
const double increment = Math.PI * 2.0 / CircleSegments;
double theta = 0.0;
Color colorFill = color * 0.5f;
System.Numerics.Vector2 v0 = center + radius * new System.Numerics.Vector2((float)Math.Cos(theta), (float)Math.Sin(theta));
FSConvert.ToDisplayUnits(ref v0, out v0);
theta += increment;
for (int i = 1; i < CircleSegments - 1; i++)
{
System.Numerics.Vector2 v1 = center + radius * new System.Numerics.Vector2((float)Math.Cos(theta), (float)Math.Sin(theta));
System.Numerics.Vector2 v2 = center + radius * new System.Numerics.Vector2((float)Math.Cos(theta + increment),
(float)Math.Sin(theta + increment));
_primitiveBatch.AddVertex(v0, colorFill, PrimitiveType.TriangleList);
_primitiveBatch.AddVertex(FSConvert.ToDisplayUnits(v1), colorFill, PrimitiveType.TriangleList);
_primitiveBatch.AddVertex(FSConvert.ToDisplayUnits(v2), colorFill, PrimitiveType.TriangleList);
theta += increment;
}
DrawCircle(center, radius, color);
DrawSegment(center, center + axis * radius, color);
}
public static Body CreateSolidArc(World world, float density, float radians, int sides, float radius,
Vector2 position = new Vector2(), float rotation = 0,
BodyType bodyType = BodyType.Static, object userData = null)
{
return(FarseerPhysics.Factories.BodyFactory.CreateSolidArc(world, density, radians, sides,
FSConvert.ToSimUnits(radius), FSConvert.ToSimUnits(position), rotation, bodyType));
}
public void DrawSegment(System.Numerics.Vector2 start, System.Numerics.Vector2 end, Color color)
{
start = FSConvert.ToDisplayUnits(start);
end = FSConvert.ToDisplayUnits(end);
_primitiveBatch.AddVertex(start, color, PrimitiveType.LineList);
_primitiveBatch.AddVertex(end, color, PrimitiveType.LineList);
}
public static Body CreateCompoundPolygon(World world, List <Vertices> list, float density,
Vector2 position = new Vector2(), float rotation = 0,
BodyType bodyType = BodyType.Static, object userData = null)
{
return(FarseerPhysics.Factories.BodyFactory.CreateCompoundPolygon(world, list, density,
FSConvert.ToSimUnits(position), rotation, bodyType, userData));
}
void drawPerformanceGraph()
{
_graphValues.Add(world.updateTime / TimeSpan.TicksPerMillisecond);
if (_graphValues.Count > valuesToGraph + 1)
{
_graphValues.RemoveAt(0);
}
float x = performancePanelBounds.X;
float deltaX = performancePanelBounds.Width / (float)valuesToGraph;
float yScale = performancePanelBounds.Bottom - (float)performancePanelBounds.Top;
// we must have at least 2 values to start rendering
if (_graphValues.Count > 2)
{
_max = _graphValues.Max();
_avg = _graphValues.Average();
_min = _graphValues.Min();
if (adaptiveLimits)
{
maximumValue = _max;
minimumValue = 0;
}
// start at last value (newest value added)
// continue until no values are left
for (int i = _graphValues.Count - 1; i > 0; i--)
{
float y1 = performancePanelBounds.Bottom - ((_graphValues[i] / (maximumValue - minimumValue)) * yScale);
float y2 = performancePanelBounds.Bottom - ((_graphValues[i - 1] / (maximumValue - minimumValue)) * yScale);
var x1 = new Vector2(MathHelper.Clamp(x, performancePanelBounds.Left, performancePanelBounds.Right), MathHelper.Clamp(y1, performancePanelBounds.Top, performancePanelBounds.Bottom));
var x2 = new Vector2(MathHelper.Clamp(x + deltaX, performancePanelBounds.Left, performancePanelBounds.Right), MathHelper.Clamp(y2, performancePanelBounds.Top, performancePanelBounds.Bottom));
drawSegment(FSConvert.toSimUnits(x1), FSConvert.toSimUnits(x2), Color.LightGreen);
x += deltaX;
}
}
drawString(performancePanelBounds.Right + 10, performancePanelBounds.Top, string.Format("Max: {0} ms", _max));
drawString(performancePanelBounds.Right + 10, performancePanelBounds.Center.Y - 7, string.Format("Avg: {0} ms", _avg));
drawString(performancePanelBounds.Right + 10, performancePanelBounds.Bottom - 15, string.Format("Min: {0} ms", _min));
//Draw background.
_background[0] = new Vector2(performancePanelBounds.X, performancePanelBounds.Y);
_background[1] = new Vector2(performancePanelBounds.X, performancePanelBounds.Y + performancePanelBounds.Height);
_background[2] = new Vector2(performancePanelBounds.X + performancePanelBounds.Width, performancePanelBounds.Y + performancePanelBounds.Height);
_background[3] = new Vector2(performancePanelBounds.X + performancePanelBounds.Width, performancePanelBounds.Y);
_background[0] = FSConvert.toSimUnits(_background[0]);
_background[1] = FSConvert.toSimUnits(_background[1]);
_background[2] = FSConvert.toSimUnits(_background[2]);
_background[3] = FSConvert.toSimUnits(_background[3]);
drawSolidPolygon(_background, 4, Color.DarkGray, true);
}
public static Body CreateEllipse(World world, float xRadius, float yRadius, int edges, float density,
Vector2 position = new Vector2(), float rotation = 0,
BodyType bodyType = BodyType.Static, object userData = null)
{
return(FarseerPhysics.Factories.BodyFactory.CreateEllipse(world, FSConvert.ToSimUnits(xRadius),
FSConvert.ToSimUnits(yRadius), edges, density, FSConvert.ToSimUnits(position), rotation, bodyType,
userData));
}
public static Body CreateRectangle(World world, float width, float height, float density,
Vector2 position = new Vector2(), float rotation = 0,
BodyType bodyType = BodyType.Static, object userData = null)
{
return(FarseerPhysics.Factories.BodyFactory.CreateRectangle(world, FSConvert.ToSimUnits(width),
FSConvert.ToSimUnits(height), density, FSConvert.ToSimUnits(position), rotation, bodyType,
userData));
}
public static Body CreateCapsule(World world, float height, float endRadius, float density,
System.Numerics.Vector2 position = new System.Numerics.Vector2(), float rotation = 0,
BodyType bodyType = BodyType.Static, object userData = null)
{
return(FarseerPhysics.Factories.BodyFactory.CreateCapsule(world, FSConvert.ToSimUnits(height),
FSConvert.ToSimUnits(endRadius), density, FSConvert.ToSimUnits(position), rotation, bodyType,
userData));
}
/// <summary>
/// Creates a chain.
/// </summary>
/// <param name="world">The world.</param>
/// <param name="start">The start.</param>
/// <param name="end">The end.</param>
/// <param name="linkWidth">The width.</param>
/// <param name="linkHeight">The height.</param>
/// <param name="numberOfLinks">The number of links.</param>
/// <param name="linkDensity">The link density.</param>
/// <param name="attachRopeJoint">Creates a rope joint between start and end. This enforces the length of the rope. Said in another way: it makes the rope less bouncy.</param>
/// <param name="fixStart"></param>
/// <param name="fixEnd"></param>
/// <returns></returns>
public static List <Body> CreateChain(World world, System.Numerics.Vector2 start, System.Numerics.Vector2 end, float linkWidth,
float linkHeight, int numberOfLinks, float linkDensity,
bool attachRopeJoint, bool fixStart = false, bool fixEnd = false)
{
return(FarseerPhysics.Factories.LinkFactory.CreateChain(world, FSConvert.DisplayToSim * start,
FSConvert.ToSimUnits(end), FSConvert.DisplayToSim * linkWidth, FSConvert.DisplayToSim * linkHeight,
numberOfLinks, linkDensity, attachRopeJoint, fixStart, fixEnd));
}
public static Fixture AttachLoopShape(this Body body, List <Vector2> vertices)
{
for (var i = 0; i < vertices.Count; i++)
{
vertices[i] = FSConvert.ToSimUnits(vertices[i]);
}
return(FixtureFactory.AttachLoopShape(new Vertices(vertices), body, null));
}
public static Body CreateGear(World world, float radius, int numberOfTeeth, float tipPercentage,
float toothHeight, float density, Vector2 position = new Vector2(),
float rotation = 0, BodyType bodyType = BodyType.Static,
object userData = null)
{
return(FarseerPhysics.Factories.BodyFactory.CreateGear(world, FSConvert.ToSimUnits(radius),
numberOfTeeth, tipPercentage, FSConvert.ToSimUnits(toothHeight), density,
FSConvert.ToSimUnits(position), rotation, bodyType, userData));
}
public static Body CreateLineArc(World world, float radians, int sides, float radius, bool closed = false,
Vector2 position = new Vector2(), float rotation = 0,
BodyType bodyType = BodyType.Static, object userData = null)
{
Body body = FarseerPhysics.Factories.BodyFactory.CreateLineArc(world, radians, sides,
FSConvert.ToSimUnits(radius), closed, FSConvert.ToSimUnits(position), rotation, bodyType);
body.UserData = userData;
return(body);
}
public static BreakableBody CreateBreakableBody(World world, Vertices vertices, float density,
Vector2 position = new Vector2(), float rotation = 0)
{
for (int i = 0; i < vertices.Count; i++)
{
vertices[i] *= FSConvert.DisplayToSim;
}
return(FarseerPhysics.Factories.BodyFactory.CreateBreakableBody(world, vertices, density,
FSConvert.ToSimUnits(position), rotation));
}
public static Body CreateLoopShape(World world, Vertices vertices, Vector2 position = new Vector2(),
object userData = null)
{
for (int i = 0; i < vertices.Count; i++)
{
vertices[i] *= FSConvert.DisplayToSim;
}
return(FarseerPhysics.Factories.BodyFactory.CreateLoopShape(world, vertices,
FSConvert.ToSimUnits(position), userData));
}
public static Body CreatePolygon(World world, Vertices vertices, float density,
Vector2 position = new Vector2(), float rotation = 0,
BodyType bodyType = BodyType.Static, object userData = null)
{
for (int i = 0; i < vertices.Count; i++)
{
vertices[i] *= FSConvert.DisplayToSim;
}
return(FarseerPhysics.Factories.BodyFactory.CreatePolygon(world, vertices, density,
FSConvert.ToSimUnits(position), rotation, bodyType, userData));
}
public void drawPolygon(Vector2[] vertices, int count, Color color, bool closed = true)
{
for (int i = 0; i < count - 1; i++)
{
_primitiveBatch.addVertex(FSConvert.toDisplayUnits(vertices[i]), color, PrimitiveType.LineList);
_primitiveBatch.addVertex(FSConvert.toDisplayUnits(vertices[i + 1]), color, PrimitiveType.LineList);
}
if (closed)
{
_primitiveBatch.addVertex(FSConvert.toDisplayUnits(vertices[count - 1]), color, PrimitiveType.LineList);
_primitiveBatch.addVertex(FSConvert.toDisplayUnits(vertices[0]), color, PrimitiveType.LineList);
}
}
public void drawCircle(Vector2 center, float radius, Color color)
{
const double increment = Math.PI * 2.0 / circleSegments;
double theta = 0.0;
for (int i = 0; i < circleSegments; i++)
{
Vector2 v1 = center + radius * new Vector2((float)Math.Cos(theta), (float)Math.Sin(theta));
Vector2 v2 = center + radius * new Vector2((float)Math.Cos(theta + increment), (float)Math.Sin(theta + increment));
_primitiveBatch.addVertex(FSConvert.toDisplayUnits(v1), color, PrimitiveType.LineList);
_primitiveBatch.addVertex(FSConvert.toDisplayUnits(v2), color, PrimitiveType.LineList);
theta += increment;
}
}
public void drawSolidPolygon(Vector2[] vertices, int count, Color color, bool outline = true)
{
if (count == 2)
{
drawPolygon(vertices, count, color);
return;
}
var colorFill = color * (outline ? 0.5f : 1.0f);
for (int i = 1; i < count - 1; i++)
{
_primitiveBatch.addVertex(FSConvert.toDisplayUnits(vertices[0]), colorFill, PrimitiveType.TriangleList);
_primitiveBatch.addVertex(FSConvert.toDisplayUnits(vertices[i]), colorFill, PrimitiveType.TriangleList);
_primitiveBatch.addVertex(FSConvert.toDisplayUnits(vertices[i + 1]), colorFill, PrimitiveType.TriangleList);
}
if (outline)
{
drawPolygon(vertices, count, color);
}
}
public static Body CreateCircle(World world, float radius, float density, Vector2 position = new Vector2(), BodyType bodyType = BodyType.Static, object userData = null)
{
return(FarseerPhysics.Factories.BodyFactory.CreateCircle(world, FSConvert.ToSimUnits(radius), density, FSConvert.ToSimUnits(position), bodyType, userData));
}
public static Body CreateEdge(World world, Vector2 start, Vector2 end, object userData = null)
{
return(FarseerPhysics.Factories.BodyFactory.CreateEdge(world, FSConvert.ToSimUnits(start), FSConvert.ToSimUnits(end), userData));
}
public static Body CreateBody(World world, Vector2 position = new Vector2(), float rotation = 0, BodyType bodyType = BodyType.Static, object userData = null)
{
return(new Body(world, FSConvert.ToSimUnits(position), rotation, bodyType, userData));
}
public static BreakableBody CreateBreakableBody(World world, IEnumerable <Shape> shapes, Vector2 position = new Vector2(), float rotation = 0)
{
return(FarseerPhysics.Factories.BodyFactory.CreateBreakableBody(world, shapes, FSConvert.ToSimUnits(position), rotation));
}
