From b28196605e0e1de536452ec5843d36e033f9e991 Mon Sep 17 00:00:00 2001 From: Evan Hemsley <2342303+ehemsley@users.noreply.github.com> Date: Thu, 2 Jan 2020 01:40:03 -0800 Subject: [PATCH 01/10] new multishape pattern --- Bonk/BroadPhase/SpatialHash.cs | 6 +- Bonk/IHasAABB2D.cs | 17 +++++ Bonk/IMultiShape2D.cs | 10 +++ Bonk/IShape2D.cs | 11 +--- Bonk/MinkowskiDifference.cs | 4 +- Bonk/MultiShapes/MultiRectangle.cs | 65 ++++++++++++++++++ Bonk/NarrowPhase/NarrowPhase.cs | 57 ++++++++++++++++ Bonk/Shapes/Polygon.cs | 7 +- Bonk/Shapes/Rectangle.cs | 62 ++++++------------ Bonk/Shapes/RectanglePolygonComparison.cs | 25 ------- Test/AABBTest.cs | 5 ++ Test/EPA2DTest.cs | 6 +- Test/Equality.cs | 80 +++-------------------- Test/{GJK2DTest.cs => NarrowPhaseTest.cs} | 78 +++++++++++++++++----- Test/SpatialHashTest.cs | 36 ++++++---- 15 files changed, 281 insertions(+), 188 deletions(-) create mode 100644 Bonk/IHasAABB2D.cs create mode 100644 Bonk/IMultiShape2D.cs create mode 100644 Bonk/MultiShapes/MultiRectangle.cs delete mode 100644 Bonk/Shapes/RectanglePolygonComparison.cs rename Test/{GJK2DTest.cs => NarrowPhaseTest.cs} (83%) diff --git a/Bonk/BroadPhase/SpatialHash.cs b/Bonk/BroadPhase/SpatialHash.cs index 72dc32c..8f54856 100644 --- a/Bonk/BroadPhase/SpatialHash.cs +++ b/Bonk/BroadPhase/SpatialHash.cs @@ -14,7 +14,7 @@ namespace MoonTools.Core.Bonk private readonly int cellSize; private readonly Dictionary> hashDictionary = new Dictionary>(); - private readonly Dictionary IDLookup = new Dictionary(); + private readonly Dictionary IDLookup = new Dictionary(); public SpatialHash(int cellSize) { @@ -32,7 +32,7 @@ namespace MoonTools.Core.Bonk /// A unique ID for the shape-transform pair. /// /// - public void Insert(T id, IShape2D shape, Transform2D transform2D) + public void Insert(T id, IHasAABB2D shape, Transform2D transform2D) { var box = shape.TransformedAABB(transform2D); var minHash = Hash(box.Min); @@ -57,7 +57,7 @@ namespace MoonTools.Core.Bonk /// /// Retrieves all the potential collisions of a shape-transform pair. Excludes any shape-transforms with the given ID. /// - public IEnumerable<(T, IShape2D, Transform2D)> Retrieve(T id, IShape2D shape, Transform2D transform2D) + public IEnumerable<(T, IHasAABB2D, Transform2D)> Retrieve(T id, IHasAABB2D shape, Transform2D transform2D) { var box = shape.TransformedAABB(transform2D); var minHash = Hash(box.Min); diff --git a/Bonk/IHasAABB2D.cs b/Bonk/IHasAABB2D.cs new file mode 100644 index 0000000..5acd583 --- /dev/null +++ b/Bonk/IHasAABB2D.cs @@ -0,0 +1,17 @@ +using System; +using MoonTools.Core.Structs; + +namespace MoonTools.Core.Bonk +{ + public interface IHasAABB2D + { + AABB AABB { get; } + + /// + /// Returns a bounding box based on the shape. + /// + /// A Transform for transforming the shape vertices. + /// Returns a bounding box based on the shape. + AABB TransformedAABB(Transform2D transform); + } +} diff --git a/Bonk/IMultiShape2D.cs b/Bonk/IMultiShape2D.cs new file mode 100644 index 0000000..390d03c --- /dev/null +++ b/Bonk/IMultiShape2D.cs @@ -0,0 +1,10 @@ +using System.Collections.Generic; +using MoonTools.Core.Structs; + +namespace MoonTools.Core.Bonk +{ + public interface IMultiShape2D : IHasAABB2D + { + IEnumerable<(IShape2D, Transform2D)> ShapeTransformPairs { get; } + } +} diff --git a/Bonk/IShape2D.cs b/Bonk/IShape2D.cs index 05d7616..1394b43 100644 --- a/Bonk/IShape2D.cs +++ b/Bonk/IShape2D.cs @@ -4,10 +4,8 @@ using MoonTools.Core.Structs; namespace MoonTools.Core.Bonk { - public interface IShape2D : IEquatable + public interface IShape2D : IHasAABB2D, IEquatable { - AABB AABB { get; } - /// /// A Minkowski support function. Gives the farthest point on the edge of a shape along the given direction. /// @@ -15,12 +13,5 @@ namespace MoonTools.Core.Bonk /// A Transform for transforming the shape vertices. /// The farthest point on the edge of the shape along the given direction. Vector2 Support(Vector2 direction, Transform2D transform); - - /// - /// Returns a bounding box based on the shape. - /// - /// A Transform for transforming the shape vertices. - /// Returns a bounding box based on the shape. - AABB TransformedAABB(Transform2D transform); } } diff --git a/Bonk/MinkowskiDifference.cs b/Bonk/MinkowskiDifference.cs index 89d7c0d..cc45fce 100644 --- a/Bonk/MinkowskiDifference.cs +++ b/Bonk/MinkowskiDifference.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Numerics; using MoonTools.Core.Structs; @@ -56,4 +56,4 @@ namespace MoonTools.Core.Bonk return !(a == b); } } -} \ No newline at end of file +} diff --git a/Bonk/MultiShapes/MultiRectangle.cs b/Bonk/MultiShapes/MultiRectangle.cs new file mode 100644 index 0000000..310af84 --- /dev/null +++ b/Bonk/MultiShapes/MultiRectangle.cs @@ -0,0 +1,65 @@ +using System.Collections.Generic; +using System.Collections.Immutable; +using MoonTools.Core.Structs; + +namespace MoonTools.Core.Bonk +{ + public struct MultiRectangle : IMultiShape2D + { + private ImmutableArray<(Rectangle, Transform2D)> Rectangles { get; } + + public IEnumerable<(IShape2D, Transform2D)> ShapeTransformPairs + { + get + { + foreach (var rectangle in Rectangles) { yield return rectangle; } + } + } + + public AABB AABB { get; } + + public MultiRectangle(ImmutableArray<(Rectangle, Transform2D)> rectangles) + { + Rectangles = rectangles; + + AABB = AABBFromRectangles(rectangles); + } + + public AABB TransformedAABB(Transform2D transform) + { + return AABB.Transformed(AABB, transform); + } + + private static AABB AABBFromRectangles(IEnumerable<(Rectangle, Transform2D)> rectangles) + { + var minX = float.MaxValue; + var minY = float.MaxValue; + var maxX = float.MinValue; + var maxY = float.MinValue; + + foreach (var (rectangle, transform) in rectangles) + { + var transformedAABB = rectangle.TransformedAABB(transform); + + if (transformedAABB.Min.X < minX) + { + minX = transformedAABB.Min.X; + } + if (transformedAABB.Min.Y < minY) + { + minY = transformedAABB.Min.Y; + } + if (transformedAABB.Max.X > maxX) + { + maxX = transformedAABB.Max.X; + } + if (transformedAABB.Max.Y > maxY) + { + maxY = transformedAABB.Max.Y; + } + } + + return new AABB(minX, minY, maxX, maxY); + } + } +} diff --git a/Bonk/NarrowPhase/NarrowPhase.cs b/Bonk/NarrowPhase/NarrowPhase.cs index 337e7ce..7cd731b 100644 --- a/Bonk/NarrowPhase/NarrowPhase.cs +++ b/Bonk/NarrowPhase/NarrowPhase.cs @@ -35,6 +35,63 @@ namespace MoonTools.Core.Bonk return FindCollisionSimplex(shapeA, transformA, shapeB, transformB).Item1; } + /// + /// Tests if a multishape-transform and shape-transform pair are overlapping. + /// Note that this must perform pairwise comparison so the worst-case performance of this method will vary inversely with the amount of shapes in the multishape. + /// + /// + /// + /// + /// + /// + public static bool TestCollision(IMultiShape2D multiShape, Transform2D multiShapeTransform, IShape2D shape, Transform2D shapeTransform) + { + foreach (var (otherShape, otherTransform) in multiShape.ShapeTransformPairs) + { + if (TestCollision(shape, shapeTransform, otherShape, multiShapeTransform.Compose(otherTransform))) { return true; } + } + return false; + } + + /// + /// Tests if a multishape-transform and shape-transform pair are overlapping. + /// Note that this must perform pairwise comparison so the worst-case performance of this method will vary inversely with the amount of shapes in the multishape. + /// + /// + /// + /// + /// + /// + public static bool TestCollision(IShape2D shape, Transform2D shapeTransform, IMultiShape2D multiShape, Transform2D multiShapeTransform) + { + foreach (var (otherShape, otherTransform) in multiShape.ShapeTransformPairs) + { + if (TestCollision(shape, shapeTransform, otherShape, multiShapeTransform.Compose(otherTransform))) { return true; } + } + return false; + } + + /// + /// Tests if two multishape-transform pairs are overlapping. + /// Note that this must perform pairwise comparison so the worst-case performance of this method will vary inversely with the amount of shapes in the multishapes. + /// + /// + /// + /// + /// + /// + public static bool TestCollision(IMultiShape2D multiShapeA, Transform2D transformA, IMultiShape2D multiShapeB, Transform2D transformB) + { + foreach (var (shapeA, shapeTransformA) in multiShapeA.ShapeTransformPairs) + { + foreach (var (shapeB, shapeTransformB) in multiShapeB.ShapeTransformPairs) + { + if (TestCollision(shapeA, transformA.Compose(shapeTransformA), shapeB, transformB.Compose(shapeTransformB))) { return true; } + } + } + return false; + } + /// /// Fast path for axis-aligned rectangles. If the transforms have non-zero rotation this will be inaccurate. /// diff --git a/Bonk/Shapes/Polygon.cs b/Bonk/Shapes/Polygon.cs index 90dc44c..bb7a1b4 100644 --- a/Bonk/Shapes/Polygon.cs +++ b/Bonk/Shapes/Polygon.cs @@ -59,7 +59,7 @@ namespace MoonTools.Core.Bonk public bool Equals(IShape2D other) { - return (other is Polygon otherPolygon && Equals(otherPolygon)) || (other is Rectangle rectangle && Equals(rectangle)); + return (other is Polygon otherPolygon && Equals(otherPolygon)); } public bool Equals(Polygon other) @@ -82,11 +82,6 @@ namespace MoonTools.Core.Bonk return true; } - public bool Equals(Rectangle rectangle) - { - return RectanglePolygonComparison.Equals(this, rectangle); - } - public override int GetHashCode() { return HashCode.Combine(Vertices); diff --git a/Bonk/Shapes/Rectangle.cs b/Bonk/Shapes/Rectangle.cs index fc6db8e..5095d02 100644 --- a/Bonk/Shapes/Rectangle.cs +++ b/Bonk/Shapes/Rectangle.cs @@ -1,5 +1,4 @@ using System; -using System.Collections.Generic; using System.Numerics; using MoonTools.Core.Structs; @@ -10,47 +9,33 @@ namespace MoonTools.Core.Bonk /// public struct Rectangle : IShape2D, IEquatable { - /// - /// The minimum position of the rectangle. Note that we assume y-down coordinates. - /// - /// - public Position2D Min { get; } - /// - /// The maximum position of the rectangle. Note that we assume y-down coordinates. - /// - /// - public Position2D Max { get; } public AABB AABB { get; } - - public int Left { get { return Min.X; } } - public int Right { get { return Max.X; } } - public int Top { get { return Min.Y; } } - public int Bottom { get { return Max.Y; } } - public int Width { get; } public int Height { get; } - public Position2D TopRight { get { return new Position2D(Right, Top); } } - public Position2D BottomLeft { get { return new Position2D(Left, Bottom); } } + public float Right { get; } + public float Left { get; } + public float Top { get; } + public float Bottom { get; } + public Vector2 BottomLeft { get; } + public Vector2 TopRight { get; } - public IEnumerable Vertices - { - get - { - yield return new Position2D(Min.X, Min.Y); - yield return new Position2D(Min.X, Max.Y); - yield return new Position2D(Max.X, Min.Y); - yield return new Position2D(Max.X, Max.Y); - } - } + public Vector2 Min { get; } + public Vector2 Max { get; } - public Rectangle(int minX, int minY, int maxX, int maxY) + public Rectangle(int width, int height) { - Min = new Position2D(minX, minY); - Max = new Position2D(maxX, maxY); - AABB = new AABB(minX, minY, maxX, maxY); - Width = Max.X - Min.X; - Height = Max.Y - Min.Y; + Width = width; + Height = height; + AABB = new AABB(-width / 2f, -height / 2f, width / 2f, height / 2f); + Right = AABB.Right; + Left = AABB.Left; + Top = AABB.Top; + Bottom = AABB.Bottom; + BottomLeft = new Vector2(Left, Bottom); + TopRight = new Vector2(Top, Right); + Min = AABB.Min; + Max = AABB.Max; } private Vector2 Support(Vector2 direction) @@ -97,7 +82,7 @@ namespace MoonTools.Core.Bonk public bool Equals(IShape2D other) { - return (other is Rectangle rectangle && Equals(rectangle)) || (other is Polygon polygon && Equals(polygon)); + return (other is Rectangle rectangle && Equals(rectangle)); } public bool Equals(Rectangle other) @@ -105,11 +90,6 @@ namespace MoonTools.Core.Bonk return Min == other.Min && Max == other.Max; } - public bool Equals(Polygon other) - { - return RectanglePolygonComparison.Equals(other, this); - } - public override int GetHashCode() { return HashCode.Combine(Min, Max); diff --git a/Bonk/Shapes/RectanglePolygonComparison.cs b/Bonk/Shapes/RectanglePolygonComparison.cs deleted file mode 100644 index 36821d7..0000000 --- a/Bonk/Shapes/RectanglePolygonComparison.cs +++ /dev/null @@ -1,25 +0,0 @@ -using MoonTools.Core.Structs; - -namespace MoonTools.Core.Bonk -{ - internal static class RectanglePolygonComparison - { - public static bool Equals(Polygon polygon, Rectangle rectangle) - { - if (polygon.VertexCount != 4) { return false; } - - int? minIndex = null; - for (var i = 0; i < 4; i++) - { - if (polygon.Vertices[i] == rectangle.Min) { minIndex = i; break; } - } - - if (!minIndex.HasValue) { return false; } - - return - polygon.Vertices[(minIndex.Value + 1) % 4] == rectangle.TopRight && - polygon.Vertices[(minIndex.Value + 2) % 4] == rectangle.Max && - polygon.Vertices[(minIndex.Value + 3) % 4] == rectangle.BottomLeft; - } - } -} diff --git a/Test/AABBTest.cs b/Test/AABBTest.cs index be842f3..b283766 100644 --- a/Test/AABBTest.cs +++ b/Test/AABBTest.cs @@ -14,6 +14,11 @@ namespace Tests var b = new AABB(new Vector2(0, 0), new Vector2(2, 2)); AABB.TestOverlap(a, b).Should().BeTrue(); + + var c = new AABB(-2, -2, 2, 1); + var d = new AABB(-2, -2, 2, 2); + + AABB.TestOverlap(c, d).Should().BeTrue(); } [Test] diff --git a/Test/EPA2DTest.cs b/Test/EPA2DTest.cs index 6ffc348..87bef7c 100644 --- a/Test/EPA2DTest.cs +++ b/Test/EPA2DTest.cs @@ -13,9 +13,9 @@ namespace Tests [Test] public void RectangleOverlap() { - var squareA = new MoonTools.Core.Bonk.Rectangle(-1, -1, 1, 1); + var squareA = new Rectangle(2, 2); var transformA = Transform2D.DefaultTransform; - var squareB = new MoonTools.Core.Bonk.Rectangle(-1, -1, 1, 1); + var squareB = new Rectangle(2, 2); var transformB = new Transform2D(new Vector2(1.5f, 0)); var (result, simplex) = NarrowPhase.FindCollisionSimplex(squareA, transformA, squareB, transformB); @@ -62,7 +62,7 @@ namespace Tests { var line = new Line(new Position2D(-4, -4), new Position2D(4, 4)); var transformA = Transform2D.DefaultTransform; - var square = new MoonTools.Core.Bonk.Rectangle(-1, -1, 1, 1); + var square = new Rectangle(2, 2); var transformB = Transform2D.DefaultTransform; var (result, simplex) = NarrowPhase.FindCollisionSimplex(line, transformA, square, transformB); diff --git a/Test/Equality.cs b/Test/Equality.cs index d441c83..9f6cb65 100644 --- a/Test/Equality.cs +++ b/Test/Equality.cs @@ -140,8 +140,8 @@ namespace Tests [Test] public void RectangleEqual() { - var a = new Rectangle(0, 0, 3, 3); - var b = new Rectangle(0, 0, 3, 3); + var a = new Rectangle(3, 3); + var b = new Rectangle(3, 3); a.Equals(b).Should().BeTrue(); } @@ -149,8 +149,8 @@ namespace Tests [Test] public void RectangleEqualOperator() { - var a = new Rectangle(0, 0, 3, 3); - var b = new Rectangle(0, 0, 3, 3); + var a = new Rectangle(3, 3); + var b = new Rectangle(3, 3); (a == b).Should().BeTrue(); } @@ -158,8 +158,8 @@ namespace Tests [Test] public void RectangleNotEqual() { - var a = new Rectangle(0, 0, 3, 3); - var b = new Rectangle(-1, -1, 5, 5); + var a = new Rectangle(3, 3); + var b = new Rectangle(6, 6); a.Equals(b).Should().BeFalse(); } @@ -167,8 +167,8 @@ namespace Tests [Test] public void RectangleNotEqualOperator() { - var a = new Rectangle(0, 0, 3, 3); - var b = new Rectangle(-1, -1, 5, 5); + var a = new Rectangle(3, 3); + var b = new Rectangle(6, 6); (a != b).Should().BeTrue(); } @@ -283,70 +283,6 @@ namespace Tests (a != b).Should().BeTrue(); } - - [Test] - public void PolygonRectangleEqual() - { - var a = new Polygon(ImmutableArray.Create( - new Position2D(-1, -1), - new Position2D(1, -1), - new Position2D(1, 1), - new Position2D(-1, 1) - )); - - var b = new Rectangle(-1, -1, 1, 1); - - a.Equals(b).Should().BeTrue(); - b.Equals(a).Should().BeTrue(); - } - - [Test] - public void PolygonRectangleNotEqual() - { - var a = new Polygon(ImmutableArray.Create( - new Position2D(-2, -1), - new Position2D(1, -1), - new Position2D(1, 1), - new Position2D(-2, 1) - )); - - var b = new Rectangle(-1, -1, 1, 1); - - a.Equals(b).Should().BeFalse(); - b.Equals(a).Should().BeFalse(); - } - - [Test] - public void PolygonRectangleEqualOperator() - { - var a = new Polygon(ImmutableArray.Create( - new Position2D(-1, -1), - new Position2D(1, -1), - new Position2D(1, 1), - new Position2D(-1, 1) - )); - - var b = new Rectangle(-1, -1, 1, 1); - - (a == b).Should().BeTrue(); - (b == a).Should().BeTrue(); - } - - [Test] - public void PolygonRectangleNotEqualOperator() - { - var a = new Polygon(ImmutableArray.Create( - new Position2D(2, 1), - new Position2D(1, -1), - new Position2D(-1, -1), - new Position2D(-2, 1) - )); - - var b = new Rectangle(-1, -1, 1, 1); - - (a != b).Should().BeTrue(); - (b != a).Should().BeTrue(); - } } public class SimplexTests diff --git a/Test/GJK2DTest.cs b/Test/NarrowPhaseTest.cs similarity index 83% rename from Test/GJK2DTest.cs rename to Test/NarrowPhaseTest.cs index 540d08b..1b3755a 100644 --- a/Test/GJK2DTest.cs +++ b/Test/NarrowPhaseTest.cs @@ -7,7 +7,7 @@ using System.Collections.Immutable; namespace Tests { - public class GJK2DTest + public class NarrowPhaseTest { [Test] public void PointLineOverlapping() @@ -55,7 +55,7 @@ namespace Tests public void PointRectangleOverlapping() { var point = new Point(); - var rectangle = new Rectangle(-2, -2, 2, 2); + var rectangle = new Rectangle(4, 4); NarrowPhase.TestCollision(point, Transform2D.DefaultTransform, rectangle, Transform2D.DefaultTransform).Should().BeTrue(); } @@ -65,7 +65,7 @@ namespace Tests { var point = new Point(); var pointTransform = new Transform2D(new Position2D(5, 5)); - var rectangle = new Rectangle(-2, -2, 2, 2); + var rectangle = new Rectangle(4, 4); NarrowPhase.TestCollision(point, pointTransform, rectangle, Transform2D.DefaultTransform).Should().BeFalse(); } @@ -354,10 +354,10 @@ namespace Tests [Test] public void RectanglesNotOverlapping() { - var rectangleA = new MoonTools.Core.Bonk.Rectangle(-6, -6, 6, 6); + var rectangleA = new Rectangle(12, 12); var transformA = new Transform2D(new Position2D(39, 249)); - var rectangleB = new MoonTools.Core.Bonk.Rectangle(0, 0, 16, 16); + var rectangleB = new Rectangle(16, 16); var transformB = new Transform2D(new Position2D(16, 240)); NarrowPhase.TestCollision(rectangleA, transformA, rectangleB, transformB).Should().BeFalse(); @@ -366,10 +366,10 @@ namespace Tests [Test] public void RotatedRectanglesOverlapping() { - var rectangleA = new MoonTools.Core.Bonk.Rectangle(-1, -1, 2, 2); + var rectangleA = new Rectangle(3, 3); var transformA = new Transform2D(new Vector2(-1, 0), -90f); - var rectangleB = new MoonTools.Core.Bonk.Rectangle(-1, -1, 1, 1); + var rectangleB = new Rectangle(2, 2); var transformB = new Transform2D(new Vector2(1, 0)); NarrowPhase.TestCollision(rectangleA, transformA, rectangleB, transformB).Should().BeTrue(); @@ -378,10 +378,10 @@ namespace Tests [Test] public void RectanglesTouchingGJK2D() { - var rectangleA = new MoonTools.Core.Bonk.Rectangle(-1, -1, 1, 1); + var rectangleA = new Rectangle(2, 2); var transformA = new Transform2D(new Position2D(-1, 0)); - var rectangleB = new MoonTools.Core.Bonk.Rectangle(-1, -1, 1, 1); + var rectangleB = new Rectangle(2, 2); var transformB = new Transform2D(new Vector2(1, 0)); NarrowPhase.TestCollision(rectangleA, transformA, rectangleB, transformB).Should().BeTrue(); @@ -390,10 +390,10 @@ namespace Tests [Test] public void RectanglesOverlappingGJK2D() { - var rectangleA = new MoonTools.Core.Bonk.Rectangle(-1, -1, 1, 1); + var rectangleA = new Rectangle(2, 2); var transformA = new Transform2D(new Position2D(0, 0)); - var rectangleB = new MoonTools.Core.Bonk.Rectangle(-1, -1, 1, 1); + var rectangleB = new Rectangle(2, 2); var transformB = new Transform2D(new Vector2(1, 0)); NarrowPhase.TestCollision(rectangleA, transformA, rectangleB, transformB).Should().BeTrue(); @@ -402,10 +402,10 @@ namespace Tests [Test] public void RectanglesTouchingOverlap() { - var rectangleA = new MoonTools.Core.Bonk.Rectangle(-1, -1, 1, 1); + var rectangleA = new Rectangle(2, 2); var transformA = new Transform2D(new Position2D(-1, 0)); - var rectangleB = new MoonTools.Core.Bonk.Rectangle(-1, -1, 1, 1); + var rectangleB = new Rectangle(2, 2); var transformB = new Transform2D(new Vector2(1, 0)); NarrowPhase.TestRectangleOverlap(rectangleA, transformA, rectangleB, transformB).Should().BeTrue(); @@ -414,13 +414,61 @@ namespace Tests [Test] public void RectanglesOverlappingOverlap() { - var rectangleA = new MoonTools.Core.Bonk.Rectangle(-1, -1, 1, 1); + var rectangleA = new Rectangle(2, 2); var transformA = new Transform2D(new Position2D(0, 0)); - var rectangleB = new MoonTools.Core.Bonk.Rectangle(-1, -1, 1, 1); + var rectangleB = new Rectangle(2, 2); var transformB = new Transform2D(new Vector2(1, 0)); NarrowPhase.TestRectangleOverlap(rectangleA, transformA, rectangleB, transformB).Should().BeTrue(); } + + [Test] + public void MultiRectanglesOverlapping() + { + var multiRectangleA = new MultiRectangle( + ImmutableArray.Create( + (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 0))), + (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 1))), + (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 2))) + ) + ); + var transformA = new Transform2D(new Position2D(5, 0)); + + var multiRectangleB = new MultiRectangle( + ImmutableArray.Create( + (new Rectangle(4, 1), new Transform2D(new Position2D(4, -1))), + (new Rectangle(4, 1), new Transform2D(new Position2D(4, 0))), + (new Rectangle(4, 1), new Transform2D(new Position2D(4, 1))) + ) + ); + var transformB = new Transform2D(new Position2D(0, 3)); + + NarrowPhase.TestCollision(multiRectangleA, transformA, multiRectangleB, transformB).Should().BeTrue(); + } + + [Test] + public void MultiRectanglesNotOverlapping() + { + var multiRectangleA = new MultiRectangle( + ImmutableArray.Create( + (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 0))), + (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 1))), + (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 2))) + ) + ); + var transformA = new Transform2D(new Position2D(5, 0)); + + var multiRectangleB = new MultiRectangle( + ImmutableArray.Create( + (new Rectangle(4, 1), new Transform2D(new Position2D(4, -1))), + (new Rectangle(4, 1), new Transform2D(new Position2D(4, 0))), + (new Rectangle(4, 1), new Transform2D(new Position2D(4, 1))) + ) + ); + var transformB = new Transform2D(new Position2D(0, -3)); + + NarrowPhase.TestCollision(multiRectangleA, transformA, multiRectangleB, transformB).Should().BeFalse(); + } } } diff --git a/Test/SpatialHashTest.cs b/Test/SpatialHashTest.cs index 2d4b153..da75900 100644 --- a/Test/SpatialHashTest.cs +++ b/Test/SpatialHashTest.cs @@ -3,6 +3,7 @@ using NUnit.Framework; using MoonTools.Core.Structs; using MoonTools.Core.Bonk; using System.Numerics; +using System.Collections.Immutable; namespace Tests { @@ -13,16 +14,16 @@ namespace Tests { var spatialHash = new SpatialHash(16); - var rectA = new Rectangle(-2, -2, 2, 2); + var rectA = new Rectangle(4, 4); var rectATransform = new Transform2D(new Vector2(-8, -8)); - var rectB = new Rectangle(-2, -2, 2, 2); + var rectB = new Rectangle(4, 4); var rectBTransform = new Transform2D(new Vector2(8, 8)); - var rectC = new Rectangle(-2, -2, 2, 2); + var rectC = new Rectangle(4, 4); var rectCTransform = new Transform2D(new Vector2(24, -4)); - var rectD = new Rectangle(-2, -2, 2, 2); + var rectD = new Rectangle(4, 4); var rectDTransform = new Transform2D(new Vector2(24, 24)); var circleA = new Circle(2); @@ -37,25 +38,38 @@ namespace Tests var point = new Point(); var pointTransform = new Transform2D(new Position2D(8, 8)); + var multiRectangle = new MultiRectangle( + ImmutableArray.Create( + (new Rectangle(4, 1), new Transform2D(new Position2D(-2, -2))), + (new Rectangle(4, 1), new Transform2D(new Position2D(-2, -1))), + (new Rectangle(4, 1), new Transform2D(new Position2D(-2, 0))) + ) + ); + var multiRectangleTransform = new Transform2D(new Position2D(8, 8)); + spatialHash.Insert(0, rectA, rectATransform); spatialHash.Insert(1, rectB, rectBTransform); spatialHash.Insert(2, rectC, rectCTransform); spatialHash.Insert(3, rectD, rectDTransform); spatialHash.Insert(4, circleA, circleATransform); - spatialHash.Insert(1, circleB, circleBTransform); + spatialHash.Insert(9, circleB, circleBTransform); spatialHash.Insert(6, line, lineTransform); spatialHash.Insert(7, point, pointTransform); + spatialHash.Insert(8, multiRectangle, multiRectangleTransform); spatialHash.Retrieve(0, rectA, rectATransform).Should().BeEmpty(); spatialHash.Retrieve(1, rectB, rectBTransform).Should().NotContain((1, circleB, circleBTransform)); spatialHash.Retrieve(1, rectB, rectBTransform).Should().Contain((7, point, pointTransform)); + spatialHash.Retrieve(1, rectB, rectBTransform).Should().Contain((8, multiRectangle, multiRectangleTransform)); spatialHash.Retrieve(2, rectC, rectCTransform).Should().Contain((6, line, lineTransform)).And.Contain((4, circleA, circleATransform)); - spatialHash.Retrieve(3, rectD, rectDTransform).Should().Contain((1, circleB, circleBTransform)); + spatialHash.Retrieve(3, rectD, rectDTransform).Should().Contain((9, circleB, circleBTransform)); spatialHash.Retrieve(4, circleA, circleATransform).Should().Contain((6, line, lineTransform)).And.Contain((2, rectC, rectCTransform)); spatialHash.Retrieve(1, circleB, circleBTransform).Should().NotContain((1, rectB, rectBTransform)).And.Contain((3, rectD, rectDTransform)); spatialHash.Retrieve(6, line, lineTransform).Should().Contain((4, circleA, circleATransform)).And.Contain((2, rectC, rectCTransform)); + + spatialHash.Retrieve(8, multiRectangle, multiRectangleTransform).Should().Contain((1, rectB, rectBTransform)); } [Test] @@ -63,13 +77,13 @@ namespace Tests { var spatialHash = new SpatialHash(16); - var rectA = new Rectangle(-2, -2, 2, 2); + var rectA = new Rectangle(4, 4); var rectATransform = new Transform2D(new Vector2(-8, -8)); - var rectB = new Rectangle(-2, -2, 2, 2); + var rectB = new Rectangle(4, 4); var rectBTransform = new Transform2D(new Vector2(-8, -8)); - var rectC = new Rectangle(-1, -1, 1, 1); + var rectC = new Rectangle(2, 2); var rectCTransform = new Transform2D(new Vector2(-8, -8)); spatialHash.Insert(0, rectA, rectATransform); @@ -84,10 +98,10 @@ namespace Tests { var spatialHash = new SpatialHash(16); - var rectA = new Rectangle(-2, -2, 2, 2); + var rectA = new Rectangle(4, 4); var rectATransform = new Transform2D(new Vector2(-8, -8)); - var rectB = new Rectangle(-2, -2, 2, 2); + var rectB = new Rectangle(4, 4); var rectBTransform = new Transform2D(new Vector2(8, 8)); spatialHash.Insert(0, rectA, rectATransform); From d23238bcfc88b3044449e92d715af175076620eb Mon Sep 17 00:00:00 2001 From: Evan Hemsley <2342303+ehemsley@users.noreply.github.com> Date: Sat, 4 Jan 2020 16:13:07 -0800 Subject: [PATCH 02/10] multishape system --- Bonk/IMultiShape2D.cs | 10 ----- Bonk/MultiShape.cs | 65 ++++++++++++++++++++++++++++++ Bonk/MultiShapes/MultiRectangle.cs | 65 ------------------------------ Bonk/NarrowPhase/NarrowPhase.cs | 30 ++++++++++++-- Bonk/Shapes/Rectangle.cs | 2 +- Test/NarrowPhaseTest.cs | 22 +++++----- Test/SpatialHashTest.cs | 5 ++- 7 files changed, 107 insertions(+), 92 deletions(-) delete mode 100644 Bonk/IMultiShape2D.cs create mode 100644 Bonk/MultiShape.cs delete mode 100644 Bonk/MultiShapes/MultiRectangle.cs diff --git a/Bonk/IMultiShape2D.cs b/Bonk/IMultiShape2D.cs deleted file mode 100644 index 390d03c..0000000 --- a/Bonk/IMultiShape2D.cs +++ /dev/null @@ -1,10 +0,0 @@ -using System.Collections.Generic; -using MoonTools.Core.Structs; - -namespace MoonTools.Core.Bonk -{ - public interface IMultiShape2D : IHasAABB2D - { - IEnumerable<(IShape2D, Transform2D)> ShapeTransformPairs { get; } - } -} diff --git a/Bonk/MultiShape.cs b/Bonk/MultiShape.cs new file mode 100644 index 0000000..e9af874 --- /dev/null +++ b/Bonk/MultiShape.cs @@ -0,0 +1,65 @@ +using System.Collections.Generic; +using System.Collections.Immutable; +using MoonTools.Core.Structs; + +namespace MoonTools.Core.Bonk +{ + public struct MultiShape : IHasAABB2D + { + public ImmutableArray<(IShape2D, Transform2D)> ShapeTransformPairs { get; } + + public AABB AABB { get; } + + public MultiShape(ImmutableArray<(IShape2D, Transform2D)> shapeTransformPairs) + { + ShapeTransformPairs = shapeTransformPairs; + + AABB = AABBFromShapes(shapeTransformPairs); + } + + public AABB TransformedAABB(Transform2D transform) + { + return AABB.Transformed(AABB, transform); + } + + public IEnumerable<(IShape2D, Transform2D)> TransformedShapeTransforms(Transform2D transform) + { + foreach (var (shape, shapeTransform) in ShapeTransformPairs) + { + yield return (shape, transform.Compose(shapeTransform)); + } + } + + private static AABB AABBFromShapes(IEnumerable<(IShape2D, Transform2D)> shapeTransforms) + { + var minX = float.MaxValue; + var minY = float.MaxValue; + var maxX = float.MinValue; + var maxY = float.MinValue; + + foreach (var (shape, transform) in shapeTransforms) + { + var aabb = shape.TransformedAABB(transform); + + if (aabb.Min.X < minX) + { + minX = aabb.Min.X; + } + if (aabb.Min.Y < minY) + { + minY = aabb.Min.Y; + } + if (aabb.Max.X > maxX) + { + maxX = aabb.Max.X; + } + if (aabb.Max.Y > maxY) + { + maxY = aabb.Max.Y; + } + } + + return new AABB(minX, minY, maxX, maxY); + } + } +} diff --git a/Bonk/MultiShapes/MultiRectangle.cs b/Bonk/MultiShapes/MultiRectangle.cs deleted file mode 100644 index 310af84..0000000 --- a/Bonk/MultiShapes/MultiRectangle.cs +++ /dev/null @@ -1,65 +0,0 @@ -using System.Collections.Generic; -using System.Collections.Immutable; -using MoonTools.Core.Structs; - -namespace MoonTools.Core.Bonk -{ - public struct MultiRectangle : IMultiShape2D - { - private ImmutableArray<(Rectangle, Transform2D)> Rectangles { get; } - - public IEnumerable<(IShape2D, Transform2D)> ShapeTransformPairs - { - get - { - foreach (var rectangle in Rectangles) { yield return rectangle; } - } - } - - public AABB AABB { get; } - - public MultiRectangle(ImmutableArray<(Rectangle, Transform2D)> rectangles) - { - Rectangles = rectangles; - - AABB = AABBFromRectangles(rectangles); - } - - public AABB TransformedAABB(Transform2D transform) - { - return AABB.Transformed(AABB, transform); - } - - private static AABB AABBFromRectangles(IEnumerable<(Rectangle, Transform2D)> rectangles) - { - var minX = float.MaxValue; - var minY = float.MaxValue; - var maxX = float.MinValue; - var maxY = float.MinValue; - - foreach (var (rectangle, transform) in rectangles) - { - var transformedAABB = rectangle.TransformedAABB(transform); - - if (transformedAABB.Min.X < minX) - { - minX = transformedAABB.Min.X; - } - if (transformedAABB.Min.Y < minY) - { - minY = transformedAABB.Min.Y; - } - if (transformedAABB.Max.X > maxX) - { - maxX = transformedAABB.Max.X; - } - if (transformedAABB.Max.Y > maxY) - { - maxY = transformedAABB.Max.Y; - } - } - - return new AABB(minX, minY, maxX, maxY); - } - } -} diff --git a/Bonk/NarrowPhase/NarrowPhase.cs b/Bonk/NarrowPhase/NarrowPhase.cs index 7cd731b..676a6e8 100644 --- a/Bonk/NarrowPhase/NarrowPhase.cs +++ b/Bonk/NarrowPhase/NarrowPhase.cs @@ -14,6 +14,30 @@ namespace MoonTools.Core.Bonk /// /// Tests if two shape-transform pairs are overlapping. Automatically detects fast-path optimizations. /// + public static bool TestCollision(IHasAABB2D hasBoundingBoxA, Transform2D transformA, IHasAABB2D hasBoundingBoxB, Transform2D transformB) + { + if (hasBoundingBoxA is MultiShape && hasBoundingBoxB is MultiShape) + { + return TestCollision((MultiShape)hasBoundingBoxA, transformA, (MultiShape)hasBoundingBoxB, transformB); + } + else if (hasBoundingBoxA is MultiShape && hasBoundingBoxB is IShape2D) + { + return TestCollision((MultiShape)hasBoundingBoxA, transformA, (IShape2D)hasBoundingBoxB, transformB); + } + else if (hasBoundingBoxA is IShape2D && hasBoundingBoxB is MultiShape) + { + return TestCollision((IShape2D)hasBoundingBoxA, transformA, (MultiShape)hasBoundingBoxB, transformB); + } + else if (hasBoundingBoxA is IShape2D && hasBoundingBoxB is IShape2D) + { + return TestCollision((IShape2D)hasBoundingBoxA, transformA, (IShape2D)hasBoundingBoxB, transformB); + } + else + { + throw new System.ArgumentException("Collision testing requires MultiShapes or IShape2Ds."); + } + } + public static bool TestCollision(IShape2D shapeA, Transform2D transformA, IShape2D shapeB, Transform2D transformB) { if (shapeA is Rectangle rectangleA && shapeB is Rectangle rectangleB && transformA.Rotation == 0 && transformB.Rotation == 0) @@ -44,7 +68,7 @@ namespace MoonTools.Core.Bonk /// /// /// - public static bool TestCollision(IMultiShape2D multiShape, Transform2D multiShapeTransform, IShape2D shape, Transform2D shapeTransform) + public static bool TestCollision(MultiShape multiShape, Transform2D multiShapeTransform, IShape2D shape, Transform2D shapeTransform) { foreach (var (otherShape, otherTransform) in multiShape.ShapeTransformPairs) { @@ -62,7 +86,7 @@ namespace MoonTools.Core.Bonk /// /// /// - public static bool TestCollision(IShape2D shape, Transform2D shapeTransform, IMultiShape2D multiShape, Transform2D multiShapeTransform) + public static bool TestCollision(IShape2D shape, Transform2D shapeTransform, MultiShape multiShape, Transform2D multiShapeTransform) { foreach (var (otherShape, otherTransform) in multiShape.ShapeTransformPairs) { @@ -80,7 +104,7 @@ namespace MoonTools.Core.Bonk /// /// /// - public static bool TestCollision(IMultiShape2D multiShapeA, Transform2D transformA, IMultiShape2D multiShapeB, Transform2D transformB) + public static bool TestCollision(MultiShape multiShapeA, Transform2D transformA, MultiShape multiShapeB, Transform2D transformB) { foreach (var (shapeA, shapeTransformA) in multiShapeA.ShapeTransformPairs) { diff --git a/Bonk/Shapes/Rectangle.cs b/Bonk/Shapes/Rectangle.cs index 5095d02..d60bf5b 100644 --- a/Bonk/Shapes/Rectangle.cs +++ b/Bonk/Shapes/Rectangle.cs @@ -5,7 +5,7 @@ using MoonTools.Core.Structs; namespace MoonTools.Core.Bonk { /// - /// A rectangle is a shape defined by a minimum and maximum X value and a minimum and maximum Y value. + /// A rectangle is a shape defined by a width and height. The origin is the center of the rectangle. /// public struct Rectangle : IShape2D, IEquatable { diff --git a/Test/NarrowPhaseTest.cs b/Test/NarrowPhaseTest.cs index 1b3755a..3cc1d1d 100644 --- a/Test/NarrowPhaseTest.cs +++ b/Test/NarrowPhaseTest.cs @@ -366,11 +366,11 @@ namespace Tests [Test] public void RotatedRectanglesOverlapping() { - var rectangleA = new Rectangle(3, 3); - var transformA = new Transform2D(new Vector2(-1, 0), -90f); + var rectangleA = new Rectangle(3, 6); + var transformA = new Transform2D(new Vector2(4f, 0), (float)System.Math.PI / 2); var rectangleB = new Rectangle(2, 2); - var transformB = new Transform2D(new Vector2(1, 0)); + var transformB = new Transform2D(new Vector2(0, 0)); NarrowPhase.TestCollision(rectangleA, transformA, rectangleB, transformB).Should().BeTrue(); } @@ -426,8 +426,8 @@ namespace Tests [Test] public void MultiRectanglesOverlapping() { - var multiRectangleA = new MultiRectangle( - ImmutableArray.Create( + var multiRectangleA = new MultiShape( + ImmutableArray.Create<(IShape2D, Transform2D)>( (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 0))), (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 1))), (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 2))) @@ -435,8 +435,8 @@ namespace Tests ); var transformA = new Transform2D(new Position2D(5, 0)); - var multiRectangleB = new MultiRectangle( - ImmutableArray.Create( + var multiRectangleB = new MultiShape( + ImmutableArray.Create<(IShape2D, Transform2D)>( (new Rectangle(4, 1), new Transform2D(new Position2D(4, -1))), (new Rectangle(4, 1), new Transform2D(new Position2D(4, 0))), (new Rectangle(4, 1), new Transform2D(new Position2D(4, 1))) @@ -450,8 +450,8 @@ namespace Tests [Test] public void MultiRectanglesNotOverlapping() { - var multiRectangleA = new MultiRectangle( - ImmutableArray.Create( + var multiRectangleA = new MultiShape( + ImmutableArray.Create<(IShape2D, Transform2D)>( (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 0))), (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 1))), (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 2))) @@ -459,8 +459,8 @@ namespace Tests ); var transformA = new Transform2D(new Position2D(5, 0)); - var multiRectangleB = new MultiRectangle( - ImmutableArray.Create( + var multiRectangleB = new MultiShape( + ImmutableArray.Create<(IShape2D, Transform2D)>( (new Rectangle(4, 1), new Transform2D(new Position2D(4, -1))), (new Rectangle(4, 1), new Transform2D(new Position2D(4, 0))), (new Rectangle(4, 1), new Transform2D(new Position2D(4, 1))) diff --git a/Test/SpatialHashTest.cs b/Test/SpatialHashTest.cs index da75900..671bc8c 100644 --- a/Test/SpatialHashTest.cs +++ b/Test/SpatialHashTest.cs @@ -38,8 +38,8 @@ namespace Tests var point = new Point(); var pointTransform = new Transform2D(new Position2D(8, 8)); - var multiRectangle = new MultiRectangle( - ImmutableArray.Create( + var multiRectangle = new MultiShape( + ImmutableArray.Create<(IShape2D, Transform2D)>( (new Rectangle(4, 1), new Transform2D(new Position2D(-2, -2))), (new Rectangle(4, 1), new Transform2D(new Position2D(-2, -1))), (new Rectangle(4, 1), new Transform2D(new Position2D(-2, 0))) @@ -70,6 +70,7 @@ namespace Tests spatialHash.Retrieve(6, line, lineTransform).Should().Contain((4, circleA, circleATransform)).And.Contain((2, rectC, rectCTransform)); spatialHash.Retrieve(8, multiRectangle, multiRectangleTransform).Should().Contain((1, rectB, rectBTransform)); + spatialHash.Retrieve(8, multiRectangle, multiRectangleTransform).Should().NotContain((0, rectA, rectATransform)); } [Test] From 9777429d074a395807e2bbbafc0cf059a71f54fa Mon Sep 17 00:00:00 2001 From: Evan Hemsley <2342303+ehemsley@users.noreply.github.com> Date: Sat, 4 Jan 2020 23:17:29 -0800 Subject: [PATCH 03/10] add sweep test --- Bonk/SweepTest/SweepResult.cs | 26 ++++++++ Bonk/SweepTest/SweepTest.cs | 108 ++++++++++++++++++++++++++++++++++ Test/SweepTestTest.cs | 34 +++++++++++ 3 files changed, 168 insertions(+) create mode 100644 Bonk/SweepTest/SweepResult.cs create mode 100644 Bonk/SweepTest/SweepTest.cs create mode 100644 Test/SweepTestTest.cs diff --git a/Bonk/SweepTest/SweepResult.cs b/Bonk/SweepTest/SweepResult.cs new file mode 100644 index 0000000..2575090 --- /dev/null +++ b/Bonk/SweepTest/SweepResult.cs @@ -0,0 +1,26 @@ +using System; +using System.Numerics; +using MoonTools.Core.Structs; + +namespace MoonTools.Core.Bonk +{ + public struct SweepResult where T : IEquatable where U : struct, IShape2D + { + public static SweepResult False = new SweepResult(); + + public bool Hit { get; } + public Vector2 Motion { get; } + public T ID { get; } + public U Shape { get; } + public Transform2D Transform { get; } + + public SweepResult(bool hit, Vector2 motion, T id, U shape, Transform2D transform) + { + Hit = hit; + Motion = motion; + ID = id; + Shape = shape; + Transform = transform; + } + } +} diff --git a/Bonk/SweepTest/SweepTest.cs b/Bonk/SweepTest/SweepTest.cs new file mode 100644 index 0000000..5001188 --- /dev/null +++ b/Bonk/SweepTest/SweepTest.cs @@ -0,0 +1,108 @@ +using System; +using System.Numerics; +using MoonTools.Core.Structs; + +namespace MoonTools.Core.Bonk +{ + public static class SweepTest + { + /// + /// Performs a sweep test on rectangles. + /// + /// + /// A spatial hash. + /// + /// A transform by which to transform the IHasAABB2D. + /// Given in world-space. + /// + public static SweepResult Rectangle(SpatialHash spatialHash, Rectangle rectangle, Transform2D transform, Vector2 ray) where T : IEquatable + { + var transformedAABB = rectangle.TransformedAABB(transform); + var sweepBox = SweepBox(transformedAABB, ray); + + var shortestDistance = float.MaxValue; + var nearestID = default(T); + Rectangle? nearestRectangle = null; + Transform2D? nearestTransform = null; + + foreach (var (id, shape, shapeTransform) in spatialHash.Retrieve(sweepBox)) + { + if (shape is Rectangle otherRectangle) + { + var otherTransformedAABB = otherRectangle.TransformedAABB(shapeTransform); + float xInvEntry, yInvEntry; + + if (ray.X > 0) + { + xInvEntry = shapeTransform.Position.X - (transform.Position.X + transformedAABB.Width); + } + else + { + xInvEntry = (shapeTransform.Position.X + otherTransformedAABB.Width) - transform.Position.X; + } + + if (ray.Y > 0) + { + yInvEntry = shapeTransform.Position.Y - (transform.Position.Y + transformedAABB.Height); + } + else + { + yInvEntry = (shapeTransform.Position.Y + otherTransformedAABB.Height) - shapeTransform.Position.Y; + } + + float xEntry, yEntry; + + if (ray.X == 0) + { + xEntry = float.MinValue; + } + else + { + xEntry = xInvEntry / ray.X; + } + + if (ray.Y == 0) + { + yEntry = float.MinValue; + } + else + { + yEntry = yInvEntry / ray.Y; + } + + var entryTime = Math.Max(xEntry, yEntry); + + if (entryTime > 0 && entryTime < 1) + { + if (entryTime < shortestDistance) + { + shortestDistance = entryTime; + nearestID = id; + nearestRectangle = rectangle; + nearestTransform = shapeTransform; + } + } + } + } + + if (nearestRectangle.HasValue) + { + return new SweepResult(true, ray * shortestDistance, nearestID, nearestRectangle.Value, nearestTransform.Value); + } + else + { + return SweepResult.False; + } + } + + private static AABB SweepBox(AABB aabb, Vector2 ray) + { + return new AABB( + Math.Min(aabb.Min.X, aabb.Min.X + ray.X), + Math.Min(aabb.Min.Y, aabb.Min.Y + ray.Y), + Math.Max(aabb.Max.X, aabb.Max.X + ray.X), + Math.Max(aabb.Max.Y, aabb.Max.Y + ray.Y) + ); + } + } +} diff --git a/Test/SweepTestTest.cs b/Test/SweepTestTest.cs new file mode 100644 index 0000000..cd7b1d4 --- /dev/null +++ b/Test/SweepTestTest.cs @@ -0,0 +1,34 @@ +using System.Numerics; +using FluentAssertions; +using MoonTools.Core.Bonk; +using MoonTools.Core.Structs; +using NUnit.Framework; + +namespace Tests +{ + class SweepTestTest + { + [Test] + public void SweepsThrough() + { + var rectangle = new Rectangle(4, 4); + var transform = new Transform2D(new Position2D(-6, 0)); + + var otherRectangle = new Rectangle(4, 4); + var otherTransform = new Transform2D(new Position2D(6, 0)); + + var farthestRectangle = new Rectangle(4, 4); + var farthestTransform = new Transform2D(new Position2D(12, 0)); + + var spatialHash = new SpatialHash(16); + spatialHash.Insert(1, otherRectangle, otherTransform); + spatialHash.Insert(2, farthestRectangle, farthestTransform); + + SweepTest.Rectangle(spatialHash, rectangle, transform, new Vector2(12, 0)).Should().Be( + new SweepResult(true, new Vector2(8, 0), 1, otherRectangle, otherTransform) + ); + + SweepTest.Rectangle(spatialHash, rectangle, transform, new Vector2(-12, 0)).Hit.Should().BeFalse(); + } + } +} From 354912d6746b0b95d54754939dd8e5b300520021 Mon Sep 17 00:00:00 2001 From: Evan Hemsley <2342303+ehemsley@users.noreply.github.com> Date: Sun, 5 Jan 2020 13:10:52 -0800 Subject: [PATCH 04/10] fixing sweep test --- Bonk/BroadPhase/SpatialHash.cs | 33 +++++++++- Bonk/MultiShape.cs | 10 +++ Bonk/SweepTest/SweepTest.cs | 115 +++++++++++++++++++-------------- Test/SweepTestTest.cs | 8 +++ 4 files changed, 118 insertions(+), 48 deletions(-) diff --git a/Bonk/BroadPhase/SpatialHash.cs b/Bonk/BroadPhase/SpatialHash.cs index 8f54856..cdd96bd 100644 --- a/Bonk/BroadPhase/SpatialHash.cs +++ b/Bonk/BroadPhase/SpatialHash.cs @@ -73,7 +73,38 @@ namespace MoonTools.Core.Bonk foreach (var t in hashDictionary[key]) { var (otherShape, otherTransform) = IDLookup[t]; - if (!id.Equals(t) && AABB.TestOverlap(shape.TransformedAABB(transform2D), otherShape.TransformedAABB(otherTransform))) + if (!id.Equals(t) && AABB.TestOverlap(box, otherShape.TransformedAABB(otherTransform))) + { + yield return (t, otherShape, otherTransform); + } + } + } + } + } + } + + + /// + /// Retrieves objects based on a pre-transformed AABB. + /// + /// A transformed AABB. + /// + public IEnumerable<(T, IHasAABB2D, Transform2D)> Retrieve(AABB aabb) + { + var minHash = Hash(aabb.Min); + var maxHash = Hash(aabb.Max); + + for (var i = minHash.Item1; i <= maxHash.Item1; i++) + { + for (var j = minHash.Item2; j <= maxHash.Item2; j++) + { + var key = MakeLong(i, j); + if (hashDictionary.ContainsKey(key)) + { + foreach (var t in hashDictionary[key]) + { + var (otherShape, otherTransform) = IDLookup[t]; + if (AABB.TestOverlap(aabb, otherShape.TransformedAABB(otherTransform))) { yield return (t, otherShape, otherTransform); } diff --git a/Bonk/MultiShape.cs b/Bonk/MultiShape.cs index e9af874..eb34cda 100644 --- a/Bonk/MultiShape.cs +++ b/Bonk/MultiShape.cs @@ -30,6 +30,16 @@ namespace MoonTools.Core.Bonk } } + public bool IsSingleShape() where T : struct, IShape2D + { + return ShapeTransformPairs.Length == 1 && ShapeTransformPairs[0].Item1 is T; + } + + public (T, Transform2D) ShapeTransformPair() where T : struct, IShape2D + { + return ((T, Transform2D))ShapeTransformPairs[0]; + } + private static AABB AABBFromShapes(IEnumerable<(IShape2D, Transform2D)> shapeTransforms) { var minX = float.MaxValue; diff --git a/Bonk/SweepTest/SweepTest.cs b/Bonk/SweepTest/SweepTest.cs index 5001188..65ea470 100644 --- a/Bonk/SweepTest/SweepTest.cs +++ b/Bonk/SweepTest/SweepTest.cs @@ -7,7 +7,7 @@ namespace MoonTools.Core.Bonk public static class SweepTest { /// - /// Performs a sweep test on rectangles. + /// Performs a sweep test on rectangles. Returns the position 1 pixel before overlap occurs. /// /// /// A spatial hash. @@ -27,67 +27,88 @@ namespace MoonTools.Core.Bonk foreach (var (id, shape, shapeTransform) in spatialHash.Retrieve(sweepBox)) { - if (shape is Rectangle otherRectangle) + Rectangle otherRectangle; + Transform2D otherTransform; + AABB otherTransformedAABB; + if (shape is Rectangle) { - var otherTransformedAABB = otherRectangle.TransformedAABB(shapeTransform); - float xInvEntry, yInvEntry; + otherRectangle = (Rectangle)shape; + otherTransformedAABB = shape.TransformedAABB(shapeTransform); + otherTransform = shapeTransform; + } + else if (shape is MultiShape multiShape && multiShape.IsSingleShape()) + { + Transform2D rectangleOffset; + (otherRectangle, rectangleOffset) = multiShape.ShapeTransformPair(); + otherTransform = shapeTransform.Compose(rectangleOffset); + otherTransformedAABB = shape.TransformedAABB(otherTransform); + } + else + { + continue; + } - if (ray.X > 0) - { - xInvEntry = shapeTransform.Position.X - (transform.Position.X + transformedAABB.Width); - } - else - { - xInvEntry = (shapeTransform.Position.X + otherTransformedAABB.Width) - transform.Position.X; - } + float xInvEntry, yInvEntry; - if (ray.Y > 0) - { - yInvEntry = shapeTransform.Position.Y - (transform.Position.Y + transformedAABB.Height); - } - else - { - yInvEntry = (shapeTransform.Position.Y + otherTransformedAABB.Height) - shapeTransform.Position.Y; - } + if (ray.X > 0) + { + xInvEntry = otherTransformedAABB.Left - (transformedAABB.Right); + } + else + { + xInvEntry = (otherTransformedAABB.Right) - transformedAABB.Left; + } - float xEntry, yEntry; + if (ray.Y > 0) + { + yInvEntry = otherTransformedAABB.Top - (transformedAABB.Bottom); + } + else + { + yInvEntry = (otherTransformedAABB.Bottom) - transformedAABB.Top; + } - if (ray.X == 0) - { - xEntry = float.MinValue; - } - else - { - xEntry = xInvEntry / ray.X; - } + float xEntry, yEntry; - if (ray.Y == 0) - { - yEntry = float.MinValue; - } - else - { - yEntry = yInvEntry / ray.Y; - } + if (ray.X == 0) + { + xEntry = float.MinValue; + } + else + { + xEntry = xInvEntry / ray.X; + } - var entryTime = Math.Max(xEntry, yEntry); + if (ray.Y == 0) + { + yEntry = float.MinValue; + } + else + { + yEntry = yInvEntry / ray.Y; + } - if (entryTime > 0 && entryTime < 1) + var entryTime = Math.Max(xEntry, yEntry); + + if (entryTime >= 0 && entryTime <= 1) + { + if (entryTime < shortestDistance) { - if (entryTime < shortestDistance) - { - shortestDistance = entryTime; - nearestID = id; - nearestRectangle = rectangle; - nearestTransform = shapeTransform; - } + shortestDistance = entryTime; + nearestID = id; + nearestRectangle = otherRectangle; + nearestTransform = shapeTransform; } } + } if (nearestRectangle.HasValue) { - return new SweepResult(true, ray * shortestDistance, nearestID, nearestRectangle.Value, nearestTransform.Value); + var overlapPosition = ray * shortestDistance; + var correctionX = ray.X > 0 ? -1 : 1; + var correctionY = ray.Y > 0 ? -1 : 1; + return new SweepResult(true, new Position2D((int)overlapPosition.X + correctionX, (int)overlapPosition.Y + correctionY), nearestID, nearestRectangle.Value, nearestTransform.Value); } else { diff --git a/Test/SweepTestTest.cs b/Test/SweepTestTest.cs index cd7b1d4..cf07de6 100644 --- a/Test/SweepTestTest.cs +++ b/Test/SweepTestTest.cs @@ -20,15 +20,23 @@ namespace Tests var farthestRectangle = new Rectangle(4, 4); var farthestTransform = new Transform2D(new Position2D(12, 0)); + var downRectangle = new Rectangle(12, 4); + var downTransform = new Transform2D(new Position2D(-6, 20)); + var spatialHash = new SpatialHash(16); spatialHash.Insert(1, otherRectangle, otherTransform); spatialHash.Insert(2, farthestRectangle, farthestTransform); + spatialHash.Insert(3, downRectangle, downTransform); SweepTest.Rectangle(spatialHash, rectangle, transform, new Vector2(12, 0)).Should().Be( new SweepResult(true, new Vector2(8, 0), 1, otherRectangle, otherTransform) ); SweepTest.Rectangle(spatialHash, rectangle, transform, new Vector2(-12, 0)).Hit.Should().BeFalse(); + + SweepTest.Rectangle(spatialHash, rectangle, transform, new Vector2(0, 20)).Should().Be( + new SweepResult(true, new Vector2(0, 16), 3, downRectangle, downTransform) + ); } } } From 38f5180a45f2e554b07f8a757aa24b841e1e37d6 Mon Sep 17 00:00:00 2001 From: Evan Hemsley <2342303+ehemsley@users.noreply.github.com> Date: Sun, 5 Jan 2020 13:14:06 -0800 Subject: [PATCH 05/10] fix sweep test correction sign --- Bonk/SweepTest/SweepTest.cs | 4 ++-- Test/SweepTestTest.cs | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Bonk/SweepTest/SweepTest.cs b/Bonk/SweepTest/SweepTest.cs index 65ea470..4dd53d4 100644 --- a/Bonk/SweepTest/SweepTest.cs +++ b/Bonk/SweepTest/SweepTest.cs @@ -106,8 +106,8 @@ namespace MoonTools.Core.Bonk if (nearestRectangle.HasValue) { var overlapPosition = ray * shortestDistance; - var correctionX = ray.X > 0 ? -1 : 1; - var correctionY = ray.Y > 0 ? -1 : 1; + var correctionX = -Math.Sign(ray.X); + var correctionY = -Math.Sign(ray.Y); return new SweepResult(true, new Position2D((int)overlapPosition.X + correctionX, (int)overlapPosition.Y + correctionY), nearestID, nearestRectangle.Value, nearestTransform.Value); } else diff --git a/Test/SweepTestTest.cs b/Test/SweepTestTest.cs index cf07de6..7b9dceb 100644 --- a/Test/SweepTestTest.cs +++ b/Test/SweepTestTest.cs @@ -29,13 +29,13 @@ namespace Tests spatialHash.Insert(3, downRectangle, downTransform); SweepTest.Rectangle(spatialHash, rectangle, transform, new Vector2(12, 0)).Should().Be( - new SweepResult(true, new Vector2(8, 0), 1, otherRectangle, otherTransform) + new SweepResult(true, new Vector2(7, 0), 1, otherRectangle, otherTransform) ); SweepTest.Rectangle(spatialHash, rectangle, transform, new Vector2(-12, 0)).Hit.Should().BeFalse(); SweepTest.Rectangle(spatialHash, rectangle, transform, new Vector2(0, 20)).Should().Be( - new SweepResult(true, new Vector2(0, 16), 3, downRectangle, downTransform) + new SweepResult(true, new Vector2(0, 15), 3, downRectangle, downTransform) ); } } From 17084154a290729425b0a68c69f4cc120caa6419 Mon Sep 17 00:00:00 2001 From: Evan Hemsley <2342303+ehemsley@users.noreply.github.com> Date: Sun, 5 Jan 2020 13:35:49 -0800 Subject: [PATCH 06/10] change multishape test transform behavior --- Bonk/NarrowPhase/NarrowPhase.cs | 14 +++++++------- Test/NarrowPhaseTest.cs | 2 +- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/Bonk/NarrowPhase/NarrowPhase.cs b/Bonk/NarrowPhase/NarrowPhase.cs index 676a6e8..fe69be5 100644 --- a/Bonk/NarrowPhase/NarrowPhase.cs +++ b/Bonk/NarrowPhase/NarrowPhase.cs @@ -70,9 +70,9 @@ namespace MoonTools.Core.Bonk /// public static bool TestCollision(MultiShape multiShape, Transform2D multiShapeTransform, IShape2D shape, Transform2D shapeTransform) { - foreach (var (otherShape, otherTransform) in multiShape.ShapeTransformPairs) + foreach (var (otherShape, otherTransform) in multiShape.TransformedShapeTransforms(multiShapeTransform)) { - if (TestCollision(shape, shapeTransform, otherShape, multiShapeTransform.Compose(otherTransform))) { return true; } + if (TestCollision(shape, shapeTransform, otherShape, otherTransform)) { return true; } } return false; } @@ -88,9 +88,9 @@ namespace MoonTools.Core.Bonk /// public static bool TestCollision(IShape2D shape, Transform2D shapeTransform, MultiShape multiShape, Transform2D multiShapeTransform) { - foreach (var (otherShape, otherTransform) in multiShape.ShapeTransformPairs) + foreach (var (otherShape, otherTransform) in multiShape.TransformedShapeTransforms(multiShapeTransform)) { - if (TestCollision(shape, shapeTransform, otherShape, multiShapeTransform.Compose(otherTransform))) { return true; } + if (TestCollision(shape, shapeTransform, otherShape, otherTransform)) { return true; } } return false; } @@ -106,11 +106,11 @@ namespace MoonTools.Core.Bonk /// public static bool TestCollision(MultiShape multiShapeA, Transform2D transformA, MultiShape multiShapeB, Transform2D transformB) { - foreach (var (shapeA, shapeTransformA) in multiShapeA.ShapeTransformPairs) + foreach (var (shapeA, shapeTransformA) in multiShapeA.TransformedShapeTransforms(transformA)) { - foreach (var (shapeB, shapeTransformB) in multiShapeB.ShapeTransformPairs) + foreach (var (shapeB, shapeTransformB) in multiShapeB.TransformedShapeTransforms(transformB)) { - if (TestCollision(shapeA, transformA.Compose(shapeTransformA), shapeB, transformB.Compose(shapeTransformB))) { return true; } + if (TestCollision(shapeA, shapeTransformA, shapeB, shapeTransformB)) { return true; } } } return false; diff --git a/Test/NarrowPhaseTest.cs b/Test/NarrowPhaseTest.cs index 3cc1d1d..c648490 100644 --- a/Test/NarrowPhaseTest.cs +++ b/Test/NarrowPhaseTest.cs @@ -418,7 +418,7 @@ namespace Tests var transformA = new Transform2D(new Position2D(0, 0)); var rectangleB = new Rectangle(2, 2); - var transformB = new Transform2D(new Vector2(1, 0)); + var transformB = new Transform2D(new Vector2(1, 0), 0, new Vector2(-1, 1)); NarrowPhase.TestRectangleOverlap(rectangleA, transformA, rectangleB, transformB).Should().BeTrue(); } From 7875342da8275917ff4a01426408fce02001e45a Mon Sep 17 00:00:00 2001 From: Evan Hemsley <2342303+ehemsley@users.noreply.github.com> Date: Sun, 5 Jan 2020 21:36:31 -0800 Subject: [PATCH 07/10] change how multishape shapes are transformed and add point sweep test --- Bonk/MultiShape.cs | 11 +++++++++-- Bonk/NarrowPhase/NarrowPhase.cs | 8 ++++---- Bonk/SweepTest/SweepResult.cs | 11 +++-------- Bonk/SweepTest/SweepTest.cs | 13 +++++++++---- 4 files changed, 25 insertions(+), 18 deletions(-) diff --git a/Bonk/MultiShape.cs b/Bonk/MultiShape.cs index eb34cda..202120a 100644 --- a/Bonk/MultiShape.cs +++ b/Bonk/MultiShape.cs @@ -1,5 +1,6 @@ using System.Collections.Generic; using System.Collections.Immutable; +using System.Numerics; using MoonTools.Core.Structs; namespace MoonTools.Core.Bonk @@ -22,11 +23,17 @@ namespace MoonTools.Core.Bonk return AABB.Transformed(AABB, transform); } - public IEnumerable<(IShape2D, Transform2D)> TransformedShapeTransforms(Transform2D transform) + /// + /// Moves the shapes by pivoting with an offset transform. + /// + /// + /// + public IEnumerable<(IShape2D, Transform2D)> TransformShapesUsingOffset(Transform2D offsetTransform) { foreach (var (shape, shapeTransform) in ShapeTransformPairs) { - yield return (shape, transform.Compose(shapeTransform)); + var newTransform = new Transform2D(Vector2.Transform(shapeTransform.Position, offsetTransform.TransformMatrix), offsetTransform.Rotation, offsetTransform.Scale); + yield return (shape, newTransform); } } diff --git a/Bonk/NarrowPhase/NarrowPhase.cs b/Bonk/NarrowPhase/NarrowPhase.cs index fe69be5..0ef1543 100644 --- a/Bonk/NarrowPhase/NarrowPhase.cs +++ b/Bonk/NarrowPhase/NarrowPhase.cs @@ -70,7 +70,7 @@ namespace MoonTools.Core.Bonk /// public static bool TestCollision(MultiShape multiShape, Transform2D multiShapeTransform, IShape2D shape, Transform2D shapeTransform) { - foreach (var (otherShape, otherTransform) in multiShape.TransformedShapeTransforms(multiShapeTransform)) + foreach (var (otherShape, otherTransform) in multiShape.TransformShapesUsingOffset(multiShapeTransform)) { if (TestCollision(shape, shapeTransform, otherShape, otherTransform)) { return true; } } @@ -88,7 +88,7 @@ namespace MoonTools.Core.Bonk /// public static bool TestCollision(IShape2D shape, Transform2D shapeTransform, MultiShape multiShape, Transform2D multiShapeTransform) { - foreach (var (otherShape, otherTransform) in multiShape.TransformedShapeTransforms(multiShapeTransform)) + foreach (var (otherShape, otherTransform) in multiShape.TransformShapesUsingOffset(multiShapeTransform)) { if (TestCollision(shape, shapeTransform, otherShape, otherTransform)) { return true; } } @@ -106,9 +106,9 @@ namespace MoonTools.Core.Bonk /// public static bool TestCollision(MultiShape multiShapeA, Transform2D transformA, MultiShape multiShapeB, Transform2D transformB) { - foreach (var (shapeA, shapeTransformA) in multiShapeA.TransformedShapeTransforms(transformA)) + foreach (var (shapeA, shapeTransformA) in multiShapeA.TransformShapesUsingOffset(transformA)) { - foreach (var (shapeB, shapeTransformB) in multiShapeB.TransformedShapeTransforms(transformB)) + foreach (var (shapeB, shapeTransformB) in multiShapeB.TransformShapesUsingOffset(transformB)) { if (TestCollision(shapeA, shapeTransformA, shapeB, shapeTransformB)) { return true; } } diff --git a/Bonk/SweepTest/SweepResult.cs b/Bonk/SweepTest/SweepResult.cs index 2575090..d6dc84d 100644 --- a/Bonk/SweepTest/SweepResult.cs +++ b/Bonk/SweepTest/SweepResult.cs @@ -1,26 +1,21 @@ using System; using System.Numerics; -using MoonTools.Core.Structs; namespace MoonTools.Core.Bonk { - public struct SweepResult where T : IEquatable where U : struct, IShape2D + public struct SweepResult where T : IEquatable { - public static SweepResult False = new SweepResult(); + public static SweepResult False = new SweepResult(); public bool Hit { get; } public Vector2 Motion { get; } public T ID { get; } - public U Shape { get; } - public Transform2D Transform { get; } - public SweepResult(bool hit, Vector2 motion, T id, U shape, Transform2D transform) + public SweepResult(bool hit, Vector2 motion, T id) { Hit = hit; Motion = motion; ID = id; - Shape = shape; - Transform = transform; } } } diff --git a/Bonk/SweepTest/SweepTest.cs b/Bonk/SweepTest/SweepTest.cs index 4dd53d4..652ebcd 100644 --- a/Bonk/SweepTest/SweepTest.cs +++ b/Bonk/SweepTest/SweepTest.cs @@ -7,7 +7,7 @@ namespace MoonTools.Core.Bonk public static class SweepTest { /// - /// Performs a sweep test on rectangles. Returns the position 1 pixel before overlap occurs. + /// Performs a sweep test on and against rectangles. Returns the position 1 pixel before overlap occurs. /// /// /// A spatial hash. @@ -15,7 +15,7 @@ namespace MoonTools.Core.Bonk /// A transform by which to transform the IHasAABB2D. /// Given in world-space. /// - public static SweepResult Rectangle(SpatialHash spatialHash, Rectangle rectangle, Transform2D transform, Vector2 ray) where T : IEquatable + public static SweepResult Test(SpatialHash spatialHash, Rectangle rectangle, Transform2D transform, Vector2 ray) where T : IEquatable { var transformedAABB = rectangle.TransformedAABB(transform); var sweepBox = SweepBox(transformedAABB, ray); @@ -108,14 +108,19 @@ namespace MoonTools.Core.Bonk var overlapPosition = ray * shortestDistance; var correctionX = -Math.Sign(ray.X); var correctionY = -Math.Sign(ray.Y); - return new SweepResult(true, new Position2D((int)overlapPosition.X + correctionX, (int)overlapPosition.Y + correctionY), nearestID, nearestRectangle.Value, nearestTransform.Value); + return new SweepResult(true, new Position2D((int)overlapPosition.X + correctionX, (int)overlapPosition.Y + correctionY), nearestID); } else { - return SweepResult.False; + return SweepResult.False; } } + public static SweepResult Test(SpatialHash spatialHash, Point point, Transform2D transform, Vector2 ray) where T : IEquatable + { + return Test(spatialHash, new Rectangle(0, 0), transform, ray); + } + private static AABB SweepBox(AABB aabb, Vector2 ray) { return new AABB( From 20df172027c643646878eeb43404f995fff0eeaf Mon Sep 17 00:00:00 2001 From: Evan Hemsley <2342303+ehemsley@users.noreply.github.com> Date: Mon, 6 Jan 2020 01:38:13 -0800 Subject: [PATCH 08/10] fix sweep test test --- Test/SweepTestTest.cs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Test/SweepTestTest.cs b/Test/SweepTestTest.cs index 7b9dceb..44ae9af 100644 --- a/Test/SweepTestTest.cs +++ b/Test/SweepTestTest.cs @@ -28,14 +28,14 @@ namespace Tests spatialHash.Insert(2, farthestRectangle, farthestTransform); spatialHash.Insert(3, downRectangle, downTransform); - SweepTest.Rectangle(spatialHash, rectangle, transform, new Vector2(12, 0)).Should().Be( - new SweepResult(true, new Vector2(7, 0), 1, otherRectangle, otherTransform) + SweepTest.Test(spatialHash, rectangle, transform, new Vector2(12, 0)).Should().Be( + new SweepResult(true, new Vector2(7, 0), 1) ); - SweepTest.Rectangle(spatialHash, rectangle, transform, new Vector2(-12, 0)).Hit.Should().BeFalse(); + SweepTest.Test(spatialHash, rectangle, transform, new Vector2(-12, 0)).Hit.Should().BeFalse(); - SweepTest.Rectangle(spatialHash, rectangle, transform, new Vector2(0, 20)).Should().Be( - new SweepResult(true, new Vector2(0, 15), 3, downRectangle, downTransform) + SweepTest.Test(spatialHash, rectangle, transform, new Vector2(0, 20)).Should().Be( + new SweepResult(true, new Vector2(0, 15), 3) ); } } From 1fb768e7b5084c012d3eb8d4ab60f91f525bd11b Mon Sep 17 00:00:00 2001 From: Evan Hemsley <2342303+ehemsley@users.noreply.github.com> Date: Mon, 6 Jan 2020 20:06:21 -0800 Subject: [PATCH 09/10] rectangles now define top-left-width-height so that we dont have subpixel bounds --- Bonk/Shapes/Rectangle.cs | 12 ++++----- Bonk/SweepTest/SweepTest.cs | 2 +- Test/EPA2DTest.cs | 6 ++--- Test/Equality.cs | 16 ++++++------ Test/NarrowPhaseTest.cs | 52 ++++++++++++++++++------------------- Test/SpatialHashTest.cs | 24 ++++++++--------- Test/SweepTestTest.cs | 8 +++--- 7 files changed, 60 insertions(+), 60 deletions(-) diff --git a/Bonk/Shapes/Rectangle.cs b/Bonk/Shapes/Rectangle.cs index d60bf5b..d75dc0d 100644 --- a/Bonk/Shapes/Rectangle.cs +++ b/Bonk/Shapes/Rectangle.cs @@ -23,15 +23,15 @@ namespace MoonTools.Core.Bonk public Vector2 Min { get; } public Vector2 Max { get; } - public Rectangle(int width, int height) + public Rectangle(int left, int top, int width, int height) { Width = width; Height = height; - AABB = new AABB(-width / 2f, -height / 2f, width / 2f, height / 2f); - Right = AABB.Right; - Left = AABB.Left; - Top = AABB.Top; - Bottom = AABB.Bottom; + Left = left; + Right = left + width; + Top = top; + Bottom = top + height; + AABB = new AABB(left, top, Right, Bottom); BottomLeft = new Vector2(Left, Bottom); TopRight = new Vector2(Top, Right); Min = AABB.Min; diff --git a/Bonk/SweepTest/SweepTest.cs b/Bonk/SweepTest/SweepTest.cs index 652ebcd..cf17d37 100644 --- a/Bonk/SweepTest/SweepTest.cs +++ b/Bonk/SweepTest/SweepTest.cs @@ -118,7 +118,7 @@ namespace MoonTools.Core.Bonk public static SweepResult Test(SpatialHash spatialHash, Point point, Transform2D transform, Vector2 ray) where T : IEquatable { - return Test(spatialHash, new Rectangle(0, 0), transform, ray); + return Test(spatialHash, new Rectangle(0, 0, 0, 0), transform, ray); } private static AABB SweepBox(AABB aabb, Vector2 ray) diff --git a/Test/EPA2DTest.cs b/Test/EPA2DTest.cs index 87bef7c..ab330db 100644 --- a/Test/EPA2DTest.cs +++ b/Test/EPA2DTest.cs @@ -13,9 +13,9 @@ namespace Tests [Test] public void RectangleOverlap() { - var squareA = new Rectangle(2, 2); + var squareA = new Rectangle(-1, -1, 2, 2); var transformA = Transform2D.DefaultTransform; - var squareB = new Rectangle(2, 2); + var squareB = new Rectangle(-1, -1, 2, 2); var transformB = new Transform2D(new Vector2(1.5f, 0)); var (result, simplex) = NarrowPhase.FindCollisionSimplex(squareA, transformA, squareB, transformB); @@ -62,7 +62,7 @@ namespace Tests { var line = new Line(new Position2D(-4, -4), new Position2D(4, 4)); var transformA = Transform2D.DefaultTransform; - var square = new Rectangle(2, 2); + var square = new Rectangle(-1, -1, 2, 2); var transformB = Transform2D.DefaultTransform; var (result, simplex) = NarrowPhase.FindCollisionSimplex(line, transformA, square, transformB); diff --git a/Test/Equality.cs b/Test/Equality.cs index 9f6cb65..8189ef4 100644 --- a/Test/Equality.cs +++ b/Test/Equality.cs @@ -140,8 +140,8 @@ namespace Tests [Test] public void RectangleEqual() { - var a = new Rectangle(3, 3); - var b = new Rectangle(3, 3); + var a = new Rectangle(-1, -1, 3, 3); + var b = new Rectangle(-1, -1, 3, 3); a.Equals(b).Should().BeTrue(); } @@ -149,8 +149,8 @@ namespace Tests [Test] public void RectangleEqualOperator() { - var a = new Rectangle(3, 3); - var b = new Rectangle(3, 3); + var a = new Rectangle(-1, -1, 3, 3); + var b = new Rectangle(-1, -1, 3, 3); (a == b).Should().BeTrue(); } @@ -158,8 +158,8 @@ namespace Tests [Test] public void RectangleNotEqual() { - var a = new Rectangle(3, 3); - var b = new Rectangle(6, 6); + var a = new Rectangle(-1, -1, 3, 3); + var b = new Rectangle(-3, -3, 6, 6); a.Equals(b).Should().BeFalse(); } @@ -167,8 +167,8 @@ namespace Tests [Test] public void RectangleNotEqualOperator() { - var a = new Rectangle(3, 3); - var b = new Rectangle(6, 6); + var a = new Rectangle(-1, -1, 3, 3); + var b = new Rectangle(-3, -3, 6, 6); (a != b).Should().BeTrue(); } diff --git a/Test/NarrowPhaseTest.cs b/Test/NarrowPhaseTest.cs index c648490..5d2f5a5 100644 --- a/Test/NarrowPhaseTest.cs +++ b/Test/NarrowPhaseTest.cs @@ -55,7 +55,7 @@ namespace Tests public void PointRectangleOverlapping() { var point = new Point(); - var rectangle = new Rectangle(4, 4); + var rectangle = new Rectangle(-2, -2, 4, 4); NarrowPhase.TestCollision(point, Transform2D.DefaultTransform, rectangle, Transform2D.DefaultTransform).Should().BeTrue(); } @@ -65,7 +65,7 @@ namespace Tests { var point = new Point(); var pointTransform = new Transform2D(new Position2D(5, 5)); - var rectangle = new Rectangle(4, 4); + var rectangle = new Rectangle(-2, -2, 4, 4); NarrowPhase.TestCollision(point, pointTransform, rectangle, Transform2D.DefaultTransform).Should().BeFalse(); } @@ -354,10 +354,10 @@ namespace Tests [Test] public void RectanglesNotOverlapping() { - var rectangleA = new Rectangle(12, 12); + var rectangleA = new Rectangle(-6, -6, 12, 12); var transformA = new Transform2D(new Position2D(39, 249)); - var rectangleB = new Rectangle(16, 16); + var rectangleB = new Rectangle(-8, -8, 16, 16); var transformB = new Transform2D(new Position2D(16, 240)); NarrowPhase.TestCollision(rectangleA, transformA, rectangleB, transformB).Should().BeFalse(); @@ -366,10 +366,10 @@ namespace Tests [Test] public void RotatedRectanglesOverlapping() { - var rectangleA = new Rectangle(3, 6); + var rectangleA = new Rectangle(-1, -3, 3, 6); var transformA = new Transform2D(new Vector2(4f, 0), (float)System.Math.PI / 2); - var rectangleB = new Rectangle(2, 2); + var rectangleB = new Rectangle(-1, -1, 2, 2); var transformB = new Transform2D(new Vector2(0, 0)); NarrowPhase.TestCollision(rectangleA, transformA, rectangleB, transformB).Should().BeTrue(); @@ -378,10 +378,10 @@ namespace Tests [Test] public void RectanglesTouchingGJK2D() { - var rectangleA = new Rectangle(2, 2); + var rectangleA = new Rectangle(-1, -1, 2, 2); var transformA = new Transform2D(new Position2D(-1, 0)); - var rectangleB = new Rectangle(2, 2); + var rectangleB = new Rectangle(-1, -1, 2, 2); var transformB = new Transform2D(new Vector2(1, 0)); NarrowPhase.TestCollision(rectangleA, transformA, rectangleB, transformB).Should().BeTrue(); @@ -390,10 +390,10 @@ namespace Tests [Test] public void RectanglesOverlappingGJK2D() { - var rectangleA = new Rectangle(2, 2); + var rectangleA = new Rectangle(-1, -1, 2, 2); var transformA = new Transform2D(new Position2D(0, 0)); - var rectangleB = new Rectangle(2, 2); + var rectangleB = new Rectangle(-1, -1, 2, 2); var transformB = new Transform2D(new Vector2(1, 0)); NarrowPhase.TestCollision(rectangleA, transformA, rectangleB, transformB).Should().BeTrue(); @@ -402,10 +402,10 @@ namespace Tests [Test] public void RectanglesTouchingOverlap() { - var rectangleA = new Rectangle(2, 2); + var rectangleA = new Rectangle(-1, -1, 2, 2); var transformA = new Transform2D(new Position2D(-1, 0)); - var rectangleB = new Rectangle(2, 2); + var rectangleB = new Rectangle(-1, -1, 2, 2); var transformB = new Transform2D(new Vector2(1, 0)); NarrowPhase.TestRectangleOverlap(rectangleA, transformA, rectangleB, transformB).Should().BeTrue(); @@ -414,10 +414,10 @@ namespace Tests [Test] public void RectanglesOverlappingOverlap() { - var rectangleA = new Rectangle(2, 2); + var rectangleA = new Rectangle(-1, -1, 2, 2); var transformA = new Transform2D(new Position2D(0, 0)); - var rectangleB = new Rectangle(2, 2); + var rectangleB = new Rectangle(-1, -1, 2, 2); var transformB = new Transform2D(new Vector2(1, 0), 0, new Vector2(-1, 1)); NarrowPhase.TestRectangleOverlap(rectangleA, transformA, rectangleB, transformB).Should().BeTrue(); @@ -428,18 +428,18 @@ namespace Tests { var multiRectangleA = new MultiShape( ImmutableArray.Create<(IShape2D, Transform2D)>( - (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 0))), - (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 1))), - (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 2))) + (new Rectangle(-2, 0, 4, 1), new Transform2D(new Position2D(-5, 0))), + (new Rectangle(-2, 0, 4, 1), new Transform2D(new Position2D(-5, 1))), + (new Rectangle(-2, 0, 4, 1), new Transform2D(new Position2D(-5, 2))) ) ); var transformA = new Transform2D(new Position2D(5, 0)); var multiRectangleB = new MultiShape( ImmutableArray.Create<(IShape2D, Transform2D)>( - (new Rectangle(4, 1), new Transform2D(new Position2D(4, -1))), - (new Rectangle(4, 1), new Transform2D(new Position2D(4, 0))), - (new Rectangle(4, 1), new Transform2D(new Position2D(4, 1))) + (new Rectangle(-2, 0, 4, 1), new Transform2D(new Position2D(4, -1))), + (new Rectangle(-2, 0, 4, 1), new Transform2D(new Position2D(4, 0))), + (new Rectangle(-2, 0, 4, 1), new Transform2D(new Position2D(4, 1))) ) ); var transformB = new Transform2D(new Position2D(0, 3)); @@ -452,18 +452,18 @@ namespace Tests { var multiRectangleA = new MultiShape( ImmutableArray.Create<(IShape2D, Transform2D)>( - (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 0))), - (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 1))), - (new Rectangle(4, 1), new Transform2D(new Position2D(-5, 2))) + (new Rectangle(-2, 0, 4, 1), new Transform2D(new Position2D(-5, 0))), + (new Rectangle(-2, 0, 4, 1), new Transform2D(new Position2D(-5, 1))), + (new Rectangle(-2, 0, 4, 1), new Transform2D(new Position2D(-5, 2))) ) ); var transformA = new Transform2D(new Position2D(5, 0)); var multiRectangleB = new MultiShape( ImmutableArray.Create<(IShape2D, Transform2D)>( - (new Rectangle(4, 1), new Transform2D(new Position2D(4, -1))), - (new Rectangle(4, 1), new Transform2D(new Position2D(4, 0))), - (new Rectangle(4, 1), new Transform2D(new Position2D(4, 1))) + (new Rectangle(-2, 0, 4, 1), new Transform2D(new Position2D(4, -1))), + (new Rectangle(-2, 0, 4, 1), new Transform2D(new Position2D(4, 0))), + (new Rectangle(-2, 0, 4, 1), new Transform2D(new Position2D(4, 1))) ) ); var transformB = new Transform2D(new Position2D(0, -3)); diff --git a/Test/SpatialHashTest.cs b/Test/SpatialHashTest.cs index 671bc8c..c2f7cc3 100644 --- a/Test/SpatialHashTest.cs +++ b/Test/SpatialHashTest.cs @@ -14,16 +14,16 @@ namespace Tests { var spatialHash = new SpatialHash(16); - var rectA = new Rectangle(4, 4); + var rectA = new Rectangle(-2, -2, 4, 4); var rectATransform = new Transform2D(new Vector2(-8, -8)); - var rectB = new Rectangle(4, 4); + var rectB = new Rectangle(-2, -2, 4, 4); var rectBTransform = new Transform2D(new Vector2(8, 8)); - var rectC = new Rectangle(4, 4); + var rectC = new Rectangle(-2, -2, 4, 4); var rectCTransform = new Transform2D(new Vector2(24, -4)); - var rectD = new Rectangle(4, 4); + var rectD = new Rectangle(-2, -2, 4, 4); var rectDTransform = new Transform2D(new Vector2(24, 24)); var circleA = new Circle(2); @@ -40,9 +40,9 @@ namespace Tests var multiRectangle = new MultiShape( ImmutableArray.Create<(IShape2D, Transform2D)>( - (new Rectangle(4, 1), new Transform2D(new Position2D(-2, -2))), - (new Rectangle(4, 1), new Transform2D(new Position2D(-2, -1))), - (new Rectangle(4, 1), new Transform2D(new Position2D(-2, 0))) + (new Rectangle(-2, 0, 4, 1), new Transform2D(new Position2D(-2, -2))), + (new Rectangle(-2, 0, 4, 1), new Transform2D(new Position2D(-2, -1))), + (new Rectangle(-2, 0, 4, 1), new Transform2D(new Position2D(-2, 0))) ) ); var multiRectangleTransform = new Transform2D(new Position2D(8, 8)); @@ -78,13 +78,13 @@ namespace Tests { var spatialHash = new SpatialHash(16); - var rectA = new Rectangle(4, 4); + var rectA = new Rectangle(-2, -2, 4, 4); var rectATransform = new Transform2D(new Vector2(-8, -8)); - var rectB = new Rectangle(4, 4); + var rectB = new Rectangle(-2, -2, 4, 4); var rectBTransform = new Transform2D(new Vector2(-8, -8)); - var rectC = new Rectangle(2, 2); + var rectC = new Rectangle(-2, -2, 2, 2); var rectCTransform = new Transform2D(new Vector2(-8, -8)); spatialHash.Insert(0, rectA, rectATransform); @@ -99,10 +99,10 @@ namespace Tests { var spatialHash = new SpatialHash(16); - var rectA = new Rectangle(4, 4); + var rectA = new Rectangle(-2, -2, 4, 4); var rectATransform = new Transform2D(new Vector2(-8, -8)); - var rectB = new Rectangle(4, 4); + var rectB = new Rectangle(-2, -2, 4, 4); var rectBTransform = new Transform2D(new Vector2(8, 8)); spatialHash.Insert(0, rectA, rectATransform); diff --git a/Test/SweepTestTest.cs b/Test/SweepTestTest.cs index 44ae9af..c94c47a 100644 --- a/Test/SweepTestTest.cs +++ b/Test/SweepTestTest.cs @@ -11,16 +11,16 @@ namespace Tests [Test] public void SweepsThrough() { - var rectangle = new Rectangle(4, 4); + var rectangle = new Rectangle(-2, -2, 4, 4); var transform = new Transform2D(new Position2D(-6, 0)); - var otherRectangle = new Rectangle(4, 4); + var otherRectangle = new Rectangle(-2, -2, 4, 4); var otherTransform = new Transform2D(new Position2D(6, 0)); - var farthestRectangle = new Rectangle(4, 4); + var farthestRectangle = new Rectangle(-2, -2, 4, 4); var farthestTransform = new Transform2D(new Position2D(12, 0)); - var downRectangle = new Rectangle(12, 4); + var downRectangle = new Rectangle(-6, -2, 12, 4); var downTransform = new Transform2D(new Position2D(-6, 20)); var spatialHash = new SpatialHash(16); From 108e0573c2a1f0171ea5ec7d98e15694c03fae75 Mon Sep 17 00:00:00 2001 From: Evan Hemsley <2342303+ehemsley@users.noreply.github.com> Date: Fri, 17 Jan 2020 02:52:38 -0800 Subject: [PATCH 10/10] spatial hash optimization --- Bonk/BroadPhase/SpatialHash.cs | 37 ++++++++++++++++++++++++++-------- 1 file changed, 29 insertions(+), 8 deletions(-) diff --git a/Bonk/BroadPhase/SpatialHash.cs b/Bonk/BroadPhase/SpatialHash.cs index cdd96bd..8e2d970 100644 --- a/Bonk/BroadPhase/SpatialHash.cs +++ b/Bonk/BroadPhase/SpatialHash.cs @@ -16,6 +16,12 @@ namespace MoonTools.Core.Bonk private readonly Dictionary> hashDictionary = new Dictionary>(); private readonly Dictionary IDLookup = new Dictionary(); + public int MinX { get; private set; } = 0; + public int MaxX { get; private set; } = 0; + public int MinY { get; private set; } = 0; + public int MaxY { get; private set; } = 0; + + public SpatialHash(int cellSize) { this.cellSize = cellSize; @@ -52,6 +58,11 @@ namespace MoonTools.Core.Bonk IDLookup[id] = (shape, transform2D); } } + + MinX = Math.Min(MinX, minHash.Item1); + MinY = Math.Min(MinY, minHash.Item2); + MaxX = Math.Max(MaxX, maxHash.Item1); + MaxY = Math.Max(MaxY, maxHash.Item2); } /// @@ -60,12 +71,17 @@ namespace MoonTools.Core.Bonk public IEnumerable<(T, IHasAABB2D, Transform2D)> Retrieve(T id, IHasAABB2D shape, Transform2D transform2D) { var box = shape.TransformedAABB(transform2D); - var minHash = Hash(box.Min); - var maxHash = Hash(box.Max); + var (minX, minY) = Hash(box.Min); + var (maxX, maxY) = Hash(box.Max); - for (var i = minHash.Item1; i <= maxHash.Item1; i++) + if (minX < MinX) { minX = MinX; } + if (maxX > MaxX) { maxX = MaxX; } + if (minY < MinY) { minY = MinY; } + if (maxY > MaxY) { maxY = MaxY; } + + for (var i = minX; i <= maxX; i++) { - for (var j = minHash.Item2; j <= maxHash.Item2; j++) + for (var j = minY; j <= maxY; j++) { var key = MakeLong(i, j); if (hashDictionary.ContainsKey(key)) @@ -91,12 +107,17 @@ namespace MoonTools.Core.Bonk /// public IEnumerable<(T, IHasAABB2D, Transform2D)> Retrieve(AABB aabb) { - var minHash = Hash(aabb.Min); - var maxHash = Hash(aabb.Max); + var (minX, minY) = Hash(aabb.Min); + var (maxX, maxY) = Hash(aabb.Max); - for (var i = minHash.Item1; i <= maxHash.Item1; i++) + if (minX < MinX) { minX = MinX; } + if (maxX > MaxX) { maxX = MaxX; } + if (minY < MinY) { minY = MinY; } + if (maxY > MaxY) { maxY = MaxY; } + + for (var i = minX; i <= maxX; i++) { - for (var j = minHash.Item2; j <= maxHash.Item2; j++) + for (var j = minY; j <= maxY; j++) { var key = MakeLong(i, j); if (hashDictionary.ContainsKey(key))