public void TestCalculateAabbTransformedTriangle()
{
float3[] vertices =
{
new float3(-1.8f, 2.4f, 4.6f),
new float3(1.4f, 1.6f, 1.6f),
new float3(0.2f, 1.2f, 3.6f)
};
float3 translation = new float3(3.4f, 2.5f, -1.1f);
quaternion rotation = quaternion.AxisAngle(math.normalize(new float3(1.1f, 10.1f, -3.4f)), 78.0f);
var collider = PolygonCollider.CreateTriangle(vertices[0], vertices[1], vertices[2]);
Aabb aabb = collider.Value.CalculateAabb(new RigidTransform(rotation, translation));
for (int i = 0; i < 3; ++i)
{
vertices[i] = translation + math.mul(rotation, vertices[i]);
}
Aabb expected = new Aabb()
{
Min = math.min(math.min(vertices[0], vertices[1]), vertices[2]),
Max = math.max(math.max(vertices[0], vertices[1]), vertices[2])
};
TestUtils.AreEqual(expected.Min, aabb.Min, 1e-3f);
TestUtils.AreEqual(expected.Max, aabb.Max, 1e-3f);
}
public void PolygonCollider()
{
var tc = new TestCore();
tc.Init();
var collider1 = new PolygonCollider();
collider1.Position = new Vector2F(30f, 30f);
collider1.Rotation = MathHelper.DegreeToRadian(10.0f);
Span <Vector2F> array = stackalloc Vector2F[]
{
new Vector2F(10f, 10f),
new Vector2F(20f, 20f),
new Vector2F(30f, 30f),
};
collider1.SetVertexes(array);
const string path = "Serialization/PolygonCollider.bin";
Serialize(path, collider1);
var collider2 = Deserialize <PolygonCollider>(path);
Assert.NotNull(collider2);
Assert.AreEqual(collider1.Position, collider2.Position);
Assert.AreEqual(collider1.Rotation, collider2.Rotation);
Assert.True(Enumerable.SequenceEqual(collider1.Vertexes, collider2.Vertexes));
tc.End();
}
public MapCollider(IsometricMap map)
{
var collidersGroup = map.ObjectGroups["Colliders"];
Colliders = new PolygonCollider[collidersGroup.Count];
for (var i = 0; i < collidersGroup.Count; i++)
{
var obj = collidersGroup[i];
var points = new Vector2[4];
points[0] = new Vector2(obj.Position.X, obj.Position.Y); //Topleft
points[1] = new Vector2(obj.Position.X + obj.Width, obj.Position.Y); //Topright
points[2] = new Vector2(obj.Position.X + obj.Width, obj.Position.Y + obj.Height); //BotRight
points[3] = new Vector2(obj.Position.X, obj.Position.Y + obj.Height); //BotLeft
for (var o = 0; o < 4; o++)
{
points[o] = Isometric.WorldToIsometricWorld(points[o], map);
}
Colliders[i] = new PolygonCollider(points);
Colliders[i].SetShouldColliderScaleAndRotateWithTransform(true);
//entity.addComponent<BoxCollider>(colliders[i]);
}
}
unsafe public void TestCreateTriangle()
{
float3[] vertices =
{
new float3(-1.4f, 1.4f, 5.6f),
new float3(1.4f, 1.4f, 3.6f),
new float3(0.2f, 1.2f, 5.6f)
};
float3 normal = math.normalize(math.cross(vertices[1] - vertices[0], vertices[2] - vertices[0]));
var collider = PolygonCollider.CreateTriangle(vertices[0], vertices[1], vertices[2]);
var triangleCollider = UnsafeUtility.AsRef <PolygonCollider>(collider.GetUnsafePtr());
Assert.IsTrue(triangleCollider.IsTriangle);
Assert.IsFalse(triangleCollider.IsQuad);
TestUtils.AreEqual(triangleCollider.Vertices[0], vertices[0], 1e-3f);
TestUtils.AreEqual(triangleCollider.Vertices[1], vertices[1], 1e-3f);
TestUtils.AreEqual(triangleCollider.Vertices[2], vertices[2], 1e-3f);
Assert.AreEqual(2, triangleCollider.Planes.Length);
TestUtils.AreEqual(normal, triangleCollider.Planes[0].Normal, 1e-3f);
TestUtils.AreEqual(-normal, triangleCollider.Planes[1].Normal, 1e-3f);
Assert.AreEqual(ColliderType.Triangle, triangleCollider.Type);
Assert.AreEqual(CollisionType.Convex, triangleCollider.CollisionType);
}
unsafe public void TestCreateQuad()
{
float3[] vertices =
{
new float3(-4.5f, 0.0f, 1.0f),
new float3(3.4f, 0.7f, 1.0f),
new float3(3.4f, 2.7f, 1.0f),
new float3(-3.4f, 1.2f, 1.0f)
};
float3 normal = math.normalize(math.cross(vertices[2] - vertices[1], vertices[0] - vertices[1]));
var collider = PolygonCollider.CreateQuad(vertices[0], vertices[1], vertices[2], vertices[3]);
var quadCollider = UnsafeUtility.AsRef <PolygonCollider>(collider.GetUnsafePtr());
Assert.IsFalse(quadCollider.IsTriangle);
Assert.IsTrue(quadCollider.IsQuad);
TestUtils.AreEqual(quadCollider.Vertices[0], vertices[0], 1e-3f);
TestUtils.AreEqual(quadCollider.Vertices[1], vertices[1], 1e-3f);
TestUtils.AreEqual(quadCollider.Vertices[2], vertices[2], 1e-3f);
TestUtils.AreEqual(quadCollider.Vertices[3], vertices[3], 1e-3f);
Assert.AreEqual(2, quadCollider.Planes.Length);
TestUtils.AreEqual(normal, quadCollider.Planes[0].Normal, 1e-3f);
TestUtils.AreEqual(-normal, quadCollider.Planes[1].Normal, 1e-3f);
Assert.AreEqual(ColliderType.Quad, quadCollider.Type);
Assert.AreEqual(CollisionType.Convex, quadCollider.CollisionType);
}
public void PolygonIsTouchingPointTest()
{
Collider coll = new PolygonCollider(new Vector2(0, 0), new Vector2(100, 0f), new Vector2(50, 100), new Vector2(-100, 300));
Assert.IsFalse(coll.IsTouching(new Vector2(500, 500)));
Assert.IsTrue(coll.IsTouching(new Vector2(50, 50)));
}
public override void onAddedToScene()
{
Initialise("baked-sword", 96);
AddAnimation(new Animation(SubTextures.Skip(1).ToList(), AnimateMeleeSystem.Animations.Swing));
AddAnimation(new Animation(SubTextures[0], AnimateMeleeSystem.Animations.Idle));
addComponent(new Weapon());
addComponent(new MeleeInput());
addComponent(new TransformLock());
var collider = addComponent(new SpriteCollider <AnimateMeleeSystem.Animations>());
var swordCollider = new PolygonCollider(new[]
{
new Vector2(-32f, 2f),
new Vector2(-23f, 22f),
new Vector2(-9f, 31f),
new Vector2(8f, 30f),
new Vector2(23f, 21f),
new Vector2(17f, 3f),
new Vector2(-14f, 10f)
});
Flags.setFlagExclusive(ref swordCollider.collidesWithLayers, PhysicsLayers.ENEMY);
Flags.setFlagExclusive(ref swordCollider.physicsLayer, PhysicsLayers.PLAYER_WEAPON);
swordCollider.isTrigger = true;
collider.AddAction(AnimateMeleeSystem.Animations.Swing, 0, swordCollider);
}
/// <summary>
/// Spawns a copy of an object at a new position
/// </summary>
/// <param name="co"></param>
/// <param name="newPosition"></param>
/// <returns></returns>
public static CelestialObject SpawnCopy(CelestialObject co, Vector2 newPosition)
{
CelestialObject coObj = new CelestialObject(co.Name + "_COPY", co.Mass, new Vector2(co.velocity.x, co.velocity.y), newPosition, co.collider, co.visuals);
if (coObj.collider != null)
{
if (coObj.collider.colliderType == ColliderType.Circle)
{
CircleCollider cc = (CircleCollider)coObj.collider;
cc.centre.Set(newPosition.x, newPosition.y);
}
else if (coObj.collider.colliderType == ColliderType.Polygon)
{
Vector2 difference = co.position - newPosition;
PolygonCollider pc = (PolygonCollider)coObj.collider;
// Update the position of the vertices
foreach (Vector2 vert in pc.Vertices)
{
vert.x += difference.x;
vert.y += difference.y;
}
}
}
return(coObj);
}
Entity LoadPlayer()
{
Entity player = new Entity("player");
Transform transform = new Transform();
transform.Position = Screen.Center;
player.AddComponent(transform);
SpriteAtlas atlas = SpriteAtlasLoader.ParseSpriteAtlas("Content/Character/atlas/character.atlas", true);
SpriteAnimator animator = new SpriteAnimator(atlas);
animator.Play("idle");
player.AddComponent(animator);
transform.Origin = animator.TargetRectangle.Size * 0.5f;
player.AddComponent <Mover>();
PolygonCollider polygonCollider = new PolygonCollider();
polygonCollider.CollisionLayer = CollisionLayer.Player;
player.AddComponent <PolygonCollider>();
player.AddComponent <Player>();
return(player);
}
public void TestCalculateAabbTransformedQuad()
{
float3[] vertices =
{
new float3(-4.5f, 0.0f, 1.0f),
new float3(3.4f, 0.7f, 1.0f),
new float3(3.4f, 2.7f, 1.0f),
new float3(-3.4f, 1.2f, 1.0f)
};
float3 translation = new float3(-3.4f, -2.5f, -1.1f);
quaternion rotation = quaternion.AxisAngle(math.normalize(new float3(11.1f, 10.1f, -3.4f)), 178.0f);
var collider = PolygonCollider.CreateQuad(vertices[0], vertices[1], vertices[2], vertices[3]);
Aabb aabb = collider.Value.CalculateAabb(new RigidTransform(rotation, translation));
for (int i = 0; i < 4; ++i)
{
vertices[i] = translation + math.mul(rotation, vertices[i]);
}
Aabb expected = Aabb.CreateFromPoints(new float3x4(vertices[0], vertices[1], vertices[2], vertices[3]));
TestUtils.AreEqual(expected.Min, aabb.Min, 1e-3f);
TestUtils.AreEqual(expected.Max, aabb.Max, 1e-3f);
}
// Use this for initialization
void OnValidate()
{
enemCol = GetComponent<PolygonCollider>();
transform.tag = "Enemy";
if(!enemCol.firstTriangleMade) enemCol.makeFirstTriangle(area, transform.position);
}
public static void PolygonCollider_ContainsPoint(float x1, float y1, float w, float h, float x2, float y2, bool shouldContain)
{
using (var quadBody = new DynamicBody()) {
quadBody.SetWorldPosition(new Vector2(x1, y1));
quadBody.Collider = PolygonCollider.CreateRectangle(w, h);
quadBody.Initialize(null);
Assert.AreEqual(shouldContain, quadBody.Collider.Contains(new Vector2(x2, y2)));
}
}
public static void Remove(PolygonCollider polygon)
{
if (Colliders == null)
{
Colliders = new List <PolygonCollider>();
return;
}
Colliders.Remove(polygon);
}
private bool CheckCollision(GameObject obj1, GameObject obj2)
{
PolygonCollider col1 = obj1.Collider;
PolygonCollider col2 = obj2.Collider;
if (col1 == null || col2 == null || col1 == col2)
{
return(false);
}
return(PolygonCollider.CheckCollision(obj1, col1, obj2, col2));
}
private static bool AABBCircle(AABBCollider a, CircleCollider c)
{
List <Vector2> AABBVerts = new List <Vector2>();
AABBVerts.Add(new Vector2(0, 0));
AABBVerts.Add(new Vector2(a.Width, 0));
AABBVerts.Add(new Vector2(a.Width, a.Height));
AABBVerts.Add(new Vector2(0, a.Height));
PolygonCollider hax = new PolygonCollider(a.position.X, a.position.Y, AABBVerts);
return(PolygonCircle(hax, c));
}
public Bullet(MainAsteroidsScene scene, int collideLayer) : base(scene)
{
polygonCollider = new PolygonCollider(this, Core.Resources.Resources.Polygones.Bullet, scene.collidersWorld, collideLayer);
polygonCollider.Tag = "Bullet";
polygonCollider.OnCollide += PolygonCollider_OnCollide;
physic = new PhysicCore(this);
polygonRender = new PolygonRender(this, Core.Resources.Resources.Polygones.Bullet);
spriteRender = new SpriteRender(this, Core.Resources.Resources.Sprites.Bullet);
spriteRender.SetActive(false);
}
public void Execute(int i)
{
var shapeData = ComputeData[ToComputeTable[i]];
switch (shapeData.ShapeType)
{
case ShapeType.Box:
{
BlobAssets[i] = BoxCollider.Create(
shapeData.BoxProperties, shapeData.CollisionFilter, shapeData.Material
);
return;
}
case ShapeType.Capsule:
{
BlobAssets[i] = CapsuleCollider.Create(
shapeData.CapsuleProperties, shapeData.CollisionFilter, shapeData.Material
);
return;
}
case ShapeType.Cylinder:
{
BlobAssets[i] = CylinderCollider.Create(
shapeData.CylinderProperties, shapeData.CollisionFilter, shapeData.Material
);
return;
}
case ShapeType.Plane:
{
var v = shapeData.PlaneVertices;
BlobAssets[i] = PolygonCollider.CreateQuad(
v.c0, v.c1, v.c2, v.c3, shapeData.CollisionFilter, shapeData.Material
);
return;
}
case ShapeType.Sphere:
{
BlobAssets[i] = SphereCollider.Create(
shapeData.SphereProperties, shapeData.CollisionFilter, shapeData.Material
);
return;
}
// Note : Mesh and Hull are not computed here as they are in a separated set of jobs
default:
return;
}
}
public void TriangleIsTouchingPolygonTest()
{
Collider coll1 = new TriangleCollider(new Vector2(0, 0), new Vector2(100, 0f), new Vector2(50, 100));
Collider coll2 = new PolygonCollider(new Vector2(200, 0), new Vector2(300, 0), new Vector2(250, 100), new Vector2(100, 100));
Assert.IsFalse(coll1.IsTouching(coll2));
Assert.IsFalse(coll2.IsTouching(coll1));
coll2.Position -= new Vector2(150, 15);
Assert.IsTrue(coll1.IsTouching(coll2));
Assert.IsTrue(coll2.IsTouching(coll1));
}
public Asteroid(MainAsteroidsScene scene, SpriteInfo spriteInfo, Polygon polygon) : base(scene)
{
this.scene = scene;
SpriteRender = new SpriteRender(this, spriteInfo);
SpriteRender.SetActive(false);
PolygonRender = new PolygonRender(this, polygon);
collider2D = new PolygonCollider(this, polygon, scene.collidersWorld, 1);
collider2D.OnCollide += Collider2D_OnCollide;
collider2D.Tag = "Asteroid";
Physic = new PhysicCore(this);
}
private void AddHexagonCollider(Sprite2D sprite)
{
PolygonCollider collider = new PolygonCollider();
collider.AddVertex(new Vector2(0, sprite.Height / 2.0f));
collider.AddVertex(new Vector2(sprite.Width / 4.0f, 0));
collider.AddVertex(new Vector2(0.75f * sprite.Width, 0));
collider.AddVertex(new Vector2(sprite.Width, sprite.Height / 2.0f));
collider.AddVertex(new Vector2(0.75f * sprite.Width, sprite.Height));
collider.AddVertex(new Vector2(sprite.Width / 4.0f, sprite.Height));
sprite.SetCollider(collider);
}
private static bool PolygonHalfPlane(PolygonCollider p, HalfPlaneCollider hp)
{
// Just check if any of the polygon's vertices satisfies the half-plane's equation.
foreach (Vector2 v in p.vertices)
{
if (hp.A * v.X + hp.B * v.Y <= hp.C)
{
return(true);
}
}
// If none does, there is no intersection.
return(false);
}
public static void Register(PolygonCollider polygon)
{
if (Colliders == null)
{
Colliders = new List <PolygonCollider>();
}
if (Colliders.Contains(polygon))
{
return;
}
Colliders.Add(polygon);
}
public override void Added()
{
base.Added();
WeaponCollider = new PolygonCollider(new float[] { 0, 0, 1, 0, 0, 1, });
//Entity.RemoveCollider(WeaponCollider);
Entity.AddCollider(WeaponCollider);
Weapon = new Weapon(new PolygonCollider[] {
new PolygonCollider(new Polygon(new float[] { 0, 0, 0, 0, 0, 0, }), CollisionTags.Combat),
new PolygonCollider(new Polygon(new float[] { 10, 20, 55, 55, 60, 0, }), CollisionTags.Combat),
new PolygonCollider(new Polygon(new float[] { 10, 10, 65, 65, 80, 0, }), CollisionTags.Combat),
new PolygonCollider(new Polygon(new float[] { 10, 20, 55, 55, 60, 0, }), CollisionTags.Combat),
});
}
public static void CircleCollider_ContainsQuadTest(float x1, float y1, float r1, float x2, float y2, float w, float h, bool shouldContain)
{
using (var circleBody = new DynamicBody())
using (var quadBody = new DynamicBody()) {
circleBody.SetWorldPosition(new Vector2(x1, y1));
circleBody.Collider = new CircleCollider(r1);
circleBody.Initialize(null);
quadBody.SetWorldPosition(new Vector2(x2, y2));
quadBody.Collider = PolygonCollider.CreateRectangle(w, h);
quadBody.Initialize(null);
Assert.AreEqual(shouldContain, circleBody.Collider.Contains(quadBody.Collider));
}
}
public static void PolygonCollider_ContainsPolygon(float x1, float y1, float w1, float h1, float x2, float y2, float w2, float h2, bool shouldContain)
{
using (var quadBody1 = new DynamicBody())
using (var quadBody2 = new DynamicBody()) {
quadBody1.SetWorldPosition(new Vector2(x1, y1));
quadBody1.Collider = PolygonCollider.CreateRectangle(w1, w1);
quadBody1.Initialize(null);
quadBody2.SetWorldPosition(new Vector2(x2, y2));
quadBody2.Collider = PolygonCollider.CreateRectangle(w2, w2);
quadBody2.Initialize(null);
Assert.AreEqual(shouldContain, quadBody1.Collider.Contains(quadBody2.Collider));
}
}
public override void UpdateFirst()
{
base.UpdateFirst();
// attempt to attach a graphic
if (graphic == null)
{
graphic = Entity.Graphic;
}
// attempt to attach a polygon collider
if (collider == null)
{
collider = Entity.Collider as PolygonCollider;
}
}
public void TestCalculateAabbLocalQuad()
{
float3[] quadVertices =
{
new float3(-4.5f, 0.0f, 1.0f),
new float3(3.4f, 0.7f, 1.0f),
new float3(3.4f, 2.7f, 1.0f),
new float3(-3.4f, 1.2f, 1.0f)
};
var collider = PolygonCollider.CreateQuad(quadVertices[0], quadVertices[1], quadVertices[2], quadVertices[3]);
Aabb aabb = collider.Value.CalculateAabb();
Aabb expected = Aabb.CreateFromPoints(new float3x4(quadVertices[0], quadVertices[1], quadVertices[2], quadVertices[3]));
TestUtils.AreEqual(expected.Min, aabb.Min, 1e-3f);
TestUtils.AreEqual(expected.Max, aabb.Max, 1e-3f);
}
/// <summary>
/// Much more complex than AABB collision detection. Works with CONVEX shapes.
/// WARNING :: DO NOT USE CONCAVE SHAPES
/// </summary>
/// <param name="r1"></param>
/// <param name="r2"></param>
/// <returns></returns>
public static bool ShapeOverlap_SAT(PolygonCollider r1, PolygonCollider r2)
{
PolygonCollider poly1 = r1;
PolygonCollider poly2 = r2;
for (int shape = 0; shape < 2; shape++)
{
if (shape == 1)
{
poly1 = r2;
poly2 = r1;
}
for (int a = 0; a < poly1.Points.Count; a++)
{
int b = (a + 1) % poly1.Points.Count;
Vector2 axisProj = new Vector2(-(poly1.Points[b].Y - poly1.Points[a].Y), poly1.Points[b].X - poly1.Points[a].X);
float min_r1 = Single.PositiveInfinity;
float max_r1 = Single.NegativeInfinity;
for (int p = 0; p < poly1.Points.Count; p++)
{
float q = (poly1.Points[p].X * axisProj.X + poly1.Points[p].Y * axisProj.Y);
min_r1 = Math.Min(min_r1, q);
max_r1 = Math.Max(max_r1, q);
}
float min_r2 = Single.PositiveInfinity;
float max_r2 = Single.NegativeInfinity;
for (int p = 0; p < poly2.Points.Count; p++)
{
float q = (poly2.Points[p].X * axisProj.X + poly2.Points[p].Y * axisProj.Y);
min_r2 = Math.Min(min_r2, q);
max_r2 = Math.Max(max_r2, q);
}
if (!(max_r2 >= min_r1 && max_r1 >= min_r2))
{
return(false);
}
}
}
return(true);
}
//[Test] // #TODO: Add test back in once we have implemented this in Physics
unsafe public void TestMassPropertiesTriangle()
{
// constructing the triangle to be parallel to the xy plane so we don't have to figure out the transformations first
float3[] vertices =
{
new float3(-1.1f, -0.4f, 0.0f),
new float3(0.8f, -0.1f, 0.0f),
new float3(-0.2f, 1.3f, 0.0f)
};
var collider = PolygonCollider.CreateTriangle(vertices[0], vertices[1], vertices[2]);
float3 inertiaTensor = collider.Value.MassProperties.MassDistribution.InertiaTensor;
float3 expectedInertiaTensor = calcTriangleInertiaTensor(vertices[0], vertices[1], vertices[2]);
TestUtils.AreEqual(expectedInertiaTensor, inertiaTensor, 1e-3f);
}
//[Test] // #TODO: Add test back in once we have implemented this in Physics
public void TestMassPropertiesQuad()
{
float3[] vertices =
{
new float3(-1.1f, -0.4f, 0.0f),
new float3(0.8f, -0.1f, 0.0f),
new float3(1.2f, 1.3f, 0.0f),
new float3(-0.2f, 1.3f, 0.0f)
};
var collider = PolygonCollider.CreateQuad(vertices[0], vertices[1], vertices[2], vertices[3]);
float3 inertiaTensor = collider.Value.MassProperties.MassDistribution.InertiaTensor;
float3 expectedInertiaTensor = calcQuadInertiaTensor(vertices[0], vertices[1], vertices[2], vertices[3]);
TestUtils.AreEqual(expectedInertiaTensor, inertiaTensor, 1e-3f);
}
public override void Start()
{
Mover = GetComponent <Mover>();
Animator = GetComponent <SpriteAnimator>();
Transform = GetComponent <Transform>();
Collider = GetComponent <PolygonCollider>();
_stateMachine = new StateMachine <Player>(this, _idleState);
_stateMachine.AddState(_swimState);
_stateMachine.AddState(_catchState);
Transform.Position = Screen.Center;
/*VesselColliderBounds = new Vector2(31, 2);
* VesselCatchCollider = new BoxCollider(VesselColliderBounds.X, VesselColliderBounds.Y);
* VesselCatchCollider.IsTrigger = true;
* AddComponent(VesselCatchCollider);
* VesselCatchCollider.Enabled = false;*/
}
