1 | /*! |
---|
2 | * @file vector.h |
---|
3 | * A basic 3D math framework |
---|
4 | * |
---|
5 | * Contains classes to handle vectors, lines, rotations and planes |
---|
6 | */ |
---|
7 | |
---|
8 | #ifndef _VECTOR_H |
---|
9 | #define _VECTOR_H |
---|
10 | |
---|
11 | #include <math.h> |
---|
12 | #include "compiler.h" |
---|
13 | #include "abstract_model.h" |
---|
14 | //! PI the circle-constant |
---|
15 | #define PI 3.14159265359f |
---|
16 | |
---|
17 | //! 3D Vector |
---|
18 | /** |
---|
19 | Class to handle 3D Vectors |
---|
20 | */ |
---|
21 | class Vector { |
---|
22 | |
---|
23 | |
---|
24 | public: |
---|
25 | Vector (float x, float y, float z) : x(x), y(y), z(z) {} //!< assignment constructor |
---|
26 | Vector () : x(0), y(0), z(0) {} |
---|
27 | ~Vector () {} |
---|
28 | |
---|
29 | /** @param v: the Vecor to compare with this one @returns true, if the Vecors are the same, false otherwise */ |
---|
30 | inline bool operator== (const Vector& v) const { return (this->x==v.x&&this->y==v.y&&this->z==v.z)?true:false; }; |
---|
31 | /** @param index The index of the "array" @returns the x/y/z coordinate */ |
---|
32 | inline float operator[] (float index) const {if( index == 0) return this->x; if( index == 1) return this->y; if( index == 2) return this->z; } |
---|
33 | /** @param v The vector to add @returns the addition between two vectors (this + v) */ |
---|
34 | inline Vector operator+ (const Vector& v) const { return Vector(x + v.x, y + v.y, z + v.z); }; |
---|
35 | /** @param v The vector to add @returns the addition between two vectors (this + v) */ |
---|
36 | inline Vector operator+ (const sVec3D& v) const { return Vector(x + v[0], y + v[1], z + v[2]); }; |
---|
37 | /** @param v The vector to add @returns the addition between two vectors (this += v) */ |
---|
38 | inline const Vector& operator+= (const Vector& v) { this->x += v.x; this->y += v.y; this->z += v.z; return *this; }; |
---|
39 | /** @param v The vector to substract @returns the substraction between two vectors (this - v) */ |
---|
40 | inline const Vector& operator+= (const sVec3D& v) { this->x += v[0]; this->y += v[1]; this->z += v[2]; return *this; }; |
---|
41 | /** @param v The vector to substract @returns the substraction between two vectors (this - v) */ |
---|
42 | inline Vector operator- (const Vector& v) const { return Vector(x - v.x, y - v.y, z - v.z); } |
---|
43 | /** @param v The vector to substract @returns the substraction between two vectors (this - v) */ |
---|
44 | inline Vector operator- (const sVec3D& v) const { return Vector(x - v[0], y - v[1], z - v[2]); } |
---|
45 | /** @param v The vector to substract @returns the substraction between two vectors (this -= v) */ |
---|
46 | inline const Vector& operator-= (const Vector& v) { this->x -= v.x; this->y -= v.y; this->z -= v.z; return *this; }; |
---|
47 | /** @param v The vector to substract @returns the substraction between two vectors (this -= v) */ |
---|
48 | inline const Vector& operator-= (const sVec3D& v) { this->x -= v[0]; this->y -= v[1]; this->z -= v[2]; return *this; }; |
---|
49 | /** @param v the second vector @returns The dotProduct between two vector (this (dot) v) */ |
---|
50 | inline float operator* (const Vector& v) const { return x * v.x + y * v.y + z * v.z; }; |
---|
51 | /** @todo strange */ |
---|
52 | inline const Vector& operator*= (const Vector& v) { this->x *= v.x; this->y *= v.y; this->z *= v.z; return *this; }; |
---|
53 | /** @param f a factor to multiply the vector with @returns the vector multiplied by f (this * f) */ |
---|
54 | inline Vector operator* (float f) const { return Vector(x * f, y * f, z * f); }; |
---|
55 | /** @param f a factor to multiply the vector with @returns the vector multiplied by f (this *= f) */ |
---|
56 | inline const Vector& operator*= (float f) { this->x *= f; this->y *= f; this->z *= f; return *this; }; |
---|
57 | /** @param f a factor to divide the vector with @returns the vector divided by f (this / f) */ |
---|
58 | inline Vector operator/ (float f) const { return (unlikely(f == 0.0))?Vector(0,0,0):Vector(this->x / f, this->y / f, this->z / f); }; |
---|
59 | /** @param f a factor to divide the vector with @returns the vector divided by f (this /= f) */ |
---|
60 | inline const Vector& operator/= (float f) {if (unlikely(f == 0.0)) {this->x=0;this->y=0;this->z=0;} else {this->x /= f; this->y /= f; this->z /= f;} return *this; }; |
---|
61 | /** copy constructor @todo (i do not know it this is faster) @param v the vector to assign to this vector. @returns the vector v */ |
---|
62 | inline const Vector& operator= (const Vector& v) { this->x = v.x; this->y = v.y; this->z = v.z; return *this; }; |
---|
63 | /** copy constructor* @param v the sVec3D to assign to this vector. @returns the vector v */ |
---|
64 | inline const Vector& operator= (const sVec3D& v) { this->x = v[0]; this->y = v[1]; this->z = v[2]; } |
---|
65 | /** @param v: the other vector \return the dot product of the vectors */ |
---|
66 | float dot (const Vector& v) const { return x*v.x+y*v.y+z*v.z; }; |
---|
67 | /** @param v: the corss-product partner @returns the cross-product between this and v (this (x) v) */ |
---|
68 | inline Vector cross (const Vector& v) const { return Vector(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x ); } |
---|
69 | /** scales the this vector with v* @param v the vector to scale this with */ |
---|
70 | void scale(const Vector& v) { x *= v.x; y *= v.y; z *= v.z; }; |
---|
71 | /** @returns the length of the vector */ |
---|
72 | inline float len() const { return sqrt (x*x+y*y+z*z); } |
---|
73 | /** normalizes the vector */ |
---|
74 | inline void normalize() { float l = len(); if( unlikely(l == 0.0))return; this->x=this->x/l; this->y=this->y/l; this->z=this->z/l; }; |
---|
75 | Vector getNormalized() const; |
---|
76 | Vector abs(); |
---|
77 | |
---|
78 | void debug() const; |
---|
79 | |
---|
80 | public: |
---|
81 | float x; //!< The x Coordinate of the Vector. |
---|
82 | float y; //!< The y Coordinate of the Vector. |
---|
83 | float z; //!< The z Coordinate of the Vector. |
---|
84 | }; |
---|
85 | |
---|
86 | /** |
---|
87 | * calculate the angle between two vectors in radiances |
---|
88 | * @param v1: a vector |
---|
89 | * @param v2: another vector |
---|
90 | * @return the angle between the vectors in radians |
---|
91 | */ |
---|
92 | inline float angleDeg (const Vector& v1, const Vector& v2) { return acos( v1 * v2 / (v1.len() * v2.len())); }; |
---|
93 | /** |
---|
94 | * calculate the angle between two vectors in degrees |
---|
95 | * @param v1: a vector |
---|
96 | * @param v2: another vector |
---|
97 | * @return the angle between the vectors in degrees |
---|
98 | */ |
---|
99 | inline float angleRad (const Vector& v1, const Vector& v2) { return acos( v1 * v2 / (v1.len() * v2.len())) * 180/M_PI; }; |
---|
100 | |
---|
101 | /** an easy way to create a Random Vector @param sideLength the length of the Vector (x not sqrt(x^2...)) */ |
---|
102 | #define VECTOR_RAND(sideLength) (Vector((float)rand()/RAND_MAX -.5, (float)rand()/RAND_MAX -.5, (float)rand()/RAND_MAX -.5) * sideLength) |
---|
103 | |
---|
104 | |
---|
105 | //! Quaternion |
---|
106 | /** |
---|
107 | Class to handle 3-dimensional rotation efficiently |
---|
108 | */ |
---|
109 | class Quaternion |
---|
110 | { |
---|
111 | public: |
---|
112 | /** creates a Default quaternion (multiplicational identity Quaternion)*/ |
---|
113 | inline Quaternion () { w = 1; v = Vector(0,0,0); } |
---|
114 | /** creates a Quaternion looking into the direction v @param v: the direction @param f: the value */ |
---|
115 | inline Quaternion (const Vector& v, float f) { this->w = f; this->v = v; } |
---|
116 | Quaternion (float m[4][4]); |
---|
117 | /** turns a rotation along an axis into a Quaternion @param angle: the amount of radians to rotate @param axis: the axis to rotate around */ |
---|
118 | inline Quaternion (float angle, const Vector& axis) { w = cos(angle/2); v = axis * sin(angle/2); } |
---|
119 | Quaternion (const Vector& dir, const Vector& up); |
---|
120 | Quaternion (float roll, float pitch, float yaw); |
---|
121 | |
---|
122 | /** @param q: the Quaternion to compare with this one. @returns true if the Quaternions are the same, false otherwise */ |
---|
123 | inline bool operator== (const Quaternion& q) const { return (unlikely(this->v==q.v&&this->w==q.w))?true:false; }; |
---|
124 | /** @param f: a real value @return a Quaternion containing the quotient */ |
---|
125 | inline Quaternion operator/ (const float& f) const { return (unlikely(f==0.0)) ? Quaternion() : Quaternion(this->v/f, this->w/f); }; |
---|
126 | /** @param f: the value to divide by @returns the quaternion devided by f (this /= f) */ |
---|
127 | inline const Quaternion& operator/= (const float& f) {*this = *this / f; return *this;} |
---|
128 | /** @param f: a real value @return a Quaternion containing the product */ |
---|
129 | inline Quaternion operator* (const float& f) const { return Quaternion(this->v*f, this->w*f); }; |
---|
130 | /** @param f: the value to multiply by @returns the quaternion multiplied by f (this *= f) */ |
---|
131 | inline const Quaternion& operator*= (const float& f) {*this = *this * f; return *this;} |
---|
132 | /** @param q: another Quaternion to rotate this by @return a quaternion that represents the first one rotated by the second one (WARUNING: this operation is not commutative! e.g. (A*B) != (B*A)) */ |
---|
133 | Quaternion operator* (const Quaternion& q) const { return Quaternion(Vector(this->w*q.v.x + this->v.x*q.w + this->v.y*q.v.z - this->v.z*q.v.y, |
---|
134 | this->w*q.v.y + this->v.y*q.w + this->v.z*q.v.x - this->v.x*q.v.z, |
---|
135 | this->w*q.v.z + this->v.z*q.w + this->v.x*q.v.y - this->v.y*q.v.x), |
---|
136 | this->w*q.w - this->v.x*q.v.x - this->v.y*q.v.y - this->v.z*q.v.z); }; |
---|
137 | /** @param q: the Quaternion to multiply by @returns the quaternion multiplied by q (this *= q) */ |
---|
138 | inline const Quaternion& operator*= (const Quaternion& q) {*this = *this * q; return *this; }; |
---|
139 | /** @param q the Quaternion by which to devide @returns the division from this by q (this / q) */ |
---|
140 | inline Quaternion operator/ (const Quaternion& q) const { return *this * q.inverse(); }; |
---|
141 | /** @param q the Quaternion by which to devide @returns the division from this by q (this /= q) */ |
---|
142 | inline const Quaternion& operator/= (const Quaternion& q) { *this = *this * q.inverse(); return *this; }; |
---|
143 | /** @param q the Quaternion to add to this @returns the quaternion added with q (this + q) */ |
---|
144 | inline Quaternion operator+ (const Quaternion& q) const { return Quaternion(q.v + v, q.w + w); }; |
---|
145 | /** @param q the Quaternion to add to this @returns the quaternion added with q (this += q) */ |
---|
146 | inline const Quaternion& operator+= (const Quaternion& q) { this->v += q.v; this->w += q.w; return *this; }; |
---|
147 | /** @param q the Quaternion to substrace from this @returns the quaternion substracted by q (this - q) */ |
---|
148 | inline Quaternion operator- (const Quaternion& q) const { return Quaternion(q.v - v, q.w - w); } |
---|
149 | /** @param q the Quaternion to substrace from this @returns the quaternion substracted by q (this -= q) */ |
---|
150 | inline const Quaternion& operator-= (const Quaternion& q) { this->v -= q.v; this->w -= q.w; return *this; }; |
---|
151 | /** copy constructor @param q: the Quaternion to set this to. @returns the Quaternion q (or this) */ |
---|
152 | inline Quaternion operator= (const Quaternion& q) {this->v = q.v; this->w = q.w; return *this;} |
---|
153 | /** conjugates this Quaternion @returns the conjugate */ |
---|
154 | inline Quaternion conjugate () const { return Quaternion(Vector(-v.x, -v.y, -v.z), this->w); }; |
---|
155 | /** @returns the norm of The Quaternion */ |
---|
156 | inline float norm () const { return sqrt(w*w + v.x*v.x + v.y*v.y + v.z*v.z); }; |
---|
157 | /** @returns the inverted Quaterntion of this */ |
---|
158 | inline Quaternion inverse () const { return conjugate() / (w*w + v.x*v.x + v.y*v.y + v.z*v.z); }; |
---|
159 | /** @param v: the Vector @return a new Vector representing v rotated by the Quaternion */ |
---|
160 | inline Vector apply (const Vector& v) const { return (*this * Quaternion(v, 0) * conjugate()).v; }; |
---|
161 | void matrix (float m[4][4]) const; |
---|
162 | /** @returns the normalized Quaternion (|this|) */ |
---|
163 | inline Quaternion getNormalized() const { float n = this->norm(); return Quaternion(this->v/n, this->w/n); }; |
---|
164 | /** normalizes the current Quaternion */ |
---|
165 | inline void normalize() { float n = this->norm(); this->v /= n; this->w/=n; }; |
---|
166 | |
---|
167 | /** @returns the rotational axis of this Quaternion */ |
---|
168 | inline Vector getSpacialAxis() const { return this->v / sin(acos(w));/*sqrt(v.x*v.x + v.y*v.y + v.z+v.z);*/ }; |
---|
169 | /** @returns the rotational angle of this Quaternion around getSpacialAxis() !! IN DEGREE !! */ |
---|
170 | inline float getSpacialAxisAngle() const { return 360.0 / M_PI * acos(this->w); }; |
---|
171 | |
---|
172 | static Quaternion quatSlerp(const Quaternion& from, const Quaternion& to, float t); |
---|
173 | |
---|
174 | void debug(); |
---|
175 | void debug2(); |
---|
176 | |
---|
177 | |
---|
178 | public: |
---|
179 | Vector v; //!< Imaginary Vector |
---|
180 | float w; //!< Real part of the number |
---|
181 | |
---|
182 | }; |
---|
183 | |
---|
184 | |
---|
185 | |
---|
186 | |
---|
187 | //! 3D rotation (OBSOLETE) |
---|
188 | /** |
---|
189 | Class to handle 3-dimensional rotations. |
---|
190 | Can create a rotation from several inputs, currently stores rotation using a 3x3 Matrix |
---|
191 | */ |
---|
192 | class Rotation { |
---|
193 | public: |
---|
194 | |
---|
195 | float m[9]; //!< 3x3 Rotation Matrix |
---|
196 | |
---|
197 | Rotation ( const Vector& v); |
---|
198 | Rotation ( const Vector& axis, float angle); |
---|
199 | Rotation ( float pitch, float yaw, float roll); |
---|
200 | Rotation (); |
---|
201 | ~Rotation () {} |
---|
202 | |
---|
203 | Rotation operator* (const Rotation& r); |
---|
204 | |
---|
205 | void glmatrix (float* buffer); |
---|
206 | }; |
---|
207 | |
---|
208 | //!< Apply a rotation to a vector |
---|
209 | Vector rotateVector( const Vector& v, const Rotation& r); |
---|
210 | |
---|
211 | //! 3D line |
---|
212 | /** |
---|
213 | Class to store Lines in 3-dimensional space |
---|
214 | |
---|
215 | Supports line-to-line distance measurements and rotation |
---|
216 | */ |
---|
217 | class Line |
---|
218 | { |
---|
219 | public: |
---|
220 | |
---|
221 | Vector r; //!< Offset |
---|
222 | Vector a; //!< Direction |
---|
223 | |
---|
224 | Line ( Vector r, Vector a) : r(r), a(a) {} //!< assignment constructor |
---|
225 | Line () : r(Vector(0,0,0)), a(Vector (1,1,1)) {} |
---|
226 | ~Line () {} |
---|
227 | |
---|
228 | float distance (const Line& l) const; |
---|
229 | float distancePoint (const Vector& v) const; |
---|
230 | float distancePoint (const sVec3D& v) const; |
---|
231 | Vector* footpoints (const Line& l) const; |
---|
232 | float len () const; |
---|
233 | |
---|
234 | void rotate(const Rotation& rot); |
---|
235 | }; |
---|
236 | |
---|
237 | //! 3D plane |
---|
238 | /** |
---|
239 | Class to handle planes in 3-dimensional space |
---|
240 | |
---|
241 | Critical for polygon-based collision detection |
---|
242 | */ |
---|
243 | class Plane |
---|
244 | { |
---|
245 | public: |
---|
246 | |
---|
247 | Vector n; //!< Normal vector |
---|
248 | float k; //!< Offset constant |
---|
249 | |
---|
250 | Plane (Vector a, Vector b, Vector c); |
---|
251 | Plane (Vector norm, Vector p); |
---|
252 | Plane (Vector norm, sVec3D p); |
---|
253 | Plane (Vector n, float k) : n(n), k(k) {} //!< assignment constructor |
---|
254 | Plane () : n(Vector(1,1,1)), k(0) {} |
---|
255 | ~Plane () {} |
---|
256 | |
---|
257 | Vector intersectLine (const Line& l) const; |
---|
258 | float distancePoint (const Vector& p) const; |
---|
259 | float distancePoint (const sVec3D& p) const; |
---|
260 | float locatePoint (const Vector& p) const; |
---|
261 | }; |
---|
262 | |
---|
263 | |
---|
264 | |
---|
265 | //! A class that represents a rectangle, this is needed for SpatialSeparation |
---|
266 | class Rectangle |
---|
267 | { |
---|
268 | |
---|
269 | public: |
---|
270 | Rectangle() { this->center = new Vector(); } |
---|
271 | Rectangle(const Vector ¢er, float len) { this->center = new Vector(center.x, center.y, center.z); this->axis[0] = len; this->axis[1] = len; } |
---|
272 | virtual ~Rectangle() {} |
---|
273 | |
---|
274 | /** \brief sets the center of the rectangle to a defined vector @param center the new center */ |
---|
275 | inline void setCenter(const Vector ¢er) { *this->center = center;} |
---|
276 | /** \brief sets the center of the rectangle to a defined vector @param x coord of the center @param y coord of the center @param z coord of the center */ |
---|
277 | inline void setCenter(float x, float y, float z) { this->center->x = x; this->center->y = y; this->center->z = z; } |
---|
278 | /** \brief returns the center of the rectangle to a defined vector @returns center the new center */ |
---|
279 | inline const Vector* getCenter() const { return this->center; } |
---|
280 | |
---|
281 | /** \brief sets both axis of the rectangle to a defined vector @param unityLength the new center */ |
---|
282 | inline void setAxis(float unityLength) { this->axis[0] = unityLength; this->axis[1] = unityLength; } |
---|
283 | /** \brief sets both axis of the rectangle to a defined vector @param v1 the length of the x axis @param v2 the length of the z axis*/ |
---|
284 | inline void setAxis(float v1, float v2) { this->axis[0] = v1; this->axis[1] = v2; } |
---|
285 | /** \brief gets one axis length of the rectangle @returns the length of the axis 0 */ |
---|
286 | inline float getAxis() { return this-> axis[0]; } |
---|
287 | |
---|
288 | private: |
---|
289 | Vector* center; |
---|
290 | float axis[2]; |
---|
291 | }; |
---|
292 | |
---|
293 | |
---|
294 | #endif /* _VECTOR_H */ |
---|
295 | |
---|