]> git.localhorst.tv Git - l2e.git/blob - src/geometry/Vector.h
store complete entity in hero
[l2e.git] / src / geometry / Vector.h
1 /*
2  * Vector.h
3  *
4  *  Created on: Aug 6, 2012
5  *      Author: holy
6  */
7
8 #ifndef GEOMETRY_VECTOR_H_
9 #define GEOMETRY_VECTOR_H_
10
11 #include <cmath>
12 #include <limits>
13 #include <ostream>
14
15 namespace geometry {
16
17 template<class Scalar>
18 class Vector {
19
20 public:
21         Vector() : x(0), y(0) { }
22         Vector(Scalar x, Scalar y) : x(x), y(y) { }
23         template<class T>
24         Vector(const Vector<T> &other) : x(other.X()), y(other.Y()) { };
25         template<class T>
26         Vector(T x, T y) : x(x), y(y) { }
27
28 public:
29         Scalar X() const { return x; }
30         Scalar Y() const { return y; }
31
32         Scalar Index(Scalar lineLength) const { return Y() * lineLength + X(); }
33         static Vector<Scalar> FromIndex(Scalar index, Scalar lineLength) {
34                 return Vector<Scalar>(index % lineLength, index / lineLength);
35         }
36
37         void Lock(const Vector<Scalar> &to);
38
39 private:
40         Scalar x, y;
41
42 };
43
44
45 template<class T>
46 inline Vector<T> operator +(const Vector<T> &lhs, const Vector<T> &rhs) {
47         return Vector<T>(lhs.X() + rhs.X(), lhs.Y() + rhs.Y());
48 }
49 template<class T, class U>
50 inline Vector<T> operator +(const Vector<T> &lhs, const Vector<U> &rhs) {
51         return Vector<T>(lhs.X() + rhs.X(), lhs.Y() + rhs.Y());
52 }
53
54 template<class T>
55 inline Vector<T> &operator +=(Vector<T> &lhs, const Vector<T> &rhs) {
56         return lhs = lhs + rhs;
57 }
58 template<class T, class U>
59 inline Vector<T> &operator +=(Vector<T> &lhs, const Vector<U> &rhs) {
60         return lhs = lhs + rhs;
61 }
62
63 template<class T>
64 inline Vector<T> operator -(const Vector<T> &lhs, const Vector<T> &rhs) {
65         return Vector<T>(lhs.X() - rhs.X(), lhs.Y() - rhs.Y());
66 }
67 template<class T, class U>
68 inline Vector<T> operator -(const Vector<T> &lhs, const Vector<U> &rhs) {
69         return Vector<T>(lhs.X() - rhs.X(), lhs.Y() - rhs.Y());
70 }
71
72 template<class T>
73 inline Vector<T> &operator -=(Vector<T> &lhs, const Vector<T> &rhs) {
74         return lhs = lhs - rhs;
75 }
76 template<class T, class U>
77 inline Vector<T> &operator -=(Vector<T> &lhs, const Vector<U> &rhs) {
78         return lhs = lhs - rhs;
79 }
80
81 template<class T>
82 inline Vector<T> operator -(const Vector<T> &v) {
83         return Vector<T>(-v.X(), -v.Y());
84 }
85
86 template<class T>
87 inline Vector<T> operator *(const Vector<T> &v1, const Vector<T> &v2) {
88         return Vector<T>(v1.X() * v2.X(), v1.Y() * v2.Y());
89 }
90 template<class T>
91 inline Vector<T> operator *(const Vector<T> &v, T s) {
92         return Vector<T>(v.X() * s, v.Y() * s);
93 }
94 template<class T>
95 inline Vector<T> operator *(T s, const Vector<T> &v) {
96         return Vector<T>(s * v.X(), s * v.Y());
97 }
98
99 template<class T>
100 inline Vector<T> operator /(const Vector<T> &v1, const Vector<T> &v2) {
101         return Vector<T>(v1.X() / v2.X(), v1.Y() / v2.Y());
102 }
103 template<class T>
104 inline Vector<T> operator /(const Vector<T> &v, T s) {
105         return Vector<T>(v.X() / s, v.Y() / s);
106 }
107 template<class T>
108 inline Vector<T> operator /(T s, const Vector<T> &v) {
109         return Vector<T>(s / v.X(), s / v.Y());
110 }
111
112 template<class T>
113 inline Vector<T> operator %(const Vector<T> &v1, const Vector<T> &v2) {
114         return Vector<T>(v1.X() % v2.X(), v1.Y() % v2.Y());
115 }
116 template<>
117 inline Vector<float> operator %(const Vector<float> &v1, const Vector<float> &v2) {
118         return Vector<float>(std::fmod(v1.X(), v2.X()), std::fmod(v1.Y(), v2.Y()));
119 }
120 template<>
121 inline Vector<double> operator %(const Vector<double> &v1, const Vector<double> &v2) {
122         return Vector<double>(std::fmod(v1.X(), v2.X()), std::fmod(v1.Y(), v2.Y()));
123 }
124 template<>
125 inline Vector<long double> operator %(const Vector<long double> &v1, const Vector<long double> &v2) {
126         return Vector<long double>(std::fmod(v1.X(), v2.X()), std::fmod(v1.Y(), v2.Y()));
127 }
128 template<class T>
129 inline Vector<T> operator %(const Vector<T> &v, T s) {
130         return Vector<T>(v.X() % s, v.Y() % s);
131 }
132 template<>
133 inline Vector<float> operator %(const Vector<float> &v, float s) {
134         return Vector<float>(std::fmod(v.X(), s), std::fmod(v.Y(), s));
135 }
136 template<>
137 inline Vector<double> operator %(const Vector<double> &v, double s) {
138         return Vector<double>(std::fmod(v.X(), s), std::fmod(v.Y(), s));
139 }
140 template<>
141 inline Vector<long double> operator %(const Vector<long double> &v, long double s) {
142         return Vector<long double>(std::fmod(v.X(), s), std::fmod(v.Y(), s));
143 }
144
145 template<class T>
146 inline bool operator ==(const Vector<T> &lhs, const Vector<T> &rhs) {
147         return lhs.X() == rhs.X() && lhs.Y() == rhs.Y();
148 }
149
150 template<class T>
151 inline bool operator !=(const Vector<T> &lhs, const Vector<T> &rhs) {
152         return lhs.X() != rhs.X() || lhs.Y() != rhs.Y();
153 }
154
155 template<class T>
156 inline std::ostream &operator <<(std::ostream &out, const Vector<T> &v) {
157         out << '<' << v.X() << ", " << v.Y() << '>';
158         return out;
159 }
160
161
162 template <class Scalar>
163 void Vector<Scalar>::Lock(const Vector<Scalar> &to) {
164         Vector<Scalar> half(to / Scalar(2));
165         Vector<Scalar> dist((*this) % to);
166
167         if (dist.X() > half.X()) {
168                 x += (to.X() - dist.X());
169         } else {
170                 x -= dist.X();
171         }
172
173         if (dist.Y() > half.Y()) {
174                 y += (to.Y() - dist.Y());
175         } else {
176                 y -= dist.Y();
177         }
178 }
179
180
181 }
182
183 #endif /* GEOMETRY_VECTOR_H_ */