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;*/ }