source: flair-src/trunk/lib/FlairCore/src/Vector3D.h@ 2

Last change on this file since 2 was 2, checked in by Sanahuja Guillaume, 7 years ago

flaircore

File size: 6.7 KB
Line 
1// %flair:license{
2// This file is part of the Flair framework distributed under the
3// CECILL-C License, Version 1.0.
4// %flair:license}
5
6/*!
7 * \file Vector3D.h
8 * \brief Class defining a 3D vector
9 * \author Guillaume Sanahuja, Copyright Heudiasyc UMR UTC/CNRS 7253
10 * \date 2013/05/02
11 * \version 4.0
12 */
13#ifndef VECTOR3D_H
14#define VECTOR3D_H
15
16#include <stddef.h>
17
18namespace flair { namespace core {
19 class Vector2D;
20 class RotationMatrix;
21 class Quaternion;
22
23 /*! \class Vector3D
24 *
25 * \brief Class defining a 3D vector
26 */
27 class Vector3D {
28 public:
29 /*!
30 * \brief Constructor
31 *
32 * Construct a Vector3D using specified values.
33 *
34 * \param x
35 * \param y
36 * \param z
37 */
38 Vector3D(float x=0,float y=0,float z=0);
39
40 /*!
41 * \brief Destructor
42 *
43 */
44 ~Vector3D();
45
46 /*!
47 * \brief x
48 */
49 float x;
50
51 /*!
52 * \brief y
53 */
54 float y;
55
56 /*!
57 * \brief z
58 */
59 float z;
60
61 /*!
62 * \brief x axis rotation
63 *
64 * \param value rotation value in radians
65 */
66 void RotateX(float value);
67
68 /*!
69 * \brief x axis rotation
70 *
71 * \param value rotation value in degrees
72 */
73 void RotateXDeg(float value);
74
75 /*!
76 * \brief y axis rotation
77 *
78 * \param value rotation value in radians
79 */
80 void RotateY(float value);
81
82 /*!
83 * \brief y axis rotation
84 *
85 * \param value rotation value in degrees
86 */
87 void RotateYDeg(float value);
88
89 /*!
90 * \brief z axis rotation
91 *
92 * \param value rotation value in radians
93 */
94 void RotateZ(float value);
95
96 /*!
97 * \brief z axis rotation
98 *
99 * \param value rotation value in degrees
100 */
101 void RotateZDeg(float value);
102
103 /*!
104 * \brief rotation
105 *
106 * \param matrix rotation matrix
107 */
108 void Rotate(const RotationMatrix &matrix);
109
110 /*!
111 * \brief rotation
112 *
113 * Compute a rotation from a quaternion. This method uses a rotation matrix
114 * internaly.
115 *
116 * \param quaternion quaternion
117 */
118 void Rotate(const Quaternion &quaternion);
119
120 /*!
121 * \brief Convert to a Vector2D
122 *
123 * Uses x and y coordinates.
124 *
125 * \param vector destination
126 */
127 void To2Dxy(Vector2D &vector) const;
128
129 /*!
130 * \brief Convert to a Vector2D
131 *
132 * Uses x and y coordinates.
133 *
134 * \return destination
135 */
136 Vector2D To2Dxy(void) const;
137
138 /*!
139 * \brief Norm
140 *
141 * \return value
142 */
143 float GetNorm(void) const;
144
145 /*!
146 * \brief Normalize
147 */
148 void Normalize(void);
149
150 /*!
151 * \brief Saturate
152 *
153 * Saturate between min and max
154 *
155 * \param min minimum value
156 * \param max maximum value
157 */
158 void Saturate(const Vector3D &min,const Vector3D &max);
159
160 /*!
161 * \brief Saturate
162 *
163 * Saturate between min and max
164 *
165 * \param min minimum Vector3D(min,min,min) value
166 * \param max maximum Vector3D(max,max,max) value
167 */
168 void Saturate(float min,float max);
169
170 /*!
171 * \brief Saturate
172 *
173 * Saturate between -abs(value) and abs(value)
174 *
175 * \param value saturation Vector3D value
176 */
177 void Saturate(const Vector3D &value);
178
179 /*!
180 * \brief Saturate
181 *
182 * Saturate between -abs(Vector3D(value,value,value)) and abs(Vector3D(value,value,value))
183 *
184 * \param value saturation Vector3D(value,value,value)
185 */
186 void Saturate(float value);
187
188 float &operator[](size_t idx);
189 const float &operator[](size_t idx) const;
190 Vector3D &operator=(const Vector3D& vector);
191 Vector3D &operator+=(const Vector3D& vector);
192 Vector3D &operator-=(const Vector3D& vector);
193
194 private:
195
196 };
197
198 /*! Add
199 *
200 * \brief Add
201 *
202 * \param vectorA vector
203 * \param vectorB vector
204 *
205 * \return vectorA+vectorB
206 */
207 Vector3D operator + (const Vector3D &vectorA,const Vector3D &vectorB);
208
209 /*! Substract
210 *
211 * \brief Substract
212 *
213 * \param vectorA vector
214 * \param vectorB vector
215 *
216 * \return vectorA-vectorB
217 */
218 Vector3D operator - (const Vector3D &vectorA,const Vector3D &vectorB);
219
220 /*! Minus
221 *
222 * \brief Minus
223 *
224 * \param vector vector
225 *
226 * \return -vector
227 */
228 Vector3D operator-(const Vector3D &vector);
229
230 /*! Divid
231 *
232 * \brief Divid
233 *
234 * \param vector vector
235 * \param coeff coefficent
236 *
237 * \return vector/coefficient
238 */
239 Vector3D operator / (const Vector3D &vector, float coeff);
240
241 /*! Hadamard product
242 *
243 * \brief Hadamard product
244 *
245 * \param vectorA vector
246 * \param vectorBA vector
247 *
248 * \return Hadamard product
249 */
250 Vector3D operator * (const Vector3D &vectorA, const Vector3D &vectorB);
251
252 /*! Multiply
253 *
254 * \brief Multiply
255 *
256 * \param vector vector
257 * \param coeff coefficent
258 *
259 * \return coefficient*vector
260 */
261 Vector3D operator * (const Vector3D &vector, float coeff);
262
263 /*! Multiply
264 *
265 * \brief Multiply
266 *
267 * \param coeff coefficent
268 * \param vector vector
269 *
270 * \return coefficient*vector
271 */
272 Vector3D operator * (float coeff, const Vector3D &vector);
273
274 /*! Cross product
275 *
276 * \brief Cross product
277 *
278 * \param vectorA first vector
279 * \param vectorB second vector
280 *
281 * \return cross product
282 */
283 Vector3D CrossProduct(const Vector3D &vectorA, const Vector3D &vectorB);
284
285 /*! Dot product
286 *
287 * \brief Dot product
288 *
289 * \param vectorA first vector
290 * \param vectorB second vector
291 *
292 * \return dot product
293 */
294 float DotProduct(const Vector3D &vectorA, const Vector3D &vectorB);
295
296} // end namespace core
297} // end namespace flair
298
299#endif // VECTOR3D_H
Note: See TracBrowser for help on using the repository browser.