Vec2.h 6.1 KB

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