vec3.h
Go to the documentation of this file.
1 
2 #pragma once
3 
4 #include "vec2.h"
5 
6 #include <glm/gtc/matrix_transform.hpp>
7 
8 
9 namespace ion
10 {
11 
14  template <typename T>
15  struct vec3
16  {
17 
18  T X;
19  T Y;
20  T Z;
21 
23  // Constructors //
25 
27  vec3()
28  : X(0), Y(0), Z(0)
29  {}
30 
32  vec3(T const in)
33  : X(in), Y(in), Z(in)
34  {}
35 
37  vec3(T const x, T const y, T const z)
38  : X(x), Y(y), Z(z)
39  {}
40 
42  template <typename U>
43  vec3(glm::tvec3<U, glm::defaultp> const & v)
44  : X(v.x), Y(v.y), Z(v.z)
45  {}
46 
48  template <typename U>
49  vec3(vec3<U> const & vec)
50  : X((T) vec.X), Y((T) vec.Y), Z((T) vec.Z)
51  {}
52 
54  vec3(vec2<T> const & vec, T const z = 0)
55  : X(vec.X), Y(vec.Y), Z(z)
56  {}
57 
59  vec3(T const x, vec2<T> const & vecYZ)
60  : X(x), Y(vecYZ.X), Z(vecYZ.Y)
61  {}
62 
63 
65  // Index Operators //
67 
69  T operator[] (int i) const
70  {
71  switch (i)
72  {
73  case 0:
74  return X;
75  case 1:
76  return Y;
77  case 2:
78  return Z;
79  default:
80  return 0;
81  }
82  }
83 
85  T & operator[] (int i)
86  {
87  switch (i)
88  {
89  case 0:
90  return X;
91  case 1:
92  return Y;
93  case 2:
94  return Z;
95  default:
96  {
97  static T Dummy;
98  return Dummy = 0;
99  }
100  }
101  }
102 
103 
105  // Assignment //
107 
109  template <typename U>
110  vec3<T> & operator = (vec3<U> const & vec)
111  {
112  set(vec);
113  return *this;
114  }
115 
117  void reset()
118  {
119  X = Y = Z = 0;
120  }
121 
123  void set(T const in)
124  {
125  X = Y = Z = in;
126  }
127 
129  void set(T const in[])
130  {
131  X = in[0];
132  Y = in[1];
133  Z = in[2];
134  }
135 
137  template <typename U>
138  void set(vec3<U> const & other)
139  {
140  X = (T) other.X;
141  Y = (T) other.Y;
142  Z = (T) other.Z;
143  }
144 
145 
147  // Length Operations //
149 
151  T Length() const
152  {
153  return Sqrt<T>(X*X + Y*Y + Z*Z);
154  }
155 
157  friend T Length(vec3<T> const & vec)
158  {
159  return vec.Length();
160  }
161 
163  T LengthSq() const
164  {
165  return X*X + Y*Y + Z*Z;
166  }
167 
169  friend T LengthSq(vec3<T> const & vec)
170  {
171  return vec.LengthSq();
172  }
173 
174 
176  // Dot Product //
178 
179  T Dot(vec3<T> const & other) const
180  {
181  return X * other.X + Y * other.Y + Z * other.Z;
182  }
183 
184  friend T Dot(vec3<T> const & lhs, vec3<T> const & rhs)
185  {
186  return lhs.Dot(rhs);
187  }
188 
189 
191  // Distance //
193 
194  T GetDistanceFrom(vec3<T> const & v) const
195  {
196  return (*this - v).Length();
197  }
198 
199  friend T Distance(vec3<T> const & lhs, vec3<T> const & rhs)
200  {
201  return (lhs - rhs).Length();
202  }
203 
204  T const GetDistanceSqFrom(vec3<T> const & v) const
205  {
206  return (* this - v).LengthSq();
207  }
208 
209  friend T DistanceSq(vec3<T> const & lhs, vec3<T> const & rhs)
210  {
211  return (lhs - rhs).LengthSq();
212  }
213 
214 
216  // Interpolation //
218 
219  template <typename Real>
220  vec3<T> GetInterpolated(vec3<T> const & v, Real const d) const
221  {
222  vec3<T> ret;
223  Real inv = (Real) 1 - d;
224  ret.X = (T) ((Real) v.X * inv + (Real) X * d);
225  ret.Y = (T) ((Real) v.Y * inv + (Real) Y * d);
226  ret.Z = (T) ((Real) v.Z * inv + (Real) Z * d);
227  return ret;
228  }
229 
230  template <typename Real>
231  friend vec3<T> Interpolate(vec3<T> const & lhs, vec3<T> const & rhs, Real const d)
232  {
233  return lhs.GetInterpolated(rhs, d);
234  }
235 
236 
238  // Normalization //
240 
242  {
243  vec3<T> ret = *this;
244  ret.Normalize();
245  return ret;
246  }
247 
250  {
251  T const len = Length();
252 
253  X /= len;
254  Y /= len;
255  Z /= len;
256 
257  return *this;
258  }
259 
260  friend vec3<T> Normalize(vec3<T> const & v)
261  {
262  vec3<T> ret = v;
263  ret.Normalize();
264  return ret;
265  }
266 
267 
269  // Basic Arithmetic //
271 
272  vec3<T> operator + (vec3<T> const & v) const
273  {
274  vec3<T> ret;
275  ret.X = X + v.X;
276  ret.Y = Y + v.Y;
277  ret.Z = Z + v.Z;
278  return ret;
279  }
280 
281  vec3<T> operator - (vec3<T> const & v) const
282  {
283  vec3<T> ret;
284  ret.X = X - v.X;
285  ret.Y = Y - v.Y;
286  ret.Z = Z - v.Z;
287  return ret;
288  }
289 
290  vec3<T> operator * (vec3<T> const & v) const
291  {
292  vec3<T> ret;
293  ret.X = X * v.X;
294  ret.Y = Y * v.Y;
295  ret.Z = Z * v.Z;
296  return ret;
297  }
298 
299  vec3<T> operator / (vec3<T> const & v) const
300  {
301  vec3<T> ret;
302  ret.X = X / v.X;
303  ret.Y = Y / v.Y;
304  ret.Z = Z / v.Z;
305  return ret;
306  }
307 
308 
310  // Scalar Arithmetic //
312 
313  vec3<T> operator + (T const s) const
314  {
315  vec3<T> ret;
316  ret.X = X + s;
317  ret.Y = Y + s;
318  ret.Z = Z + s;
319  return ret;
320  }
321 
322  vec3<T> operator - (T const s) const
323  {
324  vec3<T> ret;
325  ret.X = X - s;
326  ret.Y = Y - s;
327  ret.Z = Z - s;
328  return ret;
329  }
330 
331  vec3<T> operator * (T const s) const
332  {
333  vec3<T> ret;
334  ret.X = X * s;
335  ret.Y = Y * s;
336  ret.Z = Z * s;
337  return ret;
338  }
339 
340  vec3<T> operator / (T const s) const
341  {
342  vec3<T> ret;
343  ret.X = X / s;
344  ret.Y = Y / s;
345  ret.Z = Z / s;
346  return ret;
347  }
348 
349  friend vec3<T> operator + (T const lhs, vec3<T> const & rhs)
350  {
351  vec3<T> ret;
352  ret.X = lhs + rhs.X;
353  ret.Y = lhs + rhs.Y;
354  ret.Z = lhs + rhs.Z;
355  return ret;
356  }
357 
358  friend vec3<T> operator - (T const lhs, vec3<T> const & rhs)
359  {
360  vec3<T> ret;
361  ret.X = lhs - rhs.X;
362  ret.Y = lhs - rhs.Y;
363  ret.Z = lhs - rhs.Z;
364  return ret;
365  }
366 
367  friend vec3<T> operator * (T const lhs, vec3<T> const & rhs)
368  {
369  vec3<T> ret;
370  ret.X = lhs * rhs.X;
371  ret.Y = lhs * rhs.Y;
372  ret.Z = lhs * rhs.Z;
373  return ret;
374  }
375 
376  friend vec3<T> operator / (T const lhs, vec3<T> const & rhs)
377  {
378  vec3<T> ret;
379  ret.X = lhs / rhs.X;
380  ret.Y = lhs / rhs.Y;
381  ret.Z = lhs / rhs.Z;
382  return ret;
383  }
384 
385 
387  // Basic Arithmetic Assignment //
389 
391  {
392  X += v.X;
393  Y += v.Y;
394  Z += v.Z;
395 
396  return * this;
397  }
398 
400  {
401  X -= v.X;
402  Y -= v.Y;
403  Z -= v.Z;
404 
405  return * this;
406  }
407 
409  {
410  X *= v.X;
411  Y *= v.Y;
412  Z *= v.Z;
413 
414  return * this;
415  }
416 
418  {
419  X /= v.X;
420  Y /= v.Y;
421  Z /= v.Z;
422 
423  return * this;
424  }
425 
426 
428  // Scalar Arithmetic Assignment //
430 
431  vec3<T> & operator += (T const s)
432  {
433  X += s;
434  Y += s;
435  Z += s;
436 
437  return * this;
438  }
439 
440  vec3<T> & operator -= (T const s)
441  {
442  X -= s;
443  Y -= s;
444  Z -= s;
445 
446  return * this;
447  }
448 
449  vec3<T> & operator *= (T const s)
450  {
451  X *= s;
452  Y *= s;
453  Z *= s;
454 
455  return * this;
456  }
457 
458  vec3<T> & operator /= (T const s)
459  {
460  X /= s;
461  Y /= s;
462  Z /= s;
463 
464  return * this;
465  }
466 
468  // Negation //
470 
471  vec3<T> const operator - () const
472  {
473  vec3<T> ret;
474  ret.X = -X;
475  ret.Y = -Y;
476  ret.Z = -Z;
477  return ret;
478  }
479 
480 
482  // Inequality operator (for sorting) //
484 
485  bool operator < (vec3<T> const & v) const
486  {
487  return
488  (X < v.X) ||
489  (X == v.X && Y < v.Y) ||
490  (X == v.X && Y == v.Y && Z < v.Z);
491  }
492 
493 
495  // Equality operators //
497 
498  bool operator == (vec3<T> const & v) const
499  {
500  return Equals(v);
501  }
502 
503  bool operator != (vec3<T> const & v) const
504  {
505  return ! Equals(v);
506  }
507 
508  bool Equals(vec3<T> const & v, T const Epsilon = RoundingError<T>::Value()) const
509  {
510  return
511  ion::Equals(X, v.X, Epsilon) &&
512  ion::Equals(Y, v.Y, Epsilon) &&
513  ion::Equals(Z, v.Z, Epsilon);
514  }
515 
516 
518  // Extrema //
520 
521  friend vec3<T> ComponentMinimum(vec3<T> const & lhs, vec3<T> const & rhs)
522  {
523  vec3<T> ret;
524  ret.X = Minimum(lhs.X, rhs.X);
525  ret.Y = Minimum(lhs.Y, rhs.Y);
526  ret.Z = Minimum(lhs.Z, rhs.Z);
527  return ret;
528  }
529 
530  friend vec3<T> ComponentMaximum(vec3<T> const & lhs, vec3<T> const & rhs)
531  {
532  vec3<T> ret;
533  ret.X = Maximum(lhs.X, rhs.X);
534  ret.Y = Maximum(lhs.Y, rhs.Y);
535  ret.Z = Maximum(lhs.Z, rhs.Z);
536  return ret;
537  }
538 
539 
541  // Cross Product //
543 
545  vec3<T> CrossProduct(vec3<T> const & v) const
546  {
547  return vec3<T>(Y*v.Z - v.Y*Z, v.X*Z - X*v.Z, X*v.Y - v.X*Y);
548  }
549 
551  vec3<T> Cross(vec3<T> const & v) const
552  {
553  return vec3<T>(Y*v.Z - v.Y*Z, v.X*Z - X*v.Z, X*v.Y - v.X*Y);
554  }
555 
557  friend vec3<T> Cross(vec3<T> const & lhs, vec3<T> const & rhs)
558  {
559  return lhs.Cross(rhs);
560  }
561 
562 
564  // GLM //
566 
567  glm::vec3 const ToGLM() const
568  {
569  return glm::vec3(X, Y, Z);
570  }
571 
572  static vec3<T> FromGLM(glm::vec3 const & Vec)
573  {
574  return vec3<T>(Vec.x, Vec.y, Vec.z);
575  }
576 
577  static vec3<T> FromGLM(glm::vec4 const & Vec)
578  {
579  return vec3<T>(Vec.x, Vec.y, Vec.z);
580  }
581 
582 
584  // Matrix Transform //
586 
587  void Transform(glm::mat4 const & mat, float const TranslateComponent = 1)
588  {
589  glm::vec4 v = glm::vec4(ToGLM(), TranslateComponent);
590  v = mat * v;
591  *this = FromGLM(v);
592  }
593 
594  vec3<T> GetTransformed(glm::mat4 const & mat, float const TranslateComponent = 1) const
595  {
596  glm::vec4 v = glm::vec4(ToGLM(), TranslateComponent);
597  v = mat * v;
598  return FromGLM(v);
599  }
600 
601  vec3<T> RotateAround(vec3<T> const & other, float const radians) const
602  {
603  return GetTransformed(glm::rotate(glm::mat4(1.f), radians, other.ToGLM()));
604  }
605 
606 
608  // Swizzle //
610 
611  vec2<T> XY() const
612  {
613  return vec2<T>(X, Y);
614  }
615 
616  vec2<T> YZ() const
617  {
618  return vec2<T>(Y, Z);
619  }
620 
621  vec2<T> XZ() const
622  {
623  return vec2<T>(X, Z);
624  }
625 
626 
628  // Formatting //
630 
631  friend std::ostream & operator << (std::ostream & stream, vec3<T> const & vec)
632  {
633  return stream << +vec.X << " " << +vec.Y << " " << +vec.Z;
634  }
635 
636  };
637 
640  typedef vec3<int> vec3i;
641 
642 }
2D vector
Definition: vec2.h:17
T LengthSq() const
Squared-length of vector (computationally fast)
Definition: vec3.h:163
T operator[](int i) const
Note: Out-of-bounds access returns a dummy value without error.
Definition: vec3.h:69
vec3< T > operator/(vec3< T > const &v) const
Definition: vec3.h:299
bool Equals(vec3< T > const &v, T const Epsilon=RoundingError< T >::Value()) const
Definition: vec3.h:508
3D vector
Definition: vec3.h:15
friend vec3< T > Cross(vec3< T > const &lhs, vec3< T > const &rhs)
Vector cross product.
Definition: vec3.h:557
vec3(T const x, T const y, T const z)
Explicit constructor.
Definition: vec3.h:37
vec3< T > GetInterpolated(vec3< T > const &v, Real const d) const
Definition: vec3.h:220
vec3< T > & operator/=(vec3< T > const &v)
Definition: vec3.h:417
vec3< T > CrossProduct(vec3< T > const &v) const
Vector cross product.
Definition: vec3.h:545
void Transform(glm::mat4 const &mat, float const TranslateComponent=1)
Definition: vec3.h:587
static vec3< T > FromGLM(glm::vec3 const &Vec)
Definition: vec3.h:572
vec3< T > & operator+=(vec3< T > const &v)
Definition: vec3.h:390
vec3< float > vec3f
Definition: vec3.h:638
vec3< T > & Normalize()
Normalize this vector.
Definition: vec3.h:249
vec3< T > & operator=(vec3< U > const &vec)
Generic vector assignment operator.
Definition: vec3.h:110
friend vec3< T > ComponentMaximum(vec3< T > const &lhs, vec3< T > const &rhs)
Definition: vec3.h:530
vec3< T > Cross(vec3< T > const &v) const
Vector cross product.
Definition: vec3.h:551
friend vec3< T > Interpolate(vec3< T > const &lhs, vec3< T > const &rhs, Real const d)
Definition: vec3.h:231
vec3(vec2< T > const &vec, T const z=0)
vec2 constructor (vec2, z)
Definition: vec3.h:54
vec3< T > & operator*=(vec3< T > const &v)
Definition: vec3.h:408
vec3()
Default constructor.
Definition: vec3.h:27
vec3< int > vec3i
Definition: vec3.h:640
vec2< T > XZ() const
Definition: vec3.h:621
T GetDistanceFrom(vec3< T > const &v) const
Definition: vec3.h:194
T Z
Definition: vec3.h:20
T X
Definition: vec3.h:18
friend T LengthSq(vec3< T > const &vec)
Squared-length of vector (computationally fast)
Definition: vec3.h:169
vec3< T > operator+(vec3< T > const &v) const
Definition: vec3.h:272
glm::vec3 const ToGLM() const
Definition: vec3.h:567
T X
Definition: vec2.h:20
friend T Distance(vec3< T > const &lhs, vec3< T > const &rhs)
Definition: vec3.h:199
T Dot(vec3< T > const &other) const
Definition: vec3.h:179
vec3(vec3< U > const &vec)
Generic constructor.
Definition: vec3.h:49
friend T Length(vec3< T > const &vec)
Length of vector.
Definition: vec3.h:157
Definition: CCatmullRomAdvancedSplineInterpolator.h:7
bool operator!=(vec3< T > const &v) const
Definition: vec3.h:503
vec3< double > vec3d
Definition: vec3.h:639
vec3(T const x, vec2< T > const &vecYZ)
vec2 constructor (x, vec2)
Definition: vec3.h:59
static vec3< T > FromGLM(glm::vec4 const &Vec)
Definition: vec3.h:577
bool operator==(vec3< T > const &v) const
Definition: vec3.h:498
Helper template to enable template-dependant epsilon values.
Definition: ionComparison.h:32
friend vec3< T > ComponentMinimum(vec3< T > const &lhs, vec3< T > const &rhs)
Definition: vec3.h:521
vec3< T > GetNormalized() const
Definition: vec3.h:241
vec3< T > const operator-() const
Definition: vec3.h:471
vec2< T > XY() const
Definition: vec3.h:611
vec3(T const in)
Scalar constructor.
Definition: vec3.h:32
vec3(glm::tvec3< U, glm::defaultp > const &v)
GLM constructor.
Definition: vec3.h:43
vec3< T > & operator-=(vec3< T > const &v)
Definition: vec3.h:399
vec3< T > operator*(vec3< T > const &v) const
Definition: vec3.h:290
void reset()
Sets all values to 0.
Definition: vec3.h:117
friend T DistanceSq(vec3< T > const &lhs, vec3< T > const &rhs)
Definition: vec3.h:209
vec2< T > YZ() const
Definition: vec3.h:616
friend T Dot(vec3< T > const &lhs, vec3< T > const &rhs)
Definition: vec3.h:184
T Length() const
Length of vector.
Definition: vec3.h:151
T const GetDistanceSqFrom(vec3< T > const &v) const
Definition: vec3.h:204
vec3< T > GetTransformed(glm::mat4 const &mat, float const TranslateComponent=1) const
Definition: vec3.h:594
vec3< T > RotateAround(vec3< T > const &other, float const radians) const
Definition: vec3.h:601
friend vec3< T > Normalize(vec3< T > const &v)
Definition: vec3.h:260
T Y
Definition: vec3.h:19