Changeset 3226

Timestamp:

08/03/04 21:00:55 (9 years ago)

Author:

robert

Message:

Fixed tabbing

Files:

• OpenSceneGraph/trunk/include/osg/Quat (modified) (11 diffs)

OpenSceneGraph/trunk/include/osg/Quat

@@ -34 +34 @@
         typedef double value_type;
 
-    value_type  _v[4];    // a four-vector
-
-    inline Quat() { _v[0]=0.0; _v[1]=0.0; _v[2]=0.0; _v[3]=1.0; }
-        
-    inline Quat( value_type x, value_type y, value_type z, value_type w )
+        value_type  _v[4];    // a four-vector
+
+        inline Quat() { _v[0]=0.0; _v[1]=0.0; _v[2]=0.0; _v[3]=1.0; }
+
+        inline Quat( value_type x, value_type y, value_type z, value_type w )
         {
             _v[0]=x;
@@ -46 +46 @@
         }
 
-    inline Quat( const Vec4f& v )
+        inline Quat( const Vec4f& v )
         {
             _v[0]=v.x();
@@ -54 +54 @@
         }
 
-    inline Quat( const Vec4d& v )
+        inline Quat( const Vec4d& v )
         {
             _v[0]=v.x();
@@ -101 +101 @@
 
         /* ----------------------------------
-       Methods to access data members
-    ---------------------------------- */
-
-    inline Vec4d asVec4() const
-    {
-        return Vec4d(_v[0], _v[1], _v[2], _v[3]);
-    }
-
-    inline Vec3d asVec3() const
-    {
-        return Vec3d(_v[0], _v[1], _v[2]);
-    }
+           Methods to access data members
+        ---------------------------------- */
+
+        inline Vec4d asVec4() const
+        {
+            return Vec4d(_v[0], _v[1], _v[2], _v[3]);
+        }
+
+        inline Vec3d asVec3() const
+        {
+            return Vec3d(_v[0], _v[1], _v[2]);
+        }
 
         inline void set(value_type x, value_type y, value_type z, value_type w)
@@ -164 +164 @@
 
 
-     /* ------------------------------------------------------------- 
-               BASIC ARITHMETIC METHODS            
-    Implemented in terms of Vec4s.  Some Vec4 operators, e.g.
-    operator* are not appropriate for quaternions (as
-    mathematical objects) so they are implemented differently.
-    Also define methods for conjugate and the multiplicative inverse.            
-    ------------------------------------------------------------- */
-    /// Multiply by scalar 
+         /* ------------------------------------------------------------- 
+                   BASIC ARITHMETIC METHODS            
+        Implemented in terms of Vec4s.  Some Vec4 operators, e.g.
+        operator* are not appropriate for quaternions (as
+        mathematical objects) so they are implemented differently.
+        Also define methods for conjugate and the multiplicative inverse.            
+        ------------------------------------------------------------- */
+        /// Multiply by scalar 
         inline const Quat operator * (value_type rhs) const
         {
@@ -177 +177 @@
         }
 
-    /// Unary multiply by scalar 
+        /// Unary multiply by scalar 
         inline Quat& operator *= (value_type rhs)
         {
@@ -187 +187 @@
         }
 
-    /// Binary multiply 
-    inline const Quat operator*(const Quat& rhs) const
-    {
-        return Quat( rhs._v[3]*_v[0] + rhs._v[0]*_v[3] + rhs._v[1]*_v[2] - rhs._v[2]*_v[1],
-             rhs._v[3]*_v[1] - rhs._v[0]*_v[2] + rhs._v[1]*_v[3] + rhs._v[2]*_v[0],
-             rhs._v[3]*_v[2] + rhs._v[0]*_v[1] - rhs._v[1]*_v[0] + rhs._v[2]*_v[3],
-             rhs._v[3]*_v[3] - rhs._v[0]*_v[0] - rhs._v[1]*_v[1] - rhs._v[2]*_v[2] );
-    }
-
-    /// Unary multiply 
-    inline Quat& operator*=(const Quat& rhs)
-    {
-        value_type x = rhs._v[3]*_v[0] + rhs._v[0]*_v[3] + rhs._v[1]*_v[2] - rhs._v[2]*_v[1];
-        value_type y = rhs._v[3]*_v[1] - rhs._v[0]*_v[2] + rhs._v[1]*_v[3] + rhs._v[2]*_v[0];
-        value_type z = rhs._v[3]*_v[2] + rhs._v[0]*_v[1] - rhs._v[1]*_v[0] + rhs._v[2]*_v[3];
-        _v[3]   = rhs._v[3]*_v[3] - rhs._v[0]*_v[0] - rhs._v[1]*_v[1] - rhs._v[2]*_v[2];
-
-        _v[2] = z;
-        _v[1] = y;
-        _v[0] = x;
-
-        return (*this);            // enable nesting
-    }
-
-    /// Divide by scalar 
+        /// Binary multiply 
+        inline const Quat operator*(const Quat& rhs) const
+        {
+            return Quat( rhs._v[3]*_v[0] + rhs._v[0]*_v[3] + rhs._v[1]*_v[2] - rhs._v[2]*_v[1],
+                 rhs._v[3]*_v[1] - rhs._v[0]*_v[2] + rhs._v[1]*_v[3] + rhs._v[2]*_v[0],
+                 rhs._v[3]*_v[2] + rhs._v[0]*_v[1] - rhs._v[1]*_v[0] + rhs._v[2]*_v[3],
+                 rhs._v[3]*_v[3] - rhs._v[0]*_v[0] - rhs._v[1]*_v[1] - rhs._v[2]*_v[2] );
+        }
+
+        /// Unary multiply 
+        inline Quat& operator*=(const Quat& rhs)
+        {
+            value_type x = rhs._v[3]*_v[0] + rhs._v[0]*_v[3] + rhs._v[1]*_v[2] - rhs._v[2]*_v[1];
+            value_type y = rhs._v[3]*_v[1] - rhs._v[0]*_v[2] + rhs._v[1]*_v[3] + rhs._v[2]*_v[0];
+            value_type z = rhs._v[3]*_v[2] + rhs._v[0]*_v[1] - rhs._v[1]*_v[0] + rhs._v[2]*_v[3];
+            _v[3]   = rhs._v[3]*_v[3] - rhs._v[0]*_v[0] - rhs._v[1]*_v[1] - rhs._v[2]*_v[2];
+
+            _v[2] = z;
+            _v[1] = y;
+            _v[0] = x;
+
+            return (*this);            // enable nesting
+        }
+
+        /// Divide by scalar 
         inline Quat operator / (value_type rhs) const
         {
@@ -218 +218 @@
         }
 
-    /// Unary divide by scalar 
+        /// Unary divide by scalar 
         inline Quat& operator /= (value_type rhs)
         {
@@ -229 +229 @@
         }
 
-    /// Binary divide 
-    inline const Quat operator/(const Quat& denom) const
-    {
-        return ( (*this) * denom.inverse() );
-    }
-
-    /// Unary divide 
-    inline Quat& operator/=(const Quat& denom)
-    {
-        (*this) = (*this) * denom.inverse();
-        return (*this);            // enable nesting
-    }
-
-    /// Binary addition 
+        /// Binary divide 
+        inline const Quat operator/(const Quat& denom) const
+        {
+            return ( (*this) * denom.inverse() );
+        }
+
+        /// Unary divide 
+        inline Quat& operator/=(const Quat& denom)
+        {
+            (*this) = (*this) * denom.inverse();
+            return (*this);            // enable nesting
+        }
+
+        /// Binary addition 
         inline const Quat operator + (const Quat& rhs) const
         {
@@ -249 +249 @@
         }
 
-    /// Unary addition
+        /// Unary addition
         inline Quat& operator += (const Quat& rhs)
         {
@@ -309 +309 @@
       /* -------------------------------------------------------- 
                METHODS RELATED TO ROTATIONS
-    Set a quaternion which will perform a rotation of an
-    angle around the axis given by the vector (x,y,z).
-    Should be written to also accept an angle and a Vec3?
-
-    Define Spherical Linear interpolation method also
-
-    Not inlined - see the Quat.cpp file for implementation
-    -------------------------------------------------------- */
+        Set a quaternion which will perform a rotation of an
+        angle around the axis given by the vector (x,y,z).
+        Should be written to also accept an angle and a Vec3?
+
+        Define Spherical Linear interpolation method also
+
+        Not inlined - see the Quat.cpp file for implementation
+        -------------------------------------------------------- */
         void makeRotate( value_type  angle, 
                           value_type  x, value_type  y, value_type  z );