Changeset 4999 in orxonox.OLD for orxonox/trunk

Timestamp:

Aug 13, 2005, 7:35:16 PM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: the Quaternion multiplication-code is much faster now.
The previous approach was to brute force, and the new one is inlined

Location:

orxonox/trunk/src/lib/math

Files:

• vector.cc (modified) (1 diff)
• vector.h (modified) (1 diff)

orxonox/trunk/src/lib/math/vector.cc

@@ -131 +131 @@
   v.y = cr * sp * cy + sr * cp * sy;
   v.z = cr * cp * sy - sr * sp * cy;
-}
-
-/**
- *  rotates one Quaternion by another
- * @param q: another Quaternion to rotate this by
- * @return a quaternion that represents the first one rotated by the second one (WARUNING: this operation is not commutative! e.g. (A*B) != (B*A))
-*/
-Quaternion Quaternion::operator*(const Quaternion& q) const
-{
-  float A, B, C, D, E, F, G, H;
-
-  A = (w   + v.x)*(q.w   + q.v.x);
-  B = (v.z - v.y)*(q.v.y - q.v.z);
-  C = (w   - v.x)*(q.v.y + q.v.z);
-  D = (v.y + v.z)*(q.w   - q.v.x);
-  E = (v.x + v.z)*(q.v.x + q.v.y);
-  F = (v.x - v.z)*(q.v.x - q.v.y);
-  G = (w   + v.y)*(q.w   - q.v.z);
-  H = (w   - v.y)*(q.w   + q.v.z);
-
-  Quaternion r;
-  r.v.x = A - (E + F + G + H)/2;
-  r.v.y = C + (E - F + G - H)/2;
-  r.v.z = D + (E - F - G + H)/2;
-  r.w = B +  (-E - F + G + H)/2;
-
-  return r;
 }
 

orxonox/trunk/src/lib/math/vector.h

@@ -132 +132 @@
   /** @param f: the value to multiply by @returns the quaternion multiplied by f (this *= f) */
   inline const Quaternion& operator*= (const float& f) {*this = *this * f; return *this;}
-  Quaternion operator* (const Quaternion& q) const;
+  /** @param q: another Quaternion to rotate this by @return a quaternion that represents the first one rotated by the second one (WARUNING: this operation is not commutative! e.g. (A*B) != (B*A)) */
+  Quaternion operator* (const Quaternion& q) const { return Quaternion(Vector(this->w*q.v.x + this->v.x*q.w + this->v.y*q.v.z - this->v.z*q.v.y,
+                                                                         this->w*q.v.y + this->v.y*q.w + this->v.z*q.v.x - this->v.x*q.v.z,
+                                                                         this->w*q.v.z + this->v.z*q.w + this->v.x*q.v.y - this->v.y*q.v.x),
+                                                                         this->w*q.w - this->v.x*q.v.x - this->v.y*q.v.y - this->v.z*q.v.z);
+  };
   /** @param q: the Quaternion to multiply by @returns the quaternion multiplied by q (this *= q) */
   inline const Quaternion& operator*= (const Quaternion& q) {*this = *this * q; return *this; };