Implement AABB2D

include/J3ML/Geometry/AABB2D.h

@@ -1,10 +1,87 @@
 #pragma once
 
+#include <J3ML/LinearAlgebra/Vector2.h>
+
 namespace Geometry
 {
+    using LinearAlgebra::Vector2;
     // CaveGame AABB
     class AABB2D
     {
+    public:
 
+        Vector2 minPoint;
+        Vector2 maxPoint;
+        AABB2D(const Vector2& min, const Vector2& max):
+        minPoint(min), maxPoint(max)
+        {}
+
+        float Width() const { return maxPoint.x - minPoint.x;  }
+        float Height() const { return maxPoint.y - minPoint.y; }
+
+        float DistanceSq(const Vector2& pt) const
+        {
+            Vector2 cp = pt.Clamp(minPoint, maxPoint);
+            return cp.DistanceSq(pt);
+        }
+
+        void SetNegativeInfinity();
+
+        void Enclose(const Vector2& point)
+        {
+            minPoint = Vector2::Min(minPoint, point);
+            maxPoint = Vector2::Max(maxPoint, point);
+        }
+
+        bool Intersects(const AABB2D &rhs) const
+        {
+            return maxPoint.x >= rhs.minPoint.x &&
+                   maxPoint.y >= rhs.minPoint.y &&
+                   rhs.maxPoint.x >= minPoint.x &&
+                   rhs.maxPoint.y >= minPoint.y;
+        }
+
+        bool Contains(const AABB2D &rhs) const
+        {
+            return rhs.minPoint.x >= minPoint.x && rhs.minPoint.y >= minPoint.y
+                   && rhs.maxPoint.x <= maxPoint.x && rhs.maxPoint.y <= maxPoint.y;
+        }
+
+        bool Contains(const vec2d &pt) const
+        {
+            return pt.x >= minPoint.x && pt.y >= minPoint.y
+                   && pt.x <= maxPoint.x && pt.y <= maxPoint.y;
+        }
+
+        bool Contains(int x, int y) const
+        {
+            return x >= minPoint.x && y >= minPoint.y
+                   && x <= maxPoint.x && y <= maxPoint.y;
+        }
+
+        bool IsDegenerate() const
+        {
+            return minPoint.x >= maxPoint.x || minPoint.y >= maxPoint.y;
+        }
+
+        bool HasNegativeVolume() const
+        {
+            return maxPoint.x < minPoint.x || maxPoint.y < minPoint.y;
+        }
+
+        bool IsFinite() const
+        {
+            return minPoint.IsFinite() && maxPoint.IsFinite() && minPoint.MinElement() > -1e5f && maxPoint.MaxElement() < 1e5f;
+        }
+
+        Vector2 PosInside(const Vector2 &normalizedPos) const
+        {
+            return minPoint + normalizedPos.Mul(maxPoint - minPoint);
+        }
+
+        Vector2 ToNormalizedLocalSpace(const vec2d &pt) const
+        {
+            return (pt - minPoint).Div(maxPoint - minPoint);
+        }
     };
 }