Vec3.h 5.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180
  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. {}
  17. // Konstruktor
  18. // x: Die X Komponente des neuen Vektors
  19. // y: Die Y Komponente des neuen Vektors
  20. // z: Die Z Komponente des neuen Vektors
  21. inline Vec3( T x, T y, T z )
  22. : x( x ),
  23. y( y ),
  24. z( z )
  25. {}
  26. // Konstruktor
  27. // vect: Ein Vektor, dessen Werte kopiert werden sollen
  28. inline Vec3( const Vec3 &vect )
  29. : Vec3( vect.x, vect.y, vect.z )
  30. {}
  31. // Skalliert den Vektor, so dass er die Länge 1 hat
  32. inline Vec3 &normalize()
  33. {
  34. const T length = getLength();
  35. x /= length;
  36. y /= length;
  37. z /= length;
  38. return *this;
  39. }
  40. // Vertaucht die Werte des Vektors mit denen eines anderen Vektor
  41. // vect: Der andere Vektor
  42. inline Vec3 &Swap( Vec3 &vect )
  43. {
  44. const Vec3 tmp = vect;
  45. vect = *this;
  46. *this = tmp;
  47. return *this;
  48. }
  49. // Kopiert die Werte eines anderen Vektors
  50. // r: Der andere Vektor
  51. inline Vec3 operator=( const Vec3 &r )
  52. {
  53. x = r.x;
  54. y = r.y;
  55. z = r.z;
  56. return *this;
  57. }
  58. // Addiert einen anderen Vektor zu diesem Hinzu
  59. // r: Der andere Vektor
  60. inline Vec3 operator+=( const Vec3 &r )
  61. {
  62. x += r.x;
  63. y += r.y;
  64. z += r.z;
  65. return *this;
  66. }
  67. // Zieht einen anderen Vektor von diesem ab
  68. // r: Der andere Vektor
  69. inline Vec3 operator-=( const Vec3 &r )
  70. {
  71. x -= r.x;
  72. y -= r.y;
  73. z -= r.z;
  74. return *this;
  75. }
  76. // Skalliert diesen Vektor
  77. // r: Der Faktor
  78. inline Vec3 operator*=( const T &r )
  79. {
  80. x *= r;
  81. y *= r;
  82. z *= r;
  83. return *this;
  84. }
  85. // Skalliert diesen Vektor mit 1/Faktor
  86. // r: Der Faktor
  87. inline Vec3 operator/=( const T &r )
  88. {
  89. x /= r;
  90. y /= r;
  91. z /= r;
  92. return *this;
  93. }
  94. // Errechnet das Quadrat des Abstands zwischen zewi Vektoren
  95. // p: Der andere Vektor
  96. inline T abstandSq( const Vec3 &p ) const
  97. {
  98. return ( x - p.x ) * ( x - p.x ) + ( y - p.y ) * ( y - p.y ) + ( z - p.z ) * ( z - p.z );
  99. }
  100. // Errechnet den Abstand zwischen zwei Vektoren
  101. // p: Der andere Vektor
  102. inline T abstand( const Vec3 &p ) const
  103. {
  104. return sqrt( abstandSq( p ) );
  105. }
  106. // Gibt einen neuen Vektor zurück, der die negation von diesem ist
  107. inline Vec3 operator-() const
  108. {
  109. return{ -x, -y, -z };
  110. }
  111. template< typename T2 >
  112. // Konvertiert den Typ des Vektors in einen anderen
  113. inline operator Vec3< T2 >() const
  114. {
  115. return{ (T2)x, (T2)y, (T2)z };
  116. }
  117. // Errechnet das Quadrat der Länge des Vektors
  118. inline T getLengthSq() const
  119. {
  120. return *this * *this;
  121. }
  122. // Errechnet due Länge des Vektors
  123. inline T getLength() const
  124. {
  125. return (T)sqrt( getLengthSq() );
  126. }
  127. // Bildet das Skalarprodukt zwischen zwei Vektoren
  128. // r: Der andere Vektor
  129. inline T operator*( const Vec3 &r ) const
  130. {
  131. return x * r.x + y * r.y + z * r.z;
  132. }
  133. // Errechnet die Summe zweier Vektoren
  134. // r: Der andere Vektor
  135. inline Vec3 operator+( const Vec3 &r ) const
  136. {
  137. return Vec3( *this ) += r;
  138. }
  139. // Zieht zwei Vektoren von einander ab
  140. // r: Der andere Vektor
  141. inline Vec3 operator-( const Vec3 &r ) const
  142. {
  143. return Vec3( *this ) -= r;
  144. }
  145. // Skalliert den Vektor ohne ihn zu verändern
  146. // r: Der Faktor
  147. inline Vec3 operator*( const T &r ) const
  148. {
  149. return Vec3( *this ) *= r;
  150. }
  151. // Skalliert den Vektor mit 1/Faktor ohne ihn zu Verändern
  152. // r: Der Faktor
  153. inline Vec3 operator/( const T &r ) const
  154. {
  155. return Vec3( *this ) /= r;
  156. }
  157. // Überprüft zwei Vektoren auf Gleichheit
  158. // r: Der andere Vektor
  159. inline bool operator==( const Vec3 &r ) const
  160. {
  161. return x == r.x && y == r.y && z == r.z;
  162. }
  163. // Überprüft zwei Vektoren auf Ungleichheit
  164. // r: Der andere Vektor
  165. inline bool operator!=( const Vec3 &r ) const
  166. {
  167. return !( *this == r );
  168. }
  169. // Gibt das Kreutzprodukt zwischen diesem und einem anderen Vector zurück
  170. // b: der andere Vector
  171. inline Vec3 crossProduct( const Vec3 &b ) const
  172. {
  173. return Vec3( y * b.z - z * b.y, z * b.x - x * b.z, x * b.y - y * b.x );
  174. }
  175. };
  176. }
  177. #endif