Show
Ignore:
Timestamp:
03/21/12 18:36:20 (2 years ago)
Author:
robert
Message:

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

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

    r5328 r13041  
    1 /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield  
     1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
    22 * 
    3  * This library is open source and may be redistributed and/or modified under   
    4  * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or  
     3 * This library is open source and may be redistributed and/or modified under 
     4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
    55 * (at your option) any later version.  The full license is in LICENSE file 
    66 * included with this distribution, and on the openscenegraph.org website. 
    7  *  
     7 * 
    88 * This library is distributed in the hope that it will be useful, 
    99 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
     10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1111 * OpenSceneGraph Public License for more details. 
    1212*/ 
     
    7171        } 
    7272 
    73         inline Quat( value_type angle1, const Vec3f& axis1,  
     73        inline Quat( value_type angle1, const Vec3f& axis1, 
    7474                     value_type angle2, const Vec3f& axis2, 
    7575                     value_type angle3, const Vec3f& axis3) 
     
    7878        } 
    7979 
    80         inline Quat( value_type angle1, const Vec3d& axis1,  
     80        inline Quat( value_type angle1, const Vec3d& axis1, 
    8181                     value_type angle2, const Vec3d& axis2, 
    8282                     value_type angle3, const Vec3d& axis3) 
     
    123123            _v[3]=w; 
    124124        } 
    125          
     125 
    126126        inline void set(const osg::Vec4f& v) 
    127127        { 
     
    139139            _v[3]=v.w(); 
    140140        } 
    141          
     141 
    142142        void set(const Matrixf& matrix); 
    143          
     143 
    144144        void set(const Matrixd& matrix); 
    145          
     145 
    146146        void get(Matrixf& matrix) const; 
    147147 
    148148        void get(Matrixd& matrix) const; 
    149          
     149 
    150150 
    151151        inline value_type & operator [] (int i) { return _v[i]; } 
     
    163163 
    164164        /** return true if the Quat represents a zero rotation, and therefore can be ignored in computations.*/ 
    165         bool zeroRotation() const { return _v[0]==0.0 && _v[1]==0.0 && _v[2]==0.0 && _v[3]==1.0; }  
    166  
    167  
    168          /* -------------------------------------------------------------  
    169                    BASIC ARITHMETIC METHODS             
     165        bool zeroRotation() const { return _v[0]==0.0 && _v[1]==0.0 && _v[2]==0.0 && _v[3]==1.0; } 
     166 
     167 
     168         /* ------------------------------------------------------------- 
     169                   BASIC ARITHMETIC METHODS 
    170170        Implemented in terms of Vec4s.  Some Vec4 operators, e.g. 
    171171        operator* are not appropriate for quaternions (as 
    172172        mathematical objects) so they are implemented differently. 
    173         Also define methods for conjugate and the multiplicative inverse.             
     173        Also define methods for conjugate and the multiplicative inverse. 
    174174        ------------------------------------------------------------- */ 
    175         /// Multiply by scalar  
     175        /// Multiply by scalar 
    176176        inline const Quat operator * (value_type rhs) const 
    177177        { 
     
    179179        } 
    180180 
    181         /// Unary multiply by scalar  
     181        /// Unary multiply by scalar 
    182182        inline Quat& operator *= (value_type rhs) 
    183183        { 
     
    189189        } 
    190190 
    191         /// Binary multiply  
     191        /// Binary multiply 
    192192        inline const Quat operator*(const Quat& rhs) const 
    193193        { 
     
    198198        } 
    199199 
    200         /// Unary multiply  
     200        /// Unary multiply 
    201201        inline Quat& operator*=(const Quat& rhs) 
    202202        { 
     
    213213        } 
    214214 
    215         /// Divide by scalar  
     215        /// Divide by scalar 
    216216        inline Quat operator / (value_type rhs) const 
    217217        { 
     
    220220        } 
    221221 
    222         /// Unary divide by scalar  
     222        /// Unary divide by scalar 
    223223        inline Quat& operator /= (value_type rhs) 
    224224        { 
     
    231231        } 
    232232 
    233         /// Binary divide  
     233        /// Binary divide 
    234234        inline const Quat operator/(const Quat& denom) const 
    235235        { 
     
    237237        } 
    238238 
    239         /// Unary divide  
     239        /// Unary divide 
    240240        inline Quat& operator/=(const Quat& denom) 
    241241        { 
     
    244244        } 
    245245 
    246         /// Binary addition  
     246        /// Binary addition 
    247247        inline const Quat operator + (const Quat& rhs) const 
    248248        { 
     
    261261        } 
    262262 
    263         /// Binary subtraction  
     263        /// Binary subtraction 
    264264        inline const Quat operator - (const Quat& rhs) const 
    265265        { 
     
    268268        } 
    269269 
    270         /// Unary subtraction  
     270        /// Unary subtraction 
    271271        inline Quat& operator -= (const Quat& rhs) 
    272272        { 
     
    297297        } 
    298298 
    299         /// Conjugate  
     299        /// Conjugate 
    300300        inline Quat conj () const 
    301         {  
     301        { 
    302302             return Quat( -_v[0], -_v[1], -_v[2], _v[3] ); 
    303303        } 
     
    309309         } 
    310310 
    311       /* --------------------------------------------------------  
     311      /* -------------------------------------------------------- 
    312312               METHODS RELATED TO ROTATIONS 
    313313        Set a quaternion which will perform a rotation of an 
     
    319319        Not inlined - see the Quat.cpp file for implementation 
    320320        -------------------------------------------------------- */ 
    321         void makeRotate( value_type  angle,  
     321        void makeRotate( value_type  angle, 
    322322                          value_type  x, value_type  y, value_type  z ); 
    323323        void makeRotate ( value_type  angle, const Vec3f& vec ); 
    324324        void makeRotate ( value_type  angle, const Vec3d& vec ); 
    325325 
    326         void makeRotate ( value_type  angle1, const Vec3f& axis1,  
     326        void makeRotate ( value_type  angle1, const Vec3f& axis1, 
    327327                          value_type  angle2, const Vec3f& axis2, 
    328328                          value_type  angle3, const Vec3f& axis3); 
    329         void makeRotate ( value_type  angle1, const Vec3d& axis1,  
     329        void makeRotate ( value_type  angle1, const Vec3d& axis1, 
    330330                          value_type  angle2, const Vec3d& axis2, 
    331331                          value_type  angle3, const Vec3d& axis3); 
     
    343343            are co-incident or opposite in direction.*/ 
    344344        void makeRotate( const Vec3d& vec1, const Vec3d& vec2 ); 
    345      
     345 
    346346        void makeRotate_original( const Vec3d& vec1, const Vec3d& vec2 ); 
    347347 
     
    358358        As t goes from 0 to 1, the Quat object goes from "from" to "to". */ 
    359359        void slerp   ( value_type  t, const Quat& from, const Quat& to); 
    360                 
     360 
    361361        /** Rotate a vector by this quaternion.*/ 
    362362        Vec3f operator* (const Vec3f& v) const 
    363363        { 
    364364            // nVidia SDK implementation 
    365             Vec3f uv, uuv;  
     365            Vec3f uv, uuv; 
    366366            Vec3f qvec(_v[0], _v[1], _v[2]); 
    367367            uv = qvec ^ v; 
    368             uuv = qvec ^ uv;  
    369             uv *= ( 2.0f * _v[3] );  
    370             uuv *= 2.0f;  
     368            uuv = qvec ^ uv; 
     369            uv *= ( 2.0f * _v[3] ); 
     370            uuv *= 2.0f; 
    371371            return v + uv + uuv; 
    372372        } 
    373                 
     373 
    374374        /** Rotate a vector by this quaternion.*/ 
    375375        Vec3d operator* (const Vec3d& v) const 
    376376        { 
    377377            // nVidia SDK implementation 
    378             Vec3d uv, uuv;  
     378            Vec3d uv, uuv; 
    379379            Vec3d qvec(_v[0], _v[1], _v[2]); 
    380380            uv = qvec ^ v; 
    381             uuv = qvec ^ uv;  
    382             uv *= ( 2.0f * _v[3] );  
    383             uuv *= 2.0f;  
     381            uuv = qvec ^ uv; 
     382            uv *= ( 2.0f * _v[3] ); 
     383            uuv *= 2.0f; 
    384384            return v + uv + uuv; 
    385385        } 
    386          
     386 
    387387    protected: 
    388      
     388 
    389389};    // end of class prototype 
    390390 
    391391}    // end of namespace 
    392392 
    393 #endif  
     393#endif