Changeset 4122 in orxonox.OLD for orxonox/branches/heightMap/src/lib/math

Timestamp:

May 9, 2005, 11:29:19 AM (20 years ago)

Author:

bensch

Message:

orxonox/branches/heightMap: merged the Trunk back into branches/heightMap:
merged with Command
svn merge -r 3918:HEAD trunk branches/heightMap
conflicts resolved in favor of the Trunk

Location:

orxonox/branches/heightMap

Files:

• . (modified) (1 prop)
• src/lib/math/quaternion.h (deleted)
• src/lib/math/vector.cc (modified) (3 diffs)
• src/lib/math/vector.h (modified) (5 diffs)
• src/lib/math/vector_new.h (deleted)

orxonox/branches/heightMap

@@ -1 @@
-data http://svn.orxonox.ethz.ch/data
+

@@ -1 @@
-data http://svn.orxonox.ethz.ch/data
+

orxonox/branches/heightMap/src/lib/math/vector.cc

@@ -100 +100 @@
 */
 
-Vector* Vector::getNormalized()
+Vector Vector::getNormalized()
 {
   float l = len();
   if(unlikely(l != 1.0))
     {
-      return this;
+      return *this;
     }
   else if(unlikely(l == 0.0))
     {
-      return 0;
+      return *this;
     }
 
-  return new Vector(x / l, y /l, z / l);
+  return *this / l;
 }
 
@@ -172 +172 @@
    \brief Outputs the values of the Vector
 */
-void Vector::debug(void)
+void Vector::debug(void) const
 {
   PRINT(0)("Vector Debug information\n");
@@ -435 +435 @@
 /**
    \brief performs a smooth move.
-   \param from from where
-   \param to to where
-   \param t the time this transformation should take
-   \param res The approximation-density
-*/
-void Quaternion::quatSlerp(const Quaternion* from, const Quaternion* to, float t, Quaternion* res)
+   \param from  where
+   \param to where
+   \param t the time this transformation should take value [0..1]
+
+   \returns the Result of the smooth move
+*/
+Quaternion quatSlerp(const Quaternion& from, const Quaternion& to, float t)
 {
   float tol[4];
   double omega, cosom, sinom, scale0, scale1;
-  DELTA = 0.2;
-
-  cosom = from->v.x * to->v.x + from->v.y * to->v.y + from->v.z * to->v.z + from->w * to->w;
+  //  float DELTA = 0.2;
+
+  cosom = from.v.x * to.v.x + from.v.y * to.v.y + from.v.z * to.v.z + from.w * to.w;
 
   if( cosom < 0.0 ) 
     { 
       cosom = -cosom; 
-      tol[0] = -to->v.x;
-      tol[1] = -to->v.y;
-      tol[2] = -to->v.z;
-      tol[3] = -to->w;
+      tol[0] = -to.v.x;
+      tol[1] = -to.v.y;
+      tol[2] = -to.v.z;
+      tol[3] = -to.w;
     }
   else
     {
-      tol[0] = to->v.x;
-      tol[1] = to->v.y;
-      tol[2] = to->v.z;
-      tol[3] = to->w;
+      tol[0] = to.v.x;
+      tol[1] = to.v.y;
+      tol[2] = to.v.z;
+      tol[3] = to.w;
     }
   
   //if( (1.0 - cosom) > DELTA )
   //{
-      omega = acos(cosom);
-      sinom = sin(omega);
-      scale0 = sin((1.0 - t) * omega) / sinom;
-      scale1 = sin(t * omega) / sinom;
-      //}
-      /*
-  else
+  omega = acos(cosom);
+  sinom = sin(omega);
+  scale0 = sin((1.0 - t) * omega) / sinom;
+  scale1 = sin(t * omega) / sinom;
+  //}
+  /*
+    else
     {
-      scale0 = 1.0 - t;
-      scale1 = t;
+    scale0 = 1.0 - t;
+    scale1 = t;
     }
-      */
-  res->v.x = scale0 * from->v.x + scale1 * tol[0];
-  res->v.y = scale0 * from->v.y + scale1 * tol[1];
-  res->v.z = scale0 * from->v.z + scale1 * tol[2];
-  res->w = scale0 * from->w + scale1 * tol[3];
+  */
+
+
+  /*
+    Quaternion res;
+    res.v.x = scale0 * from.v.x + scale1 * tol[0];
+    res.v.y = scale0 * from.v.y + scale1 * tol[1];
+    res.v.z = scale0 * from.v.z + scale1 * tol[2];
+    res.w = scale0 * from.w + scale1 * tol[3];
+  */
+  return Quaternion(Vector(scale0 * from.v.x + scale1 * tol[0],
+                           scale0 * from.v.y + scale1 * tol[1],
+                           scale0 * from.v.z + scale1 * tol[2]),
+                    scale0 * from.w + scale1 * tol[3]);
 }
 

orxonox/branches/heightMap/src/lib/math/vector.h

@@ -31 +31 @@
 
   inline Vector operator+ (const Vector& v) const { return Vector(x + v.x, y + v.y, z + v.z); }
+  inline const Vector& operator+= (const Vector& v) {this->x += v.x; this->y += v.y; this->z += v.z; return *this;}
   inline Vector operator- (const Vector& v) const { return Vector(x - v.x, y - v.y, z - v.z); }
+  inline const Vector& operator-= (const Vector& v) {this->x -= v.x; this->y -= v.y; this->z -= v.z; return *this;}
   inline float operator* (const Vector& v) const { return x * v.x + y * v.y + z * v.z; }
+  inline const Vector& operator*= (const Vector& v) {this->x *= v.x; this->y *= v.y; this->z *= v.z; return *this;}
   inline Vector operator* (float f) const { return Vector(x * f, y * f, z * f); }
+  inline const Vector& operator*= (float f) {this->x *= f; this->y *= f; this->z *= f; return *this;}
   Vector operator/ (float f) const;
+  inline const Vector& operator/= (float f) {this->x /= f; this->y /= f; this->z /= f; return *this;}
+  inline const Vector& operator= (const Vector& v) {this->x = v.x; this->y = v.y; this->z = v.z; return *this;}
   float dot (const Vector& v) const;
-  inline Vector cross (const Vector& v) const {  return Vector(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x ); }
+  inline Vector cross (const Vector& v) const { return Vector(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x ); }
   void scale(const Vector& v);
   inline float len() const { return sqrt (x*x+y*y+z*z); }
@@ -50 +56 @@
                       z = z / l; 
                     }
-  Vector* getNormalized();
+  Vector getNormalized();
   Vector abs();
 
-  void debug();
+  void debug() const;
 };
 
@@ -70 +76 @@
   
   inline Quaternion () { w = 1; v = Vector(0,0,0); }
-  inline Quaternion (const Vector& b, float a) { w = a; v = b; }
+  inline Quaternion (const Vector& v, float f) { this->w = f; this->v = v; }
   Quaternion (float m[4][4]);
   inline Quaternion (float angle, const Vector& axis) { w = cos(angle/2); v = axis * sin(angle/2); }
@@ -76 +82 @@
   Quaternion (float roll, float pitch, float yaw);
   Quaternion operator/ (const float& f) const;
+  inline const Quaternion operator/= (const float& f) {*this = *this / f; return *this;}
   Quaternion operator* (const float& f) const;
+  inline const Quaternion operator*= (const float& f) {*this = *this * f; return *this;}
   Quaternion operator* (const Quaternion& q) const;
+  inline const Quaternion operator*= (const Quaternion& q) {*this = *this * q; return *this;}
   inline Quaternion operator+ (const Quaternion& q) const { return Quaternion(q.v + v, q.w + w); }
+  inline const Quaternion& operator+= (const Quaternion& q) {this->v += q.v; this->w += q.w; return *this;}
   inline Quaternion operator- (const Quaternion& q) const { return Quaternion(q.v - v, q.w - w); }
+  inline const Quaternion& operator-= (const Quaternion& q) {this->v -= q.v; this->w -= q.w; return *this;}
+  inline Quaternion operator= (const Quaternion& q) {this->v = q.v; this->w = q.w; return *this;}
   Quaternion conjugate () const {  Quaternion r(*this);
   r.v = Vector() - r.v;
@@ -87 +99 @@
   float norm () const;
   void matrix (float m[4][4]) const;
-  void quatSlerp(const Quaternion* from, const Quaternion* to, const float t, Quaternion* res);
   
   void debug();
- private:
-  float DELTA;      //!< resolution of calculation
+};
 
-};
+Quaternion quatSlerp(const Quaternion& from, const Quaternion& to, float t);
+
+
 
 //! 3D rotation (OBSOLETE)

@@ -1 @@
-data http://svn.orxonox.ethz.ch/data
+