Changeset 3226

Show
Ignore:
Timestamp:
08/03/04 21:00:55 (10 years ago)
Author:
robert
Message:

Fixed tabbing

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/include/osg/Quat

    r3093 r3226  
    3434        typedef double value_type; 
    3535 
    36     value_type  _v[4];    // a four-vector 
    37  
    38     inline Quat() { _v[0]=0.0; _v[1]=0.0; _v[2]=0.0; _v[3]=1.0; } 
    39          
    40     inline Quat( value_type x, value_type y, value_type z, value_type w ) 
     36        value_type  _v[4];    // a four-vector 
     37 
     38        inline Quat() { _v[0]=0.0; _v[1]=0.0; _v[2]=0.0; _v[3]=1.0; } 
     39 
     40        inline Quat( value_type x, value_type y, value_type z, value_type w ) 
    4141        { 
    4242            _v[0]=x; 
     
    4646        } 
    4747 
    48     inline Quat( const Vec4f& v ) 
     48        inline Quat( const Vec4f& v ) 
    4949        { 
    5050            _v[0]=v.x(); 
     
    5454        } 
    5555 
    56     inline Quat( const Vec4d& v ) 
     56        inline Quat( const Vec4d& v ) 
    5757        { 
    5858            _v[0]=v.x(); 
     
    101101 
    102102        /* ---------------------------------- 
    103        Methods to access data members 
    104     ---------------------------------- */ 
    105  
    106     inline Vec4d asVec4() const 
    107     { 
    108         return Vec4d(_v[0], _v[1], _v[2], _v[3]); 
    109     } 
    110  
    111     inline Vec3d asVec3() const 
    112     { 
    113         return Vec3d(_v[0], _v[1], _v[2]); 
    114     } 
     103           Methods to access data members 
     104        ---------------------------------- */ 
     105 
     106        inline Vec4d asVec4() const 
     107        { 
     108            return Vec4d(_v[0], _v[1], _v[2], _v[3]); 
     109        } 
     110 
     111        inline Vec3d asVec3() const 
     112        { 
     113            return Vec3d(_v[0], _v[1], _v[2]); 
     114        } 
    115115 
    116116        inline void set(value_type x, value_type y, value_type z, value_type w) 
     
    164164 
    165165 
    166      /* -------------------------------------------------------------  
    167                BASIC ARITHMETIC METHODS             
    168     Implemented in terms of Vec4s.  Some Vec4 operators, e.g. 
    169     operator* are not appropriate for quaternions (as 
    170     mathematical objects) so they are implemented differently. 
    171     Also define methods for conjugate and the multiplicative inverse.             
    172     ------------------------------------------------------------- */ 
    173     /// Multiply by scalar  
     166         /* -------------------------------------------------------------  
     167                   BASIC ARITHMETIC METHODS             
     168        Implemented in terms of Vec4s.  Some Vec4 operators, e.g. 
     169        operator* are not appropriate for quaternions (as 
     170        mathematical objects) so they are implemented differently. 
     171        Also define methods for conjugate and the multiplicative inverse.             
     172        ------------------------------------------------------------- */ 
     173        /// Multiply by scalar  
    174174        inline const Quat operator * (value_type rhs) const 
    175175        { 
     
    177177        } 
    178178 
    179     /// Unary multiply by scalar  
     179        /// Unary multiply by scalar  
    180180        inline Quat& operator *= (value_type rhs) 
    181181        { 
     
    187187        } 
    188188 
    189     /// Binary multiply  
    190     inline const Quat operator*(const Quat& rhs) const 
    191     { 
    192         return Quat( rhs._v[3]*_v[0] + rhs._v[0]*_v[3] + rhs._v[1]*_v[2] - rhs._v[2]*_v[1], 
    193              rhs._v[3]*_v[1] - rhs._v[0]*_v[2] + rhs._v[1]*_v[3] + rhs._v[2]*_v[0], 
    194              rhs._v[3]*_v[2] + rhs._v[0]*_v[1] - rhs._v[1]*_v[0] + rhs._v[2]*_v[3], 
    195              rhs._v[3]*_v[3] - rhs._v[0]*_v[0] - rhs._v[1]*_v[1] - rhs._v[2]*_v[2] ); 
    196     } 
    197  
    198     /// Unary multiply  
    199     inline Quat& operator*=(const Quat& rhs) 
    200     { 
    201         value_type x = rhs._v[3]*_v[0] + rhs._v[0]*_v[3] + rhs._v[1]*_v[2] - rhs._v[2]*_v[1]; 
    202         value_type y = rhs._v[3]*_v[1] - rhs._v[0]*_v[2] + rhs._v[1]*_v[3] + rhs._v[2]*_v[0]; 
    203         value_type z = rhs._v[3]*_v[2] + rhs._v[0]*_v[1] - rhs._v[1]*_v[0] + rhs._v[2]*_v[3]; 
    204         _v[3]   = rhs._v[3]*_v[3] - rhs._v[0]*_v[0] - rhs._v[1]*_v[1] - rhs._v[2]*_v[2]; 
    205  
    206         _v[2] = z; 
    207         _v[1] = y; 
    208         _v[0] = x; 
    209  
    210         return (*this);            // enable nesting 
    211     } 
    212  
    213     /// Divide by scalar  
     189        /// Binary multiply  
     190        inline const Quat operator*(const Quat& rhs) const 
     191        { 
     192            return Quat( rhs._v[3]*_v[0] + rhs._v[0]*_v[3] + rhs._v[1]*_v[2] - rhs._v[2]*_v[1], 
     193                 rhs._v[3]*_v[1] - rhs._v[0]*_v[2] + rhs._v[1]*_v[3] + rhs._v[2]*_v[0], 
     194                 rhs._v[3]*_v[2] + rhs._v[0]*_v[1] - rhs._v[1]*_v[0] + rhs._v[2]*_v[3], 
     195                 rhs._v[3]*_v[3] - rhs._v[0]*_v[0] - rhs._v[1]*_v[1] - rhs._v[2]*_v[2] ); 
     196        } 
     197 
     198        /// Unary multiply  
     199        inline Quat& operator*=(const Quat& rhs) 
     200        { 
     201            value_type x = rhs._v[3]*_v[0] + rhs._v[0]*_v[3] + rhs._v[1]*_v[2] - rhs._v[2]*_v[1]; 
     202            value_type y = rhs._v[3]*_v[1] - rhs._v[0]*_v[2] + rhs._v[1]*_v[3] + rhs._v[2]*_v[0]; 
     203            value_type z = rhs._v[3]*_v[2] + rhs._v[0]*_v[1] - rhs._v[1]*_v[0] + rhs._v[2]*_v[3]; 
     204            _v[3]   = rhs._v[3]*_v[3] - rhs._v[0]*_v[0] - rhs._v[1]*_v[1] - rhs._v[2]*_v[2]; 
     205 
     206            _v[2] = z; 
     207            _v[1] = y; 
     208            _v[0] = x; 
     209 
     210            return (*this);            // enable nesting 
     211        } 
     212 
     213        /// Divide by scalar  
    214214        inline Quat operator / (value_type rhs) const 
    215215        { 
     
    218218        } 
    219219 
    220     /// Unary divide by scalar  
     220        /// Unary divide by scalar  
    221221        inline Quat& operator /= (value_type rhs) 
    222222        { 
     
    229229        } 
    230230 
    231     /// Binary divide  
    232     inline const Quat operator/(const Quat& denom) const 
    233     { 
    234         return ( (*this) * denom.inverse() ); 
    235     } 
    236  
    237     /// Unary divide  
    238     inline Quat& operator/=(const Quat& denom) 
    239     { 
    240         (*this) = (*this) * denom.inverse(); 
    241         return (*this);            // enable nesting 
    242     } 
    243  
    244     /// Binary addition  
     231        /// Binary divide  
     232        inline const Quat operator/(const Quat& denom) const 
     233        { 
     234            return ( (*this) * denom.inverse() ); 
     235        } 
     236 
     237        /// Unary divide  
     238        inline Quat& operator/=(const Quat& denom) 
     239        { 
     240            (*this) = (*this) * denom.inverse(); 
     241            return (*this);            // enable nesting 
     242        } 
     243 
     244        /// Binary addition  
    245245        inline const Quat operator + (const Quat& rhs) const 
    246246        { 
     
    249249        } 
    250250 
    251     /// Unary addition 
     251        /// Unary addition 
    252252        inline Quat& operator += (const Quat& rhs) 
    253253        { 
     
    309309      /* --------------------------------------------------------  
    310310               METHODS RELATED TO ROTATIONS 
    311     Set a quaternion which will perform a rotation of an 
    312     angle around the axis given by the vector (x,y,z). 
    313     Should be written to also accept an angle and a Vec3? 
    314  
    315     Define Spherical Linear interpolation method also 
    316  
    317     Not inlined - see the Quat.cpp file for implementation 
    318     -------------------------------------------------------- */ 
     311        Set a quaternion which will perform a rotation of an 
     312        angle around the axis given by the vector (x,y,z). 
     313        Should be written to also accept an angle and a Vec3? 
     314 
     315        Define Spherical Linear interpolation method also 
     316 
     317        Not inlined - see the Quat.cpp file for implementation 
     318        -------------------------------------------------------- */ 
    319319        void makeRotate( value_type  angle,  
    320320                          value_type  x, value_type  y, value_type  z );