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();
}
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()
{
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();
}
/// <summary>
/// Make a concave polygon into a convex one
/// </summary>
/// <param name="poly"></param>
/// <returns></returns>
public static IEnumerable <IPoly> MakeConvex(IPoly poly)
{
List <Vector3> input = poly.GetPoints().ToList();
List <List <Vector3> > output = BayazitDecomposer.ConvexPartition(input);
return(output.Select(x => poly.Clone(x.ToArray())));
}
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);
}
void OnDrawGizmos()
{
if (!Application.isPlaying || !show)
{
return;
}
Gizmos.color = Color.green;
List <Vector2> worldColPoints = new List <Vector2>();
foreach (Vector2 point in col.points)
{
Vector2 currentWorldPoint = this.transform.TransformPoint(point);
worldColPoints.Add(currentWorldPoint);
}
List <Vector2> vertices = worldColPoints;
List <List <Vector2> > listOfConvexPolygonPoints = BayazitDecomposer.ConvexPartition(vertices);
foreach (List <Vector2> pointsOfIndivualConvexPolygon in listOfConvexPolygonPoints)
{
List <Vector2> currentPolygonVertices = pointsOfIndivualConvexPolygon;
for (int i = 0; i < currentPolygonVertices.Count; i++)
{
Vector2 currentVertex = currentPolygonVertices[i];
Vector2 nextVertex = currentPolygonVertices[i + 1 >= currentPolygonVertices.Count ? 0 : i + 1];
Gizmos.DrawLine(currentVertex, nextVertex);
}
}
}
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);
}
private void CreateFixtures()
{
//Partition shape into convex pieces
List <Vertices> verts;
if (!Vertices.IsConvex())
{
verts = BayazitDecomposer.ConvexPartition(Vertices);
}
else
{
verts = new List <Vertices>();
verts.Add(Vertices);
}
//Create fixtures for each piece
foreach (Vertices v in verts)
{
PolygonShape shape = new PolygonShape(v, _density);
Body.CreateFixture(shape);
}
//wake body up
Body.Awake = true;
}
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();
}
} // 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 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 LoadContent()
{
base.LoadContent();
DebugView.AppendFlags(DebugViewFlags.Shape);
World.Gravity = Vector2.Zero;
_border = new Border(World, this, ScreenManager.GraphicsDevice.Viewport);
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 = 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;
World.AddBreakableBody(breakableBody);
xOffset += 3.5f;
}
}
public bool CheckIfFilled(Map.Map map, int layer, ObstacleCollection obstacles)
{
Simplify();
var convexPolygons = BayazitDecomposer.ConvexPartition(this);
var blockPointsDictionary = new Dictionary <Block, List <Vector2> >();
var blocks = GetAssociatedBlocks(convexPolygons, map, layer, blockPointsDictionary);
var layerObstacles = CreateLayerObstacles(layer, obstacles); //ToDo: Don't call this method every time, the result does not change...
return(CheckLid(blocks, map, layer, layerObstacles, blockPointsDictionary));
}
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 void Initialize(Map.Map map)
{
var collision = new CollisionMap(map);
if (_world == null)
{
_world = new World(new Vector2(0, 0));
}
else
{
_world.Clear();
}
var obstacles = collision.GetObstacles();
var layer2Obstacles = obstacles.GetObstacles(2);
foreach (var obstacle in layer2Obstacles)
{
var body = new Body(_world)
{
BodyType = BodyType.Static
};
_json.SetName(body, "Building" + obstacle.Z);
Shape shape;
Fixture fixture;
switch (obstacle.Type)
{
case ObstacleType.Line:
var lineObstacle = (LineObstacle)obstacle;
shape = new EdgeShape(lineObstacle.Start.ToMeters(), lineObstacle.End.ToMeters());
fixture = body.CreateFixture(shape);
_json.SetName(fixture, "Building" + obstacle.Z);
break;
case ObstacleType.Polygon:
var polygonObstacle = (PolygonObstacle)obstacle;
var convexPolygons = BayazitDecomposer.ConvexPartition(polygonObstacle.Vertices);
foreach (var convexPolygon in convexPolygons)
{
shape = new PolygonShape(convexPolygon.ToMeters(), 1);
fixture = body.CreateFixture(shape);
_json.SetName(fixture, "Building" + obstacle.Z);
}
break;
case ObstacleType.Rectangle:
var rectangleObstacle = (RectangleObstacle)obstacle;
shape = new PolygonShape(rectangleObstacle.Vertices.ToMeters(), 1);
fixture = body.CreateFixture(shape);
_json.SetName(fixture, "Building" + obstacle.Z);
break;
}
}
}
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));
}
public override void HandleInput(InputHelper input, GameTime gameTime)
{
Keys[] pressedKeys = input.KeyboardState.GetPressedKeys();
if (pressedKeys.Any(x => x == Keys.Up))
{
this.MoveVertical(gamePad2, -step);
//this.gamePad2.Position = new Vector2((float)(this.gamePad2.Position.X), Math.Max(this.gamePad2.Position.Y - step, MinTop));
}
else if (pressedKeys.Any(x => x == Keys.Down))
{
//this.gamePad2.Position = new Vector2((float)(this.gamePad2.Position.X), Math.Min(this.gamePad2.Position.Y + step, MaxTop));
this.MoveVertical(gamePad2, +step);
}
if (pressedKeys.Any(x => x == Keys.W))
{
this.MoveVertical(gamePad1, -step);
}
else if (pressedKeys.Any(x => x == Keys.S))
{
this.MoveVertical(gamePad1, +step);
//this.gamePad1.Position = new Vector2((float)(this.gamePad1.Position.X), Math.Min(this.gamePad1.Position.Y + step, MaxTop));
}
if (pressedKeys.Any(x => x == Keys.Enter) && !geometryAdded)
{
geometryAdded = true;
var verts = new Vertices {
new Vector2(-2, -2), new Vector2(-2, 2), new Vector2(2, 2), new Vector2(2, -2)
};
var geo = BodyFactory.CreateCompoundPolygon(World, BayazitDecomposer.ConvexPartition(verts), 1f, new Vector2(-3));
geo.IsStatic = true;
geo.Restitution = 1f;
geo.Friction = 0f;
var sprite = new Sprite(ScreenManager.Assets.TextureFromShape(geo.FixtureList[0].Shape, MaterialType.Dots, Color.SandyBrown, 0.8f));
dymanicShit.Add(new BodySprite {
Body = geo, Sprite = sprite
});
}
base.HandleInput(input, gameTime);
}
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 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;
}
private List <Vector2[]> ProcessVertices(PolygonCollider2D collider, Vertices v, List <Vector2[]> list, ref PolygonParameters p, ref int pathIndex)
{
Vector2 offset = p.Offset;
float flipXMultiplier = (spriteRenderer.flipX ? -1.0f : 1.0f);
float flipYMultiplier = (spriteRenderer.flipY ? -1.0f : 1.0f);
if (p.DistanceThreshold > 1)
{
v = SimplifyTools.DouglasPeuckerSimplify(v, p.DistanceThreshold);
}
if (p.Decompose)
{
List <List <Vector2> > points = BayazitDecomposer.ConvexPartition(v);
for (int j = 0; j < points.Count; j++)
{
List <Vector2> v2 = points[j];
for (int i = 0; i < v2.Count; i++)
{
float xValue = (2.0f * (((v2[i].x - offset.x) + 0.5f) / p.Rect.width));
float yValue = (2.0f * (((v2[i].y - offset.y) + 0.5f) / p.Rect.height));
v2[i] = new Vector2(xValue * p.XMultiplier * Scale * flipXMultiplier, yValue * p.YMultiplier * Scale * flipYMultiplier);
}
Vector2[] arr = v2.ToArray();
collider.pathCount = pathIndex + 1;
collider.SetPath(pathIndex++, arr);
list.Add(arr);
}
}
else
{
collider.pathCount = pathIndex + 1;
for (int i = 0; i < v.Count; i++)
{
float xValue = (2.0f * (((v[i].x - offset.x) + 0.5f) / p.Rect.width));
float yValue = (2.0f * (((v[i].y - offset.y) + 0.5f) / p.Rect.height));
v[i] = new Vector2(xValue * p.XMultiplier * Scale * flipXMultiplier, yValue * p.YMultiplier * Scale * flipYMultiplier);
}
Vector2[] arr = v.ToArray();
collider.SetPath(pathIndex++, arr);
list.Add(arr);
}
return(list);
}
public void loadConvexHulls()
{
//World.Gravity = Vector2.Zero;
//load texture that will represent the physics body
_polygonTexture = Content.Load <Texture2D>("Tiles/Exit");
//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
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.CollinearSimplify(textureVertices, 1f);
//Since it is a concave polygon, we need to partition it into several smaller convex polygons
list = BayazitDecomposer.ConvexPartition(textureVertices);
//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 FarseerObject(FarseerWorld world, Texture2D texture, float density = 1, BodyType BodyType = BodyType.Dynamic, float colapseDistance = 4)
{
//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
Vertices textureVertices = PolygonTools.CreatePolygon(data, texture.Width);
//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 - new Vector2(texture.Width / 2, texture.Height / 2);;
//We simplify the vertices found in the texture.
textureVertices = SimplifyTools.ReduceByDistance(textureVertices, colapseDistance);
//Since it is a concave polygon, we need to partition it into several smaller convex polygons
List <Vertices> list = BayazitDecomposer.ConvexPartition(textureVertices);
//scale the vertices from graphics space to sim space
Vector2 vertScale = new Vector2(ConvertUnits.ToSimUnits(1));
foreach (Vertices vertices in list)
{
vertices.Scale(ref vertScale);
}
//Create a single body with multiple fixtures
body = BodyFactory.CreateCompoundPolygon(world.World, list, density, BodyType);
body.BodyType = BodyType;
body.CollisionCategories = Category.All;
body.CollidesWith = Category.All;
body.Enabled = false;
}
/*
* private void world_OnBroadPhaseCollision(ref FixtureProxy proxyA, ref FixtureProxy proxyB)
* {
* // Get the collided entities
* Entity entityA = proxyA.Fixture.Body.UserData as Entity;
* Entity entityB = proxyB.Fixture.Body.UserData as Entity;
* if (entityA == null || entityB == null)
* {
* // fail in debug builds
* Debug.Assert(entityA != null && entityB != null);
* return;
* }
* entityA.CollideWith(entityB);
* }
*/
private Body BodyFromTexture(Texture2D texture, float density)
{
//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
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.
Vector2 centroid = -textureVertices.GetCentroid();
textureVertices.Translate(ref centroid);
//2. To draw the texture the correct place.
Vector2 _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);
//scale the vertices from graphics space to sim space
Vector2 vertScale = new Vector2(WorldConversions.ConvertFromPixels(1));
foreach (Vertices vertices in list)
{
vertices.Scale(ref vertScale);
}
//Create a single body with multiple fixtures
Body body = BodyFactory.CreateCompoundPolygon(
CurrentLevel.PhysicsWorld, list, density, BodyType.Dynamic);
return(body);
}
public List <Fixture> CreateFixture(Body body)
{
var vertices = new Vertices(Verts);
List <Vertices> vertsList = BayazitDecomposer.ConvexPartition(vertices);
List <Fixture> fixtureList = new List <Fixture>();
Vector2 mainCentroid = vertices.GetCentroid();
foreach (Vertices v in vertsList)
{
PolygonShape shape = new PolygonShape(v, Density);
Fixture fixture = new Fixture(body, shape, RotationOffset);
fixture.IsSensor = IsSensor;
fixture.CollisionGroup = CollisionGroup;
fixture.CollisionCategories = (Category)CollisionCategories;
fixture.CollidesWith = (Category)CollidesWith;
fixtureList.Add(fixture);
}
return(fixtureList);
}
public static PhysicsObject createFromTexture(Texture2D texture, float density = 1f)
{
int width = texture.Width;
int height = texture.Height;
uint[] data = new uint[texture.Width * texture.Height];
texture.GetData <uint>(data);
PhysicsObject obj = new PhysicsObject();
for (int i = 0; i < Main.objects.Length; i++)
{
if (Main.objects[i].active == false)
{
Main.objects[i] = obj;
obj.whoAmI = i;
break;
}
}
Vertices verts = PolygonTools.CreatePolygon(data, width, false);
Vector2 centroid = -verts.GetCentroid();
obj.origin = Vector2.Zero;// centroid / 2;
verts = SimplifyTools.ReduceByDistance(verts, 4f);
List <Vertices> list = BayazitDecomposer.ConvexPartition(verts);
Vector2 vScale = new Vector2(ConvertUnits.ToSimUnits(1));
foreach (Vertices v in list)
{
v.Scale(ref vScale);
}
obj.body = BodyFactory.CreateCompoundPolygon(Main.physicsWorld, list, 1f);
obj.shape = 3;
obj.active = true;
obj.dwidth = width;
obj.dheight = height;
obj.body.BodyType = BodyType.Dynamic;
Debug.print("New texture body with " + verts.Count + " vertices successfully added");
return(obj);
}
/// <summary>
/// Updates data for convex decomposition of the polygon.
/// </summary>
private void UpdateConvexDecomposition()
{
if (vertices.Count <= 3)
{
return;
}
Debug.Assert(Polygon.Vertices.IsSimple(), "Polygon must be simple (no crossing edges)");
// compute convex decomposition
List <Vertices> decomposition = BayazitDecomposer.ConvexPartition(new Vertices(Polygon.Vertices));
// update convex decomposition lines
convexDecompositionLines.Clear();
foreach (Vertices decompositionVertices in decomposition)
{
PointF[] convexLines = new PointF[decompositionVertices.Count];
for (int i = 0; i < decompositionVertices.Count; ++i)
{
convexLines[i] = new PointF(decompositionVertices[i].X, decompositionVertices[i].Y);
}
convexDecompositionLines.Add(convexLines);
}
}
/// <summary>
/// Builds convex polygons out of the currently loaded 2D Shape Editor project.
/// Note: Currently simply triangulates everything instead.
/// </summary>
/// <returns>A list of convex polygons.</returns>
private List <Polygon> BuildConvexPolygons()
{
List <Polygon> polygons = new List <Polygon>();
// for each shape in the project:
foreach (Shape shape in project.shapes)
{
List <Vector2> vertices = new List <Vector2>();
// iterate through all segments of the shape:
foreach (Segment segment in shape.segments)
{
// linear segment:
if (segment.type == SegmentType.Linear)
{
vertices.Add(new Vector2(segment.position.x * project.extrudeScale.x, segment.position.y * -1.0f * project.extrudeScale.y) / 8.0f);
}
// bezier segment:
else
{
foreach (Edge edge in GetBezierEdges(segment, GetNextSegment(shape, segment)))
{
vertices.Add(new Vector2(edge.Vertex1.Position.x * project.extrudeScale.x, edge.Vertex1.Position.y * -1.0f * project.extrudeScale.y) / 8.0f);
}
}
}
// in project v1 we use the horizontal and vertical flags to keep track of the correct winding order.
Vector2[] inputVertices = vertices.ToArray();
if (project.flipHorizontally && !project.flipVertically)
{
inputVertices = ReverseWindingOrder(inputVertices);
}
if (!project.flipHorizontally && project.flipVertically)
{
inputVertices = ReverseWindingOrder(inputVertices);
}
// create convex polygons:
inputVertices = ReverseWindingOrder(inputVertices);
List <Vector2[]> convexPolygonsVertices = BayazitDecomposer.ConvexPartition(inputVertices);
foreach (Vector2[] polyVertices in convexPolygonsVertices)
{
List <Vertex> vertexList = new List <Vertex>();
foreach (Vector2 vert in polyVertices)
{
vertexList.Add(new Vertex(vert, Vector3.zero, Vector2.zero));
}
polygons.Add(new Polygon(vertexList.ToArray(), null, false, false));
}
switch (extrudeMode)
{
case ExtrudeMode.CreatePolygon:
// we make a brush for every polgon.
desiredBrushCount = polygons.Count;
break;
// we need another brush for every revolve step.
case ExtrudeMode.RevolveShape:
desiredBrushCount = polygons.Count * project.revolveSteps;
break;
case ExtrudeMode.ExtrudeShape:
// we make a brush for every polgon.
desiredBrushCount = polygons.Count;
break;
case ExtrudeMode.ExtrudePoint:
// we make a brush for every polgon.
desiredBrushCount = polygons.Count;
break;
case ExtrudeMode.ExtrudeBevel:
// we make a brush for every polgon.
desiredBrushCount = polygons.Count;
break;
}
}
return(polygons);
}
