AdventuresInLestoria/Crawler/olcUTIL_Geometry2D.h

/*
OneLoneCoder - Geometry 2D v1.01
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
A collection of 2D Geometric primitives and functions to work with
and between them.


License (OLC-3)
~~~~~~~~~~~~~~~

Copyright 2018 - 2022 OneLoneCoder.com

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

1. Redistributions or derivations of source code must retain the above
copyright notice, this list of conditions and the following disclaimer.

2. Redistributions or derivative works in binary form must reproduce
the above copyright notice. This list of conditions and the following
disclaimer must be reproduced in the documentation and/or other
materials provided with the distribution.

3. Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Links
~~~~~
YouTube:	https://www.youtube.com/javidx9
Discord:	https://discord.gg/WhwHUMV
Twitter:	https://www.twitter.com/javidx9
Twitch:		https://www.twitch.tv/javidx9
GitHub:		https://www.github.com/onelonecoder
Homepage:	https://www.onelonecoder.com

Author
~~~~~~
David Barr, aka javidx9, <EFBFBD>OneLoneCoder 2019, 2020, 2021, 2022

Changes:
v1.01:		+Made constants inline
+Header guards (lol... sigh...)

*/

#pragma once
#include "olcPixelGameEngine.h"

namespace olc::utils::geom2d
{
	// Lemon Meringue
	inline const double pi = 3.141592653589793238462643383279502884;

	// Floating point error margin
	inline const double epsilon = 0.001;

	//https://stackoverflow.com/questions/1903954/is-there-a-standard-sign-function-signum-sgn-in-c-c
	template <typename T>
	constexpr int sgn(T val) { return (T(0) < val) - (val < T(0)); }

	// Defines a line segment
	template<typename T>
	struct line
	{
		olc::v2d_generic<T> start;
		olc::v2d_generic<T> end;

		inline line(const olc::v2d_generic<T>& s = { T(0), T(0) },
			const olc::v2d_generic<T>& e = { T(0), T(0) })
			: start(s), end(e)
		{ }


		// Get length of line
		inline constexpr T length()
		{
			return (end - start).mag();
		}

		// Get length of line^2
		inline constexpr T length2()
		{
			return (end - start).mag2();
		}

		inline constexpr olc::v2d_generic<T> vector() const
		{
			return (end - start);
		}

		// Given a real distance, get point along line
		inline constexpr olc::v2d_generic<T> rpoint(const T& distance) const
		{
			return start + (end - start).norm() * distance;
		}

		// Given a unit distance, get point along line
		inline constexpr olc::v2d_generic<T> upoint(const T& distance) const
		{
			return start + (end - start) * distance;
		}

		// Return which side of the line does a point lie
		inline constexpr int32_t side(const olc::v2d_generic<T>& point) const
		{
			double d = (end - start).cross(point - start);
			if (d < 0)
				return -1;
			else
				if (d > 0)
					return 1;
				else
					return 0;
		}
	};

	template<typename T>
	struct ray
	{
		olc::v2d_generic<T> origin;
		olc::v2d_generic<T> direction;
	};

	template<typename T>
	struct rect
	{
		olc::v2d_generic<T> pos;
		olc::v2d_generic<T> size;

		inline rect(const olc::v2d_generic<T>& p = { T(0), T(0) },
			const olc::v2d_generic<T>& s = { T(1), T(1) })
			: pos(p), size(s)
		{ }

		inline olc::v2d_generic<T> middle() const
		{
			return pos + (size * double(0.5));
		}

		// Get line segment from top side of rectangle
		inline line<T> top() const
		{
			return { pos, {pos.x + size.x, pos.y } };
		}

		// Get line segment from bottom side of rectangle
		inline line<T> bottom() const
		{
			return { {pos.x, pos.y + size.y}, pos + size };
		}

		// Get line segment from left side of rectangle
		inline line<T> left() const
		{
			return { pos, {pos.x, pos.y + size.y} };
		}

		// Get line segment from right side of rectangle
		inline line<T> right() const
		{
			return { {pos.x + size.x, pos.y }, pos + size };
		}

		// Get a line from an indexed side, starting top, going clockwise
		inline line<T> side(const size_t i) const
		{
			if (i & (0b11 == 0)) return top();
			if (i & (0b11 == 1)) return right();
			if (i & (0b11 == 2)) return bottom();
			if (i & (0b11 == 3)) return left();
		}

		// Get area of rectangle
		inline constexpr T area() const
		{
			return size.x * size.y;
		}

		// Get perimeter of rectangle
		inline constexpr T perimeter() const
		{
			return T(2) * (size.x + size.y);
		}
	};

	template<typename T>
	struct ellipse
	{
		olc::v2d_generic<T> pos;
		olc::v2d_generic<T> radius;

		inline ellipse(const olc::v2d_generic<T>& p = { T(0), T(0) }, const olc::v2d_generic<T> r = {T(1),T(1)})
			: pos(p), radius(r)
		{ }

		// Get area of ellipse
		inline constexpr T area() const
		{
			return T(pi) * radius.x * radius.y;
		}

		// Get perimeter of an ellipse
		inline constexpr T perimeter() const
		{
			return T(2.0 * pi) * sqrt((radius.x*radius.x+radius.y*radius.y)/(2*1.0));
		}

		// Get circumference of ellipse. Which is the same as a permieter of one.
		inline constexpr T circumference() const
		{
			return perimeter();
		}
	};

	template<typename T>
	struct circle
	{
		olc::v2d_generic<T> pos;
		T radius = T(0);

		inline circle(const olc::v2d_generic<T>& p = { T(0), T(0) }, const T r = T(0))
			: pos(p), radius(r)
		{ }

		// Get area of circle
		inline constexpr T area() const
		{
			return T(pi) * radius * radius;
		}

		// Get circumference of circle
		inline constexpr T perimeter() const
		{
			return T(2.0 * pi) * radius;
		}

		// Get circumference of circle
		inline constexpr T circumference() const
		{
			return perimeter();
		}
	};


	template<typename T>
	struct triangle
	{
		std::array<olc::v2d_generic<T>, 3> pos;

		inline triangle(
			const olc::v2d_generic<T>& p0 = { T(0), T(0) },
			const olc::v2d_generic<T>& p1 = { T(0), T(0) },
			const olc::v2d_generic<T>& p2 = { T(0), T(0) })
			: pos{ p0,p1,p2 }
		{ }

		// Get a line from an indexed side, starting top, going clockwise
		inline line<T> side(const size_t i) const
		{
			return line(pos[i % 3], pos[(i + 1) % 3]);
		}

		// Get area of triangle
		inline constexpr T area() const
		{
			return double(0.5) * std::abs(
				(pos[0].x * (pos[1].y - pos[2].y)) +
				(pos[1].x * (pos[2].y - pos[0].y)) +
				(pos[2].x * (pos[0].y - pos[1].y)));
		}

		// Get perimeter of triangle
		inline constexpr T perimeter() const
		{
			return line(pos[0], pos[1]).length()
				+ line(pos[1], pos[2]).length()
				+ line(pos[2], pos[0]).length();
		}
	};


	template<typename T>
	struct polygon
	{
		std::vector<olc::v2d_generic<T>> vPoints;
	};


	// =========================================================================================================================
	// Closest(shape, point) ===================================================================================================

	// Returns closest point to point
	template<typename T1, typename T2>
	inline olc::v2d_generic<T1> closest(const olc::v2d_generic<T1>& p1, const olc::v2d_generic<T2>& p2)
	{
		return p1;
	}

	// Returns closest point on line to point
	template<typename T1, typename T2>
	inline olc::v2d_generic<T1> closest(const line<T1>& l, const olc::v2d_generic<T2>& p)
	{		
		auto d = l.vector();
		double u = std::clamp(double(d.dot(p - l.start)) / d.mag2(), 0.0, 1.0);
		return l.start + u * d;
	}

	// Returns closest point on circle to point
	template<typename T1, typename T2>
	inline olc::v2d_generic<T1> closest(const circle<T1>& c, const olc::v2d_generic<T2>& p)
	{		
		return c.pos + olc::vd2d(p - c.pos).norm() * c.radius;
	}

	// Returns closest point on rectangle to point
	template<typename T1, typename T2>
	inline olc::v2d_generic<T1> closest(const rect<T1>& r, const olc::v2d_generic<T2>& p)
	{
		// This could be a "constrain" function hmmmm
		// TODO: Not quite what i wanted, should restrain to boundary
		return olc::v2d_generic<T1>{ std::clamp(p.x, r.pos.x, r.pos.x + r.size.x), std::clamp(p.y, r.pos.y, r.pos.y + r.size.y) };

	}

	// Returns closest point on triangle to point
	template<typename T1, typename T2>
	inline olc::v2d_generic<T1> closest(const triangle<T1>& t, const olc::v2d_generic<T2>& p)
	{
		olc::utils::geom2d::line<T1> l{t.pos[0], t.pos[1]};
		auto p0 = closest(l, p);
		auto d0 = (p0 - p).mag2();

		l.end = t.pos[2];
		auto p1 = closest(l, p);
		auto d1 = (p1 - p).mag2();

		l.start = t.pos[1];
		auto p2 = closest(l, p);
		auto d2 = (p2 - p).mag2();

		if((d0 <= d1) && (d0 <= d2)) {
			return p0;
		} else if((d1 <= d0) && (d1 <= d2)) {
			return p1;
		} else {
			return p2;
		}
	}











	// ================================================================================================================
	// POINT ==========================================================================================================

	// Checks if point contains point
	template<typename T1, typename T2>
	inline constexpr bool contains(const olc::v2d_generic<T1>& p1, const olc::v2d_generic<T2>& p2)
	{
		return (p1 - p2).mag2() < epsilon;
	}

	// Checks if line contains point
	template<typename T1, typename T2>
	inline constexpr bool contains(const line<T1>& l, const olc::v2d_generic<T2>& p)
	{
		double d = ((p.x - l.start.x) * (l.end.y - l.start.y) - (p.y - l.start.y) * (l.end.x - l.start.x));
		if (std::abs(d) < epsilon)
		{
			// point is on line
			double u = l.vector().dot(p - l.start) / l.vector().mag2();
			return (u >= double(0.0) && u <= double(1.0));
		}

		return false;
	}

	// Checks if rectangle contains point
	template<typename T1, typename T2>
	inline constexpr bool contains(const rect<T1>& r, const olc::v2d_generic<T2>& p)
	{
		return !(p.x < r.pos.x || p.y < r.pos.y ||
			p.x > (r.pos.x + r.size.x) || p.y > (r.pos.y + r.size.y));
	}

	// Checks if ellipse contains a point
	template<typename T1, typename T2>
	inline constexpr bool contains(const ellipse<T1>& c, const olc::v2d_generic<T2>& p)
	{
		return std::pow(p.x-c.pos.x,2)/(c.radius.x*c.radius.x)+std::pow(p.y-c.pos.y,2)/(c.radius.y*c.radius.y)<1;
	}

	// Checks if circle contains a point
	template<typename T1, typename T2>
	inline constexpr bool contains(const circle<T1>& c, const olc::v2d_generic<T2>& p)
	{
		return (c.pos - p).mag2() < (c.radius * c.radius);
	}

	// Checks if triangle contains a point
	template<typename T1, typename T2>
	inline constexpr bool contains(const triangle<T1>& t, const olc::v2d_generic<T2>& p)
	{
		// http://jsfiddle.net/PerroAZUL/zdaY8/1/
		T2 A = T2(0.5) * (-t.pos[1].y * t.pos[2].x + t.pos[0].y * (-t.pos[1].x + t.pos[2].x) + t.pos[0].x * (t.pos[1].y - t.pos[2].y) + t.pos[1].x * t.pos[2].y);
		T2 sign = A < T2(0) ? T2(-1) : T2(1);
		T2 s = (t.pos[0].y * t.pos[2].x - t.pos[0].x * t.pos[2].y + (t.pos[2].y - t.pos[0].y) * p.x + (t.pos[0].x - t.pos[2].x) * p.y) * sign;
		T2 v = (t.pos[0].x * t.pos[1].y - t.pos[0].y * t.pos[1].x + (t.pos[0].y - t.pos[1].y) * p.x + (t.pos[1].x - t.pos[0].x) * p.y) * sign;
		return s > T2(0) && v > T2(0) && (s + v) < T2(2) * A * sign;
	}




	// Check if point overlaps with point (analagous to contains())
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const olc::v2d_generic<T1>& p1, const olc::v2d_generic<T2>& p2)
	{
		return contains(p1, p2);
	}

	// Checks if line segment overlaps with point
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const line<T1>& l, const olc::v2d_generic<T2>& p)
	{
		return contains(l, p);
	}

	// Checks if rectangle overlaps with point
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const rect<T1>& r, const olc::v2d_generic<T2>& p)
	{
		return contains(r, p);
	}

	// Checks if circle overlaps with point
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const circle<T1>& c, const olc::v2d_generic<T2>& p)
	{
		return contains(c, p);
	}

	// Checks if triangle overlaps with point
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const triangle<T1>& t, const olc::v2d_generic<T2>& p)
	{
		return contains(t, p);
	}




	// Get intersection points where point intersects with point
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const olc::v2d_generic<T1>& p1, const olc::v2d_generic<T2>& p2)
	{
		if (contains(p1, p2))
			return { p1 };
		else
			return {};
	}

	// Get intersection points where line segment intersects with point
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const line<T1>& l, const olc::v2d_generic<T2>& p)
	{
		if (contains(l, p))
			return { p };
		else
			return {};
	}

	// Get intersection points where rectangle intersects with point
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const rect<T1>& r, const olc::v2d_generic<T2>& p)
	{
		std::vector<olc::v2d_generic<T2>> vPoints;
		if (contains(r.top(), p)) vPoints.push_back(p);
		if (contains(r.bottom(), p)) vPoints.push_back(p);
		if (contains(r.left(), p)) vPoints.push_back(p);
		if (contains(r.right(), p)) vPoints.push_back(p);
		return vPoints;
	}

	// Get intersection points where circle intersects with point
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const circle<T1>& c, const olc::v2d_generic<T2>& p)
	{
		if (std::abs((p - c.pos).mag2() - (c.radius * c.radius)) <= epsilon)
			return { p };
		else
			return {};
	}

	// Get intersection points where triangle intersects with point
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const triangle<T1>& r, const olc::v2d_generic<T2>& p)
	{
		// TODO:
		return {};
	}












	// ================================================================================================================
	// LINE ===========================================================================================================

	// Check if point contains line segment
	template<typename T1, typename T2>
	inline constexpr bool contains(const olc::v2d_generic<T1>& p, const line<T2>& l)
	{
		return false; // It can't!
	}

	// Check if line segment contains line segment
	template<typename T1, typename T2>
	inline constexpr bool contains(const line<T1>& l1, const line<T2>& l2)
	{
		// TODO: Check if segments are colinear, and l1 exists within bounds of l2
		return false;
	}

	// Check if rectangle contains line segment
	template<typename T1, typename T2>
	inline constexpr bool contains(const rect<T1>& r, const line<T2>& l)
	{
		return contains(r, l.start) && contains(r, l.end);
	}

	// Check if circle contains line segment
	template<typename T1, typename T2>
	inline constexpr bool contains(const circle<T1>& c1, const line<T2>& l)
	{
		return contains(c1, l.start) && contains(c1, l.end);
	}

	// Check if triangle contains line segment
	template<typename T1, typename T2>
	inline constexpr bool contains(const triangle<T1>& t, const line<T2>& l)
	{
		return contains(t, l.start) && contains(t, l.end);
	}




	// Check if point overlaps line segment
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const olc::v2d_generic<T1>& p, const line<T2>& l)
	{
		return contains(l, p);
	}

	// Check if line segment overlaps line segment
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const line<T1>& l1, const line<T2>& l2)
	{
		float uA = ((l2.end.x-l2.start.x)*(l1.start.y-l2.start.y) - (l2.end.y-l2.start.y)*(l1.start.x-l2.start.x)) / ((l2.end.y-l2.start.y)*(l1.end.x-l1.start.x) - (l2.end.x-l2.start.x)*(l1.end.y-l1.start.y));
		float uB = ((l1.end.x-l1.start.x)*(l1.start.y-l2.start.y) - (l1.end.y-l1.start.y)*(l1.start.x-l2.start.x)) / ((l2.end.y-l2.start.y)*(l1.end.x-l1.start.x) - (l2.end.x-l2.start.x)*(l1.end.y-l1.start.y));
		return uA >= 0 && uA <= 1 && uB >= 0 && uB <= 1;
	}

	// Check if rectangle overlaps line segment
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const rect<T1>& r, const line<T2>& l)
	{
		return overlaps(r.left(),l)||
			overlaps(r.top(),l)||
			overlaps(r.bottom(),l)||
			overlaps(r.right(),l);
	}

	// Check if circle overlaps line segment
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const circle<T1>& c, const line<T2>& l)
	{
		// TODO:
		return false;
	}

	// Check if triangle overlaps line segment
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const triangle<T1>& t, const line<T2>& l)
	{
		return overlaps(t, l.start) || overlaps(t, l.end);

		// TODO: This method is no good, it cant detect lines whose start and end
		// points are outside the triangle
	}




	// Get intersection points where point intersects with line segment
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const olc::v2d_generic<T1>& p, const line<T2>& l)
	{
		// TODO:
		return {};
	}

	// Get intersection points where line segment intersects with line segment
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const line<T1>& l1, const line<T2>& l2)
	{
		float uA = ((l2.end.x-l2.start.x)*(l1.start.y-l2.start.y) - (l2.end.y-l2.start.y)*(l1.start.x-l2.start.x)) / ((l2.end.y-l2.start.y)*(l1.end.x-l1.start.x) - (l2.end.x-l2.start.x)*(l1.end.y-l1.start.y));
		float uB = ((l1.end.x-l1.start.x)*(l1.start.y-l2.start.y) - (l1.end.y-l1.start.y)*(l1.start.x-l2.start.x)) / ((l2.end.y-l2.start.y)*(l1.end.x-l1.start.x) - (l2.end.x-l2.start.x)*(l1.end.y-l1.start.y));

		if (uA >= 0 && uA <= 1 && uB >= 0 && uB <= 1) {
			float intersectionX = l1.start.x + (uA * (l1.end.x-l1.start.x));
			float intersectionY = l1.start.y + (uA * (l1.end.y-l1.start.y));
			return {{intersectionX,intersectionY}};
		}
		return {};
	}

	// Get intersection points where rectangle intersects with line segment
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const rect<T1>& r, const line<T2>& l)
	{
		std::vector<olc::v2d_generic<T2>>intersections;
		std::vector<olc::v2d_generic<T2>>result=intersects(r.left(),l);
		if(result.size()>0)intersections.push_back(result[0]);
		result=intersects(r.right(),l);
		if(result.size()>0)intersections.push_back(result[0]);
		result=intersects(r.top(),l);
		if(result.size()>0)intersections.push_back(result[0]);
		result=intersects(r.bottom(),l);
		if(result.size()>0)intersections.push_back(result[0]);
		return intersections;
	}

	// Get intersection points where circle intersects with line segment
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const circle<T1>& c, const line<T2>& l)
	{
		// TODO:
		return {};
	}

	// Get intersection points where triangle intersects with line segment
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const triangle<T1>& t, const line<T2>& l)
	{
		// TODO:
		return {};
	}












	// ================================================================================================================
	// RECTANGLE ======================================================================================================

	// Check if point contains rectangle
	template<typename T1, typename T2>
	inline constexpr bool contains(const olc::v2d_generic<T1>& p, const rect<T2>& r)
	{
		return false; // It can't!
	}

	// Check if line segment contains rectangle
	template<typename T1, typename T2>
	inline constexpr bool contains(const line<T1>& l, const rect<T2>& r)
	{
		return false; // It can't
	}

	// Check if rectangle contains rectangle
	template<typename T1, typename T2>
	inline constexpr bool contains(const rect<T1>& r1, const rect<T2>& r2)
	{
		return (r2.pos.x >= r1.pos.x) && (r2.pos.x + r2.size.x < r1.pos.x + r1.size.x) &&
			(r2.pos.y >= r1.pos.y) && (r2.pos.y + r2.size.y < r1.pos.y + r1.size.y);
	}

	// Check if circle contains rectangle
	template<typename T1, typename T2>
	inline constexpr bool contains(const circle<T1>& c, const rect<T2>& r)
	{
		return contains(c, r.pos) 
			&& contains(c, olc::v2d_generic<T2>{ r.pos.x + r.size.x, r.pos.y })
			&& contains(c, olc::v2d_generic<T2>{ r.pos.x, r.pos.y + r.size.y })
			&& contains(c, r.pos + r.size);
	}

	// Check if triangle contains rectangle
	template<typename T1, typename T2>
	inline constexpr bool contains(const triangle<T1>& t, const rect<T2>& r)
	{
		return contains(t, r.pos) 
			&& contains(t, r.pos + r.size)
			&& contains(t, olc::v2d_generic<T2>{ r.pos.x + r.size.x,r.pos.y })
			&& contains(t, olc::v2d_generic<T2>{ r.pos.x, r.pos.y + r.size.y });
	}




	// Check if point overlaps rectangle
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const olc::v2d_generic<T1>& p, const rect<T2>& r)
	{
		return overlaps(r, p);
	}

	// Check if line segment overlaps rectangle
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const line<T1>& l, const rect<T2>& r)
	{
		return overlaps(r, l);
	}

	// Check if rectangle overlaps rectangle
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const rect<T1>& r1, const rect<T2>& r2)
	{
		return (r1.pos.x < r2.pos.x + r2.size.x && r1.pos.x + r1.size.x >= r2.pos.x &&
			r1.pos.y < r2.pos.y + r2.size.y && r1.pos.y + r1.size.y >= r2.pos.y);
	}

	// Check if circle overlaps rectangle
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const circle<T1>& c, const rect<T2>& r)
	{
		// Inspired by this (very clever btw) 
		// https://stackoverflow.com/questions/45370692/circle-rectangle-collision-response
		// But modified to work :P
		T2 overlap = (olc::v2d_generic<T2>{ std::clamp(c.pos.x, r.pos.x, r.pos.x + r.size.x), std::clamp(c.pos.y, r.pos.y, r.pos.y + r.size.y) } - c.pos).mag2();
		if (std::isnan(overlap)) overlap = T2(0);
		return (overlap - (c.radius * c.radius)) < T2(0);
	}

	// Check if triangle overlaps rectangle
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const triangle<T1>& t, const rect<T2>& r)
	{
		return contains(t, r.pos) 
			|| contains(t, r.pos + r.size)
			|| contains(t, olc::v2d_generic<T2>{ r.pos.x + r.size.x, r.pos.y }) 
			|| contains(t, olc::v2d_generic<T2>{ r.pos.x, r.pos.y + r.size.y });

		// TODO: This method is no good, consider rectangle with all vertices
		// outside of triangle, but edges still crossing
	}




	// Get intersection points where point intersects with rectangle
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const olc::v2d_generic<T1>& p, const rect<T2>& r)
	{
		return intersects(r, p);
	}

	// Get intersection points where line segment intersects with rectangle
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const line<T1>& l, const rect<T2>& r)
	{
		return intersects(r,l);
	}

	// Get intersection points where rectangle intersects with rectangle
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const rect<T1>& r1, const rect<T2>& r2)
	{
		// TODO:
		return {};
	}

	// Get intersection points where circle intersects with rectangle
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const circle<T1>& c, const rect<T2>& r)
	{
		// TODO:
		return {};
	}

	// Get intersection points where triangle intersects with rectangle
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const triangle<T1>& t, const rect<T2>& r)
	{
		// TODO:
		return {};
	}













	// ================================================================================================================
	// CIRCLE =========================================================================================================

	// Check if point contains circle
	template<typename T1, typename T2>
	inline constexpr bool contains(const olc::v2d_generic<T1>& p, const circle<T2>& c)
	{
		return false; // It can't!
	}

	// Check if line segment contains circle
	template<typename T1, typename T2>
	inline constexpr bool contains(const line<T1>& l, const circle<T2>& c)
	{
		return false; // It can't!
	}

	// Check if rectangle contains circle
	template<typename T1, typename T2>
	inline constexpr bool contains(const rect<T1>& r, const circle<T2>& c)
	{
		// TODO:
		return false;
	}

	// Check if circle contains circle
	template<typename T1, typename T2>
	inline constexpr bool contains(const circle<T1>& c1, const circle<T2>& c2)
	{
		return (c1.pos - c2.pos).mag2() <= (c1.radius - c2.radius) * (c1.radius - c2.radius);
	}

	// Check if triangle contains circle
	template<typename T1, typename T2>
	inline constexpr bool contains(const triangle<T1>& t, const circle<T2>& c)
	{
		// TODO:
		return false;
	}




	// Check if point overlaps circle
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const olc::v2d_generic<T1>& p, const circle<T2>& c)
	{
		return overlaps(c, p);
	}

	// Check if line segment overlaps circle
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const line<T1>& l, const circle<T2>& c)
	{
		return overlaps(c, l);
	}

	// Check if rectangle overlaps circle
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const rect<T1>& r, const circle<T2>& c)
	{
		return overlaps(c, r);
	}

	// Check if circle overlaps circle
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const circle<T1>& c1, const circle<T2>& c2)
	{
		return (c1.pos - c2.pos).mag2() <= (c1.radius + c2.radius) * (c1.radius + c2.radius);
	}

	// Check if triangle overlaps circle
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const triangle<T1>& t, const circle<T2>& c)
	{
		// TODO:
		return false;
	}




	// Get intersection points where point intersects with circle
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const olc::v2d_generic<T1>& p, const circle<T2>& c)
	{
		// TODO:
		return {};
	}

	// Get intersection points where line segment intersects with circle
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const line<T1>& l, const circle<T2>& c)
	{
		// TODO:
		return {};
	}

	// Get intersection points where rectangle intersects with circle
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const rect<T1>& r, const circle<T2>& c)
	{
		// TODO:
		return {};
	}

	// Get intersection points where circle intersects with circle
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const circle<T1>& c1, const circle<T2>& c2)
	{
		// TODO:
		return {};
	}

	// Get intersection points where triangle intersects with circle
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const triangle<T1>& t, const circle<T2>& c)
	{
		// TODO:
		return {};
	}













	// ================================================================================================================
	// TRIANGLE =======================================================================================================

	// Check if point contains triangle
	template<typename T1, typename T2>
	inline constexpr bool contains(const olc::v2d_generic<T1>& p, const triangle<T2>& t)
	{
		return false; // It can't!
	}

	// Check if line segment contains triangle
	template<typename T1, typename T2>
	inline constexpr bool contains(const line<T1>& l, const triangle<T2>& t)
	{
		return false; // It can't
	}

	// Check if rectangle contains triangle
	template<typename T1, typename T2>
	inline constexpr bool contains(const rect<T1>& r, const triangle<T2>& t)
	{
		// TODO:
		return false;
	}

	// Check if circle contains triangle
	template<typename T1, typename T2>
	inline constexpr bool contains(const circle<T1>& c, const triangle<T2>& t)
	{
		// TODO:
		return false;
	}

	// Check if triangle contains triangle
	template<typename T1, typename T2>
	inline constexpr bool contains(const triangle<T1>& t1, const triangle<T2>& t2)
	{
		// TODO:
		return false;
	}




	// Check if point overlaps triangle
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const olc::v2d_generic<T1>& p, const triangle<T2>& t)
	{
		return overlaps(t, p);
	}

	// Check if line segment overlaps triangle
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const line<T1>& l, const triangle<T2>& t)
	{
		return overlaps(t, l);
	}

	// Check if rectangle overlaps triangle
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const rect<T1>& r, const triangle<T2>& t)
	{
		return overlaps(t, r);
	}

	// Check if circle overlaps triangle
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const circle<T1>& c, const triangle<T2>& t)
	{
		return overlaps(t, c);
	}

	// Check if triangle overlaps triangle
	template<typename T1, typename T2>
	inline constexpr bool overlaps(const triangle<T1>& t1, const triangle<T2>& t2)
	{
		// TODO:
		return false;
	}




	// Get intersection points where point intersects with triangle
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const olc::v2d_generic<T1>& p, const triangle<T2>& t)
	{
		// TODO:
		return {};
	}

	// Get intersection points where line segment intersects with triangle
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const line<T1>& l, const triangle<T2>& t)
	{
		// TODO:
		return {};
	}

	// Get intersection points where rectangle intersects with triangle
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const rect<T1>& r, const triangle<T2>& t)
	{
		// TODO:
		return {};
	}

	// Get intersection points where circle intersects with triangle
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const circle<T1>& c, const triangle<T2>& t)
	{
		// TODO:
		return {};
	}

	// Get intersection points where triangle intersects with triangle
	template<typename T1, typename T2>
	inline std::vector<olc::v2d_generic<T2>> intersects(const triangle<T1>& t1, const triangle<T2>& t2)
	{
		// TODO:
		return {};
	}

}

using namespace olc::utils;