vec2.h
Go to the documentation of this file.
1 
2 #pragma once
3 
4 #include "ionTypes.h"
5 #include "ionComparison.h"
6 #include "ionMathFunctions.h"
7 
8 #include <glm/glm.hpp>
9 
10 
11 namespace ion
12 {
13 
16  template <typename T>
17  struct vec2
18  {
19 
20  T X;
21  T Y;
22 
24  // Constructors //
26 
28  vec2()
29  : X(0), Y(0)
30  {}
31 
33  vec2(T const in)
34  : X(in), Y(in)
35  {}
36 
38  vec2(T const x, T const y)
39  : X(x), Y(y)
40  {}
41 
43  template <typename U>
44  vec2(glm::tvec2<U, glm::defaultp> const & v)
45  : X(v.x), Y(v.y)
46  {}
47 
49  template <typename U>
50  vec2(vec2<U> const & vec)
51  : X((T) vec.X), Y((T) vec.Y)
52  {}
53 
54 
56  // Index Operators //
58 
60  T operator[] (int i) const
61  {
62  switch (i)
63  {
64  case 0:
65  return X;
66  case 1:
67  return Y;
68  default:
69  return 0;
70  }
71  }
72 
74  T & operator[] (int i)
75  {
76  switch (i)
77  {
78  case 0:
79  return X;
80  case 1:
81  return Y;
82  default:
83  {
84  static T Dummy;
85  return Dummy = 0;
86  }
87  }
88  }
89 
90 
92  // Assignment //
94 
96  template <typename U>
97  vec2<T> & operator = (vec2<U> const & vec)
98  {
99  set(vec);
100  return *this;
101  }
102 
104  void reset()
105  {
106  X = Y = 0;
107  }
108 
110  void set(T const in)
111  {
112  X = Y = in;
113  }
114 
116  void set(T const in[])
117  {
118  X = in[0];
119  Y = in[1];
120  }
121 
123  template <typename U>
124  void set(vec2<U> const & other)
125  {
126  X = (T) other.X;
127  Y = (T) other.Y;
128  }
129 
130 
132  // Length Operations //
134 
136  T Length() const
137  {
138  return Sqrt<T>(X*X + Y*Y);
139  }
140 
142  friend T Length(vec2<T> const & vec)
143  {
144  return vec.Length();
145  }
146 
148  T LengthSq() const
149  {
150  return X*X + Y*Y;
151  }
152 
154  friend T LengthSq(vec2<T> const & vec)
155  {
156  return vec.LengthSq();
157  }
158 
159 
161  // Dot Product //
163 
164  T Dot(vec2<T> const & other) const
165  {
166  return X * other.X + Y * other.Y;
167  }
168 
169  friend T Dot(vec2<T> const & lhs, vec2<T> const & rhs)
170  {
171  return lhs.Dot(rhs);
172  }
173 
174 
176  // Distance //
178 
179  T GetDistanceFrom(vec2<T> const & v) const
180  {
181  return (*this - v).Length();
182  }
183 
184  friend T Distance(vec2<T> const & lhs, vec2<T> const & rhs)
185  {
186  return (lhs - rhs).Length();
187  }
188 
189  T const GetDistanceSqFrom(vec2<T> const & v) const
190  {
191  return (* this - v).LengthSq();
192  }
193 
194  friend T DistanceSq(vec2<T> const & lhs, vec2<T> const & rhs)
195  {
196  return (lhs - rhs).LengthSq();
197  }
198 
199 
201  // Interpolation //
203 
204  template <typename Real>
205  vec2<T> GetInterpolated(vec2<T> const & v, Real const d) const
206  {
207  vec2<T> ret;
208  Real inv = (Real) 1 - d;
209  ret.X = (T) ((Real) v.X * inv + (Real) X * d);
210  ret.Y = (T) ((Real) v.Y * inv + (Real) Y * d);
211  return ret;
212  }
213 
214  template <typename Real>
215  friend vec2<T> Interpolate(vec2<T> const & lhs, vec2<T> const & rhs, Real const d)
216  {
217  return lhs.GetInterpolated(rhs, d);
218  }
219 
220 
222  // Normalization //
224 
226  {
227  vec2<T> ret = *this;
228  ret.Normalize();
229  return ret;
230  }
231 
234  {
235  T const len = Length();
236 
237  X /= len;
238  Y /= len;
239 
240  return *this;
241  }
242 
243  friend vec2<T> Normalize(vec2<T> const & v)
244  {
245  vec2<T> ret = v;
246  ret.Normalize();
247  return ret;
248  }
249 
250 
252  // Basic Arithmetic //
254 
255  vec2<T> operator + (vec2<T> const & v) const
256  {
257  vec2<T> ret;
258  ret.X = X + v.X;
259  ret.Y = Y + v.Y;
260  return ret;
261  }
262 
263  vec2<T> operator - (vec2<T> const & v) const
264  {
265  vec2<T> ret;
266  ret.X = X - v.X;
267  ret.Y = Y - v.Y;
268  return ret;
269  }
270 
271  vec2<T> operator * (vec2<T> const & v) const
272  {
273  vec2<T> ret;
274  ret.X = X * v.X;
275  ret.Y = Y * v.Y;
276  return ret;
277  }
278 
279  vec2<T> operator / (vec2<T> const & v) const
280  {
281  vec2<T> ret;
282  ret.X = X / v.X;
283  ret.Y = Y / v.Y;
284  return ret;
285  }
286 
287 
289  // Scalar Arithmetic //
291 
292  vec2<T> operator + (T const s) const
293  {
294  vec2<T> ret;
295  ret.X = X + s;
296  ret.Y = Y + s;
297  return ret;
298  }
299 
300  vec2<T> operator - (T const s) const
301  {
302  vec2<T> ret;
303  ret.X = X - s;
304  ret.Y = Y - s;
305  return ret;
306  }
307 
308  vec2<T> operator * (T const s) const
309  {
310  vec2<T> ret;
311  ret.X = X * s;
312  ret.Y = Y * s;
313  return ret;
314  }
315 
316  vec2<T> operator / (T const s) const
317  {
318  vec2<T> ret;
319  ret.X = X / s;
320  ret.Y = Y / s;
321  return ret;
322  }
323 
324  friend vec2<T> operator + (T const lhs, vec2<T> const & rhs)
325  {
326  vec2<T> ret;
327  ret.X = lhs + rhs.X;
328  ret.Y = lhs + rhs.Y;
329  return ret;
330  }
331 
332  friend vec2<T> operator - (T const lhs, vec2<T> const & rhs)
333  {
334  vec2<T> ret;
335  ret.X = lhs - rhs.X;
336  ret.Y = lhs - rhs.Y;
337  return ret;
338  }
339 
340  friend vec2<T> operator * (T const lhs, vec2<T> const & rhs)
341  {
342  vec2<T> ret;
343  ret.X = lhs * rhs.X;
344  ret.Y = lhs * rhs.Y;
345  return ret;
346  }
347 
348  friend vec2<T> operator / (T const lhs, vec2<T> const & rhs)
349  {
350  vec2<T> ret;
351  ret.X = lhs / rhs.X;
352  ret.Y = lhs / rhs.Y;
353  return ret;
354  }
355 
356 
358  // Basic Arithmetic Assignment //
360 
362  {
363  X += v.X;
364  Y += v.Y;
365 
366  return * this;
367  }
368 
370  {
371  X -= v.X;
372  Y -= v.Y;
373 
374  return * this;
375  }
376 
378  {
379  X *= v.X;
380  Y *= v.Y;
381 
382  return * this;
383  }
384 
386  {
387  X /= v.X;
388  Y /= v.Y;
389 
390  return * this;
391  }
392 
393 
395  // Scalar Arithmetic Assignment //
397 
398  vec2<T> & operator += (T const s)
399  {
400  X += s;
401  Y += s;
402 
403  return * this;
404  }
405 
406  vec2<T> & operator -= (T const s)
407  {
408  X -= s;
409  Y -= s;
410 
411  return * this;
412  }
413 
414  vec2<T> & operator *= (T const s)
415  {
416  X *= s;
417  Y *= s;
418 
419  return * this;
420  }
421 
422  vec2<T> & operator /= (T const s)
423  {
424  X /= s;
425  Y /= s;
426 
427  return * this;
428  }
429 
431  // Negation //
433 
434  vec2<T> const operator - () const
435  {
436  vec2<T> ret;
437  ret.X = -X;
438  ret.Y = -Y;
439  return ret;
440  }
441 
442 
444  // Inequality operator (for sorting) //
446 
447  bool operator < (vec2<T> const & v) const
448  {
449  return
450  (X < v.X) ||
451  (X == v.X && Y < v.Y);
452  }
453 
454 
456  // Equality operators //
458 
459  bool operator == (vec2<T> const & v) const
460  {
461  return Equals(v);
462  }
463 
464  bool operator != (vec2<T> const & v) const
465  {
466  return ! Equals(v);
467  }
468 
469  bool Equals(vec2<T> const & v, T const Epsilon = RoundingError<T>::Value()) const
470  {
471  return
472  ion::Equals(X, v.X, Epsilon) &&
473  ion::Equals(Y, v.Y, Epsilon);
474  }
475 
476 
478  // Extrema //
480 
481  friend vec2<T> ComponentMinimum(vec2<T> const & lhs, vec2<T> const & rhs)
482  {
483  vec2<T> ret;
484  ret.X = Minimum(lhs.X, rhs.X);
485  ret.Y = Minimum(lhs.Y, rhs.Y);
486  return ret;
487  }
488 
489  friend vec2<T> ComponentMaximum(vec2<T> const & lhs, vec2<T> const & rhs)
490  {
491  vec2<T> ret;
492  ret.X = Maximum(lhs.X, rhs.X);
493  ret.Y = Maximum(lhs.Y, rhs.Y);
494  return ret;
495  }
496 
497 
499  // GLM //
501 
502  glm::vec2 const ToGLM() const
503  {
504  return glm::vec2(X, Y);
505  }
506 
507  static vec2<T> FromGLM(glm::vec2 const & Vec)
508  {
509  return vec2<T>(Vec.x, Vec.y);
510  }
511 
512 
514  // Swizzle //
516 
517  vec2<T> YX() const
518  {
519  return vec2<T>(Y, X);
520  }
521 
522  vec2<T> XX() const
523  {
524  return vec2<T>(X, X);
525  }
526 
527  vec2<T> YY() const
528  {
529  return vec2<T>(Y, Y);
530  }
531 
532 
534  // Formatting //
536 
537  friend std::ostream & operator << (std::ostream & stream, vec2<T> const & vec)
538  {
539  return stream << vec.X << " " << vec.Y;
540  }
541 
542 
544  // Rotation //
546 
547  vec2<T> Rotate(T const radians) const
548  {
549  vec2<T> Ret;
550  T C = Cos(radians);
551  T S = Sin(radians);
552  Ret.X = X * C - Y * S;
553  Ret.Y = X * S + Y * C;
554  return Ret;
555  }
556 
557  T GetAngle() const
558  {
559  return ArcTan(Y, X);
560  }
561 
563  {
564  return vec2<T>(Y, -X);
565  }
566 
568  {
569  return vec2<T>(-Y, X);
570  }
571 
572  };
573 
576  typedef vec2<int> vec2i;
577 
578 }
T GetDistanceFrom(vec2< T > const &v) const
Definition: vec2.h:179
2D vector
Definition: vec2.h:17
vec2< T > & operator/=(vec2< T > const &v)
Definition: vec2.h:385
vec2< T > & operator=(vec2< U > const &vec)
Generic vector assignment operator.
Definition: vec2.h:97
vec2(glm::tvec2< U, glm::defaultp > const &v)
GLM constructor.
Definition: vec2.h:44
T const GetDistanceSqFrom(vec2< T > const &v) const
Definition: vec2.h:189
bool Equals(vec2< T > const &v, T const Epsilon=RoundingError< T >::Value()) const
Definition: vec2.h:469
static vec2< T > FromGLM(glm::vec2 const &Vec)
Definition: vec2.h:507
vec2()
Default constructor.
Definition: vec2.h:28
friend T Distance(vec2< T > const &lhs, vec2< T > const &rhs)
Definition: vec2.h:184
friend T Length(vec2< T > const &vec)
Length of vector.
Definition: vec2.h:142
vec2< T > & operator+=(vec2< T > const &v)
Definition: vec2.h:361
friend vec2< T > Normalize(vec2< T > const &v)
Definition: vec2.h:243
T GetAngle() const
Definition: vec2.h:557
vec2< T > XX() const
Definition: vec2.h:522
friend vec2< T > ComponentMaximum(vec2< T > const &lhs, vec2< T > const &rhs)
Definition: vec2.h:489
vec2< T > Rotate(T const radians) const
Definition: vec2.h:547
vec2< T > operator+(vec2< T > const &v) const
Definition: vec2.h:255
bool operator==(vec2< T > const &v) const
Definition: vec2.h:459
vec2(T const in)
Scalar constructor.
Definition: vec2.h:33
bool operator!=(vec2< T > const &v) const
Definition: vec2.h:464
T operator[](int i) const
Note: Out-of-bounds access returns a dummy value without error.
Definition: vec2.h:60
friend vec2< T > Interpolate(vec2< T > const &lhs, vec2< T > const &rhs, Real const d)
Definition: vec2.h:215
vec2< T > & Normalize()
Normalize this vector.
Definition: vec2.h:233
vec2< T > Rotate90CW() const
Definition: vec2.h:562
T X
Definition: vec2.h:20
vec2< float > vec2f
Definition: vec2.h:574
Definition: CCatmullRomAdvancedSplineInterpolator.h:7
vec2< T > GetInterpolated(vec2< T > const &v, Real const d) const
Definition: vec2.h:205
vec2< T > YX() const
Definition: vec2.h:517
vec2< T > YY() const
Definition: vec2.h:527
T LengthSq() const
Squared-length of vector (computationally fast)
Definition: vec2.h:148
glm::vec2 const ToGLM() const
Definition: vec2.h:502
T ArcTan(T const value)
Definition: ionMathFunctions.h:52
friend T Dot(vec2< T > const &lhs, vec2< T > const &rhs)
Definition: vec2.h:169
vec2< T > GetNormalized() const
Definition: vec2.h:225
vec2(vec2< U > const &vec)
Generic vec2 constructor.
Definition: vec2.h:50
friend T DistanceSq(vec2< T > const &lhs, vec2< T > const &rhs)
Definition: vec2.h:194
Helper template to enable template-dependant epsilon values.
Definition: ionComparison.h:32
Defines typedefs for integer and floating point types.
vec2< T > & operator*=(vec2< T > const &v)
Definition: vec2.h:377
friend vec2< T > ComponentMinimum(vec2< T > const &lhs, vec2< T > const &rhs)
Definition: vec2.h:481
void reset()
Sets all values to 0.
Definition: vec2.h:104
vec2< T > const operator-() const
Definition: vec2.h:434
T Dot(vec2< T > const &other) const
Definition: vec2.h:164
vec2< int > vec2i
Definition: vec2.h:576
vec2< T > Rotate90CCW() const
Definition: vec2.h:567
T Y
Definition: vec2.h:21
vec2< T > operator*(vec2< T > const &v) const
Definition: vec2.h:271
T Sin(T const value)
Definition: ionMathFunctions.h:31
vec2< T > & operator-=(vec2< T > const &v)
Definition: vec2.h:369
vec2(T const x, T const y)
Explicit constructor.
Definition: vec2.h:38
T Cos(T const value)
Definition: ionMathFunctions.h:38
vec2< T > operator/(vec2< T > const &v) const
Definition: vec2.h:279
friend T LengthSq(vec2< T > const &vec)
Squared-length of vector (computationally fast)
Definition: vec2.h:154
vec2< double > vec2d
Definition: vec2.h:575
T Length() const
Length of vector.
Definition: vec2.h:136