/* OneLoneCoder - Geometry 2D v2.0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ A collection of 2D Geometric primitives and functions to work with and between them. License (OLC-3) ~~~~~~~~~~~~~~~ Copyright 2018 - 2024 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 Authors ~~~~~~~ David Barr, aka javidx9, (c) OneLoneCoder 2019, 2020, 2021, 2022,© 2024, 2024 With significant contributions from: Piratux, Gusgo99, Gorbit99, MaGetzUb, Dandistine, Moros1138 cstdint, sigonasr, bixxy, Qwerasd, starfreakclone, fux Changes: v1.01: +Made constants inline +Header guards (lol... sigh...) v2.0: +Major file contribution and restructuring */ /* What Is This? ~~~~~~~~~~~~~ I've worked with 2D stuff for decades and I'm tired of reapeatedly researching, deriving and implementing geometric analysis routines, so wanted a "one-stop-shop" to collate all these mathematics. You don't even need olc::PixelGameEngine, this file will run as a standalone 2D vector/geometry utility. As well as a robust 2D Vector implementation, this file offers definitions of the following shapes: point - A 2D (x,y) vector from (0,0) line - A line segment defined by a start and end point circle - A circle defined by a middle point and a radius rectangle - An axis aligned quad defined by a top left point, and a size triangle - A triangle defined by 3 points ray - A special case "line" with an origin and a direction Functions have been provided that yield useful analyses for almost every combination of shapes. The function groups all have the same names, and are differentiated via argument type: point closest(a, b) Returns closest point on Shape A to Shape B bool overlaps(a, b) Returns true if any part of Shape A overlaps any part of Shape B, including boundaries bool contains(a, b) Returns true if Shape A wholly contains Shape B within and including it's boundary vector intersects(a, b) Returns a vector of points where Shape A boundary intersects with Shape B boundary optional project(a, b, ray) Projects Shape A along a ray, until and if it contacts shape B. If it never contacts then nothing is returned. If it does contact the closest position Shape A can be to Shape B is returned without the shapes overlapping rect envelope_r(a) / bounding_box(a) Returns the minimum area rectangle that fully encompasses Shape A rect envelope_c(a) / bounding_circle(a) Returns the minimum area circle that fully encompasses Shape A ray reflect(ray, a) Returns a ray that is a reflection of supplied incident ray against Shape A optional collision(ray, a) Returns the point and normal where a ray collides with Shape A */ /* Quick Navigation ~~~~~~~~~~~~~~~~ To jump to an implementation quickly, use your editor to search in the following way: f(a, b) where: f = overlaps, intersects, contains, closest, envelope_r, envelope_b, reflects, collision a = p, l, r, c, t, q, pol (point, line, rect, circ, triangle, ray, polygon) example: "contains(r,c)" - takes you to implementation for contains(rect, circ) - Does the rectangle contain the circle? */ /* Function Matrix - Function(A, B) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ A B>| POINT | LINE | RECT | CIRCLE | TRIANGLE | RAY | ---------+--------------+--------------+--------------+--------------+--------------+--------------+ POINT | contains | contains | contains | contains | contains | | | closest | closest | closest | closest | closest | closest | | overlaps | overlaps | overlaps | overlaps | overlaps | | | intersects | intersects | intersects | intersects | intersects | | | | | | | | | ---------+--------------+--------------+--------------+--------------+--------------+--------------+ LINE | contains | contains | contains | contains | contains | | | closest | | | closest | | | | overlaps | overlaps | overlaps | overlaps | overlaps | | | intersects | intersects | intersects | intersects | intersects | | | | | | | | | ---------+--------------+--------------+--------------+--------------+--------------+--------------+ RECT | contains | contains | contains | contains | contains | | | closest | | | | | | | overlaps | overlaps | overlaps | overlaps | overlaps | | | intersects | intersects | intersects | intersects | intersects | | | | | | | | | ---------+--------------+--------------+--------------+--------------+--------------+--------------+ CIRCLE | contains | contains | contains | contains | contains | | | closest | closest | | | | | | overlaps | overlaps | overlaps | overlaps | overlaps | | | intersects | intersects | intersects | intersects | intersects | | | project | project | | project | | | ---------+--------------+--------------+--------------+--------------+--------------+--------------+ TRIANGLE | contains | contains | contains | contains | contains | | | closest | | | | | | | overlaps | overlaps | overlaps | overlaps | overlaps | | | intersects | intersects | intersects | intersects | intersects | | | | | | | | | ---------+--------------+--------------+--------------+--------------+--------------+--------------+ RAY | | | | | | | | | | | | | | | | collision | collision | collision | collision | collision* | | | intersects | intersects | intersects | intersects | intersects | | | reflect | reflect | reflect | reflect | reflect* | ---------+--------------+--------------+--------------+--------------+--------------+--------------+ * Exists but always fails */ #pragma once #include #include #include #include #include #include #include #ifndef OLC_V2D_TYPE #define OLC_V2D_TYPE namespace olc { /* A complete 2D geometric vector structure, with a variety of useful utility functions and operator overloads */ template struct v_2d { static_assert(std::is_arithmetic::value, "olc::v_2d must be numeric"); // x-axis component T x = 0; // y-axis component T y = 0; // Default constructor inline constexpr v_2d() = default; // Specific constructor inline constexpr v_2d(T _x, T _y) : x(_x), y(_y) {} // Copy constructor inline constexpr v_2d(const v_2d& v) = default; // Assignment operator inline constexpr v_2d& operator=(const v_2d& v) = default; // Returns rectangular area of vector inline constexpr auto area() const { return x * y; } // Returns magnitude of vector inline auto mag() const { return std::sqrt(x * x + y * y); } // Returns magnitude squared of vector (useful for fast comparisons) inline constexpr T mag2() const { return x * x + y * y; } // Returns normalised version of vector inline v_2d norm() const { auto r = 1 / mag(); return v_2d(x * r, y * r); } // Returns vector at 90 degrees to this one inline constexpr v_2d perp() const { return v_2d(-y, x); } // Rounds both components down inline constexpr v_2d floor() const { return v_2d(std::floor(x), std::floor(y)); } // Rounds both components up inline constexpr v_2d ceil() const { return v_2d(std::ceil(x), std::ceil(y)); } // Returns 'element-wise' max of this and another vector inline constexpr v_2d max(const v_2d& v) const { return v_2d(std::max(x, v.x), std::max(y, v.y)); } // Returns 'element-wise' min of this and another vector inline constexpr v_2d min(const v_2d& v) const { return v_2d(std::min(x, v.x), std::min(y, v.y)); } // Calculates scalar dot product between this and another vector inline constexpr auto dot(const v_2d& rhs) const { return this->x * rhs.x + this->y * rhs.y; } // Calculates 'scalar' cross product between this and another vector (useful for winding orders) inline constexpr auto cross(const v_2d& rhs) const { return this->x * rhs.y - this->y * rhs.x; } // Treat this as polar coordinate (R, Theta), return cartesian equivalent (X, Y) inline constexpr v_2d cart() const { return v_2d(std::cos(y) * x, std::sin(y) * x); } // Treat this as cartesian coordinate (X, Y), return polar equivalent (R, Theta) inline constexpr v_2d polar() const { return v_2d(mag(), std::atan2(y, x)); } // Clamp the components of this vector in between the 'element-wise' minimum and maximum of 2 other vectors inline constexpr v_2d clamp(const v_2d& v1, const v_2d& v2) const { return this->max(v1).min(v2); } // Linearly interpolate between this vector, and another vector, given normalised parameter 't' inline constexpr v_2d lerp(const v_2d& v1, const double t) const { return (*this) * (T(1.0 - t)) + (v1 * T(t)); } // Compare if this vector is numerically equal to another inline constexpr bool operator == (const v_2d& rhs) const { return (this->x == rhs.x && this->y == rhs.y); } // Compare if this vector is not numerically equal to another inline constexpr bool operator != (const v_2d& rhs) const { return (this->x != rhs.x || this->y != rhs.y); } // Return this vector as a std::string, of the form "(x,y)" inline constexpr std::string str() const { return std::string("(") + std::to_string(this->x) + "," + std::to_string(this->y) + ")"; } // Assuming this vector is incident, given a normal, return the reflection inline constexpr v_2d reflect(const v_2d& n) const { return (*this) - 2.0 * (this->dot(n) * n); } // Allow 'casting' from other v_2d types template inline constexpr operator v_2d() const { return { static_cast(this->x), static_cast(this->y) }; } }; // Multiplication operator overloads between vectors and scalars, and vectors and vectors template inline constexpr auto operator * (const TL& lhs, const v_2d& rhs) { return v_2d(lhs * rhs.x, lhs * rhs.y); } template inline constexpr auto operator * (const v_2d& lhs, const TR& rhs) { return v_2d(lhs.x * rhs, lhs.y * rhs); } template inline constexpr auto operator * (const v_2d& lhs, const v_2d& rhs) { return v_2d(lhs.x * rhs.x, lhs.y * rhs.y); } template inline constexpr auto operator *= (v_2d& lhs, const TR& rhs) { lhs = lhs * rhs; return lhs; } // Division operator overloads between vectors and scalars, and vectors and vectors template inline constexpr auto operator / (const TL& lhs, const v_2d& rhs) { return v_2d(lhs / rhs.x, lhs / rhs.y); } template inline constexpr auto operator / (const v_2d& lhs, const TR& rhs) { return v_2d(lhs.x / rhs, lhs.y / rhs); } template inline constexpr auto operator / (const v_2d& lhs, const v_2d& rhs) { return v_2d(lhs.x / rhs.x, lhs.y / rhs.y); } template inline constexpr auto operator /= (v_2d& lhs, const TR& rhs) { lhs = lhs / rhs; return lhs; } // Unary Addition operator (pointless but i like the platinum trophies) template inline constexpr auto operator + (const v_2d& lhs) { return v_2d(+lhs.x, +lhs.y); } // Addition operator overloads between vectors and scalars, and vectors and vectors template inline constexpr auto operator + (const TL& lhs, const v_2d& rhs) { return v_2d(lhs + rhs.x, lhs + rhs.y); } template inline constexpr auto operator + (const v_2d& lhs, const TR& rhs) { return v_2d(lhs.x + rhs, lhs.y + rhs); } template inline constexpr auto operator + (const v_2d& lhs, const v_2d& rhs) { return v_2d(lhs.x + rhs.x, lhs.y + rhs.y); } template inline constexpr auto operator += (v_2d& lhs, const TR& rhs) { lhs = lhs + rhs; return lhs; } template inline constexpr auto operator += (v_2d& lhs, const v_2d& rhs) { lhs = lhs + rhs; return lhs; } // Unary negation operator overoad for inverting a vector template inline constexpr auto operator - (const v_2d& lhs) { return v_2d(-lhs.x, -lhs.y); } // Subtraction operator overloads between vectors and scalars, and vectors and vectors template inline constexpr auto operator - (const TL& lhs, const v_2d& rhs) { return v_2d(lhs - rhs.x, lhs - rhs.y); } template inline constexpr auto operator - (const v_2d& lhs, const TR& rhs) { return v_2d(lhs.x - rhs, lhs.y - rhs); } template inline constexpr auto operator - (const v_2d& lhs, const v_2d& rhs) { return v_2d(lhs.x - rhs.x, lhs.y - rhs.y); } template inline constexpr auto operator -= (v_2d& lhs, const TR& rhs) { lhs = lhs - rhs; return lhs; } // Greater/Less-Than Operator overloads - mathematically useless, but handy for "sorted" container storage template inline constexpr bool operator < (const v_2d& lhs, const v_2d& rhs) { return (lhs.y < rhs.y) || (lhs.y == rhs.y && lhs.x < rhs.x); } template inline constexpr bool operator > (const v_2d& lhs, const v_2d& rhs) { return (lhs.y > rhs.y) || (lhs.y == rhs.y && lhs.x > rhs.x); } // Allow olc::v_2d to play nicely with std::cout template inline constexpr std::ostream& operator << (std::ostream& os, const v_2d& rhs) { os << rhs.str(); return os; } // Convenient types ready-to-go typedef v_2d vi2d; typedef v_2d vu2d; typedef v_2d vf2d; typedef v_2d vd2d; } #else #include "olcPixelGameEngine.h" #endif namespace olc::utils::geom2d { // Lemon Meringue inline const double pi = 3.141592653589793238462643383279502884; // Floating point error margin inline const double epsilon = 0.001; namespace internal { template inline std::vector> filter_duplicate_points(const std::vector>& points) { std::vector> filtered_points; for (const auto& point : points) { bool is_duplicate = false; for (const auto& filtered_point : filtered_points) { if (std::abs(point.x - filtered_point.x) < epsilon && std::abs(point.y - filtered_point.y) < epsilon) { is_duplicate = true; break; } } if (!is_duplicate) { filtered_points.push_back(point); } } return filtered_points; } }; //https://stackoverflow.com/questions/1903954/is-there-a-standard-sign-function-signum-sgn-in-c-c template constexpr int sgn(T val) { return (T(0) < val) - (val < T(0)); } // Defines a line segment template struct line { olc::v_2d start; olc::v_2d end; inline line(const olc::v_2d& s = { T(0), T(0) }, const olc::v_2d& e = { T(0), T(0) }) : start(s), end(e) { } // Get vector pointing from start to end inline constexpr olc::v_2d vector()const { return (end - start); } // Get length of line inline constexpr T length()const { return vector().mag(); } // Get length of line^2 inline constexpr T length2()const { return vector().mag2(); } // Given a real distance, get point along line inline constexpr olc::v_2d rpoint(const T& distance) const { if(abs(distance)<0.01f){ return start; }else{ return start + vector().norm() * distance; } } // Given a unit distance, get point along line inline constexpr olc::v_2d upoint(const T& distance) const { return start + vector() * distance; } // Return which side of the line does a point lie inline constexpr int32_t side(const olc::v_2d& point) const { double d = vector().cross(point - start); if (d < 0) return -1; else if (d > 0) return 1; else return 0; } // Returns line equation "mx + a" coefficients where: // x: m // y: a // NOTE: Returns {inf, inf} if std::abs(end.x - start.x) < epsilon: inline constexpr olc::vd2d coefficients() const { double x1 = start.x; double x2 = end.x; double y1 = start.y; double y2 = end.y; // check if line is vertical or close to vertical if (std::abs(x2 - x1) < epsilon) { return olc::vd2d{ std::numeric_limits::infinity(), std::numeric_limits::infinity() }; } double m = (y2 - y1) / (x2 - x1); return olc::vd2d {m, -m * x1 + y1}; } }; template struct ray { olc::v_2d origin; olc::v_2d direction; inline ray(const olc::v_2d& o = { T(0), T(0) }, const olc::v_2d& d = { T(0), T(0) }) : origin(o), direction(d) { } }; template struct rect { olc::v_2d pos; olc::v_2d size; inline rect(const olc::v_2d& p = { T(0), T(0) }, const olc::v_2d& s = { T(1), T(1) }) : pos(p), size(s) { } inline olc::v_2d middle() const { return pos + (size * double(0.5)); } // Get line segment from top side of rectangle inline line top() const { return { pos, {pos.x + size.x, pos.y } }; } // Get line segment from bottom side of rectangle inline line bottom() const { return { {pos.x, pos.y + size.y}, pos + size }; } // Get line segment from left side of rectangle inline line left() const { return { pos, {pos.x, pos.y + size.y} }; } // Get line segment from right side of rectangle inline line right() const { return { {pos.x + size.x, pos.y }, pos + size }; } // Get a line from an indexed side, starting top, going clockwise inline line 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(); // Dumb compilers cant fathom this 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); } // Returns side count: 4 inline constexpr size_t side_count() const { return 4; } }; template struct circle { olc::v_2d pos; T radius = T(0); inline circle(const olc::v_2d& 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 struct triangle { std::array, 3> pos; inline triangle( const olc::v_2d& p0 = { T(0), T(0) }, const olc::v_2d& p1 = { T(0), T(0) }, const olc::v_2d& p2 = { T(0), T(0) }) : pos{ p0,p1,p2 } { } // Get a line from an indexed side, starting top, going clockwise inline line 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(); } // Returns side count: 3 inline constexpr size_t side_count() const { return 3; } }; template struct polygon { std::vector> pos; }; // ========================================================================================================================= // Closest(shape, point) =================================================================================================== // Closest location on [SHAPE] to Point // closest(p,p) // Returns closest point on point to any shape (aka the original point) :P template inline olc::v_2d closest(const olc::v_2d& p, [[maybe_unused]] const T2& anything_who_cares) { return p; } // closest(l,p) // Returns closest point on line to point template inline olc::v_2d closest(const line& l, const olc::v_2d& 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; } // closest(c,p) // Returns closest point on circle to point template inline olc::v_2d closest(const circle& c, const olc::v_2d& p) { return c.pos + olc::vd2d(p - c.pos).norm() * c.radius; } // closest(r,p) // Returns closest point on rectangle to point template inline olc::v_2d closest(const rect& r, const olc::v_2d& p) { // Note: this algorithm can be reused for polygon auto c1 = closest(r.top(), p); auto c2 = closest(r.bottom(), p); auto c3 = closest(r.left(), p); auto c4 = closest(r.right(), p); auto d1 = (c1 - p).mag2(); auto d2 = (c2 - p).mag2(); auto d3 = (c3 - p).mag2(); auto d4 = (c4 - p).mag2(); auto dmin = d1; auto cmin = c1; if (d2 < dmin) { dmin = d2; cmin = c2; } if (d3 < dmin) { dmin = d3; cmin = c3; } if (d4 < dmin) { dmin = d4; cmin = c4; } return cmin; } // closest(t,p) // Returns closest point on triangle to point template inline olc::v_2d closest(const triangle& t, const olc::v_2d& p) { olc::utils::geom2d::line 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; } } // Closest location on [SHAPE] to Line // closest(l,l) // Returns closest point on line to line template inline olc::v_2d closest(const line& l1, const line& l2) { // TODO: return {}; } // closest(r,l) // Returns closest point on rectangle to line template inline olc::v_2d closest(const rect& r, const line& l) { // TODO: return {}; } // closest(c,l) // Returns closest point on circle to line template inline olc::v_2d closest(const circle& c, const line& l) { const auto p1 = closest(l, c.pos); return c.pos + olc::vd2d(p1 - c.pos).norm() * c.radius; } // closest(t,l) // Returns closest point on triangle to line template inline olc::v_2d closest(const triangle& t, const line& l) { // TODO: return {}; } // Closest location on [SHAPE] to Circle // closest(l,c) // Returns closest point on line to circle template inline olc::v_2d closest(const line& l, const circle& c) { const auto p1 = closest(c, l); // Closest point on circle to line return closest(l, p1); } // closest(r,c) // Returns closest point on rectangle to circle template inline olc::v_2d closest(const rect& r, const circle& l) { // TODO: return {}; } // closest(c,c) // Returns closest point on circle to circle template inline olc::v_2d closest(const circle& c, const circle& l) { // TODO: return {}; } // closest(t,c) // Returns closest point on triangle to circle template inline olc::v_2d closest(const triangle& r, const circle& l) { // TODO: return {}; } // Closest location on [SHAPE] to Triangle // closest(l,t) // Returns closest point on line to triangle template inline olc::v_2d closest(const line& l, const triangle& c) { // TODO: return {}; } // closest(r,t) // Returns closest point on rectangle to triangle template inline olc::v_2d closest(const rect& r, const triangle& l) { // TODO: return {}; } // closest(c,t) // Returns closest point on circle to triangle template inline olc::v_2d closest(const circle& c, const triangle& l) { // TODO: return {}; } // closest(t,t) // Returns closest point on triangle to triangle template inline olc::v_2d closest(const triangle& r, const triangle& l) { // TODO: return {}; } // ================================================================================================================ // POINT ========================================================================================================== // contains(p,p) // Checks if point contains point template inline constexpr bool contains(const olc::v_2d& p1, const olc::v_2d& p2) { return (p1 - p2).mag2() < epsilon; } // contains(l,p) // Checks if line contains point template inline constexpr bool contains(const line& l, const olc::v_2d& 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; } // contains(r,p) // Checks if rectangle contains point template inline constexpr bool contains(const rect& r, const olc::v_2d& 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)); } // contains(c,p) // Checks if circle contains a point template inline constexpr bool contains(const circle& c, const olc::v_2d& p) { return (c.pos - p).mag2() <= (c.radius * c.radius); } // contains(t,p) // Checks if triangle contains a point template inline constexpr bool contains(const triangle& t, const olc::v_2d& 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; } // overlaps(p,p) // Check if point overlaps with point (analagous to contains()) template inline constexpr bool overlaps(const olc::v_2d& p1, const olc::v_2d& p2) { return contains(p1, p2); } // overlaps(l,p) // Checks if line segment overlaps with point template inline constexpr bool overlaps(const line& l, const olc::v_2d& p) { return contains(l, p); } // overlaps(r,p) // Checks if rectangle overlaps with point template inline constexpr bool overlaps(const rect& r, const olc::v_2d& p) { return contains(r, p); } // overlaps(c,p) // Checks if circle overlaps with point template inline constexpr bool overlaps(const circle& c, const olc::v_2d& p) { return contains(c, p); } // overlaps(t,p) // Checks if triangle overlaps with point template inline constexpr bool overlaps(const triangle& t, const olc::v_2d& p) { return contains(t, p); } // intersects(p,p) // Get intersection points where point intersects with point template inline std::vector> intersects(const olc::v_2d& p1, const olc::v_2d& p2) { if (contains(p1, p2)) return { p1 }; return {}; } // intersects(l,p) // Get intersection points where line segment intersects with point template inline std::vector> intersects(const line& l, const olc::v_2d& p) { if (contains(l, p)) return { p }; return {}; } // intersects(r,p) // Get intersection points where rectangle intersects with point template inline std::vector> intersects(const rect& r, const olc::v_2d& p) { for (size_t i = 0; i < r.side_count(); i++) if (contains(r.side(i), p)) return { p }; return {}; } // intersects(c,p) // Get intersection points where circle intersects with point template inline std::vector> intersects(const circle& c, const olc::v_2d& p) { if (std::abs((p - c.pos).mag2() - (c.radius * c.radius)) <= epsilon) return { p }; return {}; } // intersects(t,p) // Get intersection points where triangle intersects with point template inline std::vector> intersects(const triangle& t, const olc::v_2d& p) { for (size_t i = 0; i < t.side_count(); i++) if (contains(t.side(i), p)) return { p }; return {}; } // ================================================================================================================ // LINE =========================================================================================================== // contains(p,l) // Check if point contains line segment template inline constexpr bool contains([[maybe_unused]] const olc::v_2d& p, [[maybe_unused]] const line& l) { return false; // It can't! } // contains(l,l) // Check if line segment contains line segment template inline constexpr bool contains(const line& l1, const line& l2) { return overlaps(l1, l2.start) && overlaps(l1, l2.end); } // contains(r,l) // Check if rectangle contains line segment template inline constexpr bool contains(const rect& r, const line& l) { return contains(r, l.start) && contains(r, l.end); } // contains(c,l) // Check if circle contains line segment template inline constexpr bool contains(const circle& c1, const line& l) { return contains(c1, l.start) && contains(c1, l.end); } // contains(t,l) // Check if triangle contains line segment template inline constexpr bool contains(const triangle& t, const line& l) { return contains(t, l.start) && contains(t, l.end); } // overlaps(p,l) // Check if point overlaps line segment template inline constexpr bool overlaps(const olc::v_2d& p, const line& l) { return contains(l, p); } // overlaps(l,l) // Check if line segment overlaps line segment template inline constexpr bool overlaps(const line& l1, const line& l2) { double D = ((l2.end.y - l2.start.y) * (l1.end.x - l1.start.x) - (l2.end.x - l2.start.x) * (l1.end.y - l1.start.y)); double 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)) / D; double 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)) / D; return uA >= 0 && uA <= 1 && uB >= 0 && uB <= 1; } // overlaps(r,l) // Check if rectangle overlaps line segment template inline constexpr bool overlaps(const rect& r, const line& l) { return contains(r, l.start) || overlaps(r.top(), l) || overlaps(r.bottom(), l) || overlaps(r.left(), l) || overlaps(r.right(), l); } // overlaps(c,l) // Check if circle overlaps line segment template inline constexpr bool overlaps(const circle& c, const line& l) { auto vClosest = closest(l, c.pos); return ((c.pos - vClosest).mag2() <= (c.radius * c.radius)); } // overlaps(t,l) // Check if triangle overlaps line segment template inline constexpr bool overlaps(const triangle& t, const line& l) { return overlaps(t, l.start) || overlaps(t.side(0), l) || overlaps(t.side(1), l) || overlaps(t.side(2), l); } // intersects(p,l) // Get intersection points where point intersects with line segment template inline std::vector> intersects(const olc::v_2d& p, const line& l) { return intersects(l, p); } // intersects(l,l) // Get intersection points where line segment intersects with line segment template inline std::vector> intersects(const line& l1, const line& l2) { float rd = l1.vector().cross(l2.vector()); if (rd == 0) return {}; // Parallel or Colinear TODO: Return two points //Inverse rd product rd = 1.f / rd; //Cross products: //rn = (b1b2 x b1a1) float rn = ((l2.end.x - l2.start.x) * (l1.start.y - l2.start.y) - (l2.end.y - l2.start.y) * (l1.start.x - l2.start.x)) * rd; //sn = (a1a2 x b1a1) float sn = ((l1.end.x - l1.start.x) * (l1.start.y - l2.start.y) - (l1.end.y - l1.start.y) * (l1.start.x - l2.start.x)) * rd; //Return the intersection depth //if (d) *d = rn; if (rn < 0.f || rn > 1.f || sn < 0.f || sn > 1.f) return {}; // Intersection not within line segment return { l1.start + rn * l1.vector()}; } // intersects(r,l) // Get intersection points where rectangle intersects with line segment template inline std::vector> intersects(const rect& r, const line& l) { std::vector> intersections; for (size_t i = 0; i < r.side_count(); i++) { auto v = intersects(r.side(i), l); intersections.insert(intersections.end(), v.begin(), v.end()); } return internal::filter_duplicate_points(intersections); } // intersects(c,l) // Get intersection points where circle intersects with line segment template inline std::vector> intersects(const circle& c, const line& l) { const auto closestPointToSegment = closest(l, c.pos); if (!overlaps(c, closestPointToSegment)) { // Circle is too far away return {}; } // Compute point closest to the circle on the line const auto d = l.vector(); const auto uLine = d.dot(c.pos - l.start) / d.mag2(); const auto closestPointToLine = l.start + uLine * d; const auto distToLine = (c.pos - closestPointToLine).mag2(); if (std::abs(distToLine - c.radius * c.radius) < epsilon) { // Circle "kisses" the line return { closestPointToLine }; } // Circle intersects the line const auto length = std::sqrt(c.radius * c.radius - distToLine); const auto p1 = closestPointToLine + l.vector().norm() * length; const auto p2 = closestPointToLine - l.vector().norm() * length; std::vector> intersections; intersections.reserve(2); if ((p1 - closest(l, p1)).mag2() < epsilon * epsilon) intersections.push_back(p1); if ((p2 - closest(l, p2)).mag2() < epsilon * epsilon) intersections.push_back(p2); return internal::filter_duplicate_points(intersections); } // intersects(t,l) // Get intersection points where triangle intersects with line segment template inline std::vector> intersects(const triangle& t, const line& l) { std::vector> intersections; for (size_t i = 0; i < t.side_count(); i++) { auto v = intersects(t.side(i), l); intersections.insert(intersections.end(), v.begin(), v.end()); } return internal::filter_duplicate_points(intersections); } // ================================================================================================================ // RECTANGLE ====================================================================================================== // contains(p,r) // Check if point contains rectangle template inline constexpr bool contains([[maybe_unused]] const olc::v_2d& p, [[maybe_unused]] const rect& r) { return false; // It can't! } // contains(l,r) // Check if line segment contains rectangle template inline constexpr bool contains([[maybe_unused]] const line& l, [[maybe_unused]] const rect& r) { return false; // It can't } // contains(r,r) // Check if rectangle contains rectangle template inline constexpr bool contains(const rect& r1, const rect& 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); } // contains(c,r) // Check if circle contains rectangle template inline constexpr bool contains(const circle& c, const rect& r) { return contains(c, r.pos) && contains(c, olc::v_2d{ r.pos.x + r.size.x, r.pos.y }) && contains(c, olc::v_2d{ r.pos.x, r.pos.y + r.size.y }) && contains(c, r.pos + r.size); } // contains(t,r) // Check if triangle contains rectangle template inline constexpr bool contains(const triangle& t, const rect& r) { return contains(t, r.pos) && contains(t, r.pos + r.size) && contains(t, olc::v_2d{ r.pos.x + r.size.x,r.pos.y }) && contains(t, olc::v_2d{ r.pos.x, r.pos.y + r.size.y }); } // overlaps(p,r) // Check if point overlaps rectangle template inline constexpr bool overlaps(const olc::v_2d& p, const rect& r) { return overlaps(r, p); } // overlaps(l,r) // Check if line segment overlaps rectangle template inline constexpr bool overlaps(const line& l, const rect& r) { return overlaps(r, l); } // overlaps(r,r) // Check if rectangle overlaps rectangle template inline constexpr bool overlaps(const rect& r1, const rect& 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); } // overlaps(c,r) // Check if circle overlaps rectangle template inline constexpr bool overlaps(const circle& c, const rect& r) { // Inspired by this (very clever btw) // https://stackoverflow.com/questions/45370692/circle-rectangle-collision-response // But modified to work :P double overlap = (olc::v_2d{ 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 = 0; return (overlap - (c.radius * c.radius)) < 0; } // overlaps(t,r) // Check if triangle overlaps rectangle template inline constexpr bool overlaps(const triangle& t, const rect& r) { return overlaps(t, r.top()) || overlaps(t, r.bottom()) || overlaps(t, r.left()) || overlaps(t, r.right()) || contains(r, t.pos[0]); } // intersects(p,r) // Get intersection points where point intersects with rectangle template inline std::vector> intersects(const olc::v_2d& p, const rect& r) { return intersects(r, p); } // intersects(l,r) // Get intersection points where line segment intersects with rectangle template inline std::vector> intersects(const line& l, const rect& r) { return intersects(r,l); } // intersects(r,r) // Get intersection points where rectangle intersects with rectangle template inline std::vector> intersects(const rect& r1, const rect& r2) { std::vector> intersections; for (size_t i = 0; i < r2.side_count(); i++) { auto v = intersects(r1, r2.side(i)); intersections.insert(intersections.end(), v.begin(), v.end()); } return internal::filter_duplicate_points(intersections); } // intersects(c,r) // Get intersection points where circle intersects with rectangle template inline std::vector> intersects(const circle& c, const rect& r) { std::vector> intersections; for (size_t i = 0; i < r.side_count(); i++) { auto v = intersects(c, r.side(i)); intersections.insert(intersections.end(), v.begin(), v.end()); } return internal::filter_duplicate_points(intersections); } // intersects(t,r) // Get intersection points where triangle intersects with rectangle template inline std::vector> intersects(const triangle& t, const rect& r) { std::vector> intersections; for (size_t i = 0; i < r.side_count(); i++) { auto v = intersects(t, r.side(i)); intersections.insert(intersections.end(), v.begin(), v.end()); } return internal::filter_duplicate_points(intersections); } // ================================================================================================================ // CIRCLE ========================================================================================================= // contains(p,c) // Check if point contains circle template inline constexpr bool contains([[maybe_unused]] const olc::v_2d& p, [[maybe_unused]] const circle& c) { return false; // It can't! } // contains(l,c) // Check if line segment contains circle template inline constexpr bool contains([[maybe_unused]] const line& l, [[maybe_unused]] const circle& c) { return false; // It can't! } // contains(r,c) // Check if rectangle contains circle template inline constexpr bool contains(const rect& r, const circle& c) { return r.pos.x + c.radius <= c.pos.x && c.pos.x <= r.pos.x + r.size.x - c.radius && r.pos.y + c.radius <= c.pos.y && c.pos.y <= r.pos.y + r.size.y - c.radius; } // contains(c,c) // Check if circle contains circle template inline constexpr bool contains(const circle& c1, const circle& c2) { return (std::sqrt(std::pow(c2.pos.x - c1.pos.x, 2) + std::pow(c2.pos.y - c1.pos.y, 2)) + c2.radius) <= c1.radius; } // contains(t,c) // Check if triangle contains circle template inline constexpr bool contains(const triangle& t, const circle& c) { return contains(t, c.pos) && (c.pos - closest(t, c.pos)).mag2() >= c.radius * c.radius; } // overlaps(p,c) // Check if point overlaps circle template inline constexpr bool overlaps(const olc::v_2d& p, const circle& c) { return overlaps(c, p); } // overlaps(l,c) // Check if line segment overlaps circle template inline constexpr bool overlaps(const line& l, const circle& c) { return overlaps(c, l); } // overlaps(r,c) // Check if rectangle overlaps circle template inline constexpr bool overlaps(const rect& r, const circle& c) { return overlaps(c, r); } // overlaps(c,c) // Check if circle overlaps circle template inline constexpr bool overlaps(const circle& c1, const circle& c2) { return (c1.pos - c2.pos).mag2() <= (c1.radius + c2.radius) * (c1.radius + c2.radius); } // overlaps(t,c) // Check if triangle overlaps circle template inline constexpr bool overlaps(const triangle& t, const circle& c) { return contains(t, c.pos) || (c.pos - closest(t, c.pos)).mag2() <= c.radius * c.radius; } // intersects(p,c) // Get intersection points where point intersects with circle template inline std::vector> intersects(const olc::v_2d& p, const circle& c) { return intersects(c, p); } // intersects(l,c) // Get intersection points where line segment intersects with circle template inline std::vector> intersects(const line& l, const circle& c) { return intersects(c, l); } // intersects(r,c) // Get intersection points where rectangle intersects with circle template inline std::vector> intersects(const rect& r, const circle& c) { return intersects(c, r); } // intersects(c,c) // Get intersection points where circle intersects with circle template inline std::vector> intersects(const circle& c1, const circle& c2) { if (c1.pos == c2.pos) return {}; // circles are either within one another so cannot intersect, or are // identical so share all points which there's no good way to represent in return value. v_2d between = c2.pos - c1.pos; float dist2 = between.mag2(); float radiusSum = c1.radius + c2.radius; if (dist2 > radiusSum*radiusSum) return {}; // circles are too far apart to be touching. if (contains(c1, c2) || contains(c2, c1)) return {}; // one circle is inside of the other, they can't be intersecting. if (dist2 == radiusSum) return {c1.pos + between.norm() * c1.radius}; // circles are touching at exactly 1 point // otherwise they're touching at 2 points. // // ______ ________ // .'' ''.X' ''. X = intersections // / / |\ \ O = chordCenter // | | | | | In order to find the intersections we first find O. // ( c1--(--O-)--c2 ) To do this, we find the distance c1->O by solving for the // | | | | | two right triangles formed by the chord and c1->c2 (L). // \ \ |/ / . Pythagorean theorem: // '. .'X ,' .'|\ (L-x)^2 + h^2 = c1.r^2 // ''----'' ''------'' c1.r / | \ c2.radius x^2 + h^2 = c2.r^2 // .' h| \ Subtract 1 equation from the other and solve: // /_____|___\ (L-x)^2 + h^2 - (x^2 + h^2) = c1.r^2 - c2.r^2 // x L-x (L-x)^2 - x^2 = c1.r^2 - c2.r^2 // L^2 - 2Lx = c1.r^2 - c2.r^2 // 2Lx - L^2 = c2.r^2 - c1.r^2 // v------------<-----------------<-----------------<-----. x = (L^2 + c2.r^2 - c1.r^2)/2 -. // Next, we have to solve for the height h, and move '-------<--------------------<-----' // that distance from O, perpendicular to c1->c2. // // Pythagorean theorem: x^2 + h^2 = c1.r^2 -> c1.r^2 - x^2 = h^2 -> h = sqrt(c1.r^2 - x^2) // // x is ccDist and h is halfChord. // float dist = std::sqrt(dist2); float ccDist = (dist2 + c1.radius * c1.radius - c2.radius * c2.radius)/(2*dist); v_2d chordCenter = c1.pos + between.norm() * ccDist; v_2d halfChord = between.norm().perp() * std::sqrt(c1.radius * c1.radius - ccDist * ccDist); return {chordCenter + halfChord, chordCenter - halfChord}; } // intersects(t,c) // Get intersection points where triangle intersects with circle template inline std::vector> intersects(const triangle& t, const circle& c) { std::vector> intersections; for (size_t i = 0; i < t.side_count(); i++) { auto v = intersects(c, t.side(i)); intersections.insert(intersections.end(), v.begin(), v.end()); } return internal::filter_duplicate_points(intersections); } // ================================================================================================================ // TRIANGLE ======================================================================================================= // contains(p,t) // Check if point contains triangle template inline constexpr bool contains([[maybe_unused]] const olc::v_2d& p, [[maybe_unused]] const triangle& t) { return false; // It can't! } // contains(l,t) // Check if line segment contains triangle template inline constexpr bool contains([[maybe_unused]] const line& l, [[maybe_unused]] const triangle& t) { return false; // It can't } // contains(r,t) // Check if rectangle contains triangle template inline constexpr bool contains(const rect& r, const triangle& t) { return contains(r, t.side(0)) && contains(r, t.side(1)) && contains(r, t.side(2)); } // contains(c,t) // Check if circle contains triangle template inline constexpr bool contains(const circle& c, const triangle& t) { return contains(c, t.pos[0]) && contains(c, t.pos[1]) && contains(c, t.pos[2]); } // contains(t,t) // Check if triangle contains triangle template inline constexpr bool contains(const triangle