vec4.h
Go to the documentation of this file.
1 
2 #pragma once
3 
4 #include "vec2.h"
5 #include "vec3.h"
6 
7 
8 namespace ion
9 {
10 
13  template <typename T>
14  class vec4
15  {
16 
17  public:
18 
19  T X;
20  T Y;
21  T Z;
22  T W;
23 
25  // Constructors //
27 
29  vec4()
30  : X(0), Y(0), Z(0), W(0)
31  {}
32 
34  vec4(T const in)
35  : X(in), Y(in), Z(in), W(in)
36  {}
37 
39  vec4(T const x, T const y, T const z, T const w)
40  : X(x), Y(y), Z(z), W(w)
41  {}
42 
44  template <typename U>
45  vec4(glm::tvec4<U, glm::defaultp> const & v)
46  : X(v.x), Y(v.y), Z(v.z), W(v.w)
47  {}
48 
50  template <typename U>
51  vec4(vec4<U> const & vec)
52  : X((T) vec.X), Y((T) vec.Y), Z((T) vec.Z), W((T) vec.W)
53  {}
54 
56  vec4(vec3<T> const & vec, T const w = 0)
57  : X(vec.X), Y(vec.Y), Z(vec.Z), W(w)
58  {}
59 
61  vec4(T const x, vec3<T> const & vecYZW)
62  : X(x), Y(vecYZW.X), Z(vecYZW.Y), W(vecYZW.Z)
63  {}
64 
66  vec4(vec2<T> const & vec, T const z = 0, T const w = 0)
67  : X(vec.X), Y(vec.Y), Z(z), W(w)
68  {}
69 
71  vec4(T const x, vec2<T> const & vecYZ, T const w)
72  : X(x), Y(vecYZ.X), Z(vecYZ.Y), W(w)
73  {}
74 
76  vec4(T const x, T const y, vec2<T> const & vecZW)
77  : X(x), Y(y), Z(vecZW.X), W(vecZW.Y)
78  {}
79 
81  vec4(vec2<T> const & vecXY, vec2<T> const & vecZW)
82  : X(vecXY.X), Y(vecXY.Y), Z(vecZW.X), W(vecZW.Y)
83  {}
84 
85 
87  // Index Operators //
89 
91  T operator[] (int i) const
92  {
93  switch (i)
94  {
95  case 0:
96  return X;
97  case 1:
98  return Y;
99  case 2:
100  return Z;
101  case 3:
102  return W;
103  default:
104  return 0;
105  }
106  }
107 
109  T & operator[] (int i)
110  {
111  switch (i)
112  {
113  case 0:
114  return X;
115  case 1:
116  return Y;
117  case 2:
118  return Z;
119  case 3:
120  return W;
121  default:
122  {
123  static T Dummy;
124  return Dummy = 0;
125  }
126  }
127  }
128 
129 
131  // Assignment //
133 
135  template <typename U>
136  vec4<T> & operator = (vec4<U> const & vec)
137  {
138  set(vec);
139  return *this;
140  }
141 
143  void reset()
144  {
145  X = Y = Z = W = 0;
146  }
147 
149  void set(T const in)
150  {
151  X = Y = Z = W = in;
152  }
153 
155  void set(T const in[])
156  {
157  X = in[0];
158  Y = in[1];
159  Z = in[2];
160  W = in[3];
161  }
162 
164  template <typename U>
165  void set(vec4<U> const & other)
166  {
167  X = (T) other.X;
168  Y = (T) other.Y;
169  Z = (T) other.Z;
170  W = (T) other.W;
171  }
172 
173 
175  // Length Operations //
177 
179  T Length() const
180  {
181  return Sqrt<T>(X*X + Y*Y + Z*Z + W*W);
182  }
183 
185  friend T Length(vec4<T> const & vec)
186  {
187  return vec.Length();
188  }
189 
191  T LengthSq() const
192  {
193  return X*X + Y*Y + Z*Z + W*W;
194  }
195 
197  friend T LengthSq(vec4<T> const & vec)
198  {
199  return vec.LengthSq();
200  }
201 
202 
204  // Dot Product //
206 
207  T Dot(vec4<T> const & other) const
208  {
209  return X * other.X + Y * other.Y + Z * other.Z + W * other.W;
210  }
211 
212  friend T Dot(vec4<T> const & lhs, vec4<T> const & rhs)
213  {
214  return lhs.Dot(rhs);
215  }
216 
217 
219  // Distance //
221 
222  T GetDistanceFrom(vec4<T> const & v) const
223  {
224  return (*this - v).Length();
225  }
226 
227  friend T Distance(vec4<T> const & lhs, vec4<T> const & rhs)
228  {
229  return (lhs - rhs).Length();
230  }
231 
232  T const GetDistanceSqFrom(vec4<T> const & v) const
233  {
234  return (* this - v).LengthSq();
235  }
236 
237  friend T DistanceSq(vec4<T> const & lhs, vec4<T> const & rhs)
238  {
239  return (lhs - rhs).LengthSq();
240  }
241 
242 
244  // Interpolation //
246 
247  template <typename Real>
248  vec4<T> GetInterpolated(vec4<T> const & v, Real const d) const
249  {
250  vec4<T> ret;
251  Real inv = (Real) 1 - d;
252  ret.X = (T) ((Real) v.X * inv + (Real) X * d);
253  ret.Y = (T) ((Real) v.Y * inv + (Real) Y * d);
254  ret.Z = (T) ((Real) v.Z * inv + (Real) Z * d);
255  ret.W = (T) ((Real) v.W * inv + (Real) W * d);
256  return ret;
257  }
258 
259  template <typename Real>
260  friend vec4<T> Interpolate(vec4<T> const & lhs, vec4<T> const & rhs, Real const d)
261  {
262  return lhs.GetInterpolated(rhs, d);
263  }
264 
265 
267  // Normalization //
269 
271  {
272  vec4<T> ret = *this;
273  ret.Normalize();
274  return ret;
275  }
276 
279  {
280  T const len = Length();
281 
282  X /= len;
283  Y /= len;
284  Z /= len;
285  W /= len;
286 
287  return *this;
288  }
289 
290  friend vec4<T> Normalize(vec4<T> const & v)
291  {
292  vec4<T> ret = v;
293  ret.Normalize();
294  return ret;
295  }
296 
297 
299  // Basic Arithmetic //
301 
302  vec4<T> operator + (vec4<T> const & v) const
303  {
304  vec4<T> ret;
305  ret.X = X + v.X;
306  ret.Y = Y + v.Y;
307  ret.Z = Z + v.Z;
308  ret.W = W + v.W;
309  return ret;
310  }
311 
312  vec4<T> operator - (vec4<T> const & v) const
313  {
314  vec3<T> ret;
315  ret.X = X - v.X;
316  ret.Y = Y - v.Y;
317  ret.Z = Z - v.Z;
318  ret.W = W - v.W;
319  return ret;
320  }
321 
322  vec4<T> operator * (vec4<T> const & v) const
323  {
324  vec4<T> ret;
325  ret.X = X * v.X;
326  ret.Y = Y * v.Y;
327  ret.Z = Z * v.Z;
328  ret.W = W * v.W;
329  return ret;
330  }
331 
332  vec4<T> operator / (vec4<T> const & v) const
333  {
334  vec4<T> ret;
335  ret.X = X / v.X;
336  ret.Y = Y / v.Y;
337  ret.Z = Z / v.Z;
338  ret.W = W / v.W;
339  return ret;
340  }
341 
342 
344  // Scalar Arithmetic //
346 
347  vec4<T> operator + (T const s) const
348  {
349  vec4<T> ret;
350  ret.X = X + s;
351  ret.Y = Y + s;
352  ret.Z = Z + s;
353  ret.W = W + s;
354  return ret;
355  }
356 
357  vec4<T> operator - (T const s) const
358  {
359  vec4<T> ret;
360  ret.X = X - s;
361  ret.Y = Y - s;
362  ret.Z = Z - s;
363  ret.W = W - s;
364  return ret;
365  }
366 
367  vec4<T> operator * (T const s) const
368  {
369  vec4<T> ret;
370  ret.X = X * s;
371  ret.Y = Y * s;
372  ret.Z = Z * s;
373  ret.W = W * s;
374  return ret;
375  }
376 
377  vec4<T> operator / (T const s) const
378  {
379  vec4<T> ret;
380  ret.X = X / s;
381  ret.Y = Y / s;
382  ret.Z = Z / s;
383  ret.W = W / s;
384  return ret;
385  }
386 
387  friend vec4<T> operator + (T const lhs, vec4<T> const & rhs)
388  {
389  vec4<T> ret;
390  ret.X = lhs + rhs.X;
391  ret.Y = lhs + rhs.Y;
392  ret.Z = lhs + rhs.Z;
393  ret.W = lhs + rhs.W;
394  return ret;
395  }
396 
397  friend vec4<T> operator - (T const lhs, vec4<T> const & rhs)
398  {
399  vec4<T> ret;
400  ret.X = lhs - rhs.X;
401  ret.Y = lhs - rhs.Y;
402  ret.Z = lhs - rhs.Z;
403  ret.W = lhs - rhs.W;
404  return ret;
405  }
406 
407  friend vec4<T> operator * (T const lhs, vec4<T> const & rhs)
408  {
409  vec4<T> ret;
410  ret.X = lhs * rhs.X;
411  ret.Y = lhs * rhs.Y;
412  ret.Z = lhs * rhs.Z;
413  ret.W = lhs * rhs.W;
414  return ret;
415  }
416 
417  friend vec4<T> operator / (T const lhs, vec4<T> const & rhs)
418  {
419  vec4<T> ret;
420  ret.X = lhs / rhs.X;
421  ret.Y = lhs / rhs.Y;
422  ret.Z = lhs / rhs.Z;
423  ret.W = lhs / rhs.W;
424  return ret;
425  }
426 
427 
429  // Basic Arithmetic Assignment //
431 
433  {
434  X += v.X;
435  Y += v.Y;
436  Z += v.Z;
437  W += v.W;
438 
439  return * this;
440  }
441 
443  {
444  X -= v.X;
445  Y -= v.Y;
446  Z -= v.Z;
447  W -= v.W;
448 
449  return * this;
450  }
451 
453  {
454  X *= v.X;
455  Y *= v.Y;
456  Z *= v.Z;
457  W *= v.W;
458 
459  return * this;
460  }
461 
463  {
464  X /= v.X;
465  Y /= v.Y;
466  Z /= v.Z;
467  W /= v.W;
468 
469  return * this;
470  }
471 
472 
474  // Scalar Arithmetic Assignment //
476 
477  vec4<T> & operator += (T const s)
478  {
479  X += s;
480  Y += s;
481  Z += s;
482  W += s;
483 
484  return * this;
485  }
486 
487  vec4<T> & operator -= (T const s)
488  {
489  X -= s;
490  Y -= s;
491  Z -= s;
492  W -= s;
493 
494  return * this;
495  }
496 
497  vec4<T> & operator *= (T const s)
498  {
499  X *= s;
500  Y *= s;
501  Z *= s;
502  W *= s;
503 
504  return * this;
505  }
506 
507  vec4<T> & operator /= (T const s)
508  {
509  X /= s;
510  Y /= s;
511  Z /= s;
512  W /= s;
513 
514  return * this;
515  }
516 
518  // Negation //
520 
521  vec4<T> const operator - () const
522  {
523  vec4<T> ret;
524  ret.X = -X;
525  ret.Y = -Y;
526  ret.Z = -Z;
527  ret.W = -W;
528  return ret;
529  }
530 
531 
533  // Inequality operator (for sorting) //
535 
536  bool operator < (vec4<T> const & v) const
537  {
538  return
539  (X < v.X) ||
540  (X == v.X && Y < v.Y) ||
541  (X == v.X && Y == v.Y && Z < v.Z) ||
542  (X == v.X && Y == v.Y && Z == v.Z && W < v.W);
543  }
544 
545 
547  // Equality operators //
549 
550  bool operator == (vec4<T> const & v) const
551  {
552  return Equals(v);
553  }
554 
555  bool operator != (vec4<T> const & v) const
556  {
557  return ! Equals(v);
558  }
559 
560  bool Equals(vec4<T> const & v, T const Epsilon = RoundingError<T>::Value()) const
561  {
562  return
563  ion::Equals(X, v.X, Epsilon) &&
564  ion::Equals(Y, v.Y, Epsilon) &&
565  ion::Equals(Z, v.Z, Epsilon) &&
566  ion::Equals(W, v.W, Epsilon);
567  }
568 
569 
571  // Extrema //
573 
574  friend vec4<T> ComponentMinimum(vec4<T> const & lhs, vec4<T> const & rhs)
575  {
576  vec4<T> ret;
577  ret.X = Minimum(lhs.X, rhs.X);
578  ret.Y = Minimum(lhs.Y, rhs.Y);
579  ret.Z = Minimum(lhs.Z, rhs.Z);
580  ret.W = Minimum(lhs.W, rhs.W);
581  return ret;
582  }
583 
584  friend vec4<T> ComponentMaximum(vec4<T> const & lhs, vec4<T> const & rhs)
585  {
586  vec4<T> ret;
587  ret.X = Maximum(lhs.X, rhs.X);
588  ret.Y = Maximum(lhs.Y, rhs.Y);
589  ret.Z = Maximum(lhs.Z, rhs.Z);
590  ret.W = Maximum(lhs.W, rhs.W);
591  return ret;
592  }
593 
594 
596  // GLM //
598 
599  glm::tvec4<T> const ToGLM() const
600  {
601  return glm::tvec4<T>(X, Y, Z, W);
602  }
603 
604  static vec4<T> FromGLM(glm::tvec4<T> const & Vec)
605  {
606  return vec4<T>(Vec.x, Vec.y, Vec.z, Vec.w);
607  }
608 
609 
611  // Matrix Transform //
613 
614  void Transform(glm::mat4 const & mat)
615  {
616  glm::vec4 v = ToGLM();
617  v = mat * v;
618  *this = FromGLM(v);
619  }
620 
621  vec4<T> GetTransformed(glm::mat4 const & mat) const
622  {
623  glm::vec4 v = ToGLM();
624  v = mat * v;
625  return FromGLM(v);
626  }
627 
628 
630  // Swizzle //
632 
633  vec2<T> XY() const
634  {
635  return vec2<T>(X, Y);
636  }
637 
638  vec2<T> XZ() const
639  {
640  return vec2<T>(X, Z);
641  }
642 
643  vec2<T> XW() const
644  {
645  return vec2<T>(X, W);
646  }
647 
648  vec2<T> YZ() const
649  {
650  return vec2<T>(Y, Z);
651  }
652 
653  vec2<T> ZW() const
654  {
655  return vec2<T>(Z, W);
656  }
657 
658  vec3<T> XYZ() const
659  {
660  return vec3<T>(X, Y, Z);
661  }
662 
663 
665  // Formatting //
667 
668  friend std::ostream & operator << (std::ostream & stream, vec4<T> const & vec)
669  {
670  return stream << +vec.X << " " << +vec.Y << " " << +vec.Z << " " << +vec.W;
671  }
672 
673  };
674 
675 
678  typedef vec4<int> vec4i;
679 
680 }
2D vector
Definition: vec2.h:17
vec4< T > operator/(vec4< T > const &v) const
Definition: vec4.h:332
vec4(T const x, T const y, T const z, T const w)
Explicit constructor.
Definition: vec4.h:39
friend vec4< T > ComponentMinimum(vec4< T > const &lhs, vec4< T > const &rhs)
Definition: vec4.h:574
vec4< T > GetTransformed(glm::mat4 const &mat) const
Definition: vec4.h:621
vec3< T > XYZ() const
Definition: vec4.h:658
vec4< double > vec4d
Definition: vec4.h:677
3D vector
Definition: vec3.h:15
vec4< T > & operator+=(vec4< T > const &v)
Definition: vec4.h:432
T Y
Definition: vec4.h:20
vec4< T > const operator-() const
Definition: vec4.h:521
vec4< T > & Normalize()
Normalize this vector.
Definition: vec4.h:278
friend T LengthSq(vec4< T > const &vec)
Squared-length of vector (computationally fast)
Definition: vec4.h:197
vec4(vec2< T > const &vecXY, vec2< T > const &vecZW)
vec2 constructor (vec2, vec2)
Definition: vec4.h:81
vec4(T const x, T const y, vec2< T > const &vecZW)
vec2 constructor (x, y, vec2)
Definition: vec4.h:76
vec2< T > ZW() const
Definition: vec4.h:653
vec4(glm::tvec4< U, glm::defaultp > const &v)
GLM constructor.
Definition: vec4.h:45
T X
Definition: vec4.h:19
vec4(vec3< T > const &vec, T const w=0)
vec3 constructor (vec3, w)
Definition: vec4.h:56
friend vec4< T > Normalize(vec4< T > const &v)
Definition: vec4.h:290
4D vector
Definition: vec4.h:14
vec4< T > & operator=(vec4< U > const &vec)
Generic vector assignment operator.
Definition: vec4.h:136
vec4(T const in)
Scalar constructor.
Definition: vec4.h:34
T Length() const
Length of vector.
Definition: vec4.h:179
bool Equals(vec4< T > const &v, T const Epsilon=RoundingError< T >::Value()) const
Definition: vec4.h:560
vec4(T const x, vec2< T > const &vecYZ, T const w)
vec2 constructor (x, vec2, w)
Definition: vec4.h:71
T Z
Definition: vec3.h:20
T const GetDistanceSqFrom(vec4< T > const &v) const
Definition: vec4.h:232
T X
Definition: vec3.h:18
vec4< T > & operator-=(vec4< T > const &v)
Definition: vec4.h:442
Definition: CCatmullRomAdvancedSplineInterpolator.h:7
vec4< T > operator+(vec4< T > const &v) const
Definition: vec4.h:302
vec2< T > XZ() const
Definition: vec4.h:638
vec4< T > & operator/=(vec4< T > const &v)
Definition: vec4.h:462
vec4(T const x, vec3< T > const &vecYZW)
vec3 constructor (x, vec3)
Definition: vec4.h:61
friend vec4< T > Interpolate(vec4< T > const &lhs, vec4< T > const &rhs, Real const d)
Definition: vec4.h:260
friend T DistanceSq(vec4< T > const &lhs, vec4< T > const &rhs)
Definition: vec4.h:237
T Dot(vec4< T > const &other) const
Definition: vec4.h:207
bool operator!=(vec4< T > const &v) const
Definition: vec4.h:555
friend vec4< T > ComponentMaximum(vec4< T > const &lhs, vec4< T > const &rhs)
Definition: vec4.h:584
Helper template to enable template-dependant epsilon values.
Definition: ionComparison.h:32
vec4< T > GetNormalized() const
Definition: vec4.h:270
T Z
Definition: vec4.h:21
static vec4< T > FromGLM(glm::tvec4< T > const &Vec)
Definition: vec4.h:604
friend T Distance(vec4< T > const &lhs, vec4< T > const &rhs)
Definition: vec4.h:227
glm::tvec4< T > const ToGLM() const
Definition: vec4.h:599
void reset()
Sets all values to 0.
Definition: vec4.h:143
friend T Dot(vec4< T > const &lhs, vec4< T > const &rhs)
Definition: vec4.h:212
T LengthSq() const
Squared-length of vector (computationally fast)
Definition: vec4.h:191
vec2< T > XY() const
Definition: vec4.h:633
vec2< T > XW() const
Definition: vec4.h:643
vec4(vec2< T > const &vec, T const z=0, T const w=0)
vec2 constructor (vec2, z, w)
Definition: vec4.h:66
T W
Definition: vec4.h:22
friend T Length(vec4< T > const &vec)
Length of vector.
Definition: vec4.h:185
vec4< T > & operator*=(vec4< T > const &v)
Definition: vec4.h:452
T operator[](int i) const
Note: Out-of-bounds access returns a dummy value without error.
Definition: vec4.h:91
T GetDistanceFrom(vec4< T > const &v) const
Definition: vec4.h:222
vec2< T > YZ() const
Definition: vec4.h:648
vec4(vec4< U > const &vec)
Generic constructor.
Definition: vec4.h:51
bool operator==(vec4< T > const &v) const
Definition: vec4.h:550
void Transform(glm::mat4 const &mat)
Definition: vec4.h:614
vec4< T > operator*(vec4< T > const &v) const
Definition: vec4.h:322
vec4()
Default constructor.
Definition: vec4.h:29
vec4< float > vec4f
Definition: vec4.h:676
vec4< int > vec4i
Definition: vec4.h:678
vec4< T > GetInterpolated(vec4< T > const &v, Real const d) const
Definition: vec4.h:248
T Y
Definition: vec3.h:19