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

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

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

    r13008 r13041  
    1 /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2004 Robert Osfield  
     1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2004 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*/ 
     
    2727{ 
    2828    public: 
    29      
     29 
    3030        typedef double value_type; 
    3131        typedef float other_value_type; 
     
    6666            return *this; 
    6767        } 
    68          
     68 
    6969        Matrixd& operator = (const Matrixf& other); 
    7070 
     
    7878            for(int i=0;i<16;++i) local_ptr[i]=(value_type)ptr[i]; 
    7979        } 
    80          
     80 
    8181        inline void set(double const * const ptr) 
    8282        { 
     
    8989                 value_type a20, value_type a21, value_type a22,value_type a23, 
    9090                 value_type a30, value_type a31, value_type a32,value_type a33); 
    91                    
     91 
    9292        value_type * ptr() { return (value_type*)_mat; } 
    9393        const value_type * ptr() const { return (const value_type *)_mat; } 
     
    102102 
    103103        void makeIdentity(); 
    104          
     104 
    105105        void makeScale( const Vec3f& ); 
    106106        void makeScale( const Vec3d& ); 
    107107        void makeScale( value_type, value_type, value_type ); 
    108          
     108 
    109109        void makeTranslate( const Vec3f& ); 
    110110        void makeTranslate( const Vec3d& ); 
    111111        void makeTranslate( value_type, value_type, value_type ); 
    112          
     112 
    113113        void makeRotate( const Vec3f& from, const Vec3f& to ); 
    114114        void makeRotate( const Vec3d& from, const Vec3d& to ); 
     
    117117        void makeRotate( value_type angle, value_type x, value_type y, value_type z ); 
    118118        void makeRotate( const Quat& ); 
    119         void makeRotate( value_type angle1, const Vec3f& axis1,  
     119        void makeRotate( value_type angle1, const Vec3f& axis1, 
    120120                         value_type angle2, const Vec3f& axis2, 
    121121                         value_type angle3, const Vec3f& axis3); 
    122         void makeRotate( value_type angle1, const Vec3d& axis1,  
     122        void makeRotate( value_type angle1, const Vec3d& axis1, 
    123123                         value_type angle2, const Vec3d& axis2, 
    124124                         value_type angle3, const Vec3d& axis3); 
    125125 
    126126 
    127         /** decompose the matrix into translation, rotation, scale and scale orientation.*/         
     127        /** decompose the matrix into translation, rotation, scale and scale orientation.*/ 
    128128        void decompose( osg::Vec3f& translation, 
    129                         osg::Quat& rotation,  
    130                         osg::Vec3f& scale,  
     129                        osg::Quat& rotation, 
     130                        osg::Vec3f& scale, 
    131131                        osg::Quat& so ) const; 
    132132 
    133         /** decompose the matrix into translation, rotation, scale and scale orientation.*/         
     133        /** decompose the matrix into translation, rotation, scale and scale orientation.*/ 
    134134        void decompose( osg::Vec3d& translation, 
    135                         osg::Quat& rotation,  
    136                         osg::Vec3d& scale,  
     135                        osg::Quat& rotation, 
     136                        osg::Vec3d& scale, 
    137137                        osg::Quat& so ) const; 
    138138 
     
    243243        bool invert_4x4( const Matrixd& rhs); 
    244244 
    245         /** ortho-normalize the 3x3 rotation & scale matrix */  
    246         void orthoNormalize(const Matrixd& rhs);  
     245        /** ortho-normalize the 3x3 rotation & scale matrix */ 
     246        void orthoNormalize(const Matrixd& rhs); 
    247247 
    248248        // basic utility functions to create new matrices 
     
    259259        inline static Matrixd rotate( value_type angle, const Vec3f& axis); 
    260260        inline static Matrixd rotate( value_type angle, const Vec3d& axis); 
    261         inline static Matrixd rotate( value_type angle1, const Vec3f& axis1,  
     261        inline static Matrixd rotate( value_type angle1, const Vec3f& axis1, 
    262262                                      value_type angle2, const Vec3f& axis2, 
    263263                                      value_type angle3, const Vec3f& axis3); 
    264         inline static Matrixd rotate( value_type angle1, const Vec3d& axis1,  
     264        inline static Matrixd rotate( value_type angle1, const Vec3d& axis1, 
    265265                                      value_type angle2, const Vec3d& axis2, 
    266266                                      value_type angle3, const Vec3d& axis3); 
    267267        inline static Matrixd rotate( const Quat& quat); 
    268268        inline static Matrixd inverse( const Matrixd& matrix); 
    269         inline static Matrixd orthoNormal(const Matrixd& matrix);  
     269        inline static Matrixd orthoNormal(const Matrixd& matrix); 
    270270        /** Create an orthographic projection matrix. 
    271271          * See glOrtho for further details. 
     
    337337        void setTrans( const Vec3f& v ); 
    338338        void setTrans( const Vec3d& v ); 
    339          
    340         inline Vec3d getTrans() const { return Vec3d(_mat[3][0],_mat[3][1],_mat[3][2]); }  
    341          
     339 
     340        inline Vec3d getTrans() const { return Vec3d(_mat[3][0],_mat[3][1],_mat[3][2]); } 
     341 
    342342        inline Vec3d getScale() const { 
    343           Vec3d x_vec(_mat[0][0],_mat[1][0],_mat[2][0]);  
    344           Vec3d y_vec(_mat[0][1],_mat[1][1],_mat[2][1]);  
    345           Vec3d z_vec(_mat[0][2],_mat[1][2],_mat[2][2]);  
    346           return Vec3d(x_vec.length(), y_vec.length(), z_vec.length());  
     343          Vec3d x_vec(_mat[0][0],_mat[1][0],_mat[2][0]); 
     344          Vec3d y_vec(_mat[0][1],_mat[1][1],_mat[2][1]); 
     345          Vec3d z_vec(_mat[0][2],_mat[1][2],_mat[2][2]); 
     346          return Vec3d(x_vec.length(), y_vec.length(), z_vec.length()); 
    347347        } 
    348          
     348 
    349349        /** apply a 3x3 transform of v*M[0..2,0..2]. */ 
    350350        inline static Vec3f transform3x3(const Vec3f& v,const Matrixd& m); 
     
    383383        inline void postMultRotate( const Quat& q ); 
    384384 
    385         inline void operator *= ( const Matrixd& other )  
     385        inline void operator *= ( const Matrixd& other ) 
    386386        {    if( this == &other ) { 
    387387                Matrixd temp(other); 
    388388                postMult( temp ); 
    389389            } 
    390             else postMult( other );  
     390            else postMult( other ); 
    391391        } 
    392392 
     
    406406{ 
    407407    public: 
    408      
     408 
    409409        RefMatrixd():Object(false), Matrixd() {} 
    410410        RefMatrixd( const Matrixd& other) : Object(false), Matrixd(other) {} 
     
    416416            Matrixd::value_type a20, Matrixd::value_type a21, Matrixd::value_type a22, Matrixd::value_type a23, 
    417417            Matrixd::value_type a30, Matrixd::value_type a31, Matrixd::value_type a32, Matrixd::value_type a33): 
    418             Object(false),  
     418            Object(false), 
    419419            Matrixd(a00, a01, a02, a03, 
    420420                    a10, a11, a12, a13, 
     
    422422                    a30, a31, a32, a33) {} 
    423423 
    424         virtual Object* cloneType() const { return new RefMatrixd(); }  
     424        virtual Object* cloneType() const { return new RefMatrixd(); } 
    425425        virtual Object* clone(const CopyOp&) const { return new RefMatrixd(*this); } 
    426426        virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const RefMatrixd*>(obj)!=NULL; } 
    427427        virtual const char* libraryName() const { return "osg"; } 
    428428        virtual const char* className() const { return "Matrix"; } 
    429          
    430          
     429 
     430 
    431431    protected: 
    432      
     432 
    433433        virtual ~RefMatrixd() {} 
    434434}; 
     
    499499    return m; 
    500500} 
    501 inline Matrixd Matrixd::rotate( value_type angle1, const Vec3f& axis1,  
     501inline Matrixd Matrixd::rotate( value_type angle1, const Vec3f& axis1, 
    502502                                value_type angle2, const Vec3f& axis2, 
    503503                                value_type angle3, const Vec3f& axis3) 
     
    507507    return m; 
    508508} 
    509 inline Matrixd Matrixd::rotate( value_type angle1, const Vec3d& axis1,  
     509inline Matrixd Matrixd::rotate( value_type angle1, const Vec3d& axis1, 
    510510                                value_type angle2, const Vec3d& axis2, 
    511511                                value_type angle3, const Vec3d& axis3) 
     
    539539  Matrixd m; 
    540540  m.orthoNormalize(matrix); 
    541   return m;  
     541  return m; 
    542542} 
    543543