[C++] The IN55 project
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

vectors.h 5.0KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202
  1. #ifndef __VECTORS_H__
  2. #define __VECTORS_H__
  3. #include <math.h>
  4. #include <string.h>
  5. #include <iostream>
  6. #include <types.h>
  7. template <class T>
  8. class AbstractVec2
  9. {
  10. public:
  11. AbstractVec2() {
  12. memset( this, 0, sizeof( T ) * 2 );
  13. }
  14. AbstractVec2( T X, T Y ) : x( X ), y( Y ) {
  15. }
  16. friend std::ostream& operator<<(std::ostream& os, const AbstractVec2<T>& v) {
  17. return os << "(" << v.x << ", " << v.y << ")";
  18. }
  19. bool operator==( const AbstractVec2 & v ) {
  20. return (x == v.x && y == v.y);
  21. }
  22. AbstractVec2 operator+( T v ) const {
  23. return AbstractVec2( x+v, y+v );
  24. }
  25. AbstractVec2 operator-( T v ) const {
  26. return AbstractVec2( x-v, y-v );
  27. }
  28. AbstractVec2 operator*( T v ) const {
  29. return AbstractVec2( x*v, y*v );
  30. }
  31. AbstractVec2 operator/( T v ) const {
  32. return AbstractVec2( x/v, y/v );
  33. }
  34. AbstractVec2 & operator+=( T v ) {
  35. x += v;
  36. y += v;
  37. return (*this);
  38. }
  39. public:
  40. T x, y;
  41. };
  42. template <class T>
  43. class AbstractVec3
  44. {
  45. public:
  46. AbstractVec3() {
  47. memset( this, 0, sizeof( T )*3 );
  48. }
  49. AbstractVec3( T X, T Y, T Z ) : x( X ), y( Y ), z( Z ) {
  50. }
  51. friend std::ostream& operator<<(std::ostream& os, const AbstractVec3<T>& v) {
  52. return os << "(" << v.x << ", " << v.y << ", " << v.z << ")";
  53. }
  54. bool operator==( const AbstractVec3 & v ) const {
  55. return (x == v.x && y == v.y && z == v.z);
  56. }
  57. bool operator!=( const AbstractVec3 & v ) const {
  58. return (x != v.x || y != v.y || z != v.z);
  59. }
  60. AbstractVec3 & operator+=( const AbstractVec3 & vVector ) {
  61. x += vVector.x;
  62. y += vVector.y;
  63. z += vVector.z;
  64. return (*this);
  65. }
  66. AbstractVec3 & operator*=( T factor ) {
  67. x *= factor;
  68. y *= factor;
  69. z *= factor;
  70. return (*this);
  71. }
  72. AbstractVec3 operator+( const AbstractVec3 & vVector ) const {
  73. return AbstractVec3(vVector.x + x, vVector.y + y, vVector.z + z);
  74. }
  75. AbstractVec3 operator-( const AbstractVec3 & vVector ) const {
  76. return AbstractVec3(x - vVector.x, y - vVector.y, z - vVector.z);
  77. }
  78. AbstractVec3 operator-() const {
  79. return AbstractVec3(-x, -y, -z);
  80. }
  81. AbstractVec3 operator*( T num ) const {
  82. return AbstractVec3(x * num, y * num, z * num);
  83. }
  84. AbstractVec3 operator/( T num ) const {
  85. num = 1/num;
  86. return AbstractVec3(x * num, y * num, z * num);
  87. }
  88. AbstractVec3 crossProduct( const AbstractVec3 & vVector ) const {
  89. AbstractVec3 vNormal;
  90. // Valeur X: (V1.y * V2.z) - (V1.z * V2.y)
  91. vNormal.x = ((y * vVector.z) - (z * vVector.y));
  92. // Valeur Y: (V1.z * V2.x) - (V1.x * V2.z)
  93. vNormal.y = ((z * vVector.x) - (x * vVector.z));
  94. // Valeur Z: (V1.x * V2.y) - (V1.y * V2.x)
  95. vNormal.z = ((x * vVector.y) - (y * vVector.x));
  96. return vNormal;
  97. }
  98. const T dotProduct( const AbstractVec3 & vVector ) const {
  99. return x*vVector.x + y*vVector.y + z*vVector.z;
  100. }
  101. static T length( const AbstractVec3 & vNormal ) {
  102. return (T) sqrt((vNormal.x * vNormal.x) + (vNormal.y * vNormal.y) + (vNormal.z * vNormal.z));
  103. }
  104. float getSquaredEuclideanDistance( const AbstractVec3 & v ) const {
  105. return SQ3DDistance( x, y, z, v.x, v.y, v.z );
  106. }
  107. float getEuclideanDistance( const AbstractVec3 & v ) const {
  108. return SR3DDistance( x, y, z, v.x, v.y, v.z );
  109. }
  110. T length() const {
  111. return (T) sqrt((x * x) + (y * y) + (z * z));
  112. }
  113. static AbstractVec3 normalize( const AbstractVec3 & vVector ) {
  114. T len = 1.0f / length(vVector);
  115. if (len != 0.0) {
  116. return vVector * len;
  117. } else {
  118. return vVector;
  119. }
  120. }
  121. void normalize() {
  122. T len = length();
  123. if( len != 0.0 ) {
  124. len = 1/len;
  125. x = x * len;
  126. y = y * len;
  127. z = z * len;
  128. }
  129. }
  130. public:
  131. T x, y, z;
  132. };
  133. template <class T>
  134. class AbstractVec4
  135. {
  136. public:
  137. T x, y, z, w;
  138. };
  139. typedef AbstractVec2<uint32> Vec2ui;
  140. typedef AbstractVec2<int32> Vec2i;
  141. typedef AbstractVec2<float32> Vec2;
  142. typedef AbstractVec3<uint32> Vec3ui;
  143. typedef AbstractVec3<int32> Vec3i;
  144. typedef AbstractVec3<float32> Vec3;
  145. typedef AbstractVec4<uint32> Vec4ui;
  146. typedef AbstractVec4<int32> Vec4i;
  147. typedef AbstractVec4<float32> Vec4;
  148. #endif