public static BreakableBody CreateBreakableBody(World world, Vertices vertices, float density)
{
List <Vertices> triangles;
if (vertices.Count <= 10)
{
triangles = DelauneyTriangulate(vertices);
}
else
{
if (rand.RandomBoolean)
{
triangles = DelauneyTriangulate(vertices);
}
else
{
triangles = EarclipDecomposer.ConvexPartition(vertices);
}
}
BreakableBody breakableBody = new BreakableBody(triangles, world, density);
world.AddBreakableBody(breakableBody);
return(breakableBody);
}
public override Tuple <IEnumerable <Fixture>, Body, object> Build(World world)
{
BreakableBody breakableBody = CreateBreakableBody(world, this.Vertices, this.Density);
this.InitBody(breakableBody.MainBody);
return(Tuple.Create <IEnumerable <Fixture>, Body, object>(breakableBody.Parts, breakableBody.MainBody, breakableBody));
}
public static BreakableBody CreateBreakableBody(World world, IEnumerable <Shape> shapes, Vector2 position = new Vector2(), GGame.Math.Fix64 rotation = new Fix64())
{
BreakableBody breakableBody = new BreakableBody(world, shapes, position, rotation);
breakableBody.MainBody.Position = position;
world.AddBreakableBody(breakableBody);
return(breakableBody);
}
public static BreakableBody CreateBreakableBody(World world, IEnumerable <Shape> shapes, Vector2 position = new Vector2(), float rotation = 0)
{
var breakableBody = new BreakableBody(world, shapes, position, rotation);
breakableBody.MainBody.Position = position;
world.AddBreakableBody(breakableBody);
return(breakableBody);
}
public IList <Texture2D> BreakableTextureFragments(BreakableBody body, string textureName)
{
List <Texture2D> result = new List <Texture2D>();
Vector2 scale = ConvertUnits.ToDisplayUnits(Vector2.One);
foreach (Fixture f in body.Parts)
{
Vertices v = null;
if (f.Shape is PolygonShape polygonShape)
{
v = new Vertices(polygonShape.Vertices);
v.Scale(ref scale);
}
if (v != null)
{
AABB polygonBounds = v.GetAABB();
List <Vertices> decomposedVertices;
if (!v.IsConvex())
{
decomposedVertices = Triangulate.ConvexPartition(v, TriangulationAlgorithm.Bayazit);
}
else
{
decomposedVertices = new List <Vertices>();
decomposedVertices.Add(v);
}
List <VertexPositionColorTexture[]> verticesFill = new List <VertexPositionColorTexture[]>(decomposedVertices.Count);
for (int i = 0; i < decomposedVertices.Count; i++)
{
verticesFill.Add(new VertexPositionColorTexture[3 * (decomposedVertices[i].Count - 2)]);
for (int j = 0; j < decomposedVertices[i].Count - 2; j++)
{
// fill vertices
verticesFill[i][3 * j].Position = new Vector3(decomposedVertices[i][0] - polygonBounds.Center, 0f);
verticesFill[i][3 * j + 1].Position = new Vector3(decomposedVertices[i].NextVertex(j) - polygonBounds.Center, 0f);
verticesFill[i][3 * j + 2].Position = new Vector3(decomposedVertices[i].NextVertex(j + 1) - polygonBounds.Center, 0f);
verticesFill[i][3 * j].TextureCoordinate = new Vector2(decomposedVertices[i][0].X / _textureList[textureName].Width, decomposedVertices[i][0].Y / _textureList[textureName].Height - 1f);
verticesFill[i][3 * j + 1].TextureCoordinate = new Vector2(decomposedVertices[i].NextVertex(j).X / _textureList[textureName].Width, decomposedVertices[i].NextVertex(j).Y / _textureList[textureName].Height - 1f);
verticesFill[i][3 * j + 2].TextureCoordinate = new Vector2(decomposedVertices[i].NextVertex(j + 1).X / _textureList[textureName].Width, decomposedVertices[i].NextVertex(j + 1).Y / _textureList[textureName].Height - 1f);
verticesFill[i][3 * j].Color = verticesFill[i][3 * j + 1].Color = verticesFill[i][3 * j + 2].Color = Color.Transparent;
}
}
Vector2 vertsSize = new Vector2(polygonBounds.UpperBound.X - polygonBounds.LowerBound.X, polygonBounds.UpperBound.Y - polygonBounds.LowerBound.Y);
result.Add(RenderTexture((int)vertsSize.X, (int)vertsSize.Y, _textureList.ContainsKey(textureName) ? _textureList[textureName] : null, Color.White, verticesFill, Array.Empty <VertexPositionColor>()));
}
else
{
result.Add(_textureList["Blank"]);
}
}
return(result);
}
public override void LoadContent()
{
base.LoadContent();
DebugView.AppendFlags(DebugViewFlags.Shape);
World.Gravity = Vector2.Zero;
_border = new Border(World, ScreenManager, Camera);
_breakableBodies = new List <BreakableBody>();
Texture2D alphabet = ScreenManager.Content.Load <Texture2D>("Samples/alphabet");
uint[] data = new uint[alphabet.Width * alphabet.Height];
alphabet.GetData(data);
List <Vertices> list = PolygonTools.CreatePolygon(data, alphabet.Width, 3.5f, 20, true, true);
for (int i = 0; i < list.Count; i++)
{
list[i].Scale(new Vector2(1f, -1f)); // flip Vert
}
float yOffset = -5f;
float xOffset = -14f;
for (int i = 0; i < list.Count; i++)
{
if (i == 9)
{
yOffset = 0f;
xOffset = -14f;
}
if (i == 18)
{
yOffset = 5f;
xOffset = -12.25f;
}
Vertices polygon = list[i];
Vector2 centroid = -polygon.GetCentroid();
polygon.Translate(ref centroid);
polygon = SimplifyTools.CollinearSimplify(polygon);
polygon = SimplifyTools.ReduceByDistance(polygon, 4);
List <Vertices> triangulated = Triangulate.ConvexPartition(polygon, TriangulationAlgorithm.Bayazit);
Vector2 vertScale = new Vector2(13.916667f, 23.25f) / new Vector2(alphabet.Width, alphabet.Height);
foreach (Vertices vertices in triangulated)
{
vertices.Scale(ref vertScale);
}
var breakableBody = new BreakableBody(World, triangulated, 1);
breakableBody.MainBody.Position = new Vector2(xOffset, yOffset);
breakableBody.Strength = 100;
_breakableBodies.Add(breakableBody);
xOffset += 3.5f;
}
}
public override void LoadContent()
{
base.LoadContent();
DebugView.AppendFlags(DebugViewFlags.Shape);
World.Gravity = Vector2.Zero;
_border = new Border(World, ScreenManager, Camera);
Texture2D alphabet = ScreenManager.Content.Load <Texture2D>("Samples/alphabet");
uint[] data = new uint[alphabet.Width * alphabet.Height];
alphabet.GetData(data);
List <Vertices> list = PolygonTools.CreatePolygon(data, alphabet.Width, 3.5f, 20, true, true);
float yOffset = -5f;
float xOffset = -14f;
for (int i = 0; i < list.Count; i++)
{
if (i == 9)
{
yOffset = 0f;
xOffset = -14f;
}
if (i == 18)
{
yOffset = 5f;
xOffset = -12.25f;
}
Vertices polygon = list[i];
Vector2 centroid = -polygon.GetCentroid();
polygon.Translate(ref centroid);
polygon = SimplifyTools.CollinearSimplify(polygon);
polygon = SimplifyTools.ReduceByDistance(polygon, 4);
List <Vertices> triangulated = Triangulate.ConvexPartition(polygon, TriangulationAlgorithm.Bayazit);
#if WINDOWS_PHONE
const float scale = 0.6f;
#else
const float scale = 1f;
#endif
Vector2 vertScale = new Vector2(ConvertUnits.ToSimUnits(1)) * scale;
foreach (Vertices vertices in triangulated)
{
vertices.Scale(ref vertScale);
}
BreakableBody breakableBody = new BreakableBody(triangulated, World, 1);
breakableBody.MainBody.Position = new Vector2(xOffset, yOffset);
breakableBody.Strength = 100;
World.AddBreakableBody(breakableBody);
xOffset += 3.5f;
}
}
public static BreakableBody CreateBreakableBody(World world, IEnumerable <Shape> shapes, Vector2 position)
{
BreakableBody breakableBody = new BreakableBody(shapes, world);
breakableBody.MainBody.Position = position;
world.AddBreakableBody(breakableBody);
return(breakableBody);
}
public static BreakableBody CreateBreakableBody(World world, Vertices vertices, GGame.Math.Fix64 density, Vector2 position = new Vector2(), GGame.Math.Fix64 rotation = new Fix64())
{
//TODO: Implement a Voronoi diagram algorithm to split up the vertices
List <Vertices> triangles = Triangulate.ConvexPartition(vertices, TriangulationAlgorithm.Earclip, true, 0.001f);
BreakableBody breakableBody = new BreakableBody(world, triangles, density, position, rotation);
breakableBody.MainBody.Position = position;
world.AddBreakableBody(breakableBody);
return(breakableBody);
}
/// <summary>
/// Creates a breakable body. You would want to remove collinear points before using this.
/// </summary>
/// <param name="world">The world.</param>
/// <param name="vertices">The vertices.</param>
/// <param name="density">The density.</param>
/// <param name="position">The position.</param>
/// <returns></returns>
public static BreakableBody CreateBreakableBody(World world, Vertices vertices, float density, Vector2 position)
{
List <Vertices> triangles = Triangulate.ConvexPartition(vertices, TriangulationAlgorithm.Earclip);
BreakableBody breakableBody = new BreakableBody(triangles, world, density);
breakableBody.MainBody.Position = position;
world.AddBreakableBody(breakableBody);
return(breakableBody);
}
public static BreakableBody CreateBreakableBody(World world, Vertices vertices, float density, Vector2 position = new Vector2(), float rotation = 0)
{
//TODO: Implement a Voronoi diagram algorithm to split up the vertices
var triangles = Triangulate.ConvexPartition(vertices, TriangulationAlgorithm.Earclip);
var breakableBody = new BreakableBody(world, triangles, density, position, rotation);
breakableBody.MainBody.Position = position;
world.AddBreakableBody(breakableBody);
return(breakableBody);
}
/// <summary>
/// Creates a breakable body. You would want to remove collinear points before using this.
/// </summary>
/// <param name="world">The world.</param>
/// <param name="vertices">The vertices.</param>
/// <param name="density">The density.</param>
/// <param name="position">The position.</param>
/// <returns></returns>
public static BreakableBody CreateBreakableBody(World world, Vertices vertices, float density, Vector2 position,
object userData)
{
List <Vertices> triangles = EarclipDecomposer.ConvexPartition(vertices);
BreakableBody breakableBody = new BreakableBody(triangles, world, density, userData);
breakableBody.MainBody.Position = position;
world.AddBreakableBody(breakableBody);
return(breakableBody);
}
public BreakableBody CreateBreakable(World world)
{
List <Shape> shapes = new List <Shape>();
foreach (FixtureTemplate f in Fixtures)
{
shapes.Add(f.Shape);
}
BreakableBody body = new BreakableBody(world, shapes);
world.AddBreakableBody(body);
return(body);
}
public override void Initialize()
{
//load texture that will represent the physics body
Texture2D polygonTexture = GameInstance.Content.Load <Texture2D>("Rock");
//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);
Vertices verts = PolygonTools.CreatePolygon(data, polygonTexture.Width);
Vector2 scale = new Vector2(0.07f, 0.07f);
verts.Scale(ref scale);
_breakableBody = new BreakableBody(World, verts, 50, new Vector2(-10, 25));
base.Initialize();
}
} // _calcSize(vertices)
#endregion
#region CreateBodyByList
/// <summary>
/// Creates a breakable Body from a list of Vertices
/// </summary>
/// <param name="list"></param>
/// <returns></returns>
private Body CreateBodyByList(List <Vertices> list)
{
// if we already have a breakable body, clear it up!
if (_breakableBody != null)
{
PhysicsGameScreen.World.BreakableBodyList.Remove(_breakableBody);
_breakableBody.MainBody.Dispose();
_breakableBody = null;
}
// this object is not broken initially
_broken = false;
_breakableBody = new BreakableBody(list, PhysicsGameScreen.World, 10);
_breakableBody.Strength = float.MaxValue; // don't break when falling down, we use hitpoints!
_breakableBody.MainBody.Mass = 10000f;
PhysicsGameScreen.World.AddBreakableBody(_breakableBody);
return(_breakableBody.MainBody);
} // CreateBodyByList(list)
private BreakableBody CreateBreakable(List <VerticesExt> ext)
{
List <PolygonShape> polygons = new List <PolygonShape>();
foreach (VerticesExt ve in ext)
{
Vertices simple = SimplifyTools.DouglasPeuckerSimplify(ve, 0.1f);
List <Vertices> list = Triangulate.ConvexPartition(simple, TriangulationAlgorithm.Bayazit);
foreach (Vertices v in list)
{
PolygonShape s = new PolygonShape(v, 1f);
polygons.Add(s);
}
}
BreakableBody body = new BreakableBody(World, polygons);
World.AddBreakableBody(body);
return(body);
}
bool SFXPlayed(BreakableBody.BodyMaterial material)
{
switch (material)
{
case BreakableBody.BodyMaterial.CONCRETE:
return cementSFX;
case BreakableBody.BodyMaterial.WOOD:
return woodSFX;
case BreakableBody.BodyMaterial.GLASS:
return glassSFX;
}
return true;
}
public override void LoadContent()
{
base.LoadContent();
World.Gravity = Vector2.Zero;
_border = new Border(World, this, ScreenManager.GraphicsDevice.Viewport);
_breakableObject = new List <List <Vertices> >();
Texture2D alphabet = ScreenManager.Content.Load <Texture2D>("Samples/alphabet");
uint[] data = new uint[alphabet.Width * alphabet.Height];
alphabet.GetData(data);
List <Vertices> list = PolygonTools.CreatePolygon(data, alphabet.Width, 3.5f, 20, true, true);
float yOffset = -5f;
float xOffset = -14f;
for (int i = 0; i < list.Count; i++)
{
if (i == 9)
{
yOffset = 0f;
xOffset = -14f;
}
if (i == 18)
{
yOffset = 5f;
xOffset = -12.25f;
}
Vertices polygon = list[i];
Vector2 centroid = -polygon.GetCentroid();
polygon.Translate(ref centroid);
//polygon = SimplifyTools.CollinearSimplify(polygon); // this breaks the split hole function
polygon = SimplifyTools.ReduceByDistance(polygon, 4);
List <Vertices> triangulated = BayazitDecomposer.ConvexPartition(polygon);
#if WINDOWS_PHONE
const float scale = 0.6f;
#else
const float scale = 1f;
#endif
Vector2 vertScale = new Vector2(ConvertUnits.ToSimUnits(1)) * scale;
foreach (Vertices vertices in triangulated)
{
vertices.Scale(ref vertScale);
}
BreakableBody breakableBody = new BreakableBody(triangulated, World, 1);
breakableBody.MainBody.Position = new Vector2(xOffset, yOffset);
breakableBody.Strength = 100;
breakableBody.MainBody.UserData = i;
World.AddBreakableBody(breakableBody);
polygon.Scale(ref vertScale);
_breakableObject.Add(polygon.SplitAtHoles());
xOffset += 3.5f;
}
}
void SFXPlayed(BreakableBody.BodyMaterial material, bool hit)
{
switch (material)
{
case BreakableBody.BodyMaterial.CONCRETE:
cementSFX = hit;
cementTime = timeToWaitForSFX;
break;
case BreakableBody.BodyMaterial.WOOD:
woodSFX = hit;
woodTime = timeToWaitForSFX;
break;
case BreakableBody.BodyMaterial.GLASS:
glassSFX = hit;
glassTime = timeToWaitForSFX;
break;
}
}
float SFXTime(BreakableBody.BodyMaterial material)
{
switch (material)
{
case BreakableBody.BodyMaterial.CONCRETE:
return cementTime;
case BreakableBody.BodyMaterial.WOOD:
return woodTime;
case BreakableBody.BodyMaterial.GLASS:
return glassTime;
}
return 1;
}
