public static Body CreateRoundedRectangle(World world, GGame.Math.Fix64 width, GGame.Math.Fix64 height, GGame.Math.Fix64 xRadius, GGame.Math.Fix64 yRadius, int segments, GGame.Math.Fix64 density, Vector2 position = new Vector2(), GGame.Math.Fix64 rotation = new Fix64(), BodyType bodyType = BodyType.Static, object userData = null)
{
Vertices verts = PolygonUtils.CreateRoundedRectangle(width, height, xRadius, yRadius, segments);
//There are too many vertices in the capsule. We decompose it.
if (verts.Count >= Settings.MaxPolygonVertices)
{
List <Vertices> vertList = Triangulate.ConvexPartition(verts, TriangulationAlgorithm.Earclip, true, 0.001f);
return(CreateCompoundPolygon(world, vertList, density, position, rotation, bodyType, userData));
}
return(CreatePolygon(world, verts, density, position, rotation, bodyType, userData));
}
public static List <Fixture> AttachSolidArc(float density, float radians, int sides, float radius, Body body)
{
Vertices arc = PolygonUtils.CreateArc(radians, sides, radius);
arc.Rotate((MathHelper.Pi - radians) / 2);
//Close the arc
arc.Add(arc[0]);
List <Vertices> triangles = Triangulate.ConvexPartition(arc, TriangulationAlgorithm.Earclip);
return(AttachCompoundPolygon(triangles, density, body));
}
public Body CreateRoundedRectangle(float width, float height, float xRadius, float yRadius, int segments, float density, Vector2 position = new Vector2(), float rotation = 0, BodyType bodyType = BodyType.Static)
{
Vertices verts = PolygonTools.CreateRoundedRectangle(width, height, xRadius, yRadius, segments);
//There are too many vertices in the capsule. We decompose it.
if (verts.Count >= Settings.MaxPolygonVertices)
{
List <Vertices> vertList = Triangulate.ConvexPartition(verts, TriangulationAlgorithm.Earclip);
return(CreateCompoundPolygon(vertList, density, position, rotation, bodyType));
}
return(CreatePolygon(verts, density, position, rotation, bodyType));
}
public Body CreateCapsule(float height, float topRadius, int topEdges, float bottomRadius, int bottomEdges, float density, Vector2 position = new Vector2(), float rotation = 0, BodyType bodyType = BodyType.Static)
{
Vertices verts = PolygonTools.CreateCapsule(height, topRadius, topEdges, bottomRadius, bottomEdges);
//There are too many vertices in the capsule. We decompose it.
if (verts.Count >= Settings.MaxPolygonVertices)
{
List <Vertices> vertList = Triangulate.ConvexPartition(verts, TriangulationAlgorithm.Earclip);
return(CreateCompoundPolygon(vertList, density, position, rotation, bodyType));
}
return(CreatePolygon(verts, density, position, rotation, bodyType));
}
public List <Fixture> CreateSolidArc(float density, float radians, int sides, float radius)
{
Vertices arc = PolygonTools.CreateArc(radians, sides, radius);
arc.Rotate((Constant.Pi - radians) / 2);
//Close the arc
arc.Add(arc[0]);
List <Vertices> triangles = Triangulate.ConvexPartition(arc, TriangulationAlgorithm.Earclip);
return(CreateCompoundPolygon(triangles, density));
}
/// <summary>
/// Creates a list of vertices from a texture.
/// </summary>
/// <param name="texture">The texture to make a body from</param>
/// <param name="scale">The scale of the texture</param>
/// <param name="imageSize">The size of each individual image in the hitbox</param>
/// <param name="density">The density of the object (Will almost always be one</param>
/// <param name="algorithm">The decomposition algorithm to use</param>
/// <remarks> Available algorithms to use are Bayazit, Dealuny, Earclip, Flipcode, Seidel, SeidelTrapazoid</remarks>
/// @warning In order for this to work the input must have a transparent background. I highly reccomend that you
/// only use this with PNGs as that is what I have tested and I know they work. This will only produce a bosy as
/// clean as the texture you give it, so avoid partically transparent areas and little edges.
private List <Vertices>[] CreateVerticesFromTexture(Texture2D texture, float scale, Point imageSize,
float density = 1, TriangulationAlgorithm algorithm = TriangulationAlgorithm.Earclip)
{
int SpriteSheetSize = texture.Width * texture.Height;
int IndividualSize = imageSize.X * imageSize.Y;
uint[] TextureData = new uint[SpriteSheetSize]; //Array to copy texture info into
texture.GetData(TextureData); //Gets which pixels of the texture are actually filled
List <uint[]> IndividualData = new List <uint[]>();
for (int Processed = 0; Processed < SpriteSheetSize; Processed += IndividualSize)
{
uint[] TempArray = new uint[IndividualSize];
try {
Array.Copy(TextureData, Processed, TempArray, 0, IndividualSize);
} catch (ArgumentException) {
//At the end of textures the amount of data left might be to small
Array.Copy(TextureData, Processed, TempArray, 0, TextureData.Length - Processed);
}
IndividualData.Add(TempArray);
}
List <Vertices>[] TextureVertices = new List <Vertices> [IndividualData.Count];
for (int count = 0; count < IndividualData.Count; ++count)
{
uint[] I = IndividualData[count];
Vertices vertices = TextureConverter.DetectVertices(I, texture.Width);
List <Vertices> VertexList = Triangulate.ConvexPartition(vertices, algorithm);
Vector2 VertScale = new Vector2(ConvertUnits.ToSimUnits(scale));
foreach (Vertices vert in VertexList)
{
vert.Scale(ref VertScale); //Scales the vertices to match the size we specified
}
Vector2 Centroid = -vertices.GetCentroid();
vertices.Translate(ref Centroid);
//basketOrigin = -centroid;
TextureVertices[count] = VertexList;
}
return(TextureVertices);
}
public BreakableBody(World world, Vertices vertices, float density, Vector2 position = new Vector2(), float rotation = 0) : this(world)
{
MainBody = World.CreateBody(position, rotation, BodyType.Dynamic);
//TODO: Implement a Voronoi diagram algorithm to split up the vertices
List <Vertices> triangles = Triangulate.ConvexPartition(vertices, TriangulationAlgorithm.Earclip);
foreach (Vertices part in triangles)
{
PolygonShape polygonShape = new PolygonShape(part, density);
Fixture fixture = MainBody.CreateFixture(polygonShape);
Parts.Add(fixture);
}
}
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)
{
var gearPolygon = PolygonTools.CreateGear(radius, numberOfTeeth, tipPercentage, toothHeight);
//Gears can in some cases be convex
if (!gearPolygon.IsConvex())
{
//Decompose the gear:
var list = Triangulate.ConvexPartition(gearPolygon, TriangulationAlgorithm.Earclip);
return(CreateCompoundPolygon(world, list, density, position, rotation, bodyType, userData));
}
return(CreatePolygon(world, gearPolygon, density, position, rotation, bodyType, userData));
}
/// <summary>
/// Convert a closed path into a polygon.
/// Convex decomposition is automatically performed.
/// </summary>
/// <param name="path">The path.</param>
/// <param name="body">The body.</param>
/// <param name="density">The density.</param>
/// <param name="subdivisions">The subdivisions.</param>
public static void ConvertPathToPolygon(Path path, Body body, float density, int subdivisions)
{
if (!path.IsClosed)
{
throw new Exception("The path must be closed to convert to a polygon.");
}
var verts = path.GetVertices(subdivisions);
var decomposedVerts = Triangulate.ConvexPartition(new Vertices(verts), TriangulationAlgorithm.Bayazit);
foreach (Vertices item in decomposedVerts)
{
body.CreateFixture(new PolygonShape(item, density));
}
}
public static Body CreateCapsule(World world, float height, float topRadius, int topEdges, float bottomRadius,
int bottomEdges, float density, Vector2 position = new Vector2(), float rotation = 0,
BodyType bodyType = BodyType.Static, object userData = null)
{
var verts = PolygonUtils.CreateCapsule(height, topRadius, topEdges, bottomRadius, bottomEdges);
//There are too many vertices in the capsule. We decompose it.
if (verts.Count >= Settings.MaxPolygonVertices)
{
var vertList = Triangulate.ConvexPartition(verts, TriangulationAlgorithm.Earclip);
return(CreateCompoundPolygon(world, vertList, density, position, rotation, bodyType, userData));
}
return(CreatePolygon(world, verts, density, position, rotation, bodyType, userData));
}
/// <summary>
/// Creates a rounded rectangle.
/// Note: Automatically decomposes the capsule if it contains too many vertices (controlled by Settings.MaxPolygonVertices)
/// </summary>
/// <param name="world">The world.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="xRadius">The x radius.</param>
/// <param name="yRadius">The y radius.</param>
/// <param name="segments">The segments.</param>
/// <param name="density">The density.</param>
/// <param name="position">The position.</param>
/// <returns></returns>
public static Body CreateRoundedRectangle(World world, float width, float height, float xRadius, float yRadius, int segments, float density, Vector2 position, object userData = null)
{
Vertices verts = PolygonTools.CreateRoundedRectangle(width, height, xRadius, yRadius, segments);
//There are too many vertices in the capsule. We decompose it.
if (verts.Count >= Settings.MaxPolygonVertices)
{
List <Vertices> vertList = Triangulate.ConvexPartition(verts, TriangulationAlgorithm.Earclip);
Body body = CreateCompoundPolygon(world, vertList, density, userData);
body.Position = position;
return(body);
}
return(CreatePolygon(world, verts, density));
}
public static Body CreateGear(World world, GGame.Math.Fix64 radius, int numberOfTeeth, GGame.Math.Fix64 tipPercentage, GGame.Math.Fix64 toothHeight, GGame.Math.Fix64 density, Vector2 position = new Vector2(), GGame.Math.Fix64 rotation = new Fix64(), BodyType bodyType = BodyType.Static, object userData = null)
{
Vertices gearPolygon = PolygonUtils.CreateGear(radius, numberOfTeeth, tipPercentage, toothHeight);
//Gears can in some cases be convex
if (!gearPolygon.IsConvex())
{
//Decompose the gear:
List <Vertices> list = Triangulate.ConvexPartition(gearPolygon, TriangulationAlgorithm.Earclip, true, 0.001f);
return(CreateCompoundPolygon(world, list, density, position, rotation, bodyType, userData));
}
return(CreatePolygon(world, gearPolygon, density, position, rotation, bodyType, userData));
}
public Body CreateGear(float radius, int numberOfTeeth, float tipPercentage, float toothHeight, float density, Vector2 position = new Vector2(), float rotation = 0, BodyType bodyType = BodyType.Static)
{
Vertices gearPolygon = PolygonTools.CreateGear(radius, numberOfTeeth, tipPercentage, toothHeight);
//Gears can in some cases be convex
if (!gearPolygon.IsConvex())
{
//Decompose the gear:
List <Vertices> list = Triangulate.ConvexPartition(gearPolygon, TriangulationAlgorithm.Earclip);
return(CreateCompoundPolygon(list, density, position, rotation, bodyType));
}
return(CreatePolygon(gearPolygon, density, position, rotation, bodyType));
}
public static Body CreateGear(World world, float radius, int numberOfTeeth, float tipPercentage, float toothHeight, float density, object userData = null)
{
Vertices gearPolygon = PolygonTools.CreateGear(radius, numberOfTeeth, tipPercentage, toothHeight);
//Gears can in some cases be convex
if (!gearPolygon.IsConvex())
{
//Decompose the gear:
List <Vertices> list = Triangulate.ConvexPartition(gearPolygon, TriangulationAlgorithm.Earclip);
return(CreateCompoundPolygon(world, list, density, userData));
}
return(CreatePolygon(world, gearPolygon, density, userData));
}
public static List <Fixture> AttachRoundedRectangle(float width, float height, float xRadius, float yRadius, int segments, float density, Body body, object userData = null)
{
var verts = PolygonTools.CreateRoundedRectangle(width, height, xRadius, yRadius, segments);
//There are too many vertices in the capsule. We decompose it.
if (verts.Count >= Settings.MaxPolygonVertices)
{
var vertList = Triangulate.ConvexPartition(verts, TriangulationAlgorithm.Earclip);
return(AttachCompoundPolygon(vertList, density, body, userData));
}
var fixtures = new List <Fixture>(1);
fixtures.Add(AttachPolygon(verts, density, body, userData));
return(fixtures);
}
private Body Create(List <VerticesExt> ext)
{
Body b = BodyFactory.CreateBody(World, bodyType: BodyType.Dynamic);
foreach (VerticesExt ve in ext)
{
List <Vertices> decomposed = Triangulate.ConvexPartition(ve, TriangulationAlgorithm.Bayazit);
foreach (Vertices v in decomposed)
{
FixtureFactory.AttachPolygon(v, 1, b);
}
}
return(b);
}
/// <summary>
/// Convert a closed path into a polygon.
/// Convex decomposition is automatically performed.
/// </summary>
/// <param name="path">The path.</param>
/// <param name="body">The body.</param>
/// <param name="density">The density.</param>
/// <param name="subdivisions">The subdivisions.</param>
public static void ConvertPathToPolygon(Path path, Body body, GGame.Math.Fix64 density, int subdivisions)
{
if (!path.Closed)
{
throw new Exception("The path must be closed to convert to a polygon.");
}
List <Vector2> verts = path.GetVertices(subdivisions);
List <Vertices> decomposedVerts = Triangulate.ConvexPartition(new Vertices(verts), TriangulationAlgorithm.Bayazit, true, 0.001f);
foreach (Vertices item in decomposedVerts)
{
body.CreateFixture(new PolygonShape(item, density));
}
}
public static Body CreateRoundedRectangle(World world, float width, float height, float xRadius, float yRadius,
int segments, float density, Vector2 position = new Vector2(),
float rotation = 0, BodyType bodyType = BodyType.Static,
object userData = null)
{
var verts = PolygonTools.CreateRoundedRectangle(width, height, xRadius, yRadius, segments);
//There are too many vertices in the rect. We decompose it.
if (verts.Count >= Settings.MaxPolygonVertices)
{
var vertList = Triangulate.ConvexPartition(verts, TriangulationAlgorithm.Earclip);
return(CreateCompoundPolygon(world, vertList, density, position, rotation, bodyType, userData));
}
return(CreatePolygon(world, verts, density, position, rotation, bodyType, userData));
}
public static List <Fixture> AttachGear(this Body body, float radius, int numberOfTeeth, float tipPercentage, float toothHeight, float density)
{
var gearPolygon = PolygonTools.CreateGear(FSConvert.DisplayToSim * radius, numberOfTeeth, tipPercentage, FSConvert.DisplayToSim * toothHeight);
// Gears can in some cases be convex
if (!gearPolygon.IsConvex())
{
//Decompose the gear:
var list = Triangulate.ConvexPartition(gearPolygon, TriangulationAlgorithm.Earclip);
return(body.AttachCompoundPolygon(list, density));
}
var fixtures = new List <Fixture>();
fixtures.Add(body.AttachPolygon(gearPolygon, density));
return(fixtures);
}
void CreateBody(Vertices vertices)
{
if (vertices == null)
{
return;
}
World.Clear();
_sw.Start();
_bodies[0] = BodyFactory.CreateCompoundPolygon(World, Triangulate.ConvexPartition(vertices, TriangulationAlgorithm.Seidel), 1);
_bodies[0].Position = new Vector2(-30, 28);
_timings[0] = _sw.ElapsedMilliseconds;
//_sw.Restart();
_sw.Stop(); _sw.Start();
_bodies[1] = BodyFactory.CreateCompoundPolygon(World, Triangulate.ConvexPartition(vertices, TriangulationAlgorithm.SeidelTrapezoids), 1);
_bodies[1].Position = new Vector2(0, 28);
_timings[1] = _sw.ElapsedMilliseconds;
//_sw.Restart();
_sw.Stop(); _sw.Start();
_bodies[2] = BodyFactory.CreateCompoundPolygon(World, Triangulate.ConvexPartition(vertices, TriangulationAlgorithm.Delauny), 1);
_bodies[2].Position = new Vector2(30, 28);
_timings[2] = _sw.ElapsedMilliseconds;
//_sw.Restart();
_sw.Stop(); _sw.Start();
_bodies[3] = BodyFactory.CreateCompoundPolygon(World, Triangulate.ConvexPartition(vertices, TriangulationAlgorithm.Earclip), 1);
_bodies[3].Position = new Vector2(-30, 5);
_timings[3] = _sw.ElapsedMilliseconds;
//_sw.Restart();
_sw.Stop(); _sw.Start();
_bodies[4] = BodyFactory.CreateCompoundPolygon(World, Triangulate.ConvexPartition(vertices, TriangulationAlgorithm.Flipcode), 1);
_bodies[4].Position = new Vector2(0, 5);
_timings[4] = _sw.ElapsedMilliseconds;
//_sw.Restart();
_sw.Stop(); _sw.Start();
_bodies[5] = BodyFactory.CreateCompoundPolygon(World, Triangulate.ConvexPartition(vertices, TriangulationAlgorithm.Bayazit), 1);
_bodies[5].Position = new Vector2(30, 5);
_timings[5] = _sw.ElapsedMilliseconds;
_sw.Stop();
}
private void CreatePolygon(Texture2D a_texture, World a_world)
{
//Create an array to hold the data from the texture
uint[] data = new uint[a_texture.Width * a_texture.Height];
//Transfer the texture data to the array
a_texture.GetData(data);
//Find the vertices that makes up the outline of the shape in the texture
Vertices textureVertices = PolygonTools.CreatePolygon(data, a_texture.Width, false);
//The tool return vertices as they were found in the texture.
//We need to find the real center (centroid) of the vertices for 2 reasons:
//1. To translate the vertices so the polygon is centered around the centroid.
Vector2 centroid = -textureVertices.GetCentroid();
textureVertices.Translate(ref centroid);
//2. To draw the texture the correct place.
_origin = -centroid;
//We simplify the vertices found in the texture.
textureVertices = SimplifyTools.ReduceByDistance(textureVertices, 4f);
//Since it is a concave polygon, we need to partition it into several smaller convex polygons
List <Vertices> list = Triangulate.ConvexPartition(textureVertices, TriangulationAlgorithm.Bayazit);
//Adjust the scale of the object for WP7's lower resolution
_scale = new Vector2(1f, 1f);
//scale the vertices from graphics space to sim space
Vector2 vertScale = new Vector2(ConvertUnits.ToSimUnits(1)) * _scale;
foreach (Vertices vertices in list)
{
vertices.Scale(ref vertScale);
}
//Create a single body with multiple fixtures
_body = BodyFactory.CreateCompoundPolygon(a_world, list, 1f, BodyType.Dynamic);
_body.BodyType = BodyType.Dynamic;
}
private static Body createBody(Sprite sprite, World world)
{
uint[] texData = new uint[sprite.Texture.Width * sprite.Texture.Height];
sprite.Texture.GetData(texData);
//Find the vertices that makes up the outline of the shape in the texture
Vertices verts = PolygonTools.CreatePolygon(texData, sprite.Texture.Width, false);
//For now we need to scale the vertices (result is in pixels, we use meters)
Vector2 scale = new Vector2(ConvertUnits.ToSimUnits(1));
verts.Scale(ref scale);
//Since it is a concave polygon, we need to partition it into several smaller convex polygons
List <Vertices> vertexList = Triangulate.ConvexPartition(verts, TriangulationAlgorithm.Bayazit);
return(BodyFactory.CreateCompoundPolygon(world, vertexList, 1f));
}
public override void Initialize()
{
base.Initialize();
//Ground
BodyFactory.CreateEdge(World, new Vector2(-40.0f, 0.0f), new Vector2(40.0f, 0.0f));
//Load texture that will represent the physics body
Bitmap polygonTexture = Bitmap.FromFile("AltData/FarseerPhysics/Testbed/Content/Texture.png");
//Create an array to hold the data from the texture
uint[] data = new uint[polygonTexture.PixelWidth * polygonTexture.PixelHeight];
//Transfer the texture data to the array
BitmapData bitmapData = polygonTexture.LockBits(ImageLockMode.ReadOnly);
byte[] src_buffer = bitmapData.Scan0;
System.Buffer.BlockCopy(src_buffer, 0, data, 0, src_buffer.Length);
polygonTexture.UnlockBits(bitmapData);
//Find the vertices that makes up the outline of the shape in the texture
Vertices verts = PolygonTools.CreatePolygon(data, polygonTexture.PixelWidth);
//For now we need to scale the vertices (result is in pixels, we use meters)
Vector2 scale = new Vector2(0.07f, -0.07f);
verts.Scale(ref scale);
//We also need to move the polygon so that (0,0) is the center of the polygon.
Vector2 centroid = -verts.GetCentroid();
verts.Translate(ref centroid);
_sw.Start();
//Create a single body with multiple fixtures
Body compund = BodyFactory.CreateCompoundPolygon(World, Triangulate.ConvexPartition(verts, TriangulationAlgorithm.Earclip), 1);
compund.BodyType = BodyType.Dynamic;
compund.Position = new Vector2(0, 20);
_sw.Stop();
}
/// <summary>
/// Creates a capsule.
/// Note: Automatically decomposes the capsule if it contains too many vertices (controlled by Settings.MaxPolygonVertices)
/// </summary>
/// <returns></returns>
public static Body CreateCapsule(World world, float height, float topRadius, int topEdges, float bottomRadius, int bottomEdges, float density, Vector2 position, object userData = null)
{
Vertices verts = PolygonTools.CreateCapsule(height, topRadius, topEdges, bottomRadius, bottomEdges);
Body body;
//There are too many vertices in the capsule. We decompose it.
if (verts.Count >= Settings.MaxPolygonVertices)
{
List <Vertices> vertList = Triangulate.ConvexPartition(verts, TriangulationAlgorithm.Earclip);
body = CreateCompoundPolygon(world, vertList, density, userData);
body.Position = position;
return(body);
}
body = CreatePolygon(world, verts, density, userData);
body.Position = position;
return(body);
}
public Body CreatePolygonFromTexture(Texture2D tex, World world, float density, Vector2 position, float scale, TriangulationAlgorithm algorithm = TriangulationAlgorithm.Bayazit)
{
uint[] texData = new uint[tex.Width * tex.Height];
tex.GetData <uint>(texData);
Vertices vertices = TextureConverter.DetectVertices(texData, tex.Width);
List <Vertices> vertexList = Triangulate.ConvexPartition(vertices, algorithm);
Vector2 vertScale = new Vector2(ConvertUnits.ToSimUnits(scale));
foreach (Vertices vert in vertexList)
{
vert.Scale(ref vertScale);
}
Vector2 centroid = vertices.GetCentroid();
vertices.Translate(ref centroid);
//basketOrigin = -centroid;
return(BodyFactory.CreateCompoundPolygon(world, vertexList, density, position, 100));
}
public void Decompose()
{
Dictionary <string, Polygon> containerCopy = new Dictionary <string, Polygon>(this);
foreach (string key in containerCopy.Keys)
{
if (containerCopy[key].Closed)
{
List <Vertices> partition = Triangulate.ConvexPartition(containerCopy[key].Vertices, TriangulationAlgorithm.Bayazit);
if (partition.Count > 1)
{
Remove(key);
for (int i = 0; i < partition.Count; i++)
{
this[key + "_" + i.ToString()] = new Polygon(partition[i], true);
}
}
_decomposed = true;
}
}
}
public TexturePolygon(Texture2D texture, Vector2 position, float rotation, DrawingHelper.DrawingLevel drawingLevel, Game game, World world, bool textureCenter)
: base(texture, position, drawingLevel, game, world)
{
// Fetch Texure data
uint[] data = new uint[texture.Width * texture.Height];
texture.GetData(data);
Vertices textureVertices = PolygonTools.CreatePolygon(data, texture.Width, true);
// Set Polygon Centroid
if (textureCenter) // Texture based center
{
Vector2 centroid = -textureVertices.GetCentroid();
textureVertices.Translate(ref centroid);
Origin = new Vector2(texture.Width / 2, texture.Height / 2);
}
else // Vertice based center
{
Vector2 centroid = -textureVertices.GetCentroid();
textureVertices.Translate(ref centroid);
Origin = new Vector2(-centroid.X, -centroid.Y);
}
// Simplify Polygon for performance
textureVertices = SimplifyTools.ReduceByDistance(textureVertices, 4f);
List <Vertices> list = Triangulate.ConvexPartition(textureVertices, TriangulationAlgorithm.Bayazit);
// Convert polygon to sim units
Vector2 vertScale = new Vector2(ConvertUnits.ToSimUnits(1));
foreach (Vertices vertice in list)
{
vertice.Scale(ref vertScale);
}
// create body compound.
RigidBody = BodyFactory.CreateCompoundPolygon(world, list, 1f, BodyType.Static);
RigidBody.BodyType = BodyType.Static;
RigidBody.Position = ConvertUnits.ToSimUnits(position);
RigidBody.Rotation = rotation;
}
public override void Initialize()
{
base.Initialize();
//Ground
BodyFactory.CreateEdge(World, new Vector2(-40.0f, 0.0f), new Vector2(40.0f, 0.0f));
//Load texture that will represent the physics body
Texture2D polygonTexture = GameInstance.Content.Load <Texture2D>("Texture");
//Create an array to hold the data from the texture
uint[] data = new uint[polygonTexture.Width * polygonTexture.Height];
//Transfer the texture data to the array
polygonTexture.GetData(data);
//Find the vertices that makes up the outline of the shape in the texture
Vertices verts = PolygonUtils.CreatePolygon(data, polygonTexture.Width);
//For now we need to scale the vertices (result is in pixels, we use meters)
Vector2 scale = new Vector2(0.07f, -0.07f);
verts.Scale(ref scale);
//We also need to move the polygon so that (0,0) is the center of the polygon.
Vector2 centroid = -verts.GetCentroid();
verts.Translate(ref centroid);
_sw.Start();
//Create a single body with multiple fixtures
Body compund = BodyFactory.CreateCompoundPolygon(World, Triangulate.ConvexPartition(verts, TriangulationAlgorithm.Earclip), 1);
compund.BodyType = BodyType.Dynamic;
compund.Position = new Vector2(0, 20);
_sw.Stop();
}
private void GenerateTerrain(int gx, int gy)
{
float ax = gx * CellSize;
float ay = gy * CellSize;
var polys = MarchingSquares.DetectSquares(
new AABB(new Vector2(ax, ay), new Vector2(ax + CellSize, ay + CellSize)), SubCellSize, SubCellSize,
_terrainMap, Iterations, true);
if (polys.Count == 0)
{
return;
}
_bodyMap[gx, gy] = new List <Body>();
// create the scale vector
var scale = new Vector2(1f / PointsPerUnit, 1f / -PointsPerUnit);
// create physics object for this grid cell
foreach (var item in polys)
{
// does this need to be negative?
item.Scale(ref scale);
item.Translate(ref _topLeft);
var simplified = SimplifyTools.CollinearSimplify(item);
var decompPolys = Triangulate.ConvexPartition(simplified, Decomposer);
foreach (var poly in decompPolys)
{
if (poly.Count > 2)
{
_bodyMap[gx, gy].Add(BodyFactory.CreatePolygon(World, poly, 1));
}
}
}
}
/// <summary>
/// Method for creating complex bodies.
/// </summary>
/// <param name="world">The new object will appear in this world</param>
/// <param name="objectTexture">The new object will get this texture</param>
/// <param name="Scale">The new object get scaled by this factor</param>
/// <param name="Algo">The new object get triangulated by this triangulation algorithm</param>
/// <returns>Returns the complex body</returns>
public Body CreateComplexBody(World world, Texture2D objectTexture, float Scale,
TriangulationAlgorithm Algo = TriangulationAlgorithm.Bayazit)
{
Body body = null;
uint[] data = new uint[objectTexture.Width * objectTexture.Height];
objectTexture.GetData(data);
Vertices textureVertices = PolygonTools.CreatePolygon(data, objectTexture.Width, false);
Vector2 centroid = -textureVertices.GetCentroid();
textureVertices.Translate(ref centroid);
tBodyOrigin = -centroid;
textureVertices = SimplifyTools.DouglasPeuckerSimplify(textureVertices, 4f);
List <Vertices> list = Triangulate.ConvexPartition(textureVertices, Algo);
Vector2 vertScale = new Vector2(ConvertUnits.ToSimUnits(1)) * Scale;
foreach (Vertices vertices in list)
{
vertices.Scale(ref vertScale);
}
return(body = BodyFactory.CreateCompoundPolygon(world, list, 1f));
}