Changeset 8868

Show
Ignore:
Timestamp:
09/17/08 18:14:28 (9 years ago)
Author:
robert
Message:

From Mathias Froehlich, "This is a generic optimization that does not depend on any cpu or instruction
set.

The optimization is based on the observation that matrix matrix multiplication
with a dense matrix 4x4 is 43 Operations whereas multiplication with a
transform, or scale matrix is only 4
2 operations. Which is a gain of a
*FACTOR*4* for these special cases.
The change implements these special cases, provides a unit test for these
implementation and converts uses of the expensiver dense matrix matrix
routine with the specialized versions.

Depending on the transform nodes in the scenegraph this change gives a
noticable improovement.
For example the osgforest code using the MatrixTransform? is about 20% slower
than the same codepath using the PositionAttitudeTransform? instead of the
MatrixTransform? with this patch applied.

If I remember right, the sse type optimizations did *not* provide a factor 4
improovement. Also these changes are totally independent of any cpu or
instruction set architecture. So I would prefer to have this current kind of
change instead of some hand coded and cpu dependent assembly stuff. If we
need that hand tuned stuff, these can go on top of this changes which must
provide than hand optimized additional variants for the specialized versions
to give a even better result in the end.

An other change included here is a change to rotation matrix from quaterion
code. There is a sqrt call which couold be optimized away. Since we divide in
effect by sqrt(length)*sqrt(length) which is just length ...
"

Location:
OpenSceneGraph/trunk
Files:
21 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/examples/osgdepthpeeling/osgdepthpeeling.cpp

    r7648 r8868  
    175175  void rotate(float x, float y) 
    176176  { 
    177     osg::Matrixd baseMatrix = _modelGroupTransform->getMatrix(); 
    178      
    179     osg::Matrixd preTransMatrix; 
    180     osg::Matrixd postTransMatrix; 
    181     osg::Matrixd rotMatrixX; 
    182     osg::Matrixd rotMatrixZ; 
    183      
    184     preTransMatrix.makeTranslate(_rotCenter); 
    185     postTransMatrix.makeTranslate(-_rotCenter); 
    186  
    187     rotMatrixZ.makeRotate((x - _prevX) * 3., osg::Vec3d(0.0, 0.0,1.0)); 
    188      
    189     baseMatrix.preMult(preTransMatrix); 
    190     baseMatrix.preMult(rotMatrixZ); 
    191     baseMatrix.preMult(postTransMatrix); 
    192  
    193     rotMatrixX.makeRotate(-(y - _prevY) * 3., (baseMatrix * osg::Vec3d(1.0, 0.0,0.0))); 
    194      
    195     baseMatrix.preMult(preTransMatrix); 
    196     baseMatrix.preMult(rotMatrixX); 
    197     baseMatrix.preMult(postTransMatrix); 
     177    osg::Matrix baseMatrix = _modelGroupTransform->getMatrix(); 
     178     
     179    baseMatrix.preMultTranslate(_rotCenter); 
     180    baseMatrix.preMultRotate(osg::Quat((x - _prevX) * 3, osg::Vec3d(0.0, 0.0, 1.0))); 
     181    baseMatrix.preMultRotate(osg::Quat(-(y - _prevY) * 3, (baseMatrix * osg::Vec3d(1.0, 0.0, 0.0)))); 
     182    baseMatrix.preMultTranslate(-_rotCenter); 
    198183     
    199184    _modelGroupTransform->setMatrix(baseMatrix); 
  • OpenSceneGraph/trunk/examples/osghangglide/osghangglide.cpp

    r6941 r8868  
    5555        { 
    5656            osg::Vec3 eyePointLocal = cv->getEyeLocal(); 
    57             matrix.preMult(osg::Matrix::translate(eyePointLocal.x(),eyePointLocal.y(),0.0f)); 
     57            matrix.preMultTranslate(osg::Vec3(eyePointLocal.x(),eyePointLocal.y(),0.0f)); 
    5858        } 
    5959        return true; 
     
    6969        { 
    7070            osg::Vec3 eyePointLocal = cv->getEyeLocal(); 
    71             matrix.postMult(osg::Matrix::translate(-eyePointLocal.x(),-eyePointLocal.y(),0.0f)); 
     71            matrix.postMultTranslate(osg::Vec3(-eyePointLocal.x(),-eyePointLocal.y(),0.0f)); 
    7272        } 
    7373        return true; 
  • OpenSceneGraph/trunk/examples/osglogo/osglogo.cpp

    r7848 r8868  
    6868            } 
    6969 
    70  
    71             matrix.preMult(osg::Matrix::translate(-_pivotPoint)* 
    72                            osg::Matrix::rotate(_attitude)* 
    73                            osg::Matrix::rotate(billboardRotation)* 
    74                            osg::Matrix::translate(_position)); 
     70            matrix.preMultTranslate(_position); 
     71            matrix.preMultRotate(billboardRotation); 
     72            matrix.preMultRotate(_attitude); 
     73            matrix.preMultTranslate(_pivotPoint); 
    7574            return true; 
    7675        } 
  • OpenSceneGraph/trunk/examples/osgsimulation/osgsimulation.cpp

    r8087 r8868  
    147147                    //osg::Matrixd matrix; 
    148148                    ellipsoid->computeLocalToWorldTransformFromLatLongHeight(_latitude,_longitude,_height,matrix); 
    149                     matrix.preMult(osg::Matrix::rotate(_rotation)); 
     149                    matrix.preMultRotate(_rotation); 
    150150                     
    151151                    mt->setMatrix(matrix); 
  • OpenSceneGraph/trunk/examples/osgunittests/UnitTests_osg.cpp

    r6941 r8868  
    2020 
    2121#include <osg/Matrixd> 
     22#include <osg/Matrixf> 
     23#include <osg/Vec3d> 
    2224#include <osg/Vec3> 
    2325#include <sstream> 
     
    8587OSGUTX_AUTOREGISTER_TESTSUITE_AT(Vec3, root.osg) 
    8688 
    87 } 
     89/////////////////////////////////////////////////////////////////////////////// 
     90//  
     91//  Matrix Tests 
     92// 
     93class MatrixTestFixture 
     94{ 
     95public: 
     96 
     97    MatrixTestFixture(); 
     98 
     99    void testPreMultTranslate(const osgUtx::TestContext& ctx); 
     100    void testPostMultTranslate(const osgUtx::TestContext& ctx); 
     101    void testPreMultScale(const osgUtx::TestContext& ctx); 
     102    void testPostMultScale(const osgUtx::TestContext& ctx); 
     103    void testPreMultRotate(const osgUtx::TestContext& ctx); 
     104    void testPostMultRotate(const osgUtx::TestContext& ctx); 
     105 
     106private: 
     107 
     108    // Some convenience variables for use in the tests 
     109    Matrixd _md; 
     110    Matrixf _mf; 
     111    Vec3d _v3d; 
     112    Vec3 _v3; 
     113    Quat _q1; 
     114    Quat _q2; 
     115    Quat _q3; 
     116    Quat _q4; 
     117 
     118}; 
     119 
     120MatrixTestFixture::MatrixTestFixture(): 
     121    _md(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), 
     122    _mf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), 
     123    _v3d(1, 2, 3), 
     124    _v3(1, 2, 3), 
     125    _q1(1, 0, 0, 0), 
     126    _q2(0, 1, 0, 0), 
     127    _q3(0, 0, 1, 0), 
     128    _q4(0, 0, 0, 1) 
     129{ 
     130} 
     131 
     132void MatrixTestFixture::testPreMultTranslate(const osgUtx::TestContext&) 
     133{ 
     134    osg::Matrixd tdo; 
     135    osg::Matrixd tdn; 
     136    osg::Matrixf tfo; 
     137    osg::Matrixf tfn; 
     138 
     139    tdo = _md; 
     140    tdn = _md; 
     141    tdo.preMult(osg::Matrixd::translate(_v3d)); 
     142    tdn.preMultTranslate(_v3d); 
     143    OSGUTX_TEST_F( tdo == tdn ) 
     144 
     145    tdo = _md; 
     146    tdn = _md; 
     147    tdo.preMult(osg::Matrixd::translate(_v3)); 
     148    tdn.preMultTranslate(_v3); 
     149    OSGUTX_TEST_F( tdo == tdn ) 
     150 
     151    tfo = _mf; 
     152    tfn = _mf; 
     153    tfo.preMult(osg::Matrixf::translate(_v3d)); 
     154    tfn.preMultTranslate(_v3d); 
     155    OSGUTX_TEST_F( tfo == tfn ) 
     156 
     157    tfo = _mf; 
     158    tfn = _mf; 
     159    tfo.preMult(osg::Matrixf::translate(_v3)); 
     160    tfn.preMultTranslate(_v3); 
     161    OSGUTX_TEST_F( tfo == tfn ) 
     162} 
     163 
     164void MatrixTestFixture::testPostMultTranslate(const osgUtx::TestContext&) 
     165{ 
     166    osg::Matrixd tdo; 
     167    osg::Matrixd tdn; 
     168    osg::Matrixf tfo; 
     169    osg::Matrixf tfn; 
     170 
     171    tdo = _md; 
     172    tdn = _md; 
     173    tdo.postMult(osg::Matrixd::translate(_v3d)); 
     174    tdn.postMultTranslate(_v3d); 
     175    OSGUTX_TEST_F( tdo == tdn ) 
     176 
     177    tdo = _md; 
     178    tdn = _md; 
     179    tdo.postMult(osg::Matrixd::translate(_v3)); 
     180    tdn.postMultTranslate(_v3); 
     181    OSGUTX_TEST_F( tdo == tdn ) 
     182 
     183    tfo = _mf; 
     184    tfn = _mf; 
     185    tfo.postMult(osg::Matrixf::translate(_v3d)); 
     186    tfn.postMultTranslate(_v3d); 
     187    OSGUTX_TEST_F( tfo == tfn ) 
     188 
     189    tfo = _mf; 
     190    tfn = _mf; 
     191    tfo.postMult(osg::Matrixf::translate(_v3)); 
     192    tfn.postMultTranslate(_v3); 
     193    OSGUTX_TEST_F( tfo == tfn ) 
     194} 
     195 
     196void MatrixTestFixture::testPreMultScale(const osgUtx::TestContext&) 
     197{ 
     198    osg::Matrixd tdo; 
     199    osg::Matrixd tdn; 
     200    osg::Matrixf tfo; 
     201    osg::Matrixf tfn; 
     202 
     203    tdo = _md; 
     204    tdn = _md; 
     205    tdo.preMult(osg::Matrixd::scale(_v3d)); 
     206    tdn.preMultScale(_v3d); 
     207    OSGUTX_TEST_F( tdo == tdn ) 
     208 
     209    tdo = _md; 
     210    tdn = _md; 
     211    tdo.preMult(osg::Matrixd::scale(_v3)); 
     212    tdn.preMultScale(_v3); 
     213    OSGUTX_TEST_F( tdo == tdn ) 
     214 
     215    tfo = _mf; 
     216    tfn = _mf; 
     217    tfo.preMult(osg::Matrixf::scale(_v3d)); 
     218    tfn.preMultScale(_v3d); 
     219    OSGUTX_TEST_F( tfo == tfn ) 
     220 
     221    tfo = _mf; 
     222    tfn = _mf; 
     223    tfo.preMult(osg::Matrixf::scale(_v3)); 
     224    tfn.preMultScale(_v3); 
     225    OSGUTX_TEST_F( tfo == tfn ) 
     226} 
     227 
     228void MatrixTestFixture::testPostMultScale(const osgUtx::TestContext&) 
     229{ 
     230    osg::Matrixd tdo; 
     231    osg::Matrixd tdn; 
     232    osg::Matrixf tfo; 
     233    osg::Matrixf tfn; 
     234 
     235    tdo = _md; 
     236    tdn = _md; 
     237    tdo.postMult(osg::Matrixd::scale(_v3d)); 
     238    tdn.postMultScale(_v3d); 
     239    OSGUTX_TEST_F( tdo == tdn ) 
     240 
     241    tdo = _md; 
     242    tdn = _md; 
     243    tdo.postMult(osg::Matrixd::scale(_v3)); 
     244    tdn.postMultScale(_v3); 
     245    OSGUTX_TEST_F( tdo == tdn ) 
     246 
     247    tfo = _mf; 
     248    tfn = _mf; 
     249    tfo.postMult(osg::Matrixf::scale(_v3d)); 
     250    tfn.postMultScale(_v3d); 
     251    OSGUTX_TEST_F( tfo == tfn ) 
     252 
     253    tfo = _mf; 
     254    tfn = _mf; 
     255    tfo.postMult(osg::Matrixf::scale(_v3)); 
     256    tfn.postMultScale(_v3); 
     257    OSGUTX_TEST_F( tfo == tfn ) 
     258} 
     259 
     260void MatrixTestFixture::testPreMultRotate(const osgUtx::TestContext&) 
     261{ 
     262    osg::Matrixd tdo; 
     263    osg::Matrixd tdn; 
     264    osg::Matrixf tfo; 
     265    osg::Matrixf tfn; 
     266 
     267    tdo = _md; 
     268    tdn = _md; 
     269    tdo.preMult(osg::Matrixd::rotate(_q1)); 
     270    tdn.preMultRotate(_q1); 
     271    OSGUTX_TEST_F( tdo == tdn ) 
     272 
     273    tdo = _md; 
     274    tdn = _md; 
     275    tdo.preMult(osg::Matrixd::rotate(_q2)); 
     276    tdn.preMultRotate(_q2); 
     277    OSGUTX_TEST_F( tdo == tdn ) 
     278 
     279    tdo = _md; 
     280    tdn = _md; 
     281    tdo.preMult(osg::Matrixd::rotate(_q3)); 
     282    tdn.preMultRotate(_q3); 
     283    OSGUTX_TEST_F( tdo == tdn ) 
     284 
     285    tdo = _md; 
     286    tdn = _md; 
     287    tdo.preMult(osg::Matrixd::rotate(_q4)); 
     288    tdn.preMultRotate(_q4); 
     289    OSGUTX_TEST_F( tdo == tdn ) 
     290 
     291    tfo = _mf; 
     292    tfn = _mf; 
     293    tfo.preMult(osg::Matrixf::rotate(_q1)); 
     294    tfn.preMultRotate(_q1); 
     295    OSGUTX_TEST_F( tfo == tfn ) 
     296 
     297    tfo = _mf; 
     298    tfn = _mf; 
     299    tfo.preMult(osg::Matrixf::rotate(_q2)); 
     300    tfn.preMultRotate(_q2); 
     301    OSGUTX_TEST_F( tfo == tfn ) 
     302 
     303    tfo = _mf; 
     304    tfn = _mf; 
     305    tfo.preMult(osg::Matrixf::rotate(_q3)); 
     306    tfn.preMultRotate(_q3); 
     307    OSGUTX_TEST_F( tfo == tfn ) 
     308 
     309    tfo = _mf; 
     310    tfn = _mf; 
     311    tfo.preMult(osg::Matrixf::rotate(_q4)); 
     312    tfn.preMultRotate(_q4); 
     313    OSGUTX_TEST_F( tfo == tfn ) 
     314} 
     315 
     316void MatrixTestFixture::testPostMultRotate(const osgUtx::TestContext&) 
     317{ 
     318    osg::Matrixd tdo; 
     319    osg::Matrixd tdn; 
     320    osg::Matrixf tfo; 
     321    osg::Matrixf tfn; 
     322 
     323    tdo = _md; 
     324    tdn = _md; 
     325    tdo.postMult(osg::Matrixd::rotate(_q1)); 
     326    tdn.postMultRotate(_q1); 
     327    OSGUTX_TEST_F( tdo == tdn ) 
     328 
     329    tdo = _md; 
     330    tdn = _md; 
     331    tdo.postMult(osg::Matrixd::rotate(_q2)); 
     332    tdn.postMultRotate(_q2); 
     333    OSGUTX_TEST_F( tdo == tdn ) 
     334 
     335    tdo = _md; 
     336    tdn = _md; 
     337    tdo.postMult(osg::Matrixd::rotate(_q3)); 
     338    tdn.postMultRotate(_q3); 
     339    OSGUTX_TEST_F( tdo == tdn ) 
     340 
     341    tdo = _md; 
     342    tdn = _md; 
     343    tdo.postMult(osg::Matrixd::rotate(_q4)); 
     344    tdn.postMultRotate(_q4); 
     345    OSGUTX_TEST_F( tdo == tdn ) 
     346 
     347    tfo = _mf; 
     348    tfn = _mf; 
     349    tfo.postMult(osg::Matrixf::rotate(_q1)); 
     350    tfn.postMultRotate(_q1); 
     351    OSGUTX_TEST_F( tfo == tfn ) 
     352 
     353    tfo = _mf; 
     354    tfn = _mf; 
     355    tfo.postMult(osg::Matrixf::rotate(_q2)); 
     356    tfn.postMultRotate(_q2); 
     357    OSGUTX_TEST_F( tfo == tfn ) 
     358 
     359    tfo = _mf; 
     360    tfn = _mf; 
     361    tfo.postMult(osg::Matrixf::rotate(_q3)); 
     362    tfn.postMultRotate(_q3); 
     363    OSGUTX_TEST_F( tfo == tfn ) 
     364 
     365    tfo = _mf; 
     366    tfn = _mf; 
     367    tfo.postMult(osg::Matrixf::rotate(_q4)); 
     368    tfn.postMultRotate(_q4); 
     369    OSGUTX_TEST_F( tfo == tfn ) 
     370} 
     371 
     372OSGUTX_BEGIN_TESTSUITE(Matrix) 
     373    OSGUTX_ADD_TESTCASE(MatrixTestFixture, testPreMultTranslate) 
     374    OSGUTX_ADD_TESTCASE(MatrixTestFixture, testPostMultTranslate) 
     375    OSGUTX_ADD_TESTCASE(MatrixTestFixture, testPreMultScale) 
     376    OSGUTX_ADD_TESTCASE(MatrixTestFixture, testPostMultScale) 
     377    OSGUTX_ADD_TESTCASE(MatrixTestFixture, testPreMultRotate) 
     378    OSGUTX_ADD_TESTCASE(MatrixTestFixture, testPostMultRotate) 
     379OSGUTX_END_TESTSUITE 
     380 
     381OSGUTX_AUTOREGISTER_TESTSUITE_AT(Matrix, root.osg) 
     382 
     383 
     384} 
  • OpenSceneGraph/trunk/examples/osgvertexprogram/osgvertexprogram.cpp

    r6941 r8868  
    227227        { 
    228228            osg::Vec3 eyePointLocal = cv->getEyeLocal(); 
    229             matrix.preMult(osg::Matrix::translate(eyePointLocal)); 
     229            matrix.preMultTranslate(eyePointLocal); 
    230230        } 
    231231        return true; 
     
    239239        { 
    240240            osg::Vec3 eyePointLocal = cv->getEyeLocal(); 
    241             matrix.postMult(osg::Matrix::translate(-eyePointLocal)); 
     241            matrix.postMultTranslate(-eyePointLocal); 
    242242        } 
    243243        return true; 
  • OpenSceneGraph/trunk/include/osg/AnimationPath

    r8768 r8868  
    9292            inline void getMatrix(Matrixf& matrix) const 
    9393            { 
    94                 matrix.makeScale(_scale); 
    95                 matrix.postMult(osg::Matrixf::rotate(_rotation)); 
    96                 matrix.postMult(osg::Matrixf::translate(_position)); 
     94                matrix.makeRotate(_rotation); 
     95                matrix.preMultScale(_scale); 
     96                matrix.postMultTranslate(_position); 
    9797            } 
    9898 
    9999            inline void getMatrix(Matrixd& matrix) const 
    100100            { 
    101                 matrix.makeScale(_scale); 
    102                 matrix.postMult(osg::Matrixd::rotate(_rotation)); 
    103                 matrix.postMult(osg::Matrixd::translate(_position)); 
     101                matrix.makeRotate(_rotation); 
     102                matrix.preMultScale(_scale); 
     103                matrix.postMultTranslate(_position); 
    104104            } 
    105105 
    106106            inline void getInverse(Matrixf& matrix) const 
    107107            { 
    108                 matrix.makeScale(1.0/_scale.x(),1.0/_scale.y(),1.0/_scale.z()); 
    109                 matrix.preMult(osg::Matrixf::rotate(_rotation.inverse())); 
    110                 matrix.preMult(osg::Matrixf::translate(-_position)); 
     108                matrix.makeRotate(_rotation.inverse()); 
     109                matrix.postMultScale(osg::Vec3d(1.0/_scale.x(),1.0/_scale.y(),1.0/_scale.z())); 
     110                matrix.preMultTranslate(-_position); 
    111111            } 
    112112 
    113113            inline void getInverse(Matrixd& matrix) const 
    114114            { 
    115                 matrix.makeScale(1.0/_scale.x(),1.0/_scale.y(),1.0/_scale.z()); 
    116                 matrix.preMult(osg::Matrixd::rotate(_rotation.inverse())); 
    117                 matrix.preMult(osg::Matrixd::translate(-_position)); 
     115                matrix.makeRotate(_rotation.inverse()); 
     116                matrix.postMultScale(osg::Vec3d(1.0/_scale.x(),1.0/_scale.y(),1.0/_scale.z())); 
     117                matrix.preMultTranslate(-_position); 
    118118            } 
    119119 
  • OpenSceneGraph/trunk/include/osg/Matrixd

    r7890 r8868  
    348348        void postMult( const Matrixd& ); 
    349349 
     350        /** Optimized version of preMult(translate(v)); */ 
     351        inline void preMultTranslate( const Vec3d& v ); 
     352        inline void preMultTranslate( const Vec3f& v ); 
     353        /** Optimized version of postMult(translate(v)); */ 
     354        inline void postMultTranslate( const Vec3d& v ); 
     355        inline void postMultTranslate( const Vec3f& v ); 
     356 
     357        /** Optimized version of preMult(scale(v)); */ 
     358        inline void preMultScale( const Vec3d& v ); 
     359        inline void preMultScale( const Vec3f& v ); 
     360        /** Optimized version of postMult(scale(v)); */ 
     361        inline void postMultScale( const Vec3d& v ); 
     362        inline void postMultScale( const Vec3f& v ); 
     363 
     364        /** Optimized version of preMult(rotate(q)); */ 
     365        inline void preMultRotate( const Quat& q ); 
     366        /** Optimized version of postMult(rotate(q)); */ 
     367        inline void postMultRotate( const Quat& q ); 
     368 
    350369        inline void operator *= ( const Matrixd& other )  
    351370        {    if( this == &other ) { 
     
    648667} 
    649668 
     669inline void Matrixd::preMultTranslate( const Vec3d& v ) 
     670{ 
     671    for (unsigned i = 0; i < 3; ++i) 
     672    { 
     673        double tmp = v[i]; 
     674        if (tmp == 0) 
     675            continue; 
     676        _mat[3][0] += tmp*_mat[i][0]; 
     677        _mat[3][1] += tmp*_mat[i][1]; 
     678        _mat[3][2] += tmp*_mat[i][2]; 
     679        _mat[3][3] += tmp*_mat[i][3]; 
     680    } 
     681} 
     682 
     683inline void Matrixd::preMultTranslate( const Vec3f& v ) 
     684{ 
     685    for (unsigned i = 0; i < 3; ++i) 
     686    { 
     687        float tmp = v[i]; 
     688        if (tmp == 0) 
     689            continue; 
     690        _mat[3][0] += tmp*_mat[i][0]; 
     691        _mat[3][1] += tmp*_mat[i][1]; 
     692        _mat[3][2] += tmp*_mat[i][2]; 
     693        _mat[3][3] += tmp*_mat[i][3]; 
     694    } 
     695} 
     696 
     697inline void Matrixd::postMultTranslate( const Vec3d& v ) 
     698{ 
     699    for (unsigned i = 0; i < 3; ++i) 
     700    { 
     701        double tmp = v[i]; 
     702        if (tmp == 0) 
     703            continue; 
     704        _mat[0][i] += tmp*_mat[0][3]; 
     705        _mat[1][i] += tmp*_mat[1][3]; 
     706        _mat[2][i] += tmp*_mat[2][3]; 
     707        _mat[3][i] += tmp*_mat[3][3]; 
     708    } 
     709} 
     710 
     711inline void Matrixd::postMultTranslate( const Vec3f& v ) 
     712{ 
     713    for (unsigned i = 0; i < 3; ++i) 
     714    { 
     715        float tmp = v[i]; 
     716        if (tmp == 0) 
     717            continue; 
     718        _mat[0][i] += tmp*_mat[0][3]; 
     719        _mat[1][i] += tmp*_mat[1][3]; 
     720        _mat[2][i] += tmp*_mat[2][3]; 
     721        _mat[3][i] += tmp*_mat[3][3]; 
     722    } 
     723} 
     724 
     725inline void Matrixd::preMultScale( const Vec3d& v ) 
     726{ 
     727    _mat[0][0] *= v[0]; _mat[0][1] *= v[0]; _mat[0][2] *= v[0]; _mat[0][3] *= v[0]; 
     728    _mat[1][0] *= v[1]; _mat[1][1] *= v[1]; _mat[1][2] *= v[1]; _mat[1][3] *= v[1]; 
     729    _mat[2][0] *= v[2]; _mat[2][1] *= v[2]; _mat[2][2] *= v[2]; _mat[2][3] *= v[2]; 
     730} 
     731 
     732inline void Matrixd::preMultScale( const Vec3f& v ) 
     733{ 
     734    _mat[0][0] *= v[0]; _mat[0][1] *= v[0]; _mat[0][2] *= v[0]; _mat[0][3] *= v[0]; 
     735    _mat[1][0] *= v[1]; _mat[1][1] *= v[1]; _mat[1][2] *= v[1]; _mat[1][3] *= v[1]; 
     736    _mat[2][0] *= v[2]; _mat[2][1] *= v[2]; _mat[2][2] *= v[2]; _mat[2][3] *= v[2]; 
     737} 
     738 
     739inline void Matrixd::postMultScale( const Vec3d& v ) 
     740{ 
     741    _mat[0][0] *= v[0]; _mat[1][0] *= v[0]; _mat[2][0] *= v[0]; _mat[3][0] *= v[0]; 
     742    _mat[0][1] *= v[1]; _mat[1][1] *= v[1]; _mat[2][1] *= v[1]; _mat[3][1] *= v[1]; 
     743    _mat[0][2] *= v[2]; _mat[1][2] *= v[2]; _mat[2][2] *= v[2]; _mat[3][2] *= v[2]; 
     744} 
     745 
     746inline void Matrixd::postMultScale( const Vec3f& v ) 
     747{ 
     748    _mat[0][0] *= v[0]; _mat[1][0] *= v[0]; _mat[2][0] *= v[0]; _mat[3][0] *= v[0]; 
     749    _mat[0][1] *= v[1]; _mat[1][1] *= v[1]; _mat[2][1] *= v[1]; _mat[3][1] *= v[1]; 
     750    _mat[0][2] *= v[2]; _mat[1][2] *= v[2]; _mat[2][2] *= v[2]; _mat[3][2] *= v[2]; 
     751} 
     752 
     753inline void Matrixd::preMultRotate( const Quat& q ) 
     754{ 
     755    if (q.zeroRotation()) 
     756        return; 
     757    Matrixd r; 
     758    r.setRotate(q); 
     759    preMult(r); 
     760} 
     761 
     762inline void Matrixd::postMultRotate( const Quat& q ) 
     763{ 
     764    if (q.zeroRotation()) 
     765        return; 
     766    Matrixd r; 
     767    r.setRotate(q); 
     768    postMult(r); 
     769} 
     770 
    650771inline Vec3f operator* (const Vec3f& v, const Matrixd& m ) 
    651772{ 
  • OpenSceneGraph/trunk/include/osg/Matrixf

    r7890 r8868  
    350350        void postMult( const Matrixf& ); 
    351351 
     352        /** Optimized version of preMult(translate(v)); */ 
     353        inline void preMultTranslate( const Vec3d& v ); 
     354        inline void preMultTranslate( const Vec3f& v ); 
     355        /** Optimized version of postMult(translate(v)); */ 
     356        inline void postMultTranslate( const Vec3d& v ); 
     357        inline void postMultTranslate( const Vec3f& v ); 
     358 
     359        /** Optimized version of preMult(scale(v)); */ 
     360        inline void preMultScale( const Vec3d& v ); 
     361        inline void preMultScale( const Vec3f& v ); 
     362        /** Optimized version of postMult(scale(v)); */ 
     363        inline void postMultScale( const Vec3d& v ); 
     364        inline void postMultScale( const Vec3f& v ); 
     365 
     366        /** Optimized version of preMult(rotate(q)); */ 
     367        inline void preMultRotate( const Quat& q ); 
     368        /** Optimized version of postMult(rotate(q)); */ 
     369        inline void postMultRotate( const Quat& q ); 
     370 
    352371        inline void operator *= ( const Matrixf& other )  
    353372        {    if( this == &other ) { 
     
    642661} 
    643662 
     663inline void Matrixf::preMultTranslate( const Vec3d& v ) 
     664{ 
     665    for (unsigned i = 0; i < 3; ++i) 
     666    { 
     667        double tmp = v[i]; 
     668        if (tmp == 0) 
     669            continue; 
     670        _mat[3][0] += tmp*_mat[i][0]; 
     671        _mat[3][1] += tmp*_mat[i][1]; 
     672        _mat[3][2] += tmp*_mat[i][2]; 
     673        _mat[3][3] += tmp*_mat[i][3]; 
     674    } 
     675} 
     676 
     677inline void Matrixf::preMultTranslate( const Vec3f& v ) 
     678{ 
     679    for (unsigned i = 0; i < 3; ++i) 
     680    { 
     681        float tmp = v[i]; 
     682        if (tmp == 0) 
     683            continue; 
     684        _mat[3][0] += tmp*_mat[i][0]; 
     685        _mat[3][1] += tmp*_mat[i][1]; 
     686        _mat[3][2] += tmp*_mat[i][2]; 
     687        _mat[3][3] += tmp*_mat[i][3]; 
     688    } 
     689} 
     690 
     691inline void Matrixf::postMultTranslate( const Vec3d& v ) 
     692{ 
     693    for (unsigned i = 0; i < 3; ++i) 
     694    { 
     695        double tmp = v[i]; 
     696        if (tmp == 0) 
     697            continue; 
     698        _mat[0][i] += tmp*_mat[0][3]; 
     699        _mat[1][i] += tmp*_mat[1][3]; 
     700        _mat[2][i] += tmp*_mat[2][3]; 
     701        _mat[3][i] += tmp*_mat[3][3]; 
     702    } 
     703} 
     704 
     705inline void Matrixf::postMultTranslate( const Vec3f& v ) 
     706{ 
     707    for (unsigned i = 0; i < 3; ++i) 
     708    { 
     709        float tmp = v[i]; 
     710        if (tmp == 0) 
     711            continue; 
     712        _mat[0][i] += tmp*_mat[0][3]; 
     713        _mat[1][i] += tmp*_mat[1][3]; 
     714        _mat[2][i] += tmp*_mat[2][3]; 
     715        _mat[3][i] += tmp*_mat[3][3]; 
     716    } 
     717} 
     718 
     719inline void Matrixf::preMultScale( const Vec3d& v ) 
     720{ 
     721    _mat[0][0] *= v[0]; _mat[0][1] *= v[0]; _mat[0][2] *= v[0]; _mat[0][3] *= v[0]; 
     722    _mat[1][0] *= v[1]; _mat[1][1] *= v[1]; _mat[1][2] *= v[1]; _mat[1][3] *= v[1]; 
     723    _mat[2][0] *= v[2]; _mat[2][1] *= v[2]; _mat[2][2] *= v[2]; _mat[2][3] *= v[2]; 
     724} 
     725 
     726inline void Matrixf::preMultScale( const Vec3f& v ) 
     727{ 
     728    _mat[0][0] *= v[0]; _mat[0][1] *= v[0]; _mat[0][2] *= v[0]; _mat[0][3] *= v[0]; 
     729    _mat[1][0] *= v[1]; _mat[1][1] *= v[1]; _mat[1][2] *= v[1]; _mat[1][3] *= v[1]; 
     730    _mat[2][0] *= v[2]; _mat[2][1] *= v[2]; _mat[2][2] *= v[2]; _mat[2][3] *= v[2]; 
     731} 
     732 
     733inline void Matrixf::postMultScale( const Vec3d& v ) 
     734{ 
     735    _mat[0][0] *= v[0]; _mat[1][0] *= v[0]; _mat[2][0] *= v[0]; _mat[3][0] *= v[0]; 
     736    _mat[0][1] *= v[1]; _mat[1][1] *= v[1]; _mat[2][1] *= v[1]; _mat[3][1] *= v[1]; 
     737    _mat[0][2] *= v[2]; _mat[1][2] *= v[2]; _mat[2][2] *= v[2]; _mat[3][2] *= v[2]; 
     738} 
     739 
     740inline void Matrixf::postMultScale( const Vec3f& v ) 
     741{ 
     742    _mat[0][0] *= v[0]; _mat[1][0] *= v[0]; _mat[2][0] *= v[0]; _mat[3][0] *= v[0]; 
     743    _mat[0][1] *= v[1]; _mat[1][1] *= v[1]; _mat[2][1] *= v[1]; _mat[3][1] *= v[1]; 
     744    _mat[0][2] *= v[2]; _mat[1][2] *= v[2]; _mat[2][2] *= v[2]; _mat[3][2] *= v[2]; 
     745} 
     746 
     747 
     748inline void Matrixf::preMultRotate( const Quat& q ) 
     749{ 
     750    if (q.zeroRotation()) 
     751        return; 
     752    Matrixf r; 
     753    r.setRotate(q); 
     754    preMult(r); 
     755} 
     756 
     757inline void Matrixf::postMultRotate( const Quat& q ) 
     758{ 
     759    if (q.zeroRotation()) 
     760        return; 
     761    Matrixf r; 
     762    r.setRotate(q); 
     763    postMult(r); 
     764} 
    644765 
    645766inline Vec3f operator* (const Vec3f& v, const Matrixf& m ) 
  • OpenSceneGraph/trunk/src/osg/AutoTransform.cpp

    r8804 r8868  
    8484bool AutoTransform::computeWorldToLocalMatrix(Matrix& matrix,NodeVisitor*) const 
    8585{ 
     86    if (_scale.x() == 0.0 || _scale.y() == 0.0 || _scale.z() == 0.0) 
     87        return false; 
     88 
    8689    if (_referenceFrame==RELATIVE_RF) 
    8790    { 
    88         matrix.postMult(osg::Matrix::translate(-_position)* 
    89                         osg::Matrix::rotate(_rotation.inverse())* 
    90                         osg::Matrix::scale(1.0/_scale.x(),1.0/_scale.y(),1.0/_scale.z())* 
    91                         osg::Matrix::translate(_pivotPoint)); 
     91        matrix.postMultTranslate(-_position); 
     92        matrix.postMultRotate(_rotation.inverse()); 
     93        matrix.postMultScale(Vec3d(1.0/_scale.x(), 1.0/_scale.y(), 1.0/_scale.z())); 
     94        matrix.postMultTranslate(_pivotPoint); 
    9295    } 
    9396    else // absolute 
    9497    { 
    95         matrix = osg::Matrix::translate(-_position)* 
    96                  osg::Matrix::rotate(_rotation.inverse())* 
    97                  osg::Matrix::scale(1.0/_scale.x(),1.0/_scale.y(),1.0/_scale.z())* 
    98                  osg::Matrix::translate(_pivotPoint); 
     98        matrix.makeRotate(_rotation.inverse()); 
     99        matrix.preMultTranslate(-_position); 
     100        matrix.postMultScale(Vec3d(1.0/_scale.x(), 1.0/_scale.y(), 1.0/_scale.z())); 
     101        matrix.postMultTranslate(_pivotPoint); 
    99102    } 
    100103    return true; 
     
    105108    if (!_matrixDirty) return; 
    106109     
    107     _cachedMatrix.set(osg::Matrix::translate(-_pivotPoint)* 
    108                       osg::Matrix::scale(_scale)* 
    109                       osg::Matrix::rotate(_rotation)* 
    110                       osg::Matrix::translate(_position)); 
     110    _cachedMatrix.makeRotate(_rotation); 
     111    _cachedMatrix.postMultTranslate(_position); 
     112    _cachedMatrix.preMultScale(_scale); 
     113    _cachedMatrix.preMultTranslate(-_pivotPoint); 
    111114     
    112115    _matrixDirty = false; 
  • OpenSceneGraph/trunk/src/osg/CameraView.cpp

    r5328 r8868  
    2626    if (_referenceFrame==RELATIVE_RF) 
    2727    { 
    28         matrix.preMult(osg::Matrix::rotate(_attitude)* 
    29                        osg::Matrix::translate(_position)); 
     28        matrix.preMultTranslate(_position); 
     29        matrix.preMultRotate(_attitude); 
    3030    } 
    3131    else // absolute 
    3232    { 
    33         matrix = osg::Matrix::rotate(_attitude)* 
    34                  osg::Matrix::translate(_position); 
     33        matrix.makeRotate(_attitude); 
     34        matrix.postMultTranslate(_position); 
    3535    } 
    3636    return true; 
     
    4242    if (_referenceFrame==RELATIVE_RF) 
    4343    { 
    44         matrix.postMult(osg::Matrix::translate(-_position)* 
    45                         osg::Matrix::rotate(_attitude.inverse())); 
     44        matrix.postMultTranslate(-_position); 
     45        matrix.postMultRotate(_attitude.inverse()); 
    4646    } 
    4747    else // absolute 
    4848    { 
    49         matrix = osg::Matrix::translate(-_position)* 
    50                  osg::Matrix::rotate(_attitude.inverse()); 
     49        matrix.makeRotate(_attitude.inverse()); 
     50        matrix.preMultTranslate(-_position); 
    5151    } 
    5252    return true; 
  • OpenSceneGraph/trunk/src/osg/Matrix_implementation.cpp

    r7301 r8868  
    1919#include <osg/GL> 
    2020 
     21#include <limits> 
    2122#include <stdlib.h> 
    2223 
     
    6364#define QW  q._v[3] 
    6465 
    65 void Matrix_implementation::setRotate(const Quat& q_in) 
    66 { 
    67     Quat q(q_in); 
     66void Matrix_implementation::setRotate(const Quat& q) 
     67{ 
    6868    double length2 = q.length2(); 
    69     if (length2!=1.0 && length2!=0) 
    70     { 
     69    if (fabs(length2) <= std::numeric_limits<double>::min()) 
     70    { 
     71        _mat[0][0] = 0.0; _mat[1][0] = 0.0; _mat[2][0] = 0.0; 
     72        _mat[0][1] = 0.0; _mat[1][1] = 0.0; _mat[2][1] = 0.0; 
     73        _mat[0][2] = 0.0; _mat[1][2] = 0.0; _mat[2][2] = 0.0; 
     74    } 
     75    else 
     76    { 
     77        double rlength2; 
    7178        // normalize quat if required. 
    72         q /= sqrt(length2); 
    73     } 
    74  
    75     // Source: Gamasutra, Rotating Objects Using Quaternions 
    76     // 
    77     //http://www.gamasutra.com/features/19980703/quaternions_01.htm 
    78  
    79     double wx, wy, wz, xx, yy, yz, xy, xz, zz, x2, y2, z2; 
    80  
    81     // calculate coefficients 
    82     x2 = QX + QX; 
    83     y2 = QY + QY; 
    84     z2 = QZ + QZ; 
    85  
    86     xx = QX * x2; 
    87     xy = QX * y2; 
    88     xz = QX * z2; 
    89  
    90     yy = QY * y2; 
    91     yz = QY * z2; 
    92     zz = QZ * z2; 
    93  
    94     wx = QW * x2; 
    95     wy = QW * y2; 
    96     wz = QW * z2; 
    97  
    98     // Note.  Gamasutra gets the matrix assignments inverted, resulting 
    99     // in left-handed rotations, which is contrary to OpenGL and OSG's  
    100     // methodology.  The matrix assignment has been altered in the next 
    101     // few lines of code to do the right thing. 
    102     // Don Burns - Oct 13, 2001 
    103     _mat[0][0] = 1.0 - (yy + zz); 
    104     _mat[1][0] = xy - wz; 
    105     _mat[2][0] = xz + wy; 
    106  
    107  
    108     _mat[0][1] = xy + wz; 
    109     _mat[1][1] = 1.0 - (xx + zz); 
    110     _mat[2][1] = yz - wx; 
    111  
    112     _mat[0][2] = xz - wy; 
    113     _mat[1][2] = yz + wx; 
    114     _mat[2][2] = 1.0 - (xx + yy); 
     79        // We can avoid the expensive sqrt in this case since all 'coefficients' below are products of two q components. 
     80        // That is a square of a square root, so it is possible to avoid that 
     81        if (length2 != 1.0) 
     82        { 
     83            rlength2 = 2.0/length2; 
     84        } 
     85        else 
     86        { 
     87            rlength2 = 2.0; 
     88        } 
     89         
     90        // Source: Gamasutra, Rotating Objects Using Quaternions 
     91        // 
     92        //http://www.gamasutra.com/features/19980703/quaternions_01.htm 
     93         
     94        double wx, wy, wz, xx, yy, yz, xy, xz, zz, x2, y2, z2; 
     95         
     96        // calculate coefficients 
     97        x2 = rlength2*QX; 
     98        y2 = rlength2*QY; 
     99        z2 = rlength2*QZ; 
     100         
     101        xx = QX * x2; 
     102        xy = QX * y2; 
     103        xz = QX * z2; 
     104         
     105        yy = QY * y2; 
     106        yz = QY * z2; 
     107        zz = QZ * z2; 
     108         
     109        wx = QW * x2; 
     110        wy = QW * y2; 
     111        wz = QW * z2; 
     112         
     113        // Note.  Gamasutra gets the matrix assignments inverted, resulting 
     114        // in left-handed rotations, which is contrary to OpenGL and OSG's  
     115        // methodology.  The matrix assignment has been altered in the next 
     116        // few lines of code to do the right thing. 
     117        // Don Burns - Oct 13, 2001 
     118        _mat[0][0] = 1.0 - (yy + zz); 
     119        _mat[1][0] = xy - wz; 
     120        _mat[2][0] = xz + wy; 
     121         
     122         
     123        _mat[0][1] = xy + wz; 
     124        _mat[1][1] = 1.0 - (xx + zz); 
     125        _mat[2][1] = yz - wx; 
     126         
     127        _mat[0][2] = xz - wy; 
     128        _mat[1][2] = yz + wx; 
     129        _mat[2][2] = 1.0 - (xx + yy); 
     130    } 
    115131 
    116132#if 0 
     
    904920        0.0,     0.0,     0.0,      1.0); 
    905921 
    906     preMult(Matrix_implementation::translate(-eye)); 
     922    preMultTranslate(-eye); 
    907923} 
    908924 
  • OpenSceneGraph/trunk/src/osg/PositionAttitudeTransform.cpp

    r5328 r8868  
    1616 
    1717PositionAttitudeTransform::PositionAttitudeTransform(): 
    18     _scale(1.0f,1.0f,1.0f) 
     18    _scale(1.0,1.0,1.0) 
    1919{ 
    2020} 
     
    2424    if (_referenceFrame==RELATIVE_RF) 
    2525    { 
    26         matrix.preMult(osg::Matrix::translate(-_pivotPoint)* 
    27                        osg::Matrix::scale(_scale)* 
    28                        osg::Matrix::rotate(_attitude)* 
    29                        osg::Matrix::translate(_position)); 
     26        matrix.preMultTranslate(_position); 
     27        matrix.preMultRotate(_attitude); 
     28        matrix.preMultScale(_scale); 
     29        matrix.preMultTranslate(-_pivotPoint); 
    3030    } 
    3131    else // absolute 
    3232    { 
    33         matrix = osg::Matrix::translate(-_pivotPoint)* 
    34                  osg::Matrix::scale(_scale)* 
    35                  osg::Matrix::rotate(_attitude)* 
    36                  osg::Matrix::translate(_position); 
     33        matrix.makeRotate(_attitude); 
     34        matrix.postMultTranslate(_position); 
     35        matrix.preMultScale(_scale); 
     36        matrix.preMultTranslate(-_pivotPoint); 
    3737    } 
    3838    return true; 
     
    4242bool PositionAttitudeTransform::computeWorldToLocalMatrix(Matrix& matrix,NodeVisitor*) const 
    4343{ 
     44    if (_scale.x() == 0.0 || _scale.y() == 0.0 || _scale.z() == 0.0) 
     45        return false; 
     46 
    4447    if (_referenceFrame==RELATIVE_RF) 
    4548    { 
    46         matrix.postMult(osg::Matrix::translate(-_position)* 
    47                         osg::Matrix::rotate(_attitude.inverse())* 
    48                         osg::Matrix::scale(1.0f/_scale.x(),1.0f/_scale.y(),1.0f/_scale.z())* 
    49                         osg::Matrix::translate(_pivotPoint)); 
     49        matrix.postMultTranslate(-_position); 
     50        matrix.postMultRotate(_attitude.inverse()); 
     51        matrix.postMultScale(Vec3d(1.0/_scale.x(), 1.0/_scale.y(), 1.0/_scale.z())); 
     52        matrix.postMultTranslate(_pivotPoint); 
    5053    } 
    5154    else // absolute 
    5255    { 
    53         matrix = osg::Matrix::translate(-_position)* 
    54                  osg::Matrix::rotate(_attitude.inverse())* 
    55                  osg::Matrix::scale(1.0f/_scale.x(),1.0f/_scale.y(),1.0f/_scale.z())* 
    56                  osg::Matrix::translate(_pivotPoint); 
     56        matrix.makeRotate(_attitude.inverse()); 
     57        matrix.preMultTranslate(-_position); 
     58        matrix.postMultScale(Vec3d(1.0/_scale.x(), 1.0/_scale.y(), 1.0/_scale.z())); 
     59        matrix.postMultTranslate(_pivotPoint); 
    5760    } 
    5861    return true; 
  • OpenSceneGraph/trunk/src/osgManipulator/AntiSquish.cpp

    r6383 r8868  
    117117    if (_usePivot) 
    118118    { 
    119         osg::Matrix tmpPivot; 
    120         tmpPivot.setTrans(-_pivot); 
    121         unsquished.postMult(tmpPivot); 
     119        unsquished.postMultTranslate(-_pivot); 
    122120 
    123121        osg::Matrix tmps, invtmps; 
    124122        so.get(tmps); 
    125         invtmps = osg::Matrix::inverse(tmps); 
    126         if (invtmps.isNaN()) 
    127         { 
     123        if (!invtmps.invert(tmps)) 
     124        { 
    128125            flag = false; 
    129126            return osg::Matrix::identity(); 
     
    133130        unsquished.postMult(invtmps); 
    134131        //S 
    135         unsquished.postMult(osg::Matrix::scale(s[0], s[1], s[2])); 
     132        unsquished.postMultScale(s); 
    136133        //SO 
    137134        unsquished.postMult(tmps); 
    138         tmpPivot.makeIdentity(); 
    139         osg::Matrix tmpr; 
    140         r.get(tmpr); 
    141135        //R 
    142         unsquished.postMult(tmpr); 
     136        unsquished.postMultRotate(r); 
    143137        //T 
    144         unsquished.postMult(osg::Matrix::translate(t[0],t[1],t[2])); 
     138        unsquished.postMultTranslate(t); 
    145139 
    146140        osg::Matrix invltw; 
    147         invltw = osg::Matrix::inverse(LTW); 
    148         if (invltw.isNaN()) 
    149         { 
    150             flag =false; 
     141        if (!invltw.invert(LTW)) 
     142        { 
     143            flag = false; 
    151144            return osg::Matrix::identity(); 
    152145        } 
     
    155148 
    156149        // Position 
    157         tmpPivot.makeIdentity(); 
    158150        if (_usePosition) 
    159             tmpPivot.setTrans(_position); 
     151            unsquished.postMult(_position); 
    160152        else 
    161             tmpPivot.setTrans(_pivot); 
    162  
    163         unsquished.postMult(tmpPivot);  
     153            unsquished.postMult(_pivot); 
    164154    } 
    165155    else 
     
    167157        osg::Matrix tmps, invtmps; 
    168158        so.get(tmps); 
    169         invtmps = osg::Matrix::inverse(tmps); 
     159        if (!invtmps.invert(tmps)) 
     160        { 
     161            flag = false; 
     162            return osg::Matrix::identity(); 
     163        } 
    170164        unsquished.postMult(invtmps); 
    171         unsquished.postMult(osg::Matrix::scale(s[0], s[1], s[2])); 
     165        unsquished.postMultScale(s); 
    172166        unsquished.postMult(tmps); 
    173         osg::Matrix tmpr; 
    174         r.get(tmpr); 
    175         unsquished.postMult(tmpr); 
    176         unsquished.postMult(osg::Matrix::translate(t[0],t[1],t[2])); 
    177         unsquished.postMult( osg::Matrix::inverse(LTW) ); 
     167        unsquished.postMultRotate(r); 
     168        unsquished.postMultTranslate(t); 
     169        osg::Matrix invltw; 
     170        if (!invltw.invert(LTW)) 
     171        { 
     172            flag = false; 
     173            return osg::Matrix::identity(); 
     174        } 
     175        unsquished.postMult( invltw ); 
    178176    } 
    179177 
  • OpenSceneGraph/trunk/src/osgParticle/PrecipitationEffect.cpp

    r8716 r8868  
    838838 
    839839    *mymodelview = *(cv->getModelViewMatrix()); 
    840     mymodelview->preMult(osg::Matrix::translate(position)); 
    841     mymodelview->preMult(osg::Matrix::scale(scale)); 
     840    mymodelview->preMultTranslate(position); 
     841    mymodelview->preMultScale(scale); 
    842842     
    843843    cv->updateCalculatedNearFar(*(cv->getModelViewMatrix()),bb); 
  • OpenSceneGraph/trunk/src/osgSim/DOFTransform.cpp

    r6112 r8868  
    133133 
    134134    //and scale: 
    135     current.preMult(osg::Matrix::scale(getCurrentScale())); 
     135    current.preMultScale(getCurrentScale()); 
    136136 
    137137    l2w.postMult(current); 
     
    202202 
    203203    //and scale: 
    204     current.postMult(osg::Matrix::scale(1./getCurrentScale()[0], 1./getCurrentScale()[1], 1./getCurrentScale()[2])); 
     204    current.postMultScale(osg::Vec3d(1./getCurrentScale()[0], 1./getCurrentScale()[1], 1./getCurrentScale()[2])); 
    205205 
    206206    w2l.postMult(current); 
  • OpenSceneGraph/trunk/src/osgSim/Sector.cpp

    r8370 r8868  
    235235  double roll    = _rollAngle; 
    236236 
    237   _local_to_LP = osg::Matrixd::identity(); 
    238   _local_to_LP.preMult(osg::Matrix::rotate(heading, 0.0, 0.0, -1.0)); 
    239   _local_to_LP.preMult(osg::Matrix::rotate(pitch, 1.0, 0.0, 0.0)); 
    240   _local_to_LP.preMult(osg::Matrix::rotate(roll, 0.0, 1.0, 0.0)); 
     237  _local_to_LP.setRotate(osg::Quat(heading, 0.0, 0.0, -1.0)); 
     238  _local_to_LP.preMultRotate(osg::Quat(pitch, 1.0, 0.0, 0.0)); 
     239  _local_to_LP.preMultRotate(osg::Quat(roll, 0.0, 1.0, 0.0)); 
    241240} 
    242241 
  • OpenSceneGraph/trunk/src/osgText/Text.cpp

    r8093 r8868  
    641641        } 
    642642 
    643         if (!_rotation.zeroRotation() ) 
    644         { 
    645             matrix.postMult(osg::Matrix::rotate(_rotation)); 
    646         } 
     643        matrix.postMultRotate(_rotation); 
    647644 
    648645        if (_characterSizeMode!=OBJECT_COORDS) 
    649646        { 
    650647 
    651             osg::Matrix M(rotate_matrix*osg::Matrix::translate(_position)*atc._modelview); 
     648            osg::Matrix M(rotate_matrix); 
     649            M.postMultTranslate(_position); 
     650            M.postMult(atc._modelview); 
    652651            osg::Matrix& P = atc._projection; 
    653652             
     
    694693                if (P10<0) 
    695694                   scale_font_vert=-scale_font_vert; 
    696                 matrix.postMult(osg::Matrix::scale(scale_font_hori, scale_font_vert,1.0f)); 
     695                matrix.postMultScale(osg::Vec3f(scale_font_hori, scale_font_vert,1.0f)); 
    697696            } 
    698697            else if (pixelSizeVert>getFontHeight()) 
    699698            { 
    700699                float scale_font = getFontHeight()/pixelSizeVert; 
    701                 matrix.postMult(osg::Matrix::scale(scale_font, scale_font,1.0f)); 
     700                matrix.postMultScale(osg::Vec3f(scale_font, scale_font,1.0f)); 
    702701            } 
    703702 
     
    709708        } 
    710709 
    711         matrix.postMult(osg::Matrix::translate(_position)); 
     710        matrix.postMultTranslate(_position); 
    712711    } 
    713712    else if (!_rotation.zeroRotation()) 
    714713    { 
    715         matrix.makeTranslate(-_offset); 
    716         matrix.postMult(osg::Matrix::rotate(_rotation)); 
    717         matrix.postMult(osg::Matrix::translate(_position)); 
     714        matrix.makeRotate(_rotation); 
     715        matrix.preMultTranslate(-_offset); 
     716        matrix.postMultTranslate(_position); 
    718717    } 
    719718    else 
  • OpenSceneGraph/trunk/src/osgText/Text3D.cpp

    r8441 r8868  
    458458     
    459459    float scale = _font->getScale(); 
    460     osg::Matrix scaleMatrix = osg::Matrix::scale(scale * _characterHeight,  
    461                                                  scale * _characterHeight / _characterAspectRatio,  
    462                                                  _characterDepth); 
    463     if (!_rotation.zeroRotation()) 
    464     { 
    465         matrix.makeTranslate(-_offset); 
    466         matrix.postMult(scaleMatrix); 
    467         matrix.postMult(osg::Matrix::rotate(_rotation)); 
    468         matrix.postMult(osg::Matrix::translate(_position)); 
    469     } 
    470     else 
    471     { 
    472         matrix.makeTranslate(-_offset); 
    473         matrix.postMult(scaleMatrix); 
    474         matrix.postMult(osg::Matrix::translate(_position)); 
    475     } 
     460    osg::Vec3 scaleVec(scale * _characterHeight, scale * _characterHeight / _characterAspectRatio, _characterDepth); 
     461    matrix.makeTranslate(-_offset); 
     462    matrix.postMultScale(scaleVec); 
     463    matrix.postMultRotate(_rotation); 
     464    matrix.postMultTranslate(_position); 
    476465 
    477466     
  • OpenSceneGraph/trunk/src/osgUtil/SceneGraphBuilder.cpp

    r7941 r8868  
    8787{ 
    8888    if (_matrixStack.empty()) _matrixStack.push_back(osg::Matrixd()); 
    89     _matrixStack.back().preMult(osg::Matrixd::translate(x,y,z)); 
     89    _matrixStack.back().preMultTranslate(osg::Vec3d(x,y,z)); 
    9090 
    9191    matrixChanged(); 
     
    9595{ 
    9696    if (_matrixStack.empty()) _matrixStack.push_back(osg::Matrixd()); 
    97     _matrixStack.back().preMult(osg::Matrixd::scale(x,y,z)); 
     97    _matrixStack.back().preMultScale(osg::Vec3d(x,y,z)); 
    9898 
    9999    matrixChanged(); 
     
    103103{ 
    104104    if (_matrixStack.empty()) _matrixStack.push_back(osg::Matrixd()); 
    105     _matrixStack.back().preMult(osg::Matrixd::rotate(osg::inDegrees(angle),x,y,z)); 
     105    _matrixStack.back().preMultRotate(osg::Quat(osg::inDegrees(angle),osg::Vec3d(x,y,z))); 
    106106 
    107107    matrixChanged(); 
  • OpenSceneGraph/trunk/src/osgViewer/View.cpp

    r8633 r8868  
    9797                y = osg::Matrixd::transform3x3(y,coordinateFrame); 
    9898                z = osg::Matrixd::transform3x3(z,coordinateFrame); 
    99                 coordinateFrame.preMult(osg::Matrixd::scale(1.0/x.length(),1.0/y.length(),1.0/z.length())); 
     99                coordinateFrame.preMultScale(osg::Vec3d(1.0/x.length(),1.0/y.length(),1.0/z.length())); 
    100100 
    101101                // reapply the position.