Changeset 167 in flair-src for trunk/lib/FlairCore/src/Vector3D.cpp

Timestamp:

Apr 12, 2017, 1:59:38 PM (8 years ago)

Author:

Sanahuja Guillaume

Message:

modifs pour template vectors

File:

• trunk/lib/FlairCore/src/Vector3D.cpp (modified) (14 diffs)

trunk/lib/FlairCore/src/Vector3D.cpp

@@ -23 +23 @@
 #include "Object.h"
 #include <math.h>
-//#include "Vector3DSpinBox.h"
 
 namespace flair {
 namespace core {
-
-Vector3D::Vector3D(float inX, float inY, float inZ) : x(inX), y(inY), z(inZ) {}
-
-Vector3D::~Vector3D() {}
+  
+template class Vector3D<double>;
+template Vector3D<double> operator+(const Vector3D<double>&, const Vector3D<double>&);
+template Vector3D<double> operator-(const Vector3D<double>&, const Vector3D<double>&);
+template Vector3D<double> operator-(const Vector3D<double>&);
+template Vector3D<double> operator/(const Vector3D<double>&, float);
+template Vector3D<double> operator*(const Vector3D<double>&, const Vector3D<double>&);
+template Vector3D<double> operator*(const Vector3D<double>&, float);
+template Vector3D<double> operator*(float, const Vector3D<double>&);
+template Vector3D<double> CrossProduct(const Vector3D<double>&, const Vector3D<double>&);
+template float DotProduct(const Vector3D<double>&, const Vector3D<double>&);
+
+template class Vector3D<float>;
+template Vector3D<float> operator+(const Vector3D<float>&, const Vector3D<float>&);
+template Vector3D<float> operator-(const Vector3D<float>&, const Vector3D<float>&);
+template Vector3D<float> operator-(const Vector3D<float>&);
+template Vector3D<float> operator/(const Vector3D<float>&, float);
+template Vector3D<float> operator*(const Vector3D<float>&, const Vector3D<float>&);
+template Vector3D<float> operator*(const Vector3D<float>&, float);
+template Vector3D<float> operator*(float, const Vector3D<float>&);
+template Vector3D<float> CrossProduct(const Vector3D<float>&, const Vector3D<float>&);
+template float DotProduct(const Vector3D<float>&, const Vector3D<float>&);
+
+template <typename T> Vector3D<T>::Vector3D(T inX, T inY, T inZ) {
+  x=inX;
+  y=inY;
+  z=inZ;
+}
+
+template <typename T> Vector3D<T>::~Vector3D() {}
+
 /*
 void Vector3D::operator=(const gui::Vector3DSpinBox *vector) {
@@ -38 +64 @@
     z=vect.z;
 }*/
-
-Vector3D &Vector3D::operator=(const Vector3D &vector) {
+/*
+template<typename T,typename S> Vector3D<T> &Vector3D<T>::operator=(const Vector3D<S> &vector) {
+//template <typename T> Vector3D<T> &Vector3D<T>::operator=(const Vector3D<T> &vector) {
   x = vector.x;
   y = vector.y;
@@ -45 +72 @@
   return (*this);
 }
-
-Vector3D &Vector3D::operator+=(const Vector3D &vector) {
+*/
+template <typename T> Vector3D<T> &Vector3D<T>::operator+=(const Vector3D<T> &vector) {
   x += vector.x;
   y += vector.y;
@@ -53 +80 @@
 }
 
-Vector3D &Vector3D::operator-=(const Vector3D &vector) {
+template <typename T> Vector3D<T> &Vector3D<T>::operator-=(const Vector3D<T> &vector) {
   x -= vector.x;
   y -= vector.y;
@@ -60 +87 @@
 }
 
-float &Vector3D::operator[](size_t idx) {
+template <typename T> T &Vector3D<T>::operator[](size_t idx) {
   if (idx == 0) {
     return x;
@@ -73 +100 @@
 }
 
-const float &Vector3D::operator[](size_t idx) const {
+template <typename T> const T &Vector3D<T>::operator[](size_t idx) const {
   if (idx == 0) {
     return x;
@@ -86 +113 @@
 }
 
-Vector3D CrossProduct(const Vector3D &vectorA, const Vector3D &vectorB) {
-  return Vector3D(vectorA.y * vectorB.z - vectorA.z * vectorB.y,
+template <typename T> Vector3D<T> CrossProduct(const Vector3D<T> &vectorA, const Vector3D<T> &vectorB) {
+  return Vector3D<T>(vectorA.y * vectorB.z - vectorA.z * vectorB.y,
                   vectorA.z * vectorB.x - vectorA.x * vectorB.z,
                   vectorA.x * vectorB.y - vectorA.y * vectorB.x);
 }
 
-float DotProduct(const Vector3D &vectorA, const Vector3D &vectorB) {
+template <typename T> float DotProduct(const Vector3D<T> &vectorA, const Vector3D<T> &vectorB) {
   return vectorA.x * vectorB.x + vectorA.y * vectorB.y + vectorA.z * vectorB.z;
 }
 
-Vector3D operator+(const Vector3D &vectorA, const Vector3D &vectorB) {
-  return Vector3D(vectorA.x + vectorB.x, vectorA.y + vectorB.y,
+template <typename T> Vector3D<T> operator+(const Vector3D<T> &vectorA, const Vector3D<T> &vectorB) {
+  return Vector3D<T>(vectorA.x + vectorB.x, vectorA.y + vectorB.y,
                   vectorA.z + vectorB.z);
 }
 
-Vector3D operator-(const Vector3D &vectorA, const Vector3D &vectorB) {
-  return Vector3D(vectorA.x - vectorB.x, vectorA.y - vectorB.y,
+template <typename T> Vector3D<T> operator-(const Vector3D<T> &vectorA, const Vector3D<T> &vectorB) {
+  return Vector3D<T>(vectorA.x - vectorB.x, vectorA.y - vectorB.y,
                   vectorA.z - vectorB.z);
 }
 
-Vector3D operator-(const Vector3D &vector) {
-  return Vector3D(-vector.x, -vector.y, -vector.z);
-}
-
-Vector3D operator*(const Vector3D &vectorA, const Vector3D &vectorB) {
-  return Vector3D(vectorA.x * vectorB.x, vectorA.y * vectorB.y,
+template <typename T> Vector3D<T> operator-(const Vector3D<T> &vector) {
+  return Vector3D<T>(-vector.x, -vector.y, -vector.z);
+}
+
+template <typename T> Vector3D<T> operator*(const Vector3D<T> &vectorA, const Vector3D<T> &vectorB) {
+  return Vector3D<T>(vectorA.x * vectorB.x, vectorA.y * vectorB.y,
                   vectorA.z * vectorB.z);
 }
 
-Vector3D operator*(const Vector3D &vector, float coeff) {
-  return Vector3D(vector.x * coeff, vector.y * coeff, vector.z * coeff);
-}
-
-Vector3D operator*(float coeff, const Vector3D &vector) {
-  return Vector3D(vector.x * coeff, vector.y * coeff, vector.z * coeff);
-}
-
-Vector3D operator/(const Vector3D &vector, float coeff) {
+template <typename T> Vector3D<T> operator*(const Vector3D<T> &vector, float coeff) {
+  return Vector3D<T>(vector.x * coeff, vector.y * coeff, vector.z * coeff);
+}
+
+template <typename T> Vector3D<T> operator*(float coeff, const Vector3D<T> &vector) {
+  return Vector3D<T>(vector.x * coeff, vector.y * coeff, vector.z * coeff);
+}
+
+template <typename T> Vector3D<T> operator/(const Vector3D<T> &vector, float coeff) {
   if (coeff != 0) {
-    return Vector3D(vector.x / coeff, vector.y / coeff, vector.z / coeff);
+    return Vector3D<T>(vector.x / coeff, vector.y / coeff, vector.z / coeff);
   } else {
     printf("Vector3D: err divinding by 0\n");
-    return Vector3D(0, 0, 0);
-  }
-}
-
-void Vector3D::RotateX(float value) {
+    return Vector3D<T>(0, 0, 0);
+  }
+}
+
+template <typename T> void Vector3D<T>::RotateX(float value) {
   float y_tmp;
   y_tmp = y * cosf(value) - z * sinf(value);
@@ -139 +166 @@
 }
 
-void Vector3D::RotateXDeg(float value) { RotateX(Euler::ToRadian(value)); }
-
-void Vector3D::RotateY(float value) {
+template <typename T> void Vector3D<T>::RotateXDeg(float value) { RotateX(Euler::ToRadian(value)); }
+
+template <typename T> void Vector3D<T>::RotateY(float value) {
   float x_tmp;
   x_tmp = x * cosf(value) + z * sinf(value);
@@ -148 +175 @@
 }
 
-void Vector3D::RotateYDeg(float value) { RotateY(Euler::ToRadian(value)); }
-
-void Vector3D::RotateZ(float value) {
+template <typename T> void Vector3D<T>::RotateYDeg(float value) { RotateY(Euler::ToRadian(value)); }
+
+template <typename T> void Vector3D<T>::RotateZ(float value) {
   float x_tmp;
   x_tmp = x * cosf(value) - y * sinf(value);
@@ -157 +184 @@
 }
 
-void Vector3D::RotateZDeg(float value) { RotateZ(Euler::ToRadian(value)); }
-
-void Vector3D::Rotate(const RotationMatrix &matrix) {
-  float a[3] = {0, 0, 0};
-  float b[3] = {x, y, z};
+template <typename T> void Vector3D<T>::RotateZDeg(float value) { RotateZ(Euler::ToRadian(value)); }
+
+template <typename T> void Vector3D<T>::Rotate(const RotationMatrix &matrix) {
+  T a[3] = {0, 0, 0};
+  T b[3] = {x, y, z};
 
   for (int i = 0; i < 3; i++) {
@@ -174 +201 @@
 }
 
-void Vector3D::Rotate(const Quaternion &quaternion) {
+template <typename T> void Vector3D<T>::Rotate(const Quaternion &quaternion) {
   RotationMatrix matrix;
   quaternion.ToRotationMatrix(matrix);
@@ -180 +207 @@
 }
 
-void Vector3D::To2Dxy(Vector2D &vector) const {
+template <typename T> void Vector3D<T>::To2Dxy(Vector2D<T> &vector) const {
   vector.x = x;
   vector.y = y;
 }
 
-Vector2D Vector3D::To2Dxy(void) const {
-  Vector2D vect;
+template <typename T> Vector2D<T> Vector3D<T>::To2Dxy(void) const {
+  Vector2D<T> vect;
   To2Dxy(vect);
   return vect;
 }
 
-float Vector3D::GetNorm(void) const { return sqrt(x * x + y * y + z * z); }
-
-void Vector3D::Normalize(void) {
+template <typename T> float Vector3D<T>::GetNorm(void) const { return sqrt(x * x + y * y + z * z); }
+
+template <typename T> void Vector3D<T>::Normalize(void) {
   float n = GetNorm();
   if (n != 0) {
@@ -202 +229 @@
 }
 
-void Vector3D::Saturate(const Vector3D &min, const Vector3D &max) {
+template <typename T> void Vector3D<T>::Saturate(const Vector3D<T> &min, const Vector3D<T> &max) {
   if (x < min.x)
     x = min.x;
@@ -219 +246 @@
 }
 
-void Vector3D::Saturate(float min, float max) {
-  Saturate(Vector3D(min, min, min), Vector3D(max, max, max));
-}
-
-void Vector3D::Saturate(const Vector3D &value) {
+template <typename T> void Vector3D<T>::Saturate(float min, float max) {
+  Saturate(Vector3D<T>(min, min, min), Vector3D<T>(max, max, max));
+}
+
+template <typename T> void Vector3D<T>::Saturate(const Vector3D<T> &value) {
   float x = fabs(value.x);
   float y = fabs(value.y);
   float z = fabs(value.z);
-  Saturate(Vector3D(-x, -y, -z), Vector3D(x, y, z));
-}
-
-void Vector3D::Saturate(float value) {
+  Saturate(Vector3D<T>(-x, -y, -z), Vector3D<T>(x, y, z));
+}
+
+template <typename T> void Vector3D<T>::Saturate(float value) {
   float sat = fabs(value);
-  Saturate(Vector3D(-sat, -sat, -sat), Vector3D(sat, sat, sat));
+  Saturate(Vector3D<T>(-sat, -sat, -sat), Vector3D<T>(sat, sat, sat));
 }