svn merge -r39781:39792 https://svn.blender.org/svnroot/bf-blender/trunk/blender...
[blender-staging.git] / intern / audaspace / intern / AUD_3DMath.h
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * Copyright 2009-2011 Jörg Hermann Müller
7  *
8  * This file is part of AudaSpace.
9  *
10  * Audaspace is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * AudaSpace is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with Audaspace; if not, write to the Free Software Foundation,
22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file audaspace/intern/AUD_3DMath.h
28  *  \ingroup audaspaceintern
29  */
30
31
32 #ifndef AUD_3DMATH
33 #define AUD_3DMATH
34
35 #include <cmath>
36 #include <cstring>
37
38 /**
39  * This class represents a 3 dimensional vector.
40  */
41 class AUD_Vector3
42 {
43 private:
44         /**
45          * The vector components.
46          */
47         union
48         {
49                 float m_v[3];
50                 struct
51                 {
52                         float m_x;
53                         float m_y;
54                         float m_z;
55                 };
56         };
57
58 public:
59         /**
60          * Creates a new 3 dimensional vector.
61          * \param x The x component.
62          * \param y The y component.
63          * \param z The z component.
64          */
65         inline AUD_Vector3(float x = 0, float y = 0, float z = 0) :
66                 m_x(x), m_y(y), m_z(z)
67         {
68         }
69
70         /**
71          * Retrieves the x component of the vector.
72          * \return The x component.
73          */
74         inline const float& x() const
75         {
76                 return m_x;
77         }
78
79         /**
80          * Retrieves the y component of the vector.
81          * \return The y component.
82          */
83         inline const float& y() const
84         {
85                 return m_y;
86         }
87
88         /**
89          * Retrieves the z component of the vector.
90          * \return The z component.
91          */
92         inline const float& z() const
93         {
94                 return m_z;
95         }
96
97         /**
98          * Retrieves the components of the vector.
99          * \param destination Where the 3 float values should be saved to.
100          */
101         inline void get(float* destination) const
102         {
103                 memcpy(destination, m_v, sizeof(m_v));
104         }
105
106         /**
107          * Retrieves the components of the vector.
108          * \return The components as float[3].
109          */
110         inline float* get()
111         {
112                 return m_v;
113         }
114
115         /**
116          * Retrieves the components of the vector.
117          * \return The components as float[3].
118          */
119         inline const float* get() const
120         {
121                 return m_v;
122         }
123
124         /**
125          * Retrieves the length of the vector.
126          * \return The length of the vector.
127          */
128         inline float length() const
129         {
130                 return sqrt(m_x*m_x + m_y*m_y + m_z*m_z);
131         }
132
133         /**
134          * Retrieves the cross product.
135          * \param op The second operand.
136          * \return The cross product of the two vectors.
137          */
138         inline AUD_Vector3 cross(const AUD_Vector3& op) const
139         {
140                 return AUD_Vector3(m_y * op.m_z - m_z * op.m_y,
141                                                    m_z * op.m_x - m_x * op.m_z,
142                                                    m_x * op.m_y - m_y * op.m_x);
143         }
144
145         /**
146          * Retrieves the dot product.
147          * \param op The second operand.
148          * \return The dot product of the two vectors.
149          */
150         inline float operator*(const AUD_Vector3& op) const
151         {
152                 return m_x * op.m_x + m_y * op.m_y + m_z * op.m_z;
153         }
154
155         /**
156          * Retrieves the product with a scalar.
157          * \param op The second operand.
158          * \return The scaled vector.
159          */
160         inline AUD_Vector3 operator*(const float& op) const
161         {
162                 return AUD_Vector3(m_x * op, m_y * op, m_z * op);
163         }
164
165         /**
166          * Adds two vectors.
167          * \param op The second operand.
168          * \return The sum vector.
169          */
170         inline AUD_Vector3 operator+(const AUD_Vector3& op) const
171         {
172                 return AUD_Vector3(m_x + op.m_x, m_y + op.m_y, m_z + op.m_z);
173         }
174
175         /**
176          * Subtracts two vectors.
177          * \param op The second operand.
178          * \return The difference vector.
179          */
180         inline AUD_Vector3 operator-(const AUD_Vector3& op) const
181         {
182                 return AUD_Vector3(m_x - op.m_x, m_y - op.m_y, m_z - op.m_z);
183         }
184
185         /**
186          * Negates the vector.
187          * \return The vector facing in the opposite direction.
188          */
189         inline AUD_Vector3 operator-() const
190         {
191                 return AUD_Vector3(-m_x, -m_y, -m_z);
192         }
193
194         /**
195          * Subtracts the second vector.
196          * \param op The second operand.
197          * \return The difference vector.
198          */
199         inline AUD_Vector3& operator-=(const AUD_Vector3& op)
200         {
201                 m_x -= op.m_x;
202                 m_y -= op.m_y;
203                 m_z -= op.m_z;
204                 return *this;
205         }
206 };
207
208 /**
209  * This class represents a quaternion used for 3D rotations.
210  */
211 class AUD_Quaternion
212 {
213 private:
214         /**
215          * The quaternion components.
216          */
217         union
218         {
219                 float m_v[4];
220                 struct
221                 {
222                         float m_w;
223                         float m_x;
224                         float m_y;
225                         float m_z;
226                 };
227         };
228
229 public:
230         /**
231          * Creates a new quaternion.
232          * \param w The w component.
233          * \param x The x component.
234          * \param y The y component.
235          * \param z The z component.
236          */
237         inline AUD_Quaternion(float w = 1, float x = 0, float y = 0, float z = 0) :
238                 m_w(w), m_x(x), m_y(y), m_z(z)
239         {
240         }
241
242         /**
243          * Retrieves the w component of the quarternion.
244          * \return The w component.
245          */
246         inline const float& w() const
247         {
248                 return m_w;
249         }
250
251         /**
252          * Retrieves the x component of the quarternion.
253          * \return The x component.
254          */
255         inline const float& x() const
256         {
257                 return m_x;
258         }
259
260         /**
261          * Retrieves the y component of the quarternion.
262          * \return The y component.
263          */
264         inline const float& y() const
265         {
266                 return m_y;
267         }
268
269         /**
270          * Retrieves the z component of the quarternion.
271          * \return The z component.
272          */
273         inline const float& z() const
274         {
275                 return m_z;
276         }
277
278         /**
279          * Retrieves the components of the vector.
280          * \param destination Where the 4 float values should be saved to.
281          */
282         inline void get(float* destination) const
283         {
284                 memcpy(destination, m_v, sizeof(m_v));
285         }
286
287         /**
288          * Retrieves the components of the vector.
289          * \return The components as float[4].
290          */
291         inline float* get()
292         {
293                 return m_v;
294         }
295
296         /**
297          * Retrieves the components of the vector.
298          * \return The components as float[4].
299          */
300         inline const float* get() const
301         {
302                 return m_v;
303         }
304
305         /**
306          * When the quaternion represents an orientation, this returns the negative
307          * z axis vector.
308          * \return The negative z axis vector.
309          */
310         inline AUD_Vector3 getLookAt() const
311         {
312                 return AUD_Vector3(-2 * (m_w * m_y + m_x * m_z),
313                                                         2 * (m_x * m_w - m_z * m_y),
314                                                         2 * (m_x * m_x + m_y * m_y) - 1);
315         }
316
317         /**
318          * When the quaternion represents an orientation, this returns the y axis
319          * vector.
320          * \return The y axis vector.
321          */
322         inline AUD_Vector3 getUp() const
323         {
324                 return AUD_Vector3(2 * (m_x * m_y - m_w * m_z),
325                                                         1 - 2 * (m_x * m_x + m_z * m_z),
326                                                         2 * (m_w * m_x + m_y * m_z));
327         }
328 };
329
330 #endif //AUD_3DMATH