Vec3.h 6.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246
  1. #ifndef Vec3_H
  2. #define Vec3_H
  3. #include "FrameworkMath.h"
  4. namespace Framework
  5. {
  6. template<typename T>
  7. //! Ein 3D Vektor
  8. class Vec3
  9. {
  10. public:
  11. T x; //! X Komponente des Vektors
  12. T y; //! y Komponente des Vektors
  13. T z; //! z Komponente des Vektors
  14. //! Konstruktor
  15. inline Vec3() {}
  16. //! Konstruktor
  17. //! \param x Die X Komponente des neuen Vektors
  18. //! \param y Die Y Komponente des neuen Vektors
  19. //! \param z Die Z Komponente des neuen Vektors
  20. inline Vec3(T x, T y, T z)
  21. : x(x),
  22. y(y),
  23. z(z)
  24. {}
  25. //! Konstruktor
  26. //! \param vect Ein Vektor, dessen Werte kopiert werden sollen
  27. inline Vec3(const Vec3& vect)
  28. : Vec3(vect.x, vect.y, vect.z)
  29. {}
  30. //! Skalliert den Vektor, so dass er die Länge 1 hat
  31. inline Vec3& normalize()
  32. {
  33. const T length = getLength();
  34. x /= length;
  35. y /= length;
  36. z /= length;
  37. return *this;
  38. }
  39. //! Vertaucht die Werte des Vektors mit denen eines anderen Vektor
  40. //! \param vect Der andere Vektor
  41. inline Vec3& swap(Vec3& vect)
  42. {
  43. const Vec3 tmp = vect;
  44. vect = *this;
  45. *this = tmp;
  46. return *this;
  47. }
  48. //! Berechnet einen winkel zwischen diesem und einem anderen Vektor
  49. inline float angle(Vec3 vect)
  50. {
  51. return lowPrecisionACos(
  52. (float)(*this * vect)
  53. / ((float)getLength() * (float)vect.getLength()));
  54. }
  55. //! Kopiert die Werte eines anderen Vektors
  56. //! \param r Der andere Vektor
  57. inline Vec3 operator=(const Vec3& r)
  58. {
  59. x = r.x;
  60. y = r.y;
  61. z = r.z;
  62. return *this;
  63. }
  64. //! Addiert einen anderen Vektor zu diesem Hinzu
  65. //! \param r Der andere Vektor
  66. inline Vec3 operator+=(const Vec3& r)
  67. {
  68. x += r.x;
  69. y += r.y;
  70. z += r.z;
  71. return *this;
  72. }
  73. //! Zieht einen anderen Vektor von diesem ab
  74. //! \param r Der andere Vektor
  75. inline Vec3 operator-=(const Vec3& r)
  76. {
  77. x -= r.x;
  78. y -= r.y;
  79. z -= r.z;
  80. return *this;
  81. }
  82. //! Skalliert diesen Vektor
  83. //! \param r Der Faktor
  84. inline Vec3 operator*=(const T& r)
  85. {
  86. x *= r;
  87. y *= r;
  88. z *= r;
  89. return *this;
  90. }
  91. //! Skalliert diesen Vektor mit 1/Faktor
  92. //! \param r Der Faktor
  93. inline Vec3 operator/=(const T& r)
  94. {
  95. x /= r;
  96. y /= r;
  97. z /= r;
  98. return *this;
  99. }
  100. //! Errechnet das Quadrat des Abstands zwischen zewi Vektoren
  101. //! \param p Der andere Vektor
  102. inline T abstandSq(const Vec3& p) const
  103. {
  104. return (x - p.x) * (x - p.x) + (y - p.y) * (y - p.y)
  105. + (z - p.z) * (z - p.z);
  106. }
  107. //! Errechnet den Abstand zwischen zwei Vektoren
  108. //! \param p Der andere Vektor
  109. inline T abstand(const Vec3& p) const
  110. {
  111. return sqrt(abstandSq(p));
  112. }
  113. //! Gibt einen neuen Vektor zurück, der die negation von diesem ist
  114. inline Vec3 operator-() const
  115. {
  116. return {-x, -y, -z};
  117. }
  118. template<typename T2>
  119. //! Konvertiert den Typ des Vektors in einen anderen
  120. inline operator Vec3<T2>() const
  121. {
  122. return {(T2)x, (T2)y, (T2)z};
  123. }
  124. //! Errechnet das Quadrat der Länge des Vektors
  125. inline T getLengthSq() const
  126. {
  127. return *this * *this;
  128. }
  129. //! Errechnet due Länge des Vektors
  130. inline T getLength() const
  131. {
  132. return (T)sqrt(getLengthSq());
  133. }
  134. //! Bildet das Skalarprodukt zwischen zwei Vektoren
  135. //! \param r Der andere Vektor
  136. inline T operator*(const Vec3& r) const
  137. {
  138. return x * r.x + y * r.y + z * r.z;
  139. }
  140. //! Errechnet die Summe zweier Vektoren
  141. //! \param r Der andere Vektor
  142. inline Vec3 operator+(const Vec3& r) const
  143. {
  144. return Vec3(*this) += r;
  145. }
  146. //! Zieht zwei Vektoren von einander ab
  147. //! \param r Der andere Vektor
  148. inline Vec3 operator-(const Vec3& r) const
  149. {
  150. return Vec3(*this) -= r;
  151. }
  152. //! Skalliert den Vektor ohne ihn zu verändern
  153. //! \param r Der Faktor
  154. inline Vec3 operator*(const T& r) const
  155. {
  156. return Vec3(*this) *= r;
  157. }
  158. //! Skalliert den Vektor mit 1/Faktor ohne ihn zu Verändern
  159. //! \param r Der Faktor
  160. inline Vec3 operator/(const T& r) const
  161. {
  162. return Vec3(*this) /= r;
  163. }
  164. //! Überprüft zwei Vektoren auf Gleichheit
  165. //! \param r Der andere Vektor
  166. inline bool operator==(const Vec3& r) const
  167. {
  168. return x == r.x && y == r.y && z == r.z;
  169. }
  170. //! Überprüft zwei Vektoren auf Ungleichheit
  171. //! \param r Der andere Vektor
  172. inline bool operator!=(const Vec3& r) const
  173. {
  174. return !(*this == r);
  175. }
  176. //! Gibt das Kreutzprodukt zwischen diesem und einem anderen Vector
  177. //! zurück \param b der andere Vector
  178. inline Vec3 crossProduct(const Vec3& b) const
  179. {
  180. return Vec3(
  181. y * b.z - z * b.y, z * b.x - x * b.z, x * b.y - y * b.x);
  182. }
  183. inline Vec3& rotateY(float radian)
  184. {
  185. const float cosTheta = lowPrecisionCos(radian);
  186. const float sinTheta = lowPrecisionSin(radian);
  187. float x = cosTheta * this->x + sinTheta * this->z;
  188. float z = -sinTheta * this->x + cosTheta * this->z;
  189. this->x = (T)x;
  190. this->z = (T)z;
  191. return *this;
  192. }
  193. inline Vec3& rotateX(float radian)
  194. {
  195. const float cosTheta = lowPrecisionCos(radian);
  196. const float sinTheta = lowPrecisionSin(radian);
  197. float y = cosTheta * this->y + -sinTheta * this->z;
  198. float z = sinTheta * this->y + cosTheta * this->z;
  199. this->y = (T)y;
  200. this->z = (T)z;
  201. return *this;
  202. }
  203. inline Vec3& rotateZ(float radian)
  204. {
  205. const float cosTheta = lowPrecisionCos(radian);
  206. const float sinTheta = lowPrecisionSin(radian);
  207. float x = cosTheta * this->x + -sinTheta * this->y;
  208. float y = sinTheta * this->x + cosTheta * this->y;
  209. this->x = (T)x;
  210. this->y = (T)y;
  211. return *this;
  212. }
  213. };
  214. } // namespace Framework
  215. #endif