public void ShapeFromTexture(string shape, float scale, Color color, out Texture2D outputTexture, out Vertices vertices)
{
Texture2D shapeTexture = _shapes[shape];
uint[] data = new uint[shapeTexture.Width * shapeTexture.Height];
shapeTexture.GetData(data);
Vertices textureVertices = PolygonTools.CreatePolygon(data, shapeTexture.Width, false);
AABB vertsBounds = textureVertices.GetCollisionBox();
Vector2 origin = vertsBounds.Center;
textureVertices.Translate(-origin);
int width = (int)((vertsBounds.UpperBound.X - vertsBounds.LowerBound.X) * scale);
int height = (int)((vertsBounds.UpperBound.Y - vertsBounds.LowerBound.Y) * scale);
textureVertices = SimplifyTools.ReduceByDistance(textureVertices, 4f);
Vector2 vertScale = ConvertUnits.ToSimUnits(Vector2.One) * scale;
textureVertices.Scale(ref vertScale);
vertices = new Vertices(textureVertices);
RenderTarget2D renderTarget = new RenderTarget2D(_device, width + 2, height + 2, false, SurfaceFormat.Color,
DepthFormat.None, 8,
RenderTargetUsage.DiscardContents);
SpriteBatch batch = new SpriteBatch(_device);
_device.SetRenderTarget(renderTarget);
_device.Clear(Color.Transparent);
batch.Begin(SpriteSortMode.Immediate, null, SamplerState.LinearClamp, null, RasterizerState.CullNone);
batch.Draw(shapeTexture, new Vector2(renderTarget.Width / 2, renderTarget.Height / 2), null, color, 0, origin, scale, SpriteEffects.None, 0f);
batch.End();
_device.SetRenderTarget(null);
outputTexture = renderTarget as Texture2D;
}
static private void CreateShape(SFML.Graphics.Texture texture, World world)
{
// Make collision Geo from bitmap
// Get pixel data in array
byte[] bytes = texture.CopyToImage().Pixels;
uint[] data = new uint[texture.Size.X * texture.Size.Y];
for (int i = 0; i < bytes.Length; i += 4)
{
data[i / 4] = BitConverter.ToUInt32(bytes, i);
}
Byte myByte = 1;
List <Vertices> _list = PolygonTools.CreatePolygon(data, (int)texture.Size.X, 0.05f, myByte, true, true);
Vertices verts = new Vertices();
Vector2 scale = ConvertUnits.ToSimUnits(new Vector2(1, 1));
foreach (Vertices v in _list)
{
v.Scale(scale);
// v.Translate(ConvertUnits.ToSimUnits(new Vector2(-16, -16)));
Body body = new Body(world);
body.SleepingAllowed = false;
body.UserData = "wall";
List <Fixture> fixtures = FixtureFactory.AttachCompoundPolygon(
FarseerPhysics.Common.Decomposition.Triangulate.ConvexPartition(SimplifyTools.DouglasPeuckerSimplify(v, 0.05f), TriangulationAlgorithm.Bayazit, false, 0.05f),
1, body);
}
}
public void findShadowHull(Texture2D texture)
{
//Create an array to hold the data from the texture
uint[] data = new uint[texture.Width * texture.Height];
//Transfer the texture data to the array
texture.GetData(data);
//Find the vertices that makes up the outline of the shape in the texture
textureVertices = PolygonTools.CreatePolygon(data, texture.Width, false);
//We simplify the vertices found in the texture.
textureVertices = SimplifyTools.DouglasPeuckerSimplify(textureVertices, 0.5f);
//Since it is a concave polygon, we need to partition it into several smaller convex polygons
vertices = BayazitDecomposer.ConvexPartition(textureVertices);
_scale = 1f;
//scale the vertices from graphics space to sim space
foreach (Vertices vertex in vertices)
{
Vector2[] verticesArray = vertex.ToArray();
var hull = ShadowHull.CreateConvex(ref verticesArray);
hulls.Add(hull);
krypton.Hulls.Add(hull);
}
}
public override void Initialize()
{
//Load texture that will represent the physics body
Texture2D polygonTexture = CCApplication.SharedApplication.Content.Load <Texture2D>("box2d/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 = PolygonTools.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);
//Create a single body with multiple fixtures
Body compund = BodyFactory.CreateCompoundPolygon(World, BayazitDecomposer.ConvexPartition(verts), 1);
compund.BodyType = BodyType.Dynamic;
compund.Position = new Vector2(0, 20);
base.Initialize();
}
public override void Initialize()
{
Bitmap polygonTexture = Bitmap.FromFile("AltData/FarseerPhysics/Testbed/Content/Texture.png");
uint[] data = new uint[polygonTexture.PixelWidth * polygonTexture.PixelHeight];
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);
Vertices verts = PolygonTools.CreatePolygon(data, polygonTexture.PixelWidth);
Vector2 scale = new Vector2(0.07f, -0.07f);
verts.Scale(ref scale);
Vector2 centroid = -verts.GetCentroid();
verts.Translate(ref centroid);
Body compund = BodyFactory.CreateCompoundPolygon(World, Triangulate.ConvexPartition(verts, TriangulationAlgorithm.Bayazit), 1);
compund.Position = new Vector2(-25, 30);
Body b = compund.DeepClone();
b.Position = new Vector2(20, 30);
b.BodyType = BodyType.Dynamic;
base.Initialize();
}
public FSCompoundPolygonBody(World world, Subtexture subtexture, float density, Vector2 position = default(Vector2), BodyType bodyType = BodyType.Static)
: base(world, subtexture, position, bodyType)
{
var data = new uint[subtexture.sourceRect.Width * subtexture.sourceRect.Height];
subtexture.texture2D.GetData(0, subtexture.sourceRect, data, 0, data.Length);
var verts = PolygonTools.CreatePolygon(data, subtexture.sourceRect.Width);
verts = SimplifyTools.DouglasPeuckerSimplify(verts, 2);
var decomposedVerts = Triangulate.ConvexPartition(verts, TriangulationAlgorithm.Bayazit);
for (var i = 0; i < decomposedVerts.Count; i++)
{
var polygon = decomposedVerts[i];
polygon.Translate(-subtexture.center);
}
// add the fixtures
var fixtures = Farseer.FixtureFactory.attachCompoundPolygon(decomposedVerts, density, body);
// fetch all the Vertices and save a copy in case we need to scale them later
foreach (var fixture in fixtures)
{
_verts.Add(new Vertices((fixture.Shape as PolygonShape).Vertices));
}
}
public static List <Vertices> GetCompoundPolygonVertices(Texture2D _polygonTexture, float _scale, ref Vector2 origin)
{
uint[] data = new uint[_polygonTexture.Width * _polygonTexture.Height];
_polygonTexture.GetData(data);
Vertices textureVertices = PolygonTools.CreatePolygon(data, _polygonTexture.Width, false);
Vector2 centroid = -textureVertices.GetCentroid();
textureVertices.Translate(ref centroid);
origin = -centroid;
textureVertices = SimplifyTools.ReduceByDistance(textureVertices, 4f);
List <Vertices> list = BayazitDecomposer.ConvexPartition(textureVertices);
Vector2 vertScale = new Vector2(ConvertUnits.ToSimUnits(1)) * _scale;
foreach (Vertices vertices in list)
{
vertices.Scale(ref vertScale);
}
return(list);
}
public override void Initialize()
{
if (_world != null && Texture != null)
{
var data = new uint[Texture.Width * Texture.Height];
Texture.GetData(data);
var verts = PolygonTools.CreatePolygon(data, Texture.Width, true);
var scale = ConvertUnits.ToSimUnits(new Vector2(1, 1));
verts.Scale(ref scale);
var list = BayazitDecomposer.ConvexPartition(verts);
var compound = BodyFactory.CreateCompoundPolygon(_world, list, 1);
compound.BodyType = BodyType.Dynamic;
Body = compound;
Body.Restitution = 1;
SetStartPosition();
var joint = new FixedPrismaticJoint(Body, Body.Position, new Vector2(1, 0));
joint.LimitEnabled = true;
joint.LowerLimit = -ConvertUnits.ToSimUnits((_screenBounds.Width - Texture.Width) / 2f);
joint.UpperLimit = ConvertUnits.ToSimUnits((_screenBounds.Width - Texture.Width) / 2f);
joint.Enabled = true;
joint.MaxMotorForce = 70f;
_world.AddJoint(joint);
}
base.Initialize();
}
} // PhysicTexture(setPos, setDensity, setDiffuseTexture, setCollisionTexture)
#endregion
#region CreateBody
/// <summary> Creates the physics Body </summary>
private void CreateBody()
{
uint[] data = new uint[collisionTexture.Width * collisionTexture.Height];
collisionTexture.GetData(data);
Vertices textureVertices = PolygonTools.CreatePolygon(data, collisionTexture.Width, true);
Vector2 centroid = -textureVertices.GetCentroid();
textureVertices.Translate(ref centroid);
origin = -centroid;
textureVertices = SimplifyTools.ReduceByDistance(textureVertices, 4f);
Vector2 vertScale = new Vector2(ConvertUnits.ToSimUnits(1));
List <Vertices> list = BayazitDecomposer.ConvexPartition(textureVertices);
list.ForEach(v => v.Scale(ref vertScale));
size = list.SelectMany(v => v).CalculateSize();
body = BodyFactory.CreateCompoundPolygon(PhysicsGameScreen.World, list, density, BodyType.Static);//BodyType.Dynamic);
body.Position = position;
body.UserData = "physictexture";
body.Friction = 10f;
} // CreateBody(setPos, setDensity)
public static List <Fixture> TextureToPolygon(Texture2D texture, Vector2 scaling, BodyType bodyType, Vector2 position, float density)
{
uint[] data = new uint[texture.Width * texture.Height];
texture.GetData(data);
Vertices vertices = PolygonTools.CreatePolygon(data, texture.Width, texture.Height, true);
var polygonOffset = new Vector2(-texture.Width / 2, -texture.Height / 2);
vertices.Translate(ref polygonOffset);
Vector2 scale = new Vector2(0.01f, 0.01f) * scaling;
vertices.Scale(ref scale);
List <Vertices> tempList = EarclipDecomposer.ConvexPartition(vertices);
List <Vertices> toRemove = new List <Vertices>();
foreach (Vertices item in tempList)
{
if (item.Count == 0)
{
toRemove.Add(item);
}
}
foreach (Vertices item in toRemove)
{
tempList.Remove(item);
}
List <Fixture> combine = FixtureFactory.CreateCompoundPolygon(Level.Physics, tempList, 1);
combine[0].Body.BodyType = bodyType;
combine[0].Body.Position = ToMeter(position);
return(combine);
}
private void CreateBody()
{
uint[] data = new uint[_textureBodyXna.Width * _textureBodyXna.Height];
_textureBodyXna.GetData(data);
Vertices textureVertices = PolygonTools.CreatePolygon(data, _textureBodyXna.Width, true);
Vector2 centroid = -textureVertices.GetCentroid();
textureVertices.Translate(ref centroid);
Vector2 vertScale = new Vector2(ConvertUnits.ToSimUnits(1));
List <Vertices> triangulated = BayazitDecomposer.ConvexPartition(textureVertices);
triangulated.ForEach(v => v.Scale(ref vertScale));
_size = _calcSize(triangulated.SelectMany(v => v));
_origin = -centroid * vertScale;
body = CreateBodyByList(triangulated);
_parts = new Body[0];
_infos.Values.ToList().ForEach(info => info.Effect.Dispose());
_infos.Clear();
foreach (Fixture fixture in body.FixtureList)
{
Guid id = Guid.NewGuid();
fixture.UserData = id;
_infos[id] = new FixtureInfo(_effectXna.Clone(), fixture, _origin,
new Vector2(_diffuseTexture.Width, _diffuseTexture.Height)); //this.TextureSize
}
} // CreateBody()
public override void Initialize()
{
Texture2D polygonTexture = CCApplication.SharedApplication.Content.Load <Texture2D>("box2d/Texture");
uint[] data = new uint[polygonTexture.Width * polygonTexture.Height];
polygonTexture.GetData(data);
Vertices verts = PolygonTools.CreatePolygon(data, polygonTexture.Width);
Vector2 scale = new Vector2(0.07f, -0.07f);
verts.Scale(ref scale);
Vector2 centroid = -verts.GetCentroid();
verts.Translate(ref centroid);
Body compund = BodyFactory.CreateCompoundPolygon(World, BayazitDecomposer.ConvexPartition(verts), 1);
compund.Position = new Vector2(-25, 30);
Body b = compund.DeepClone();
b.Position = new Vector2(20, 30);
b.BodyType = BodyType.Dynamic;
base.Initialize();
}
public void shapeFromTexture(Texture tex)
{
byte[] data;
using (MemoryStream ms = new MemoryStream())
{
tex.bitmap.Save(ms, ImageFormat.Png);
data = ms.ToArray();
ms.Dispose();
}
uint[] bytes = new uint[data.Length];
for (int i = 0; i < data.Length; i++)
{
bytes[i] = data[i];
}
Vertices verts = PolygonTools.CreatePolygon(bytes, tex.bitmap.Width, true);
vertices.Clear();
for (int i = 0; i < verts.Count; i++)
{
vertices.Add(new Vector((float)verts[i].X, (float)verts[i].Y));
}
}
public static Body ConvertToBody(this Texture2D me, Scene scene)
{
var polygonTexture = me;
var data = new uint[polygonTexture.Width * polygonTexture.Height];
polygonTexture.GetData(data);
var verts = PolygonTools.CreatePolygon(data, polygonTexture.Width, true);
//These 2 seem to work the best with tile maps
verts = SimplifyTools.CollinearSimplify(verts);
verts = SimplifyTools.DouglasPeuckerSimplify(verts, 0f);
var list = BayazitDecomposer.ConvexPartition(verts);
var vertScale = new Vector2(1f / ConvertUnits._displayUnitsToSimUnitsRatio);
foreach (var vertices in list)
{
vertices.Scale(ref vertScale);
}
var body = BodyFactory.CreateCompoundPolygon(scene.World, list, 1);
Debugging.Debug.WriteLine(
"WARNING: In Texture2D.ConvertToBody, Body functions have not been implemented!");
body.Friction = 0f;
body.IsStatic = true;
return(body);
}
public override void Initialize()
{
Texture2D polygonTexture = GameInstance.Content.Load <Texture2D>("Texture");
uint[] data = new uint[polygonTexture.Width * polygonTexture.Height];
polygonTexture.GetData(data);
Vertices verts = PolygonTools.CreatePolygon(data, polygonTexture.Width);
Vector2 scale = new Vector2(0.07f, -0.07f);
verts.Scale(ref scale);
Vector2 centroid = -verts.GetCentroid();
verts.Translate(ref centroid);
Body compund = World.CreateCompoundPolygon(Triangulate.ConvexPartition(verts, TriangulationAlgorithm.Bayazit), 1);
compund.Position = new Vector2(-25, 30);
Body b = compund.DeepClone();
b.Position = new Vector2(20, 30);
b.BodyType = BodyType.Dynamic;
base.Initialize();
}
public CaveWall(GameWorld gameWorld, string textureName)
: base(gameWorld, textureName)
{
// Read the texture data
var textureData = new uint[Texture.Width * Texture.Height];
Texture.GetData(textureData);
// Detect an outline of the texture
var outline = PolygonTools.CreatePolygon(textureData, Texture.Width);
// Scale the outline so that it fits the size of my game world
var scaleVector = ConvertUnits.ToSimUnits(2, 2);
outline.Scale(scaleVector);
// Simplify the outline to remove redundant points
outline = SimplifyTools.CollinearSimplify(outline);
// Decompose the outline into polygons
var decomposed = BayazitDecomposer.ConvexPartition(outline);
// Create the body for the game world
Body = BodyFactory.CreateCompoundPolygon(World, decomposed, 1f);
}
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 MPTanks.Engine.Serialization.GameObjectBodySpecifierJSON BuildBody(uint[] imageData, int width, Vector2 objSize)
{
var vertices = PolygonTools.CreatePolygon(imageData, width, true);
var imgHeight = imageData.Length / width;
var scale = new Vector2(objSize.X / width, objSize.Y / imgHeight);
vertices.Scale(scale);
var decomposed = Triangulate.ConvexPartition(vertices, TriangulationAlgorithm.Seidel);
var result = new Engine.Serialization.GameObjectBodySpecifierJSON();
var fixtures = new List <Engine.Serialization.GameObjectBodySpecifierJSON.FixtureSpecifierJSON>();
foreach (var fixture in decomposed)
{
var fx = new Engine.Serialization.GameObjectBodySpecifierJSON.FixtureSpecifierJSON();
var vertList = new List <Engine.Serialization.JSONVector>();
var holeList = new List <Engine.Serialization.GameObjectBodySpecifierJSON.FixtureSpecifierJSON.HolesSpecifierJSON>();
foreach (var vert in fixture)
{
vertList.Add(new Engine.Serialization.JSONVector
{
X = vert.X - (objSize.X / 2),
Y = vert.Y - (objSize.Y / 2)
});
}
if (fixture.Holes != null)
{
foreach (var h in fixture.Holes)
{
var hole = new Engine.Serialization.GameObjectBodySpecifierJSON.FixtureSpecifierJSON.HolesSpecifierJSON();
var vList = new List <Engine.Serialization.JSONVector>();
foreach (var v in h)
{
vList.Add(new Engine.Serialization.JSONVector
{
X = v.X - (objSize.X / 2),
Y = v.Y - (objSize.Y / 2)
});
}
hole.Vertices = vList.ToArray();
holeList.Add(hole);
}
}
fx.Vertices = vertList.ToArray();
fx.Holes = holeList.ToArray();
fixtures.Add(fx);
}
result.Fixtures = fixtures.ToArray();
result.Size = new Engine.Serialization.JSONVector {
X = objSize.X, Y = objSize.Y
};
return(result);
}
public override void LoadContent()
{
base.LoadContent();
World.Gravity = Vector2.Zero;
_border = new Border(World, this, ScreenManager.GraphicsDevice.Viewport);
//load texture that will represent the physics body
_polygonTexture = ScreenManager.Content.Load <Texture2D>("Samples/object");
//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 textureVertices = PolygonTools.CreatePolygon(data, _polygonTexture.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 = BayazitDecomposer.ConvexPartition(textureVertices);
//Adjust the scale of the object for WP7's lower resolution
#if WINDOWS_PHONE
_scale = 0.6f;
#else
_scale = 1f;
#endif
//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
_compound = BodyFactory.CreateCompoundPolygon(World, list, 1f, BodyType.Dynamic);
_compound.BodyType = BodyType.Dynamic;
}
public override void LoadContent()
{
base.LoadContent();
World.Gravity = Vector2.Zero;
_border = new Border(World, ScreenManager, Camera);
//load texture that will represent the physics body
_polygonTexture = ScreenManager.Content.Load <Texture2D>("Samples/object");
//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 textureVertices = PolygonTools.CreatePolygon(data, _polygonTexture.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;
var aabb = textureVertices.GetAABB();
_polygonSize = new Vector2(aabb.Width, aabb.Height);
//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);
//scale the vertices from graphics space to sim space
Vector2 vertScale = new Vector2(1f / 24f);
_polygonSize *= vertScale;
foreach (Vertices vertices in list)
{
vertices.Scale(new Vector2(1f, -1f));
vertices.Translate(new Vector2(0f, 30f));
vertices.Scale(vertScale);
}
//Create a single body with multiple fixtures
_compound = World.CreateCompoundPolygon(list, 1f, Vector2.Zero, 0, BodyType.Dynamic);
_compound.BodyType = BodyType.Dynamic;
}
public static PhysicsFrame GetVerticesForTextureData(uint[] textureData, int textureWidth)
{
Vertices textureVertices = PolygonTools.CreatePolygon(textureData, textureWidth, false);
Vector2 offset = -textureVertices.GetCentroid();
textureVertices.Translate(ref offset);
SimplifyTools.MergeParallelEdges(textureVertices, 0);
List <Vertices> convexVertices = BayazitDecomposer.ConvexPartition(textureVertices);
ConvertUnits.ScaleToSimUnits(ref convexVertices);
return(new PhysicsFrame(convexVertices, -offset));
}
static List <Vertices> ToVertices(Texture2D texture, out Vector2 origin)
{
//Create an array to hold the data from the texture
uint[] data = new uint[texture.Width * texture.Height];
//Transfer the texture data to the array
texture.GetData(data);
Vertices textureVertices = PolygonTools.CreatePolygon(data, 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.
var 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, 5f);
//Since it is a concave polygon, we need to partition it into several smaller convex polygons
//List<Vertices> list = BayazitDecomposer.ConvexPartition(textureVertices);
try
{
List <Vertices> list = BayazitDecomposer.ConvexPartition(textureVertices);
//Now we need to scale the vertices (result is in pixels, we use meters)
//At the same time we flip the y-axis.
var scale = new Vector2(0.015f, 0.015f);
foreach (Vertices vertices in list)
{
vertices.Scale(ref scale);
//When we flip the y-axis, the orientation can change.
//We need to remember that FPE works with CCW polygons only.
vertices.ForceCounterClockWise();
}
return(list);
}
catch
{
return(new List <Vertices>());
}
}
/// <summary>
///
/// </summary>
/// <param name="tex">Texture of shape</param>
/// <param name="pos">Postion in physics units</param>
/// <param name="isStatic">True for static</param>
/// <param name="world">World</param>
public Shape(Texture2D tex, Vector2 pos, bool isStatic, bool colliedsWithPlayerLaser, World world)
{
this.tex = tex;
this.pos = pos;
uint[] data = new uint[tex.Width * tex.Height];
tex.GetData(data);
Vertices verts = PolygonTools.CreatePolygon(data, tex.Width);
// How do we work out what the correct scale factor is? - Trial and error
Vector2 scale = new Vector2(0.015f, 0.015f); // was 0.025f
verts.Scale(ref scale);
Vector2 centroid = -verts.GetCentroid();
// orgin = centroid; // just a little test
verts.Translate(ref centroid);
var decomposedVertices = BayazitDecomposer.ConvexPartition(verts);
shapeBody = BodyFactory.CreateCompoundPolygon(world, decomposedVertices, 1);
if (this.isStatic)
{
shapeBody.BodyType = BodyType.Static;
}
else
{
shapeBody.BodyType = BodyType.Dynamic;
}
if (isStatic == true)
{
shapeBody.BodyType = BodyType.Static;
}
shapeBody.Position = pos / 64;
shapeBody.BodyId = 3;
if (colliedsWithPlayerLaser)
{
shapeBody.CollisionCategories = Category.Cat4;
}
else
{
shapeBody.CollisionCategories = Category.Cat8;
}
shapeBody.CollidesWith = Category.All ^ Category.Cat2;
orgin = new Vector2(tex.Width / 2, tex.Height / 2); // this seems to work well
}
public static TexVertOutput TexToVert(World world, Texture2D texture, float mass, bool useCentroid, float scale)
{
Vertices verts;
TexVertOutput output = new TexVertOutput();
// Creates an array for every pixel in the texture
uint[] data = new uint[texture.Width * texture.Height];
texture.GetData(data);
verts = PolygonTools.CreatePolygon(data, texture.Width, false);
Vector2 centroid = Vector2.Zero;
// Origin needs to be altered so it uses the origin of the verts
// rather than the texture's centre.
if (useCentroid)
{
centroid = -verts.GetCentroid();
verts.Translate(ref centroid);
}
else
{
centroid = ConvertUnits.ToSimUnits(new Vector2(texture.Width, texture.Height) * 0.5f);
}
float simScale = ConvertUnits.ToSimUnits(scale);
Vector2 Scale = new Vector2(simScale, simScale);
verts.Scale(ref Scale);
verts = SimplifyTools.ReduceByDistance(verts, ConvertUnits.ToSimUnits(4f));
Body body = BodyFactory.CreateCompoundPolygon(world, EarclipDecomposer.ConvexPartition(verts), mass);
body.BodyType = BodyType.Dynamic;
if (!useCentroid)
{
body.LocalCenter = centroid;
}
output.Body = body;
output.Origin = ConvertUnits.ToDisplayUnits(centroid);
return(output);
}
public void findShadowHull(Texture2D texture)
{
//Create an array to hold the data from the texture
uint[] data = new uint[texture.Width * texture.Height];
//Transfer the texture data to the array
texture.GetData(data);
//Find the vertices that makes up the outline of the shape in the texture
textureVertices = PolygonTools.CreatePolygon(data, 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.CollinearSimplify(textureVertices, 0f);
//Since it is a concave polygon, we need to partition it into several smaller convex polygons
list = BayazitDecomposer.ConvexPartition(textureVertices);
//Adjust the scale of the object for WP7's lower resolution
//Adjust the scale of the object for WP7's lower resolution
#if WINDOWS_PHONE
_scale = 0.6f;
#else
_scale = 1f;
#endif
//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);
Vector2[] verticesArray = vertices.ToArray();
var hull = ShadowHull.CreateConvex(ref verticesArray);
hulls.Add(hull);
krypton.Hulls.Add(hull);
}
}
public PhysicObj(World world, Texture2D texture, Vector2 scale, float density)
: base(texture, 0, scale, Vector2.Zero)
{
this.texture = texture;
this.scale = scale;
scale /= MULTIPLER;
uint[] data = new uint[texture.Width * texture.Height];
texture.GetData(data);
Vertices textureVertices = PolygonTools.CreatePolygon(data, texture.Width, false);
Vector2 centroid = -textureVertices.GetCentroid();
textureVertices.Translate(ref centroid);
origin = -centroid;
textureVertices = SimplifyTools.ReduceByDistance(textureVertices, 4f);
List <Vertices> list = BayazitDecomposer.ConvexPartition(textureVertices);
float minX = float.PositiveInfinity;
float maxX = float.NegativeInfinity;
foreach (Vertices vertices in list)
{
vertices.Scale(ref scale);
foreach (Vector2 vec in vertices)
{
if (vec.X < minX)
{
minX = vec.X;
}
if (maxX < vec.X)
{
maxX = vec.X;
}
}
}
body = BodyFactory.CreateCompoundPolygon(world, list, density, BodyType.Dynamic);
body.BodyType = BodyType.Dynamic;
}
public void AddShadowForObject(Texture2D texture, Vector2 position)
{
uint[] data = new uint[texture.Width * texture.Height];
texture.GetData <uint>(data);
foreach (var poly in EarclipDecomposer.ConvexPartition(PolygonTools.CreatePolygon(data, texture.Width)))
{
if (poly.Count >= 3)
{
var array = poly.ToArray();
var hull = ShadowHull.CreateConvex(ref array);
hull.Position = position;
_krypton.Hulls.Add(hull);
}
}
}
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));
}