]> git.localhorst.tv Git - orbi.git/blob - src/graphics/Vector.h
0fd5bfe49f84d878a688df600b919b29f8cc367e
[orbi.git] / 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 constexpr Vector<Scalar> min(Vector<Scalar> lhs, Vector<Scalar> rhs) {
168         return Vector<Scalar>(std::min(lhs.x, rhs.x), std::min(lhs.y, rhs.y));
169 }
170 template<class Scalar>
171 constexpr Vector<Scalar> max(Vector<Scalar> lhs, Vector<Scalar> rhs) {
172         return Vector<Scalar>(std::max(lhs.x, rhs.x), std::max(lhs.y, rhs.y));
173 }
174
175
176 template<class Scalar>
177 constexpr Scalar Cross2D(Vector<Scalar> lhs, Vector<Scalar> rhs) {
178         return (lhs.x * rhs.y) - (lhs.y * rhs.x);
179 }
180 template<class Scalar>
181 constexpr Scalar Dot(Vector<Scalar> lhs, Vector<Scalar> rhs) {
182         return (lhs.x * rhs.x) + (lhs.y * rhs.y);
183 }
184 template<class Scalar>
185 constexpr Scalar Length(Vector<Scalar> v) {
186         return std::sqrt(Dot(v, v));
187 }
188 template<class Scalar>
189 constexpr Vector<Scalar> Norm(Vector<Scalar> v) {
190         return v / Length(v);
191 }
192
193 template<class Scalar>
194 constexpr Vector<Scalar> Rotate90(Vector<Scalar> v) {
195         return Vector<Scalar>(-v.y, v.x);
196 }
197 template<class Scalar>
198 constexpr Vector<Scalar> Rotate180(Vector<Scalar> v) {
199         return -v;
200 }
201 template<class Scalar>
202 constexpr Vector<Scalar> Rotate270(Vector<Scalar> v) {
203         return Vector<Scalar>(v.y, -v.x);
204 }
205 template<class Scalar, class Float>
206 inline Vector<Scalar> Rotate(Vector<Scalar> v, Float by) {
207         Float sine(std::sin(by));
208         Float cosine(std::cos(by));
209         return Vector<Scalar>(v.x * cosine - v.y * sine, v.x * sine + v.y * cosine);
210 }
211
212 /// reflect v along normalized n
213 template<class Scalar>
214 inline Vector<Scalar> Reflect(Vector<Scalar> v, Vector<Scalar> n) {
215         const Scalar dd = Scalar(2) * Dot(v, n);
216         return Vector<Scalar>(v.x - (dd * n.x), v.y - (dd * n.y));
217 }
218 /// project v onto normalized n
219 template<class Scalar>
220 inline Vector<Scalar> Project(Vector<Scalar> v, Vector<Scalar> n) {
221         return Dot(v, n) * n;
222 }
223
224
225 template<class Scalar>
226 inline std::ostream &operator <<(std::ostream &out, Vector<Scalar> v) {
227         return out << '<' << v.x << ',' << v.y << '>';
228 }
229
230 }
231
232
233 namespace std {
234
235 template<class Scalar>
236 constexpr orbi::Vector<Scalar> min(
237                 orbi::Vector<Scalar> lhs,
238                 orbi::Vector<Scalar> rhs
239 ) {
240         return orbi::Vector<Scalar>(
241                 min(lhs.x, rhs.x),
242                 min(lhs.y, rhs.y)
243         );
244 }
245
246 template<class Scalar>
247 constexpr orbi::Vector<Scalar> max(
248                 orbi::Vector<Scalar> lhs,
249                 orbi::Vector<Scalar> rhs
250 ) {
251         return orbi::Vector<Scalar>(
252                 max(lhs.x, rhs.x),
253                 max(lhs.y, rhs.y)
254         );
255 }
256
257 }
258
259 #endif