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/Matrixf

    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 float value_type; 
    3131        typedef double other_value_type; 
     
    6666            return *this; 
    6767        } 
    68          
     68 
    6969        Matrixf& operator = (const Matrixd& 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 
    126          
    127         /** decompose the matrix into translation, rotation, scale and scale orientation.*/         
     126 
     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 Matrixf& rhs); 
    244244 
    245         /** ortho-normalize the 3x3 rotation & scale matrix */  
    246         void orthoNormalize(const Matrixf& rhs);  
     245        /** ortho-normalize the 3x3 rotation & scale matrix */ 
     246        void orthoNormalize(const Matrixf& rhs); 
    247247 
    248248        //basic utility functions to create new matrices 
     
    259259        inline static Matrixf rotate( value_type angle, const Vec3f& axis); 
    260260        inline static Matrixf rotate( value_type angle, const Vec3d& axis); 
    261         inline static Matrixf rotate( value_type angle1, const Vec3f& axis1,  
     261        inline static Matrixf rotate( value_type angle1, const Vec3f& axis1, 
    262262                                      value_type angle2, const Vec3f& axis2, 
    263263                                      value_type angle3, const Vec3f& axis3); 
    264         inline static Matrixf rotate( value_type angle1, const Vec3d& axis1,  
     264        inline static Matrixf rotate( value_type angle1, const Vec3d& axis1, 
    265265                                      value_type angle2, const Vec3d& axis2, 
    266266                                      value_type angle3, const Vec3d& axis3); 
    267267        inline static Matrixf rotate( const Quat& quat); 
    268268        inline static Matrixf inverse( const Matrixf& matrix); 
    269         inline static Matrixf orthoNormal(const Matrixf& matrix);  
    270          
     269        inline static Matrixf orthoNormal(const Matrixf& matrix); 
     270 
    271271        /** Create an orthographic projection matrix. 
    272272          * See glOrtho for further details. 
     
    339339        void setTrans( const Vec3f& v ); 
    340340        void setTrans( const Vec3d& v ); 
    341          
    342         inline Vec3d getTrans() const { return Vec3d(_mat[3][0],_mat[3][1],_mat[3][2]); }  
    343          
     341 
     342        inline Vec3d getTrans() const { return Vec3d(_mat[3][0],_mat[3][1],_mat[3][2]); } 
     343 
    344344        inline Vec3d getScale() const { 
    345           Vec3d x_vec(_mat[0][0],_mat[1][0],_mat[2][0]);  
    346           Vec3d y_vec(_mat[0][1],_mat[1][1],_mat[2][1]);  
    347           Vec3d z_vec(_mat[0][2],_mat[1][2],_mat[2][2]);  
    348           return Vec3d(x_vec.length(), y_vec.length(), z_vec.length());  
    349         } 
    350          
     345          Vec3d x_vec(_mat[0][0],_mat[1][0],_mat[2][0]); 
     346          Vec3d y_vec(_mat[0][1],_mat[1][1],_mat[2][1]); 
     347          Vec3d z_vec(_mat[0][2],_mat[1][2],_mat[2][2]); 
     348          return Vec3d(x_vec.length(), y_vec.length(), z_vec.length()); 
     349        } 
     350 
    351351        /** apply a 3x3 transform of v*M[0..2,0..2]. */ 
    352352        inline static Vec3f transform3x3(const Vec3f& v,const Matrixf& m); 
     
    385385        inline void postMultRotate( const Quat& q ); 
    386386 
    387         inline void operator *= ( const Matrixf& other )  
     387        inline void operator *= ( const Matrixf& other ) 
    388388        {    if( this == &other ) { 
    389389                Matrixf temp(other); 
    390390                postMult( temp ); 
    391391            } 
    392             else postMult( other );  
     392            else postMult( other ); 
    393393        } 
    394394 
     
    430430            _mat[3][3]*=rhs; 
    431431            return *this; 
    432         }   
     432        } 
    433433 
    434434        /** Divide by scalar. */ 
     
    462462            _mat[3][3]/=rhs; 
    463463            return *this; 
    464         }           
     464        } 
    465465 
    466466        /** Binary vector add. */ 
     
    483483                _mat[3][1] + rhs._mat[3][1], 
    484484                _mat[3][2] + rhs._mat[3][2], 
    485                 _mat[3][3] + rhs._mat[3][3]);                          
     485                _mat[3][3] + rhs._mat[3][3]); 
    486486        } 
    487487 
     
    508508            _mat[3][3] += rhs._mat[3][3]; 
    509509            return *this; 
    510         }             
     510        } 
    511511 
    512512    protected: 
     
    518518{ 
    519519    public: 
    520      
     520 
    521521        RefMatrixf():Object(false), Matrixf() {} 
    522522        RefMatrixf( const Matrixf& other) : Object(false), Matrixf(other) {} 
     
    528528            Matrixf::value_type a20, Matrixf::value_type a21, Matrixf::value_type a22, Matrixf::value_type a23, 
    529529            Matrixf::value_type a30, Matrixf::value_type a31, Matrixf::value_type a32, Matrixf::value_type a33): 
    530             Object(false),  
     530            Object(false), 
    531531            Matrixf(a00, a01, a02, a03, 
    532532                   a10, a11, a12, a13, 
     
    534534                   a30, a31, a32, a33) {} 
    535535 
    536         virtual Object* cloneType() const { return new RefMatrixf(); }  
     536        virtual Object* cloneType() const { return new RefMatrixf(); } 
    537537        virtual Object* clone(const CopyOp&) const { return new RefMatrixf(*this); } 
    538538        virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const RefMatrixf*>(obj)!=NULL; } 
    539539        virtual const char* libraryName() const { return "osg"; } 
    540540        virtual const char* className() const { return "Matrix"; } 
    541          
    542          
     541 
     542 
    543543    protected: 
    544      
     544 
    545545        virtual ~RefMatrixf() {} 
    546546}; 
     
    611611    return m; 
    612612} 
    613 inline Matrixf Matrixf::rotate( value_type angle1, const Vec3f& axis1,  
     613inline Matrixf Matrixf::rotate( value_type angle1, const Vec3f& axis1, 
    614614                              value_type angle2, const Vec3f& axis2, 
    615615                              value_type angle3, const Vec3f& axis3) 
     
    619619    return m; 
    620620} 
    621 inline Matrixf Matrixf::rotate( value_type angle1, const Vec3d& axis1,  
     621inline Matrixf Matrixf::rotate( value_type angle1, const Vec3d& axis1, 
    622622                              value_type angle2, const Vec3d& axis2, 
    623623                              value_type angle3, const Vec3d& axis3) 
     
    651651  Matrixf m; 
    652652  m.orthoNormalize(matrix); 
    653   return m;  
     653  return m; 
    654654} 
    655655