Aether3D Game Engine
Vec3.hpp
1 #ifndef VEC3_H
2 #define VEC3_H
3 
4 #ifndef INCLUDE_MATH_H
5 # include <cmath>
6 # define INCLUDE_MATH_H
7 #endif
8 #ifndef INCLUDE_ALGORITHM_H
9 # include <algorithm>
10 # define INCLUDE_ALGORITHM_H
11 #endif
12 
22 struct Vec3
23 {
24  float x, y, z;
25 
33  static Vec3 Cross( const Vec3& v1, const Vec3& v2 )
34  {
35  return Vec3( v1.y * v2.z - v1.z * v2.y,
36  v1.z * v2.x - v1.x * v2.z,
37  v1.x * v2.y - v1.y * v2.x );
38  }
39 
48  static float Distance( const Vec3& v1, const Vec3& v2 )
49  {
50  return (v2 - v1).Length();
51  }
52 
61  static float DistanceSquared( const Vec3& v1, const Vec3& v2 )
62  {
63  const Vec3 sub = v2 - v1;
64  return sub.x * sub.x + sub.y * sub.y + sub.z * sub.z;
65  }
66 
74  static float Dot( const Vec3& v1, const Vec3& v2 )
75  {
76  return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
77  }
78 
88  static Vec3 Min2( const Vec3& v1, const Vec3& v2 )
89  {
90  return Vec3( std::min( v1.x, v2.x ), std::min( v1.y, v2.y ), std::min( v1.z, v2.z ) );
91  }
92 
101  static Vec3 Max2( const Vec3& v1, const Vec3& v2 )
102  {
103  return Vec3( std::max( v1.x, v2.x ), std::max( v1.y, v2.y ), std::max( v1.z, v2.z ) );
104  }
105 
113  static Vec3 Reflect( const Vec3& vec, const Vec3& normal ) { return vec - normal * Dot( normal, vec ) * 2; }
114 
116  inline Vec3( const Vec3& other ) = default;
117 
119  inline Vec3() : x( 0 ), y( 0 ), z( 0 ) {}
120 
128  inline Vec3( float ax, float ay, float az ) : x( ax ), y( ay ), z( az ) {}
129 
136  bool IsAlmost( const Vec3& v ) const
137  {
138  const float acceptableDelta = 0.0001f;
139  if (std::fabs( x - v.x ) > acceptableDelta) { return false; }
140  if (std::fabs( y - v.y ) > acceptableDelta) { return false; }
141  if (std::fabs( z - v.z ) > acceptableDelta) { return false; }
142  return true;
143  }
144 
151  inline Vec3 operator/( float f ) const
152  {
153  const float inv = 1.0f / f;
154  return Vec3( x * inv, y * inv, z * inv );
155  }
156 
163  inline Vec3 operator/( const Vec3& v ) const
164  {
165  return Vec3( x / v.x, y / v.y, z / v.z );
166  }
167 
173  inline Vec3 operator-() const
174  {
175  return Vec3( -x, -y, -z );
176  }
177 
184  inline Vec3 operator-( const Vec3& v ) const
185  {
186  return Vec3( x - v.x, y - v.y, z - v.z );
187  }
188 
195  inline Vec3 operator+( const Vec3& v ) const
196  {
197  return Vec3( x + v.x, y + v.y, z + v.z );
198  }
199 
206  inline Vec3 operator+( float f ) const
207  {
208  return Vec3( x + f, y + f, z + f );
209  }
210 
217  inline bool operator==( const Vec3& v) const
218  {
219  return x == v.x && y == v.y && z == v.z;
220  }
221 
228  inline bool operator!=( const Vec3& v) const
229  {
230  return x != v.x || y != v.y || z != v.z;
231  }
232 
239  inline Vec3& operator-=( const Vec3& v )
240  {
241  x -= v.x;
242  y -= v.y;
243  z -= v.z;
244 
245  return *this;
246  }
247 
254  inline Vec3& operator+=( const Vec3& v )
255  {
256  x += v.x;
257  y += v.y;
258  z += v.z;
259 
260  return *this;
261  }
262 
269  inline Vec3& operator*=( float f )
270  {
271  x *= f;
272  y *= f;
273  z *= f;
274 
275  return *this;
276  }
277 
284  inline Vec3& operator/=(float f)
285  {
286  const float inv = 1.0f / f;
287 
288  x *= inv;
289  y *= inv;
290  z *= inv;
291 
292  return *this;
293  }
294 
301  inline Vec3& operator*=( const Vec3& v )
302  {
303  x *= v.x;
304  y *= v.y;
305  z *= v.z;
306 
307  return *this;
308  }
309 
316  inline Vec3& operator=( const Vec3& v ) { x = v.x; y = v.y; z = v.z; return *this; }
317 
324  inline Vec3 operator*( const Vec3& v ) const
325  {
326  return Vec3( x * v.x, y * v.y, z * v.z );
327  }
328 
335  inline Vec3 operator*( float f ) const
336  {
337  return Vec3( x * f, y * f, z * f );
338  }
339 
343  inline Vec3 Normalized() const
344  {
345  Vec3 out = *this;
346 
347  const float len = Length();
348 
349  if( std::abs( len ) < 0.0001f )
350  {
351  out.x = 1.0f;
352  out.y = 0.0f;
353  out.z = 0.0f;
354  return out;
355  }
356 
357  out *= (1.0f / len);
358  return out;
359  }
360 
362  inline float Length() const { return std::sqrt( x * x + y * y + z * z ); }
363 
365  inline void Zero() { x = y = z = 0; }
366 };
367 
369 #if defined( _MSC_VER ) || defined( COMPILER_INTEL )
370 # define BEGIN_ALIGNED( n, a ) __declspec( align( a ) ) n
371 # define END_ALIGNED( n, a )
372 #elif defined( __GNUC__ ) || defined( __clang__ )
373 # define BEGIN_ALIGNED( n, a ) n
374 # define END_ALIGNED( n, a ) __attribute__( (aligned( a ) ) )
375 #endif
376 
377 #ifdef SIMD_SSE3
378 struct BEGIN_ALIGNED( Vec4, 16 )
379 #else
380 struct Vec4
381 #endif
382 {
383  float x, y, z, w;
384 
386  inline Vec4() : x( 0 ), y( 0 ), z( 0 ), w( 0 ) {}
387 
396  inline Vec4( float ax, float ay, float az, float aw ) : x( ax ), y( ay ), z( az ), w( aw ) {}
397 
399  inline Vec4( const Vec3& v ) : x( v.x ), y( v.y ), z( v.z ), w( 1 ) {}
400 
407  inline Vec4( const Vec3& v, float aW ) : x( v.x ), y( v.y ), z( v.z ), w( aW ) {}
408 
415  inline Vec4 operator*( float f ) const
416  {
417  return Vec4( x * f, y * f, z * f, w * f );
418  }
419 
425  inline Vec4& operator+=( const Vec4& v )
426  {
427  x += v.x;
428  y += v.y;
429  z += v.z;
430 
431  return *this;
432  }
433 
439  inline Vec4& operator-=( const Vec4& v )
440  {
441  x -= v.x;
442  y -= v.y;
443  z -= v.z;
444 
445  return *this;
446  }
447 
454  inline float Dot( const Vec4& v ) const
455  {
456  return x * v.x + y * v.y + z * v.z + w * v.w;
457  }
458 
460  inline float Length() const { return std::sqrt( x * x + y * y + z * z ); }
461 
465  inline void Normalize()
466  {
467  const float len = Length();
468 
469  if( std::abs( len ) < 0.0001f )
470  {
471  x = 1;
472  y = 0;
473  z = 0;
474  return;
475  }
476 
477  const float iLength = 1 / len;
478 
479  x *= iLength;
480  y *= iLength;
481  z *= iLength;
482  }
483 }
484 #ifdef SIMD_SSE3
485 END_ALIGNED( Vec4, 16 )
486 #endif
487 ;
488 
489 #endif
Vec3 operator-(const Vec3 &v) const
Definition: Vec3.hpp:184
Vec3 & operator-=(const Vec3 &v)
Definition: Vec3.hpp:239
Vec3 & operator*=(const Vec3 &v)
Definition: Vec3.hpp:301
static float DistanceSquared(const Vec3 &v1, const Vec3 &v2)
Definition: Vec3.hpp:61
Vec3 operator*(const Vec3 &v) const
Definition: Vec3.hpp:324
Vec4(const Vec3 &v, float aW)
Definition: Vec3.hpp:407
static Vec3 Min2(const Vec3 &v1, const Vec3 &v2)
Definition: Vec3.hpp:88
static float Distance(const Vec3 &v1, const Vec3 &v2)
Definition: Vec3.hpp:48
static Vec3 Cross(const Vec3 &v1, const Vec3 &v2)
Cross product.
Definition: Vec3.hpp:33
Vec3 & operator*=(float f)
Definition: Vec3.hpp:269
bool IsAlmost(const Vec3 &v) const
Definition: Vec3.hpp:136
Vec4 operator*(float f) const
Definition: Vec3.hpp:415
Vec4 & operator+=(const Vec4 &v)
Definition: Vec3.hpp:425
void Zero()
Resets this vector&#39;s values to 0.
Definition: Vec3.hpp:365
Vec4(const Vec3 &v)
Definition: Vec3.hpp:399
static float Dot(const Vec3 &v1, const Vec3 &v2)
Definition: Vec3.hpp:74
4-component vector.
Definition: Vec3.hpp:380
Vec3 operator+(float f) const
Definition: Vec3.hpp:206
Vec3 & operator/=(float f)
Definition: Vec3.hpp:284
Vec3 operator/(const Vec3 &v) const
Definition: Vec3.hpp:163
Vec3 Normalized() const
Definition: Vec3.hpp:343
Vec3 operator*(float f) const
Definition: Vec3.hpp:335
3-component vector.
Definition: Vec3.hpp:22
Vec3 operator/(float f) const
Definition: Vec3.hpp:151
Vec3()
Constructor.
Definition: Vec3.hpp:119
Vec4()
Constructor.
Definition: Vec3.hpp:386
Vec3 operator+(const Vec3 &v) const
Definition: Vec3.hpp:195
Vec4 & operator-=(const Vec4 &v)
Definition: Vec3.hpp:439
static Vec3 Reflect(const Vec3 &vec, const Vec3 &normal)
Definition: Vec3.hpp:113
Vec4(float ax, float ay, float az, float aw)
Definition: Vec3.hpp:396
float Length() const
Definition: Vec3.hpp:460
Vec3 & operator=(const Vec3 &v)
Definition: Vec3.hpp:316
float Length() const
Definition: Vec3.hpp:362
void Normalize()
Definition: Vec3.hpp:465
Vec3(float ax, float ay, float az)
Definition: Vec3.hpp:128
static Vec3 Max2(const Vec3 &v1, const Vec3 &v2)
Definition: Vec3.hpp:101
bool operator==(const Vec3 &v) const
Definition: Vec3.hpp:217
bool operator!=(const Vec3 &v) const
Definition: Vec3.hpp:228
float Dot(const Vec4 &v) const
Definition: Vec3.hpp:454
Vec3 operator-() const
Definition: Vec3.hpp:173
Vec3 & operator+=(const Vec3 &v)
Definition: Vec3.hpp:254