3a6abf811ce2b739cc473ce143ef545ec2b4cf40
[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 const float* get() const
106         {
107                 return m_v;
108         }
109
110         /**
111          * Retrieves the length of the vector.
112          * \return The length of the vector.
113          */
114         inline float length() const
115         {
116                 return sqrt(m_x*m_x + m_y*m_y + m_z*m_z);
117         }
118
119         inline AUD_Vector3 cross(const AUD_Vector3& op) const
120         {
121                 return AUD_Vector3(m_y * op.m_z - m_z * op.m_y,
122                                                    m_z * op.m_x - m_x * op.m_z,
123                                                    m_x * op.m_y - m_y * op.m_x);
124         }
125
126         /**
127          * Retrieves the dot product.
128          * \param op The second operand.
129          * \return The dot product of the two vectors.
130          */
131         inline float operator*(const AUD_Vector3& op) const
132         {
133                 return m_x * op.m_x + m_y * op.m_y + m_z * op.m_z;
134         }
135
136         inline AUD_Vector3 operator*(const float& op) const
137         {
138                 return AUD_Vector3(m_x * op, m_y * op, m_z * op);
139         }
140
141         inline AUD_Vector3 operator+(const AUD_Vector3& op) const
142         {
143                 return AUD_Vector3(m_x + op.m_x, m_y + op.m_y, m_z + op.m_z);
144         }
145
146         inline AUD_Vector3 operator-(const AUD_Vector3& op) const
147         {
148                 return AUD_Vector3(m_x - op.m_x, m_y - op.m_y, m_z - op.m_z);
149         }
150
151         inline AUD_Vector3 operator-() const
152         {
153                 return AUD_Vector3(-m_x, -m_y, -m_z);
154         }
155 };
156
157 class AUD_Quaternion
158 {
159 private:
160         union
161         {
162                 float m_v[4];
163                 struct
164                 {
165                         float m_w;
166                         float m_x;
167                         float m_y;
168                         float m_z;
169                 };
170         };
171
172 public:
173         /**
174          * Creates a new quaternion.
175          * \param w The w component.
176          * \param x The x component.
177          * \param y The y component.
178          * \param z The z component.
179          */
180         inline AUD_Quaternion(float w = 1, float x = 0, float y = 0, float z = 0) :
181                 m_w(w), m_x(x), m_y(y), m_z(z)
182         {
183         }
184
185         /**
186          * Retrieves the w component of the quarternion.
187          * \return The w component.
188          */
189         inline const float& w() const
190         {
191                 return m_w;
192         }
193
194         /**
195          * Retrieves the x component of the quarternion.
196          * \return The x component.
197          */
198         inline const float& x() const
199         {
200                 return m_x;
201         }
202
203         /**
204          * Retrieves the y component of the quarternion.
205          * \return The y component.
206          */
207         inline const float& y() const
208         {
209                 return m_y;
210         }
211
212         /**
213          * Retrieves the z component of the quarternion.
214          * \return The z component.
215          */
216         inline const float& z() const
217         {
218                 return m_z;
219         }
220
221         /**
222          * Retrieves the components of the vector.
223          * \param destination Where the 4 float values should be saved to.
224          */
225         inline void get(float* destination) const
226         {
227                 destination[0] = m_w;
228                 destination[1] = m_x;
229                 destination[2] = m_y;
230                 destination[3] = m_z;
231         }
232
233         /**
234          * Retrieves the components of the vector.
235          * \return The components as float[4].
236          */
237         inline const float* get() const
238         {
239                 return m_v;
240         }
241
242         inline AUD_Vector3 getLookAt() const
243         {
244                 return AUD_Vector3(-2 * (m_w * m_y + m_x * m_z),
245                                                         2 * (m_x * m_w - m_z * m_y),
246                                                         2 * (m_x * m_x + m_y * m_y) - 1);
247         }
248
249         inline AUD_Vector3 getUp() const
250         {
251                 return AUD_Vector3(2 * (m_x * m_y - m_w * m_z),
252                                                         1 - 2 * (m_x * m_x + m_z * m_z),
253                                                         2 * (m_w * m_x + m_y * m_z));
254         }
255 };
256
257 #endif //AUD_3DMATH