Vec2.h 6.3 KB

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