X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=simgear%2Fmath%2FSGVec4.hxx;h=4339dfd9b79879a3fab0da2b59a5cca747cc5578;hb=584ee1364f25e5c3795f9ff4633a792cba39bfc7;hp=feee964b4b5b57b68915e1be74db7f289a20ceef;hpb=607987def582820eb738b61d336d2a301df1c38d;p=simgear.git

diff --git a/simgear/math/SGVec4.hxx b/simgear/math/SGVec4.hxx
index feee964b..4339dfd9 100644
--- a/simgear/math/SGVec4.hxx
+++ b/simgear/math/SGVec4.hxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2006  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2006-2009  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -18,6 +18,8 @@
 #ifndef SGVec4_H
 #define SGVec4_H
 
+#include <iosfwd>
+
 /// 4D Vector Class
 template<typename T>
 class SGVec4 {
@@ -33,82 +35,78 @@ public:
     /// uninitialized values in the debug build very fast ...
 #ifndef NDEBUG
     for (unsigned i = 0; i < 4; ++i)
-      _data[i] = SGLimits<T>::quiet_NaN();
+      data()[i] = SGLimits<T>::quiet_NaN();
 #endif
   }
   /// Constructor. Initialize by the given values
   SGVec4(T x, T y, T z, T w)
-  { _data[0] = x; _data[1] = y; _data[2] = z; _data[3] = w; }
+  { data()[0] = x; data()[1] = y; data()[2] = z; data()[3] = w; }
   /// Constructor. Initialize by the content of a plain array,
   /// make sure it has at least 3 elements
   explicit SGVec4(const T* d)
-  { _data[0] = d[0]; _data[1] = d[1]; _data[2] = d[2]; _data[3] = d[3]; }
-
+  { data()[0] = d[0]; data()[1] = d[1]; data()[2] = d[2]; data()[3] = d[3]; }
+  template<typename S>
+  explicit SGVec4(const SGVec4<S>& d)
+  { data()[0] = d[0]; data()[1] = d[1]; data()[2] = d[2]; data()[3] = d[3]; }
+  explicit SGVec4(const SGVec3<T>& v3, const T& v4 = 0)
+  { data()[0] = v3[0]; data()[1] = v3[1]; data()[2] = v3[2]; data()[3] = v4; }
 
   /// Access by index, the index is unchecked
   const T& operator()(unsigned i) const
-  { return _data[i]; }
+  { return data()[i]; }
   /// Access by index, the index is unchecked
   T& operator()(unsigned i)
-  { return _data[i]; }
+  { return data()[i]; }
 
   /// Access raw data by index, the index is unchecked
   const T& operator[](unsigned i) const
-  { return _data[i]; }
+  { return data()[i]; }
   /// Access raw data by index, the index is unchecked
   T& operator[](unsigned i)
-  { return _data[i]; }
+  { return data()[i]; }
 
   /// Access the x component
   const T& x(void) const
-  { return _data[0]; }
+  { return data()[0]; }
   /// Access the x component
   T& x(void)
-  { return _data[0]; }
+  { return data()[0]; }
   /// Access the y component
   const T& y(void) const
-  { return _data[1]; }
+  { return data()[1]; }
   /// Access the y component
   T& y(void)
-  { return _data[1]; }
+  { return data()[1]; }
   /// Access the z component
   const T& z(void) const
-  { return _data[2]; }
+  { return data()[2]; }
   /// Access the z component
   T& z(void)
-  { return _data[2]; }
+  { return data()[2]; }
   /// Access the x component
   const T& w(void) const
-  { return _data[3]; }
+  { return data()[3]; }
   /// Access the x component
   T& w(void)
-  { return _data[3]; }
-
-
-  /// Get the data pointer, usefull for interfacing with plib's sg*Vec
-  const T* data(void) const
-  { return _data; }
-  /// Get the data pointer, usefull for interfacing with plib's sg*Vec
-  T* data(void)
-  { return _data; }
+  { return data()[3]; }
 
-  /// Readonly interface function to ssg's sgVec3/sgdVec3
-  const T (&sg(void) const)[4]
+  /// Readonly raw storage interface
+  const T (&data(void) const)[4]
   { return _data; }
-  /// Interface function to ssg's sgVec3/sgdVec3
-  T (&sg(void))[4]
+  /// Readonly raw storage interface
+  T (&data(void))[4]
   { return _data; }
 
   /// Inplace addition
   SGVec4& operator+=(const SGVec4& v)
-  { _data[0]+=v(0);_data[1]+=v(1);_data[2]+=v(2);_data[3]+=v(3);return *this; }
+  { data()[0]+=v(0);data()[1]+=v(1);data()[2]+=v(2);data()[3]+=v(3);return *this; }
   /// Inplace subtraction
   SGVec4& operator-=(const SGVec4& v)
-  { _data[0]-=v(0);_data[1]-=v(1);_data[2]-=v(2);_data[3]-=v(3);return *this; }
+  { data()[0]-=v(0);data()[1]-=v(1);data()[2]-=v(2);data()[3]-=v(3);return *this; }
   /// Inplace scalar multiplication
   template<typename S>
   SGVec4& operator*=(S s)
-  { _data[0] *= s; _data[1] *= s; _data[2] *= s; _data[3] *= s; return *this; }
+  { data()[0] *= s; data()[1] *= s; data()[2] *= s; data()[3] *= s; return *this; }
   /// Inplace scalar multiplication by 1/s
   template<typename S>
   SGVec4& operator/=(S s)
@@ -128,7 +126,6 @@ public:
   { return SGVec4(0, 0, 0, 1); }
 
 private:
-  /// The actual data
   T _data[4];
 };
 
@@ -174,6 +171,92 @@ SGVec4<T>
 operator*(const SGVec4<T>& v, S s)
 { return SGVec4<T>(s*v(0), s*v(1), s*v(2), s*v(3)); }
 
+/// multiplication as a multiplicator, that is assume that the first vector
+/// represents a 4x4 diagonal matrix with the diagonal elements in the vector.
+/// Then the result is the product of that matrix times the second vector.
+template<typename T>
+inline
+SGVec4<T>
+mult(const SGVec4<T>& v1, const SGVec4<T>& v2)
+{ return SGVec4<T>(v1(0)*v2(0), v1(1)*v2(1), v1(2)*v2(2), v1(3)*v2(3)); }
+
+/// component wise min
+template<typename T>
+inline
+SGVec4<T>
+min(const SGVec4<T>& v1, const SGVec4<T>& v2)
+{
+  return SGVec4<T>(SGMisc<T>::min(v1(0), v2(0)),
+                   SGMisc<T>::min(v1(1), v2(1)),
+                   SGMisc<T>::min(v1(2), v2(2)),
+                   SGMisc<T>::min(v1(3), v2(3)));
+}
+template<typename S, typename T>
+inline
+SGVec4<T>
+min(const SGVec4<T>& v, S s)
+{
+  return SGVec4<T>(SGMisc<T>::min(s, v(0)),
+                   SGMisc<T>::min(s, v(1)),
+                   SGMisc<T>::min(s, v(2)),
+                   SGMisc<T>::min(s, v(3)));
+}
+template<typename S, typename T>
+inline
+SGVec4<T>
+min(S s, const SGVec4<T>& v)
+{
+  return SGVec4<T>(SGMisc<T>::min(s, v(0)),
+                   SGMisc<T>::min(s, v(1)),
+                   SGMisc<T>::min(s, v(2)),
+                   SGMisc<T>::min(s, v(3)));
+}
+
+/// component wise max
+template<typename T>
+inline
+SGVec4<T>
+max(const SGVec4<T>& v1, const SGVec4<T>& v2)
+{
+  return SGVec4<T>(SGMisc<T>::max(v1(0), v2(0)),
+                   SGMisc<T>::max(v1(1), v2(1)),
+                   SGMisc<T>::max(v1(2), v2(2)),
+                   SGMisc<T>::max(v1(3), v2(3)));
+}
+template<typename S, typename T>
+inline
+SGVec4<T>
+max(const SGVec4<T>& v, S s)
+{
+  return SGVec4<T>(SGMisc<T>::max(s, v(0)),
+                   SGMisc<T>::max(s, v(1)),
+                   SGMisc<T>::max(s, v(2)),
+                   SGMisc<T>::max(s, v(3)));
+}
+template<typename S, typename T>
+inline
+SGVec4<T>
+max(S s, const SGVec4<T>& v)
+{
+  return SGVec4<T>(SGMisc<T>::max(s, v(0)),
+                   SGMisc<T>::max(s, v(1)),
+                   SGMisc<T>::max(s, v(2)),
+                   SGMisc<T>::max(s, v(3)));
+}
+
+/// Add two vectors taking care of (integer) overflows. The values are limited
+/// to the respective minimum and maximum values.
+template<class T>
+SGVec4<T> addClipOverflow(SGVec4<T> const& lhs, SGVec4<T> const& rhs)
+{
+  return SGVec4<T>(
+    SGMisc<T>::addClipOverflow(lhs.x(), rhs.x()),
+    SGMisc<T>::addClipOverflow(lhs.y(), rhs.y()),
+    SGMisc<T>::addClipOverflow(lhs.z(), rhs.z()),
+    SGMisc<T>::addClipOverflow(lhs.w(), rhs.w())
+  );
+}
+
 /// Scalar dot product
 template<typename T>
 inline
@@ -203,12 +286,24 @@ T
 norm1(const SGVec4<T>& v)
 { return fabs(v(0)) + fabs(v(1)) + fabs(v(2)) + fabs(v(3)); }
 
+/// The inf-norm of the vector
+template<typename T>
+inline
+T
+normI(const SGVec4<T>& v)
+{ return SGMisc<T>::max(fabs(v(0)), fabs(v(1)), fabs(v(2)), fabs(v(2))); }
+
 /// The euclidean norm of the vector, that is what most people call length
 template<typename T>
 inline
 SGVec4<T>
 normalize(const SGVec4<T>& v)
-{ return (1/norm(v))*v; }
+{
+  T normv = norm(v);
+  if (normv <= SGLimits<T>::min())
+    return SGVec4<T>::zeros();
+  return (1/normv)*v;
+}
 
 /// Return true if exactly the same
 template<typename T>
@@ -224,6 +319,47 @@ bool
 operator!=(const SGVec4<T>& v1, const SGVec4<T>& v2)
 { return ! (v1 == v2); }
 
+/// Return true if smaller, good for putting that into a std::map
+template<typename T>
+inline
+bool
+operator<(const SGVec4<T>& v1, const SGVec4<T>& v2)
+{
+  if (v1(0) < v2(0)) return true;
+  else if (v2(0) < v1(0)) return false;
+  else if (v1(1) < v2(1)) return true;
+  else if (v2(1) < v1(1)) return false;
+  else if (v1(2) < v2(2)) return true;
+  else if (v2(2) < v1(2)) return false;
+  else return (v1(3) < v2(3));
+}
+
+template<typename T>
+inline
+bool
+operator<=(const SGVec4<T>& v1, const SGVec4<T>& v2)
+{
+  if (v1(0) < v2(0)) return true;
+  else if (v2(0) < v1(0)) return false;
+  else if (v1(1) < v2(1)) return true;
+  else if (v2(1) < v1(1)) return false;
+  else if (v1(2) < v2(2)) return true;
+  else if (v2(2) < v1(2)) return false;
+  else return (v1(3) <= v2(3));
+}
+
+template<typename T>
+inline
+bool
+operator>(const SGVec4<T>& v1, const SGVec4<T>& v2)
+{ return operator<(v2, v1); }
+
+template<typename T>
+inline
+bool
+operator>=(const SGVec4<T>& v1, const SGVec4<T>& v2)
+{ return operator<=(v2, v1); }
+
 /// Return true if equal to the relative tolerance tol
 template<typename T>
 inline
@@ -262,6 +398,18 @@ T
 distSqr(const SGVec4<T>& v1, const SGVec4<T>& v2)
 { SGVec4<T> tmp = v1 - v2; return dot(tmp, tmp); }
 
+// calculate the projection of u along the direction of d.
+template<typename T>
+inline
+SGVec4<T>
+projection(const SGVec4<T>& u, const SGVec4<T>& d)
+{
+  T denom = dot(d, d);
+  T ud = dot(u, d);
+  if (SGLimits<T>::min() < denom) return u;
+  else return d * (dot(u, d) / denom);
+}
+
 #ifndef NDEBUG
 template<typename T>
 inline