[286] | 1 | // This file is a part of Framsticks SDK. http://www.framsticks.com/ |
---|
[848] | 2 | // Copyright (C) 1999-2019 Maciej Komosinski and Szymon Ulatowski. |
---|
[286] | 3 | // See LICENSE.txt for details. |
---|
[122] | 4 | |
---|
[109] | 5 | #ifndef _2D_H_ |
---|
| 6 | #define _2D_H_ |
---|
| 7 | |
---|
| 8 | #include "nonstd_stl.h" |
---|
| 9 | #include <math.h> |
---|
| 10 | |
---|
[848] | 11 | //unification of old GUIXY and Pt2D |
---|
[109] | 12 | template <typename T> class XY |
---|
| 13 | { |
---|
| 14 | public: |
---|
[848] | 15 | T x, y; |
---|
| 16 | XY() {} |
---|
| 17 | XY(T _x, T _y) :x(_x), y(_y) {} |
---|
| 18 | template <typename Q> XY(const Q& other) : x(other.x), y(other.y) {} |
---|
| 19 | template <typename Q> const XY& operator=(const Q& other) { x = other.x; y = other.y; return *this; } |
---|
| 20 | template <typename Q> const XY operator()(const Q& other) { return XY(other.x, other.y); } |
---|
| 21 | XY operator+(const XY&p) const { return XY(x + p.x, y + p.y); } |
---|
| 22 | XY operator-(const XY&p) const { return XY(x - p.x, y - p.y); } |
---|
| 23 | XY operator+=(const XY&p) { x += p.x; y += p.y; return *this; } |
---|
| 24 | XY operator-=(const XY&p) { x -= p.x; y -= p.y; return *this; } |
---|
| 25 | XY operator-() const { return XY(-x, -y); } |
---|
| 26 | // allows float operations on ints |
---|
| 27 | template <typename Q> XY operator*=(Q q) { x *= q; y *= q; return *this; } |
---|
| 28 | template <typename Q> XY operator/=(Q q) { x /= q; y /= q; return *this; } |
---|
[856] | 29 | template <typename Q> XY operator/(Q q) const { return XY(x / q, y / q); } |
---|
[848] | 30 | template <typename Q> XY operator*(Q q) const { return XY(q*x, q*y); } |
---|
[898] | 31 | XY operator*=(const XY& q) { x *= q.x; y *= q.y; return *this; } |
---|
| 32 | XY operator/=(const XY& q) { x /= q.x; y /= q.y; return *this; } |
---|
| 33 | XY operator*(const XY& q) const { return XY(x*q.x, y*q.y); } |
---|
| 34 | XY operator/(const XY& q) const { return XY(x/q.x, y/q.y); } |
---|
[848] | 35 | void set(T _x, T _y) { x = _x; y = _y; } |
---|
| 36 | void add(T _x, T _y) { x += _x; y += _y; } |
---|
| 37 | void sub(T _x, T _y) { x -= _x; y -= _y; } |
---|
| 38 | bool operator==(const XY& p) const { return (fabs(double(x - p.x)) < 1e-20) && (fabs(double(y - p.y)) < 1e-20); } |
---|
| 39 | bool operator!=(const XY& p) const { return !operator==(p); } |
---|
| 40 | T distanceTo(const XY& p) const { return sqrt(double((p.x - x)*(p.x - x) + (p.y - y)*(p.y - y))); } |
---|
| 41 | T magnitude() const { return sqrt(x*x + y * y); } |
---|
| 42 | T length() const { return sqrt(x*x + y * y); } |
---|
| 43 | T lengthSq() const { return x * x + y * y; } |
---|
| 44 | T dotProduct(const XY& v) const { return x * v.x + y * v.y; } |
---|
| 45 | T crossProduct(const XY& v) const { return x * v.y - y * v.x; } |
---|
| 46 | void normalize() { operator/=(length()); } // length becomes 1 |
---|
| 47 | static XY average(const XY& v1, const XY& v2) { return XY((v1.x + v2.x)*0.5, (v1.y + v2.y)*0.5); } |
---|
| 48 | double getDirection() const { return atan2(y, x); } |
---|
[898] | 49 | static XY interpolate(const XY& v1, const XY& v2, double t) { return universal_lerp(v1,v2,t); } |
---|
[848] | 50 | XY toInt() const { return XY(int(x), int(y)); } |
---|
| 51 | XY transpose() const { return XY(y, x); } |
---|
| 52 | static const XY& zero() { static XY t(0, 0); return t; } |
---|
| 53 | static const XY& one() { static XY t(1, 1); return t; } |
---|
[109] | 54 | }; |
---|
| 55 | |
---|
[848] | 56 | //specialized: int equality not using fabs() |
---|
| 57 | template<> inline bool XY<int>::operator==(const XY<int>& p) const { return (x == p.x) && (y == p.y); } |
---|
[109] | 58 | |
---|
[848] | 59 | template <typename T> XY<T> xymin(const XY<T>& a, const XY<T>& b) { return XY<T>(min(a.x, b.x), min(a.y, b.y)); } |
---|
| 60 | template <typename T> XY<T> xymax(const XY<T>& a, const XY<T>& b) { return XY<T>(max(a.x, b.x), max(a.y, b.y)); } |
---|
| 61 | |
---|
[766] | 62 | template <typename T> |
---|
| 63 | class XYMargin |
---|
| 64 | { |
---|
[848] | 65 | public: |
---|
| 66 | XYMargin(T x = 0) :left(x), top(x), right(x), bottom(x) {} |
---|
| 67 | XYMargin(T l, T t, T r, T b) :left(l), top(t), right(r), bottom(b) {} |
---|
| 68 | T left, top, right, bottom; |
---|
| 69 | void operator=(T x) { left = top = right = bottom = x; } |
---|
| 70 | XYMargin operator-() const { return XYMargin(-left, -top, -right, -bottom); } |
---|
| 71 | void operator=(const XYMargin<T> &other) { left = other.left; top = other.top; right = other.right; bottom = other.bottom; } |
---|
| 72 | T horizontal() const { return left + right; } |
---|
| 73 | T vertical() const { return top + bottom; } |
---|
| 74 | bool operator==(const XYMargin &other) const { return left == other.left && top == other.top && right == other.right && bottom == other.bottom; } |
---|
| 75 | XYMargin normalized() const { return XYMargin(max(left, T(0)), max(top, T(0)), max(right, T(0)), max(bottom, T(0))); } |
---|
[766] | 76 | }; |
---|
[109] | 77 | |
---|
| 78 | template <typename T> |
---|
| 79 | class XYRect |
---|
| 80 | { |
---|
| 81 | public: |
---|
[848] | 82 | XY<T> p, size; |
---|
| 83 | XYRect() {} |
---|
| 84 | XYRect(const XY<T>& p1, const XY<T>& s) :p(p1), size(s) {} |
---|
| 85 | template <typename Q> XYRect(const Q& other) : p(other.p), size(other.size) {} |
---|
| 86 | XYRect(T _x, T _y, T _w, T _h) :p(_x, _y), size(_w, _h) {} |
---|
| 87 | static XYRect<T> centeredAt(const XY<T>& p, XY<T> s) { return XYRect<T>(p - s * 0.5, s); } |
---|
[109] | 88 | |
---|
[848] | 89 | bool isEmpty() const { return (size.x < 0) || (size.y < 0); } |
---|
| 90 | XYRect toInt() const { return XYRect(int(p.x), int(p.y), int(p.x + size.x) - int(p.x), int(p.y + size.y) - int(p.y)); } |
---|
| 91 | bool operator==(const XYRect& r) const { return (p == r.p) && (size == r.size); } |
---|
| 92 | template <typename Q> const XYRect& operator=(const Q& other) { p = other.p; size = other.size; return *this; } |
---|
[109] | 93 | |
---|
[866] | 94 | T right() const { return p.x + size.x; } |
---|
| 95 | T bottom() const { return p.y + size.y; } |
---|
| 96 | T top() const { return p.y; } |
---|
| 97 | T left() const { return p.x; } |
---|
| 98 | XY<T> center() const { return p + size / 2; } |
---|
| 99 | const XY<T>& topLeft() const { return p; } |
---|
| 100 | XY<T> bottomRight() const { return p + size; } |
---|
| 101 | XY<T> topRight() const { return XY<T>(p.x + size.x, p.y); } |
---|
| 102 | XY<T> bottomLeft() const { return XY<T>(p.x, p.y + size.y); } |
---|
| 103 | |
---|
[856] | 104 | T area() const { return size.x*size.y; } |
---|
| 105 | |
---|
[848] | 106 | bool intersects(const XYRect& r) const |
---|
| 107 | { |
---|
| 108 | if (r.p.x >= (p.x + size.x)) return false; |
---|
| 109 | if (r.p.y >= (p.y + size.y)) return false; |
---|
| 110 | if ((r.p.x + r.size.x) <= p.x) return false; |
---|
| 111 | if ((r.p.y + r.size.y) <= p.y) return false; |
---|
| 112 | return true; |
---|
| 113 | } |
---|
[109] | 114 | |
---|
[848] | 115 | bool contains(const XY<T>& n) const |
---|
| 116 | { |
---|
| 117 | if (n.x < p.x) return false; |
---|
| 118 | if (n.x > (p.x + size.x)) return false; |
---|
| 119 | if (n.y < p.y) return false; |
---|
| 120 | if (n.y > (p.y + size.y)) return false; |
---|
| 121 | return true; |
---|
| 122 | } |
---|
[109] | 123 | |
---|
[856] | 124 | bool contains(const XYRect& r) const |
---|
| 125 | { |
---|
[866] | 126 | return contains(r.p) && contains(r.p + r.size); |
---|
[856] | 127 | } |
---|
[866] | 128 | |
---|
[848] | 129 | void add(const XY<T>& n) |
---|
| 130 | { |
---|
| 131 | if (n.x < p.x) { size.x += p.x - n.x; p.x = n.x; } |
---|
| 132 | else if (n.x > (p.x + size.x)) size.x = n.x - p.x; |
---|
| 133 | if (n.y < p.y) { size.y += p.y - n.y; p.y = n.y; } |
---|
| 134 | else if (n.y > (p.y + size.y)) size.y = n.y - p.y; |
---|
| 135 | } |
---|
[109] | 136 | |
---|
[848] | 137 | XYRect extendBy(const XY<T>& border_size) const |
---|
| 138 | { |
---|
| 139 | return XYRect(p - border_size, size + border_size * 2); |
---|
| 140 | } |
---|
[109] | 141 | |
---|
[848] | 142 | XYRect shrinkBy(const XY<T>& border_size) const |
---|
| 143 | { |
---|
| 144 | return XYRect(p + border_size, size - border_size * 2); |
---|
| 145 | } |
---|
[766] | 146 | |
---|
[848] | 147 | XYRect extendBy(const XYMargin<T>& m) const |
---|
| 148 | { |
---|
| 149 | return XYRect(p.x - m.left, p.y - m.top, size.x + m.horizontal(), size.y + m.vertical()); |
---|
| 150 | } |
---|
[766] | 151 | |
---|
[848] | 152 | XYRect shrinkBy(const XYMargin<T>& m) const |
---|
| 153 | { |
---|
| 154 | return XYRect(p.x + m.left, p.y + m.top, size.x - m.horizontal(), size.y - m.vertical()); |
---|
| 155 | } |
---|
[766] | 156 | |
---|
[848] | 157 | XYMargin<T> marginTowards(const XYRect &r) const |
---|
| 158 | { |
---|
| 159 | return XYMargin<T>(r.p.x - p.x, r.p.y - p.y, |
---|
| 160 | (p.x + size.x) - (r.p.x + r.size.x), (p.y + size.y) - (r.p.y + r.size.y)); |
---|
| 161 | } |
---|
[766] | 162 | |
---|
[905] | 163 | XYRect fitAspect(float aspect) ///< place a new rectangle having 'aspect' inside the rectangle |
---|
| 164 | { |
---|
| 165 | XYRect r; |
---|
| 166 | r.size=size; |
---|
| 167 | if (size.x < size.y*aspect) |
---|
| 168 | r.size.y = r.size.x/aspect; |
---|
| 169 | else |
---|
| 170 | r.size.x = r.size.y*aspect; |
---|
| 171 | r.p=p+(size-r.size)*0.5; |
---|
| 172 | return r; |
---|
| 173 | } |
---|
| 174 | |
---|
[848] | 175 | XYRect intersection(const XYRect& r) const |
---|
| 176 | { |
---|
| 177 | XYRect i; |
---|
| 178 | XY<T> p2 = p + size; |
---|
| 179 | XY<T> rp2 = r.p + r.size; |
---|
| 180 | i.p.x = max(p.x, r.p.x); |
---|
| 181 | i.p.y = max(p.y, r.p.y); |
---|
| 182 | i.size.x = min(p2.x, rp2.x) - i.p.x; |
---|
| 183 | i.size.y = min(p2.y, rp2.y) - i.p.y; |
---|
| 184 | return i; |
---|
| 185 | } |
---|
[109] | 186 | |
---|
[885] | 187 | XYRect extensionContaining(const XYRect& r) const |
---|
| 188 | { |
---|
| 189 | XY<T> p1 = xymin(topLeft(), r.topLeft()); |
---|
| 190 | XY<T> p2 = xymax(bottomRight(), r.bottomRight()); |
---|
| 191 | return XYRect(p1, p2 - p1); |
---|
| 192 | } |
---|
| 193 | |
---|
[848] | 194 | XYRect translation(const XY<T>& t) const |
---|
| 195 | { |
---|
| 196 | return XYRect(p + t, size); |
---|
| 197 | } |
---|
[766] | 198 | |
---|
[848] | 199 | T distanceTo(const XY<T>& n) const |
---|
| 200 | { |
---|
| 201 | XY<T> tp = n; |
---|
| 202 | if (n.x < p.x) tp.x = p.x; else if (n.x >= (p.x + size.x)) tp.x = p.x + size.x; |
---|
| 203 | if (n.y < p.y) tp.y = p.y; else if (n.y >= (p.y + size.y)) tp.y = p.y + size.y; |
---|
| 204 | return tp.distanceTo(n); |
---|
| 205 | } |
---|
[109] | 206 | |
---|
[856] | 207 | T distanceTo(const XYRect<T>& r) const |
---|
| 208 | { |
---|
[866] | 209 | bool r_above = (r.bottom() <= top()); |
---|
| 210 | bool r_below = (r.top() >= bottom()); |
---|
| 211 | bool r_left = (r.right() <= left()); |
---|
| 212 | bool r_right = (r.left() >= right()); |
---|
[856] | 213 | |
---|
[866] | 214 | if (r_above) |
---|
[856] | 215 | { |
---|
[866] | 216 | if (r_left) return r.bottomRight().distanceTo(topLeft()); |
---|
| 217 | else if (r_right) return r.bottomLeft().distanceTo(topRight()); |
---|
| 218 | else return top() - r.bottom(); |
---|
[856] | 219 | } |
---|
[866] | 220 | else if (r_below) |
---|
[856] | 221 | { |
---|
[866] | 222 | if (r_left) return r.topRight().distanceTo(bottomLeft()); |
---|
| 223 | else if (r_right) return r.topLeft().distanceTo(bottomRight()); |
---|
| 224 | else return r.top() - bottom(); |
---|
[856] | 225 | } |
---|
[866] | 226 | else if (r_left) |
---|
[856] | 227 | { |
---|
[866] | 228 | return left() - r.right(); |
---|
[856] | 229 | } |
---|
[866] | 230 | else if (r_right) |
---|
[856] | 231 | { |
---|
[866] | 232 | return r.left() - right(); |
---|
[856] | 233 | } |
---|
[866] | 234 | else |
---|
| 235 | return 0; //intersection |
---|
[856] | 236 | } |
---|
| 237 | |
---|
[848] | 238 | static const XYRect& zero() { static XYRect t(0, 0, 0, 0); return t; } |
---|
| 239 | static const XYRect& one() { static XYRect t(0, 0, 1, 1); return t; } |
---|
[109] | 240 | }; |
---|
| 241 | |
---|
[766] | 242 | typedef XY<int> IntXY; |
---|
| 243 | typedef XYRect<int> IntRect; |
---|
[109] | 244 | |
---|
[866] | 245 | typedef XY<float> FloatXY; |
---|
| 246 | typedef XYRect<float> FloatRect; |
---|
| 247 | |
---|
[109] | 248 | #endif |
---|