Changeset 2551 in orxonox.OLD for orxonox/trunk/src/vector.cc

Timestamp:

Oct 11, 2004, 12:53:43 AM (21 years ago)

Author:

patrick

Message:

orxonox/trunk: minor changes - enhanced sc controll, fixed uncontrolled rotation effect, added some debug outputs for testing purposes, reformatted some src files from win style but not all

File:

• orxonox/trunk/src/vector.cc (modified) (7 diffs)

orxonox/trunk/src/vector.cc

@@ -12 +12 @@
 
    ### File Specific:
-   main-programmer: Christian Meyer
-   co-programmer: ...
+   main-programmer: Christian Meyer 
+   co-programmer: Patrick Boenzli : Vector::scale()
+                                    Vector::abs()
    
    Quaternion code borrowed from an Gamasutra article by Nick Bobick and Ken Shoemake
@@ -147 +148 @@
   z = z / l;
 }
+
+
+/**
+   \bref returns the voctor normalized to length 1.0
+*/
+
+Vector* Vector::getNormalized()
+{
+  float l = len();
+  if(l != 1.0)
+    {
+      return this;
+    }
+  else if(l == 0.0)
+    {
+      return 0;
+    }
+  
+  Vector *normalizedVector = new Vector(x / l, y /l, z / l);
+  return normalizedVector;
+}
+
+
+void Vector::scale(const Vector& v)
+{
+  x *= v.x;
+  y *= v.y;
+  z *= v.z;
+}
+
  
 /**
@@ -156 +187 @@
   return sqrt (x*x+y*y+z*z);
 }
+
+
+
+Vector Vector::abs() 
+{
+  Vector v(fabs(x), fabs(y), fabs(z));
+  return v;
+}
+
 
 /**
@@ -168 +208 @@
 }
 
+
 /**
    \brief calculate the angle between two vectors in degrees
@@ -202 +243 @@
 
 /**
-        \brief calculates a look_at rotation
-        \param dir: the direction you want to look
-        \param up: specify what direction up should be
-        
-        Mathematically this determines the rotation a (0,0,1)-Vector has to undergo to point the same way as dir.
-        If you want to use this with cameras, you'll have to reverse the dir Vector (Vector(0,0,0) - your viewing direction)
-        or you'll point the wrong way. You can use this for meshes as well (then you do not have to reverse the vector), but keep in mind that if you do that, the model's front
-        has to point in +z direction, and left and right should be -x or +x respectively or the mesh wont rotate correctly.
+   \brief calculates a look_at rotation
+   \param dir: the direction you want to look
+   \param up: specify what direction up should be
+   
+   Mathematically this determines the rotation a (0,0,1)-Vector has to undergo to point
+   the same way as dir. If you want to use this with cameras, you'll have to reverse the
+   dir Vector (Vector(0,0,0) - your viewing direction) or you'll point the wrong way. You
+   can use this for meshes as well (then you do not have to reverse the vector), but keep 
+   in mind that if you do that, the model's front has to point in +z direction, and left 
+   and right should be -x or +x respectively or the mesh wont rotate correctly.
 */
 Quaternion::Quaternion (const Vector& dir, const Vector& up)
 {
-        Vector z = dir;
+  Vector z = dir;
   z.normalize(); 
   Vector x = up.cross(z);
@@ -246 +289 @@
         \param yaw: the yaw in radians
         
-        I DO HONESTLY NOT EXACTLY KNOW WHICH ANGLE REPRESENTS WHICH ROTATION. And I do not know in what order they are applied,
-        I just copy-pasted the code.
+        I DO HONESTLY NOT EXACTLY KNOW WHICH ANGLE REPRESENTS WHICH ROTATION. And I do not know 
+        in what order they are applied, I just copy-pasted the code.
 */
 Quaternion::Quaternion (float roll, float pitch, float yaw)
@@ -407 +450 @@
 void Quaternion::matrix (float m[4][4]) const
 {
-        float wx, wy, wz, xx, yy, yz, xy, xz, zz, x2, y2, z2; 
-
-        // calculate coefficients
-        x2 = v.x + v.x;
+  float wx, wy, wz, xx, yy, yz, xy, xz, zz, x2, y2, z2; 
+  
+  // calculate coefficients
+  x2 = v.x + v.x;
   y2 = v.y + v.y; 
-        z2 = v.z + v.z;
-        xx = v.x * x2; xy = v.x * y2; xz = v.x * z2;
-        yy = v.y * y2; yz = v.y * z2; zz = v.z * z2;
-        wx = w * x2; wy = w * y2; wz = w * z2;
-        
-        m[0][0] = 1.0 - (yy + zz); m[1][0] = xy - wz;
-        m[2][0] = xz + wy; m[3][0] = 0.0;
-        
-        m[0][1] = xy + wz; m[1][1] = 1.0 - (xx + zz);
-        m[2][1] = yz - wx; m[3][1] = 0.0;
-        
-        m[0][2] = xz - wy; m[1][2] = yz + wx;
-        m[2][2] = 1.0 - (xx + yy); m[3][2] = 0.0;
-        
-        m[0][3] = 0; m[1][3] = 0;
-        m[2][3] = 0; m[3][3] = 1;
-}
-
-/**
-        \brief convert a rotational 4x4 glMatrix into a Quaternion
-        \param m: a 4x4 matrix in glMatrix order
+  z2 = v.z + v.z;
+  xx = v.x * x2; xy = v.x * y2; xz = v.x * z2;
+  yy = v.y * y2; yz = v.y * z2; zz = v.z * z2;
+  wx = w * x2; wy = w * y2; wz = w * z2;
+  
+  m[0][0] = 1.0 - (yy + zz); m[1][0] = xy - wz;
+  m[2][0] = xz + wy; m[3][0] = 0.0;
+        
+  m[0][1] = xy + wz; m[1][1] = 1.0 - (xx + zz);
+  m[2][1] = yz - wx; m[3][1] = 0.0;
+  
+  m[0][2] = xz - wy; m[1][2] = yz + wx;
+  m[2][2] = 1.0 - (xx + yy); m[3][2] = 0.0;
+  
+  m[0][3] = 0; m[1][3] = 0;
+  m[2][3] = 0; m[3][3] = 1;
+}
+
+
+void Quaternion::quatSlerp(const Quaternion* from, const Quaternion* to, float t, Quaternion* res)
+{
+  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;
+
+  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;
+    }
+  else
+    {
+      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
+    {
+      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];
+}
+
+
+/**
+   \brief convert a rotational 4x4 glMatrix into a Quaternion
+   \param m: a 4x4 matrix in glMatrix order
 */
 Quaternion::Quaternion (float m[4][4])