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/src/osg/Matrix_implementation.cpp

    r13008 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*/ 
     
    8888            rlength2 = 2.0; 
    8989        } 
    90          
     90 
    9191        // Source: Gamasutra, Rotating Objects Using Quaternions 
    9292        // 
    9393        //http://www.gamasutra.com/features/19980703/quaternions_01.htm 
    94          
     94 
    9595        double wx, wy, wz, xx, yy, yz, xy, xz, zz, x2, y2, z2; 
    96          
     96 
    9797        // calculate coefficients 
    9898        x2 = rlength2*QX; 
    9999        y2 = rlength2*QY; 
    100100        z2 = rlength2*QZ; 
    101          
     101 
    102102        xx = QX * x2; 
    103103        xy = QX * y2; 
    104104        xz = QX * z2; 
    105          
     105 
    106106        yy = QY * y2; 
    107107        yz = QY * z2; 
    108108        zz = QZ * z2; 
    109          
     109 
    110110        wx = QW * x2; 
    111111        wy = QW * y2; 
    112112        wz = QW * z2; 
    113          
     113 
    114114        // Note.  Gamasutra gets the matrix assignments inverted, resulting 
    115         // in left-handed rotations, which is contrary to OpenGL and OSG's  
     115        // in left-handed rotations, which is contrary to OpenGL and OSG's 
    116116        // methodology.  The matrix assignment has been altered in the next 
    117117        // few lines of code to do the right thing. 
     
    120120        _mat[1][0] = xy - wz; 
    121121        _mat[2][0] = xz + wy; 
    122          
    123          
     122 
     123 
    124124        _mat[0][1] = xy + wz; 
    125125        _mat[1][1] = 1.0 - (xx + zz); 
    126126        _mat[2][1] = yz - wx; 
    127          
     127 
    128128        _mat[0][2] = xz - wy; 
    129129        _mat[1][2] = yz + wx; 
     
    172172        /* perform instant calculation */ 
    173173        QW = tq[0]; 
    174         QX = _mat[1][2]-_mat[2][1];  
    175         QY = _mat[2][0]-_mat[0][2];  
    176         QZ = _mat[0][1]-_mat[1][0];  
     174        QX = _mat[1][2]-_mat[2][1]; 
     175        QY = _mat[2][0]-_mat[0][2]; 
     176        QZ = _mat[0][1]-_mat[1][0]; 
    177177    } 
    178178    else if (j==1) 
    179179    { 
    180         QW = _mat[1][2]-_mat[2][1];  
     180        QW = _mat[1][2]-_mat[2][1]; 
    181181        QX = tq[1]; 
    182         QY = _mat[0][1]+_mat[1][0];  
    183         QZ = _mat[2][0]+_mat[0][2];  
     182        QY = _mat[0][1]+_mat[1][0]; 
     183        QZ = _mat[2][0]+_mat[0][2]; 
    184184    } 
    185185    else if (j==2) 
    186186    { 
    187         QW = _mat[2][0]-_mat[0][2];  
    188         QX = _mat[0][1]+_mat[1][0];  
     187        QW = _mat[2][0]-_mat[0][2]; 
     188        QX = _mat[0][1]+_mat[1][0]; 
    189189        QY = tq[2]; 
    190         QZ = _mat[1][2]+_mat[2][1];  
     190        QZ = _mat[1][2]+_mat[2][1]; 
    191191    } 
    192192    else /* if (j==3) */ 
    193193    { 
    194         QW = _mat[0][1]-_mat[1][0];  
    195         QX = _mat[2][0]+_mat[0][2];  
    196         QY = _mat[1][2]+_mat[2][1];  
     194        QW = _mat[0][1]-_mat[1][0]; 
     195        QX = _mat[2][0]+_mat[0][2]; 
     196        QY = _mat[1][2]+_mat[2][1]; 
    197197        QZ = tq[3]; 
    198198    } 
     
    409409} 
    410410 
    411 void Matrix_implementation::makeRotate( value_type angle, value_type x, value_type y, value_type z )  
     411void Matrix_implementation::makeRotate( value_type angle, value_type x, value_type y, value_type z ) 
    412412{ 
    413413    makeIdentity(); 
     
    425425} 
    426426 
    427 void Matrix_implementation::makeRotate( value_type angle1, const Vec3f& axis1,  
     427void Matrix_implementation::makeRotate( value_type angle1, const Vec3f& axis1, 
    428428                         value_type angle2, const Vec3f& axis2, 
    429429                         value_type angle3, const Vec3f& axis3) 
     
    432432 
    433433    Quat quat; 
    434     quat.makeRotate(angle1, axis1,  
     434    quat.makeRotate(angle1, axis1, 
    435435                    angle2, axis2, 
    436436                    angle3, axis3); 
     
    438438} 
    439439 
    440 void Matrix_implementation::makeRotate( value_type angle1, const Vec3d& axis1,  
     440void Matrix_implementation::makeRotate( value_type angle1, const Vec3d& axis1, 
    441441                         value_type angle2, const Vec3d& axis2, 
    442442                         value_type angle3, const Vec3d& axis3) 
     
    445445 
    446446    Quat quat; 
    447     quat.makeRotate(angle1, axis1,  
     447    quat.makeRotate(angle1, axis1, 
    448448                    angle2, axis2, 
    449449                    angle3, axis3); 
     
    452452 
    453453void Matrix_implementation::mult( const Matrix_implementation& lhs, const Matrix_implementation& rhs ) 
    454 {    
     454{ 
    455455    if (&lhs==this) 
    456456    { 
     
    531531    value_type y_colMag = (rhs._mat[0][1] * rhs._mat[0][1]) + (rhs._mat[1][1] * rhs._mat[1][1]) + (rhs._mat[2][1] * rhs._mat[2][1]); 
    532532    value_type z_colMag = (rhs._mat[0][2] * rhs._mat[0][2]) + (rhs._mat[1][2] * rhs._mat[1][2]) + (rhs._mat[2][2] * rhs._mat[2][2]); 
    533      
     533 
    534534    if(!equivalent((double)x_colMag, 1.0) && !equivalent((double)x_colMag, 0.0)) 
    535535    { 
     
    658658    if( osg::square(d-1.0) > 1.0e-6 )  // Involves perspective, so we must 
    659659    {                       // compute the full inverse 
    660      
     660 
    661661        Matrix_implementation TPinv; 
    662662        _mat[3][0] = _mat[3][1] = _mat[3][2] = 0.0; 
     
    832832    zNear = (_mat[3][2]+1.0) / _mat[2][2]; 
    833833    zFar = (_mat[3][2]-1.0) / _mat[2][2]; 
    834      
     834 
    835835    left = -(1.0+_mat[3][0]) / _mat[0][0]; 
    836836    right = (1.0-_mat[3][0]) / _mat[0][0]; 
     
    838838    bottom = -(1.0+_mat[3][1]) / _mat[1][1]; 
    839839    top = (1.0-_mat[3][1]) / _mat[1][1]; 
    840      
     840 
    841841    return true; 
    842 }             
     842} 
    843843 
    844844bool Matrix_implementation::getOrtho(Matrix_implementation::other_value_type& left, Matrix_implementation::other_value_type& right, 
     
    895895    top = temp_near * (1.0+_mat[2][1]) / _mat[1][1]; 
    896896    bottom = temp_near * (_mat[2][1]-1.0) / _mat[1][1]; 
    897      
     897 
    898898    zNear = temp_near; 
    899899    zFar = temp_far; 
    900900 
    901901    return true; 
    902 }                  
     902} 
    903903 
    904904bool Matrix_implementation::getFrustum(Matrix_implementation::other_value_type& left, Matrix_implementation::other_value_type& right,