Vec2.h 5.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
  1. #ifndef Vec2_H
  2. #define Vec2_H
  3. #include "FrameworkMath.h"
  4. namespace Framework
  5. {
  6. // Ein zweidimensionaler Vektor
  7. template< typename T >
  8. class Vec2
  9. {
  10. public:
  11. T x; // x Komponente des Vektors
  12. T y; // y Komponente des Vektors
  13. // Konstruktor
  14. inline Vec2()
  15. {}
  16. // Konstruktor
  17. // x: X Komponente des Vektors
  18. // y: Y Komponente des Vektors
  19. inline Vec2( T x, T y )
  20. : x( x ),
  21. y( y )
  22. {}
  23. // Konstruktor
  24. // vect: Ein Vektor, dessen Komponenten übernommen werden
  25. inline Vec2( const Vec2 &vect )
  26. : x( (T)vect.x ),
  27. y( (T)vect.y )
  28. {}
  29. // Skalliert den Vektor, so dass er die Länge 1 hat
  30. inline Vec2 &normalize()
  31. {
  32. const T length = getLength();
  33. x /= length;
  34. y /= length;
  35. return *this;
  36. }
  37. // Dreht den Vektor um 90 Grad gegen den Uhrzeigersinn
  38. inline Vec2 &CCW90()
  39. {
  40. T temp = y;
  41. y = -x;
  42. x = temp;
  43. return *this;
  44. }
  45. // Dreht den Vektor um 90 Grad im Uhrzeigersinn
  46. inline Vec2 &CW90()
  47. {
  48. T temp = y;
  49. y = x;
  50. x = -temp;
  51. return *this;
  52. }
  53. // Tauscht die Werte der Vektoren aus
  54. // vect: Der Vektor, mit dem getauscht werden soll
  55. inline Vec2 &Swap( Vec2 &vect )
  56. {
  57. const Vec2 tmp = vect;
  58. vect = *this;
  59. *this = tmp;
  60. return *this;
  61. }
  62. // nimmt die Werte eines anderen Vektors an
  63. // r: Der andere Vektor
  64. inline Vec2 operator=( const Vec2 &r )
  65. {
  66. x = r.x;
  67. y = r.y;
  68. return *this;
  69. }
  70. // addiert einen anderen Vektor zu diesem hinzu
  71. // r: Der andere Vektor
  72. inline Vec2 operator+=( const Vec2 &r )
  73. {
  74. x += r.x;
  75. y += r.y;
  76. return *this;
  77. }
  78. // Zieht einen anderen Vektor von diesem ab
  79. // r: Der andere Vektor
  80. inline Vec2 operator-=( const Vec2 &r )
  81. {
  82. x -= r.x;
  83. y -= r.y;
  84. return *this;
  85. }
  86. // Skalliert diesen Vektor mit einem anderen Vektor
  87. // r: Der andere Vektor
  88. inline Vec2 operator*=( const T &r )
  89. {
  90. x *= r;
  91. y *= r;
  92. return *this;
  93. }
  94. // Verkürtzt diesen Vektor durch einen anderen Vektor
  95. // r: Der andere Vektor
  96. inline Vec2 operator/=( const T &r )
  97. {
  98. x /= r;
  99. y /= r;
  100. return *this;
  101. }
  102. // Bildet die Negation des Vektors
  103. inline Vec2 operator-() const
  104. {
  105. return Vec2< T >( -x, -y );
  106. }
  107. // Konvertiert den Vektor in ein Vektor eines anderen Typs
  108. template< typename T2 >
  109. inline operator Vec2< T2 >() const
  110. {
  111. return Vec2< T2 >( (T2)x, (T2)y );
  112. }
  113. // Errechnet das Quadrat der Länge desVektors
  114. inline T getLengthSq() const
  115. {
  116. return *this * *this;
  117. }
  118. // Errechnet die Länge des Vektors
  119. inline T getLength() const
  120. {
  121. return sqrt( getLengthSq() );
  122. }
  123. // Errechnet das Skalarprodukt zwischen zwei Vektoren
  124. // r: Der andere Vektor
  125. inline T operator*( const Vec2 &r ) const
  126. {
  127. return x * r.x + y * r.y;
  128. }
  129. // Addiert zwei Vektoren
  130. // r: Der andere Vektor
  131. inline Vec2 operator+( const Vec2 &r ) const
  132. {
  133. return Vec2( *this ) += r;
  134. }
  135. // Subtrahiert zwei Vektoren
  136. // r: Der andere Vektor
  137. inline Vec2 operator-( const Vec2 &r ) const
  138. {
  139. return Vec2( *this ) -= r;
  140. }
  141. // Multipliziert die Komponenten zweier Vektoren
  142. // r: Der andere Vektor
  143. inline Vec2 operator*( const T &r ) const
  144. {
  145. return Vec2( *this ) *= r;
  146. }
  147. // Dividiert die Komponenten zweier Vektoren
  148. // r: Der andere Vektor
  149. inline Vec2 operator/( const T &r ) const
  150. {
  151. return Vec2( *this ) /= r;
  152. }
  153. // Prüft, ob sich der Vektor in dem Rechteck zwischen zwei Vektoren befindet
  154. // p1: Ein Vektor zur einen Ecke des Rechtecks
  155. // p2: Ein Vektor zur gegenüberliegenden Ecke des Rechtecks
  156. inline bool istInRegion( const Vec2 &p1, const Vec2 &p2 ) const
  157. {
  158. const T medianX = (T)( ( p1.x + p2.x ) / 2.0 );
  159. const T medianY = (T)( ( p1.y + p2.y ) / 2.0 );
  160. return abs< T >( medianX - x ) <= abs< T >( medianX - p1.x ) &&
  161. abs< T >( medianY - y ) <= abs< T >( medianY - p1.y );
  162. }
  163. // Überprüft zwei Vektoren auf Gleichheit
  164. // r: Der andere Vektor
  165. inline bool operator==( const Vec2 &r ) const
  166. {
  167. return x == r.x && y == r.y;
  168. }
  169. // Überprüft zwei Vektoren auf Ungleichheit
  170. // r: Der andere Vektor
  171. inline bool operator!=( const Vec2 &r ) const
  172. {
  173. return !( *this == r );
  174. }
  175. // Errechnet den Mittelpunkt zwischen zwei Vektoren
  176. // p2: Der andere Vektor
  177. inline Vec2 mittelpunktMit( const Vec2 &p2 ) const
  178. {
  179. return Vec2( (T)( ( x + p2.x ) / 2.0 ), (T)( ( y + p2.y ) / 2.0 ) );
  180. }
  181. // Rotiert den Vektor gegen den Uhrzeigersinn
  182. // angle: Der Winkel in Bogenmas
  183. inline Vec2 rotation( const float angle ) const
  184. {
  185. Vec2 result;
  186. float cosine = cosf( angle );
  187. float sine = sinf( angle );
  188. result.x = (T)( x * cosine - y * sine );
  189. result.y = (T)( x * sine + y * cosine );
  190. return result;
  191. }
  192. };
  193. }
  194. #endif