src/graphics/Vector.h

   1 #ifndef ORBI_VECTOR_H_
   2 #define ORBI_VECTOR_H_
   3
   4 #include <algorithm>
   5 #include <cmath>
   6 #include <limits>
   7 #include <ostream>
   8 #include <SDL.h>
   9
  10
  11 namespace orbi {
  12
  13 template<class Scalar>
  14 class Vector {
  15
  16 public:
  17         constexpr Vector() : x(0), y(0) { }
  18         constexpr Vector(Scalar x, Scalar y) : x(x), y(y) { }
  19
  20         template<class Other>
  21         constexpr Vector(Vector<Other> other) : x(other.x), y(other.y) { }
  22
  23         static Vector<Scalar> FromPolar(Scalar rad, Scalar az) {
  24                 return Vector<Scalar>(rad * std::cos(az), rad * std::sin(az));
  25         }
  26
  27         static constexpr Vector<Scalar> unit45 = Vector<Scalar>(-0.7071, 0.7071);
  28
  29 public:
  30         Vector<Scalar> &operator +=(Vector<Scalar> other) {
  31                 x += other.x;
  32                 y += other.y;
  33                 return *this;
  34         }
  35         Vector<Scalar> &operator -=(Vector<Scalar> other) {
  36                 x -= other.x;
  37                 y -= other.y;
  38                 return *this;
  39         }
  40         Vector<Scalar> &operator *=(Scalar factor) {
  41                 x *= factor;
  42                 y *= factor;
  43                 return *this;
  44         }
  45         Vector<Scalar> &operator /=(Scalar factor) {
  46                 x /= factor;
  47                 y /= factor;
  48                 return *this;
  49         }
  50
  51         SDL_Point ToPoint() const {
  52                 SDL_Point p;
  53                 p.x = x;
  54                 p.y = y;
  55                 return p;
  56         }
  57
  58 public:
  59         Scalar x;
  60         Scalar y;
  61
  62 };
  63
  64 template<class T>
  65 constexpr Vector<T> Vector<T>::unit45;
  66
  67 /// specialization with same layout as SDL_Point
  68 template<>
  69 class Vector<int>
  70 : public SDL_Point {
  71
  72 public:
  73         constexpr Vector() : SDL_Point({0, 0}) { }
  74         constexpr Vector(int x, int y) : SDL_Point({x, y}) { }
  75
  76         template<class Other>
  77         constexpr Vector(Vector<Other> other)
  78         : SDL_Point({int(other.x), int(other.y)}) { }
  79
  80 public:
  81         Vector<int> &operator +=(Vector<int> other) {
  82                 x += other.x;
  83                 y += other.y;
  84                 return *this;
  85         }
  86         Vector<int> &operator -=(Vector<int> other) {
  87                 x -= other.x;
  88                 y -= other.y;
  89                 return *this;
  90         }
  91
  92         SDL_Point ToPoint() const {
  93                 return *this;
  94         }
  95
  96 };
  97
  98
  99 template<class Scalar>
 100 constexpr Vector<Scalar> operator -(Vector<Scalar> v) {
 101         return Vector<Scalar>(-v.x, -v.y);
 102 }
 103
 104
 105 template<class Scalar>
 106 constexpr Vector<Scalar> operator +(Vector<Scalar> lhs, Vector<Scalar> rhs) {
 107         return Vector<Scalar>(lhs.x + rhs.x, lhs.y + rhs.y);
 108 }
 109
 110 template<class Scalar>
 111 constexpr Vector<Scalar> operator -(Vector<Scalar> lhs, Vector<Scalar> rhs) {
 112         return Vector<Scalar>(lhs.x - rhs.x, lhs.y - rhs.y);
 113 }
 114
 115
 116 template<class Scalar>
 117 constexpr Vector<Scalar> operator *(Vector<Scalar> lhs, Scalar rhs) {
 118         return Vector<Scalar>(lhs.x * rhs, lhs.y * rhs);
 119 }
 120
 121 template<class Scalar>
 122 constexpr Vector<Scalar> operator *(Scalar lhs, Vector<Scalar> rhs) {
 123         return rhs * lhs;
 124 }
 125 template<class Scalar>
 126 constexpr Vector<Scalar> operator *(Vector<Scalar> lhs, Vector<Scalar> rhs) {
 127         return Vector<Scalar>(lhs.x * rhs.x, lhs.y * rhs.y);
 128 }
 129
 130
 131 template<class Scalar>
 132 constexpr Vector<Scalar> operator /(Vector<Scalar> lhs, Scalar rhs) {
 133         return Vector<Scalar>(lhs.x / rhs, lhs.y / rhs);
 134 }
 135
 136 template<class Scalar>
 137 constexpr Vector<Scalar> operator /(Scalar lhs, Vector<Scalar> rhs) {
 138         return rhs / lhs;
 139 }
 140 template<class Scalar>
 141 constexpr Vector<Scalar> operator /(Vector<Scalar> lhs, Vector<Scalar> rhs) {
 142         return Vector<Scalar>(lhs.x / rhs.x, lhs.y / rhs.y);
 143 }
 144
 145
 146 template<class Scalar>
 147 constexpr bool operator ==(Vector<Scalar> lhs, Vector<Scalar> rhs) {
 148         return lhs.x == rhs.x && lhs.y == rhs.y;
 149 }
 150 template<class Scalar>
 151 constexpr bool operator !=(Vector<Scalar> lhs, Vector<Scalar> rhs) {
 152         return lhs.x != rhs.x && lhs.y != rhs.y;
 153 }
 154
 155
 156 template<class Scalar>
 157 constexpr bool IsZero(Vector<Scalar> v) {
 158         return std::abs(v.x) < std::numeric_limits<Scalar>::epsilon()
 159                 && std::abs(v.y) < std::numeric_limits<Scalar>::epsilon();
 160 }
 161
 162 template<class Scalar>
 163 constexpr Vector<Scalar> abs(Vector<Scalar> v) {
 164         return Vector<Scalar>(std::abs(v.x), std::abs(v.y));
 165 }
 166 template<class Scalar>
 167 inline Vector<Scalar> round(Vector<Scalar> v) {
 168         return Vector<Scalar>(std::round(v.x), std::round(v.y));
 169 }
 170 template<>
 171 inline Vector<float> round(Vector<float> v) {
 172         return Vector<float>(std::roundf(v.x), std::roundf(v.y));
 173 }
 174 template<class Scalar>
 175 constexpr Vector<Scalar> min(Vector<Scalar> lhs, Vector<Scalar> rhs) {
 176         return Vector<Scalar>(std::min(lhs.x, rhs.x), std::min(lhs.y, rhs.y));
 177 }
 178 template<class Scalar>
 179 constexpr Vector<Scalar> max(Vector<Scalar> lhs, Vector<Scalar> rhs) {
 180         return Vector<Scalar>(std::max(lhs.x, rhs.x), std::max(lhs.y, rhs.y));
 181 }
 182
 183
 184 template<class Scalar>
 185 constexpr Scalar Cross2D(Vector<Scalar> lhs, Vector<Scalar> rhs) {
 186         return (lhs.x * rhs.y) - (lhs.y * rhs.x);
 187 }
 188 template<class Scalar>
 189 constexpr Scalar Dot(Vector<Scalar> lhs, Vector<Scalar> rhs) {
 190         return (lhs.x * rhs.x) + (lhs.y * rhs.y);
 191 }
 192 template<class Scalar>
 193 constexpr Scalar Length(Vector<Scalar> v) {
 194         return std::sqrt(Dot(v, v));
 195 }
 196 template<class Scalar>
 197 constexpr Vector<Scalar> Norm(Vector<Scalar> v) {
 198         return v / Length(v);
 199 }
 200
 201 template<class Scalar>
 202 constexpr Vector<Scalar> MirrorX(Vector<Scalar> v) {
 203         return Vector<Scalar>(v.x, -v.y);
 204 }
 205 template<class Scalar>
 206 constexpr Vector<Scalar> MirrorY(Vector<Scalar> v) {
 207         return Vector<Scalar>(-v.x, v.y);
 208 }
 209
 210 template<class Scalar>
 211 constexpr Vector<Scalar> Rotate90(Vector<Scalar> v) {
 212         return Vector<Scalar>(-v.y, v.x);
 213 }
 214 template<class Scalar>
 215 constexpr Vector<Scalar> Rotate180(Vector<Scalar> v) {
 216         return -v;
 217 }
 218 template<class Scalar>
 219 constexpr Vector<Scalar> Rotate270(Vector<Scalar> v) {
 220         return Vector<Scalar>(v.y, -v.x);
 221 }
 222 // angle given in radians
 223 template<class Scalar, class Float>
 224 inline Vector<Scalar> Rotate(Vector<Scalar> v, Float by) {
 225         Float sine(std::sin(by));
 226         Float cosine(std::cos(by));
 227         return Vector<Scalar>(v.x * cosine - v.y * sine, v.x * sine + v.y * cosine);
 228 }
 229
 230 /// reflect v along normalized n
 231 template<class Scalar>
 232 inline Vector<Scalar> Reflect(Vector<Scalar> v, Vector<Scalar> n) {
 233         const Scalar dd = Scalar(2) * Dot(v, n);
 234         return Vector<Scalar>(v.x - (dd * n.x), v.y - (dd * n.y));
 235 }
 236 /// project v onto normalized n
 237 template<class Scalar>
 238 inline Vector<Scalar> Project(Vector<Scalar> v, Vector<Scalar> n) {
 239         return Dot(v, n) * n;
 240 }
 241
 242
 243 template<class Scalar>
 244 inline std::ostream &operator <<(std::ostream &out, Vector<Scalar> v) {
 245         return out << '<' << v.x << ',' << v.y << '>';
 246 }
 247
 248 }
 249
 250
 251 namespace std {
 252
 253 template<class Scalar>
 254 constexpr orbi::Vector<Scalar> min(
 255                 orbi::Vector<Scalar> lhs,
 256                 orbi::Vector<Scalar> rhs
 257 ) {
 258         return orbi::Vector<Scalar>(
 259                 min(lhs.x, rhs.x),
 260                 min(lhs.y, rhs.y)
 261         );
 262 }
 263
 264 template<class Scalar>
 265 constexpr orbi::Vector<Scalar> max(
 266                 orbi::Vector<Scalar> lhs,
 267                 orbi::Vector<Scalar> rhs
 268 ) {
 269         return orbi::Vector<Scalar>(
 270                 max(lhs.x, rhs.x),
 271                 max(lhs.y, rhs.y)
 272         );
 273 }
 274
 275 }
 276
 277 #endif