007682df2914dbe60d07100a907108e00e8f13dd
[blender.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
37 class AUD_Vector3
38 {
39 private:
40         union
41         {
42                 float m_v[3];
43                 struct
44                 {
45                         float m_x;
46                         float m_y;
47                         float m_z;
48                 };
49         };
50
51 public:
52         /**
53          * Creates a new 3 dimensional vector.
54          * \param x The x component.
55          * \param y The y component.
56          * \param z The z component.
57          */
58         inline AUD_Vector3(float x = 0, float y = 0, float z = 0) :
59                 m_x(x), m_y(y), m_z(z)
60         {
61         }
62
63         /**
64          * Retrieves the x component of the vector.
65          * \return The x component.
66          */
67         inline const float& x() const
68         {
69                 return m_x;
70         }
71
72         /**
73          * Retrieves the y component of the vector.
74          * \return The y component.
75          */
76         inline const float& y() const
77         {
78                 return m_y;
79         }
80
81         /**
82          * Retrieves the z component of the vector.
83          * \return The z component.
84          */
85         inline const float& z() const
86         {
87                 return m_z;
88         }
89
90         /**
91          * Retrieves the components of the vector.
92          * \param destination Where the 3 float values should be saved to.
93          */
94         inline void get(float* destination) const
95         {
96                 destination[0] = m_x;
97                 destination[1] = m_y;
98                 destination[2] = m_z;
99         }
100
101         /**
102          * Retrieves the components of the vector.
103          * \return The components as float[3].
104          */
105         inline float* get()
106         {
107                 return m_v;
108         }
109
110         /**
111          * Retrieves the components of the vector.
112          * \return The components as float[3].
113          */
114         inline const float* get() const
115         {
116                 return m_v;
117         }
118
119         /**
120          * Retrieves the length of the vector.
121          * \return The length of the vector.
122          */
123         inline float length() const
124         {
125                 return sqrt(m_x*m_x + m_y*m_y + m_z*m_z);
126         }
127
128         inline AUD_Vector3 cross(const AUD_Vector3& op) const
129         {
130                 return AUD_Vector3(m_y * op.m_z - m_z * op.m_y,
131                                                    m_z * op.m_x - m_x * op.m_z,
132                                                    m_x * op.m_y - m_y * op.m_x);
133         }
134
135         /**
136          * Retrieves the dot product.
137          * \param op The second operand.
138          * \return The dot product of the two vectors.
139          */
140         inline float operator*(const AUD_Vector3& op) const
141         {
142                 return m_x * op.m_x + m_y * op.m_y + m_z * op.m_z;
143         }
144
145         inline AUD_Vector3 operator*(const float& op) const
146         {
147                 return AUD_Vector3(m_x * op, m_y * op, m_z * op);
148         }
149
150         inline AUD_Vector3 operator+(const AUD_Vector3& op) const
151         {
152                 return AUD_Vector3(m_x + op.m_x, m_y + op.m_y, m_z + op.m_z);
153         }
154
155         inline AUD_Vector3 operator-(const AUD_Vector3& op) const
156         {
157                 return AUD_Vector3(m_x - op.m_x, m_y - op.m_y, m_z - op.m_z);
158         }
159
160         inline AUD_Vector3 operator-() const
161         {
162                 return AUD_Vector3(-m_x, -m_y, -m_z);
163         }
164
165         inline AUD_Vector3& operator-=(const AUD_Vector3& op)
166         {
167                 m_x -= op.m_x;
168                 m_y -= op.m_y;
169                 m_z -= op.m_z;
170                 return *this;
171         }
172 };
173
174 class AUD_Quaternion
175 {
176 private:
177         union
178         {
179                 float m_v[4];
180                 struct
181                 {
182                         float m_w;
183                         float m_x;
184                         float m_y;
185                         float m_z;
186                 };
187         };
188
189 public:
190         /**
191          * Creates a new quaternion.
192          * \param w The w component.
193          * \param x The x component.
194          * \param y The y component.
195          * \param z The z component.
196          */
197         inline AUD_Quaternion(float w = 1, float x = 0, float y = 0, float z = 0) :
198                 m_w(w), m_x(x), m_y(y), m_z(z)
199         {
200         }
201
202         /**
203          * Retrieves the w component of the quarternion.
204          * \return The w component.
205          */
206         inline const float& w() const
207         {
208                 return m_w;
209         }
210
211         /**
212          * Retrieves the x component of the quarternion.
213          * \return The x component.
214          */
215         inline const float& x() const
216         {
217                 return m_x;
218         }
219
220         /**
221          * Retrieves the y component of the quarternion.
222          * \return The y component.
223          */
224         inline const float& y() const
225         {
226                 return m_y;
227         }
228
229         /**
230          * Retrieves the z component of the quarternion.
231          * \return The z component.
232          */
233         inline const float& z() const
234         {
235                 return m_z;
236         }
237
238         /**
239          * Retrieves the components of the vector.
240          * \param destination Where the 4 float values should be saved to.
241          */
242         inline void get(float* destination) const
243         {
244                 destination[0] = m_w;
245                 destination[1] = m_x;
246                 destination[2] = m_y;
247                 destination[3] = m_z;
248         }
249
250         /**
251          * Retrieves the components of the vector.
252          * \return The components as float[4].
253          */
254         inline float* get()
255         {
256                 return m_v;
257         }
258
259         /**
260          * Retrieves the components of the vector.
261          * \return The components as float[4].
262          */
263         inline const float* get() const
264         {
265                 return m_v;
266         }
267
268         inline AUD_Vector3 getLookAt() const
269         {
270                 return AUD_Vector3(-2 * (m_w * m_y + m_x * m_z),
271                                                         2 * (m_x * m_w - m_z * m_y),
272                                                         2 * (m_x * m_x + m_y * m_y) - 1);
273         }
274
275         inline AUD_Vector3 getUp() const
276         {
277                 return AUD_Vector3(2 * (m_x * m_y - m_w * m_z),
278                                                         1 - 2 * (m_x * m_x + m_z * m_z),
279                                                         2 * (m_w * m_x + m_y * m_z));
280         }
281 };
282
283 #endif //AUD_3DMATH