Changeset 8868

Timestamp:

09/17/08 18:14:28 (5 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 4^{3 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:

• examples/osgdepthpeeling/osgdepthpeeling.cpp (modified) (1 diff)
• examples/osghangglide/osghangglide.cpp (modified) (2 diffs)
• examples/osglogo/osglogo.cpp (modified) (1 diff)
• examples/osgsimulation/osgsimulation.cpp (modified) (1 diff)
• examples/osgunittests/UnitTests_osg.cpp (modified) (2 diffs)
• examples/osgvertexprogram/osgvertexprogram.cpp (modified) (2 diffs)
• include/osg/AnimationPath (modified) (1 diff)
• include/osg/Matrixd (modified) (2 diffs)
• include/osg/Matrixf (modified) (2 diffs)
• src/osg/AutoTransform.cpp (modified) (2 diffs)
• src/osg/CameraView.cpp (modified) (2 diffs)
• src/osg/Matrix_implementation.cpp (modified) (3 diffs)
• src/osg/PositionAttitudeTransform.cpp (modified) (3 diffs)
• src/osgManipulator/AntiSquish.cpp (modified) (4 diffs)
• src/osgParticle/PrecipitationEffect.cpp (modified) (1 diff)
• src/osgSim/DOFTransform.cpp (modified) (2 diffs)
• src/osgSim/Sector.cpp (modified) (1 diff)
• src/osgText/Text.cpp (modified) (3 diffs)
• src/osgText/Text3D.cpp (modified) (1 diff)
• src/osgUtil/SceneGraphBuilder.cpp (modified) (3 diffs)
• src/osgViewer/View.cpp (modified) (1 diff)

OpenSceneGraph/trunk/examples/osgdepthpeeling/osgdepthpeeling.cpp

@@ -175 +175 @@
   void rotate(float x, float y)
   {
-    osg::Matrixd baseMatrix = _modelGroupTransform->getMatrix();
-    
-    osg::Matrixd preTransMatrix;
-    osg::Matrixd postTransMatrix;
-    osg::Matrixd rotMatrixX;
-    osg::Matrixd rotMatrixZ;
-    
-    preTransMatrix.makeTranslate(_rotCenter);
-    postTransMatrix.makeTranslate(-_rotCenter);
-
-    rotMatrixZ.makeRotate((x - _prevX) * 3., osg::Vec3d(0.0, 0.0,1.0));
-    
-    baseMatrix.preMult(preTransMatrix);
-    baseMatrix.preMult(rotMatrixZ);
-    baseMatrix.preMult(postTransMatrix);
-
-    rotMatrixX.makeRotate(-(y - _prevY) * 3., (baseMatrix * osg::Vec3d(1.0, 0.0,0.0)));
-    
-    baseMatrix.preMult(preTransMatrix);
-    baseMatrix.preMult(rotMatrixX);
-    baseMatrix.preMult(postTransMatrix);
+    osg::Matrix baseMatrix = _modelGroupTransform->getMatrix();
+    
+    baseMatrix.preMultTranslate(_rotCenter);
+    baseMatrix.preMultRotate(osg::Quat((x - _prevX) * 3, osg::Vec3d(0.0, 0.0, 1.0)));
+    baseMatrix.preMultRotate(osg::Quat(-(y - _prevY) * 3, (baseMatrix * osg::Vec3d(1.0, 0.0, 0.0))));
+    baseMatrix.preMultTranslate(-_rotCenter);
     
     _modelGroupTransform->setMatrix(baseMatrix);

OpenSceneGraph/trunk/examples/osghangglide/osghangglide.cpp

@@ -55 +55 @@
         {
             osg::Vec3 eyePointLocal = cv->getEyeLocal();
-            matrix.preMult(osg::Matrix::translate(eyePointLocal.x(),eyePointLocal.y(),0.0f));
+            matrix.preMultTranslate(osg::Vec3(eyePointLocal.x(),eyePointLocal.y(),0.0f));
         }
         return true;
@@ -69 +69 @@
         {
             osg::Vec3 eyePointLocal = cv->getEyeLocal();
-            matrix.postMult(osg::Matrix::translate(-eyePointLocal.x(),-eyePointLocal.y(),0.0f));
+            matrix.postMultTranslate(osg::Vec3(-eyePointLocal.x(),-eyePointLocal.y(),0.0f));
         }
         return true;

OpenSceneGraph/trunk/examples/osglogo/osglogo.cpp

@@ -68 +68 @@
             }
 
-
-            matrix.preMult(osg::Matrix::translate(-_pivotPoint)*
-                           osg::Matrix::rotate(_attitude)*
-                           osg::Matrix::rotate(billboardRotation)*
-                           osg::Matrix::translate(_position));
+            matrix.preMultTranslate(_position);
+            matrix.preMultRotate(billboardRotation);
+            matrix.preMultRotate(_attitude);
+            matrix.preMultTranslate(_pivotPoint);
             return true;
         }

OpenSceneGraph/trunk/examples/osgsimulation/osgsimulation.cpp

@@ -147 +147 @@
                     //osg::Matrixd matrix;
                     ellipsoid->computeLocalToWorldTransformFromLatLongHeight(_latitude,_longitude,_height,matrix);
-                    matrix.preMult(osg::Matrix::rotate(_rotation));
+                    matrix.preMultRotate(_rotation);
                     
                     mt->setMatrix(matrix);

OpenSceneGraph/trunk/examples/osgunittests/UnitTests_osg.cpp

@@ -20 +20 @@
 
 #include <osg/Matrixd>
+#include <osg/Matrixf>
+#include <osg/Vec3d>
 #include <osg/Vec3>
 #include <sstream>
@@ -85 +87 @@
 OSGUTX_AUTOREGISTER_TESTSUITE_AT(Vec3, root.osg)
 
-}
+///////////////////////////////////////////////////////////////////////////////
+// 
+//  Matrix Tests
+//
+class MatrixTestFixture
+{
+public:
+
+    MatrixTestFixture();
+
+    void testPreMultTranslate(const osgUtx::TestContext& ctx);
+    void testPostMultTranslate(const osgUtx::TestContext& ctx);
+    void testPreMultScale(const osgUtx::TestContext& ctx);
+    void testPostMultScale(const osgUtx::TestContext& ctx);
+    void testPreMultRotate(const osgUtx::TestContext& ctx);
+    void testPostMultRotate(const osgUtx::TestContext& ctx);
+
+private:
+
+    // Some convenience variables for use in the tests
+    Matrixd _md;
+    Matrixf _mf;
+    Vec3d _v3d;
+    Vec3 _v3;
+    Quat _q1;
+    Quat _q2;
+    Quat _q3;
+    Quat _q4;
+
+};
+
+MatrixTestFixture::MatrixTestFixture():
+    _md(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16),
+    _mf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16),
+    _v3d(1, 2, 3),
+    _v3(1, 2, 3),
+    _q1(1, 0, 0, 0),
+    _q2(0, 1, 0, 0),
+    _q3(0, 0, 1, 0),
+    _q4(0, 0, 0, 1)
+{
+}
+
+void MatrixTestFixture::testPreMultTranslate(const osgUtx::TestContext&)
+{
+    osg::Matrixd tdo;
+    osg::Matrixd tdn;
+    osg::Matrixf tfo;
+    osg::Matrixf tfn;
+
+    tdo = _md;
+    tdn = _md;
+    tdo.preMult(osg::Matrixd::translate(_v3d));
+    tdn.preMultTranslate(_v3d);
+    OSGUTX_TEST_F( tdo == tdn )
+
+    tdo = _md;
+    tdn = _md;
+    tdo.preMult(osg::Matrixd::translate(_v3));
+    tdn.preMultTranslate(_v3);
+    OSGUTX_TEST_F( tdo == tdn )
+
+    tfo = _mf;
+    tfn = _mf;
+    tfo.preMult(osg::Matrixf::translate(_v3d));
+    tfn.preMultTranslate(_v3d);
+    OSGUTX_TEST_F( tfo == tfn )
+
+    tfo = _mf;
+    tfn = _mf;
+    tfo.preMult(osg::Matrixf::translate(_v3));
+    tfn.preMultTranslate(_v3);
+    OSGUTX_TEST_F( tfo == tfn )
+}
+
+void MatrixTestFixture::testPostMultTranslate(const osgUtx::TestContext&)
+{
+    osg::Matrixd tdo;
+    osg::Matrixd tdn;
+    osg::Matrixf tfo;
+    osg::Matrixf tfn;
+
+    tdo = _md;
+    tdn = _md;
+    tdo.postMult(osg::Matrixd::translate(_v3d));
+    tdn.postMultTranslate(_v3d);
+    OSGUTX_TEST_F( tdo == tdn )
+
+    tdo = _md;
+    tdn = _md;
+    tdo.postMult(osg::Matrixd::translate(_v3));
+    tdn.postMultTranslate(_v3);
+    OSGUTX_TEST_F( tdo == tdn )
+
+    tfo = _mf;
+    tfn = _mf;
+    tfo.postMult(osg::Matrixf::translate(_v3d));
+    tfn.postMultTranslate(_v3d);
+    OSGUTX_TEST_F( tfo == tfn )
+
+    tfo = _mf;
+    tfn = _mf;
+    tfo.postMult(osg::Matrixf::translate(_v3));
+    tfn.postMultTranslate(_v3);
+    OSGUTX_TEST_F( tfo == tfn )
+}
+
+void MatrixTestFixture::testPreMultScale(const osgUtx::TestContext&)
+{
+    osg::Matrixd tdo;
+    osg::Matrixd tdn;
+    osg::Matrixf tfo;
+    osg::Matrixf tfn;
+
+    tdo = _md;
+    tdn = _md;
+    tdo.preMult(osg::Matrixd::scale(_v3d));
+    tdn.preMultScale(_v3d);
+    OSGUTX_TEST_F( tdo == tdn )
+
+    tdo = _md;
+    tdn = _md;
+    tdo.preMult(osg::Matrixd::scale(_v3));
+    tdn.preMultScale(_v3);
+    OSGUTX_TEST_F( tdo == tdn )
+
+    tfo = _mf;
+    tfn = _mf;
+    tfo.preMult(osg::Matrixf::scale(_v3d));
+    tfn.preMultScale(_v3d);
+    OSGUTX_TEST_F( tfo == tfn )
+
+    tfo = _mf;
+    tfn = _mf;
+    tfo.preMult(osg::Matrixf::scale(_v3));
+    tfn.preMultScale(_v3);
+    OSGUTX_TEST_F( tfo == tfn )
+}
+
+void MatrixTestFixture::testPostMultScale(const osgUtx::TestContext&)
+{
+    osg::Matrixd tdo;
+    osg::Matrixd tdn;
+    osg::Matrixf tfo;
+    osg::Matrixf tfn;
+
+    tdo = _md;
+    tdn = _md;
+    tdo.postMult(osg::Matrixd::scale(_v3d));
+    tdn.postMultScale(_v3d);
+    OSGUTX_TEST_F( tdo == tdn )
+
+    tdo = _md;
+    tdn = _md;
+    tdo.postMult(osg::Matrixd::scale(_v3));
+    tdn.postMultScale(_v3);
+    OSGUTX_TEST_F( tdo == tdn )
+
+    tfo = _mf;
+    tfn = _mf;
+    tfo.postMult(osg::Matrixf::scale(_v3d));
+    tfn.postMultScale(_v3d);
+    OSGUTX_TEST_F( tfo == tfn )
+
+    tfo = _mf;
+    tfn = _mf;
+    tfo.postMult(osg::Matrixf::scale(_v3));
+    tfn.postMultScale(_v3);
+    OSGUTX_TEST_F( tfo == tfn )
+}
+
+void MatrixTestFixture::testPreMultRotate(const osgUtx::TestContext&)
+{
+    osg::Matrixd tdo;
+    osg::Matrixd tdn;
+    osg::Matrixf tfo;
+    osg::Matrixf tfn;
+
+    tdo = _md;
+    tdn = _md;
+    tdo.preMult(osg::Matrixd::rotate(_q1));
+    tdn.preMultRotate(_q1);
+    OSGUTX_TEST_F( tdo == tdn )
+
+    tdo = _md;
+    tdn = _md;
+    tdo.preMult(osg::Matrixd::rotate(_q2));
+    tdn.preMultRotate(_q2);
+    OSGUTX_TEST_F( tdo == tdn )
+
+    tdo = _md;
+    tdn = _md;
+    tdo.preMult(osg::Matrixd::rotate(_q3));
+    tdn.preMultRotate(_q3);
+    OSGUTX_TEST_F( tdo == tdn )
+
+    tdo = _md;
+    tdn = _md;
+    tdo.preMult(osg::Matrixd::rotate(_q4));
+    tdn.preMultRotate(_q4);
+    OSGUTX_TEST_F( tdo == tdn )
+
+    tfo = _mf;
+    tfn = _mf;
+    tfo.preMult(osg::Matrixf::rotate(_q1));
+    tfn.preMultRotate(_q1);
+    OSGUTX_TEST_F( tfo == tfn )
+
+    tfo = _mf;
+    tfn = _mf;
+    tfo.preMult(osg::Matrixf::rotate(_q2));
+    tfn.preMultRotate(_q2);
+    OSGUTX_TEST_F( tfo == tfn )
+
+    tfo = _mf;
+    tfn = _mf;
+    tfo.preMult(osg::Matrixf::rotate(_q3));
+    tfn.preMultRotate(_q3);
+    OSGUTX_TEST_F( tfo == tfn )
+
+    tfo = _mf;
+    tfn = _mf;
+    tfo.preMult(osg::Matrixf::rotate(_q4));
+    tfn.preMultRotate(_q4);
+    OSGUTX_TEST_F( tfo == tfn )
+}
+
+void MatrixTestFixture::testPostMultRotate(const osgUtx::TestContext&)
+{
+    osg::Matrixd tdo;
+    osg::Matrixd tdn;
+    osg::Matrixf tfo;
+    osg::Matrixf tfn;
+
+    tdo = _md;
+    tdn = _md;
+    tdo.postMult(osg::Matrixd::rotate(_q1));
+    tdn.postMultRotate(_q1);
+    OSGUTX_TEST_F( tdo == tdn )
+
+    tdo = _md;
+    tdn = _md;
+    tdo.postMult(osg::Matrixd::rotate(_q2));
+    tdn.postMultRotate(_q2);
+    OSGUTX_TEST_F( tdo == tdn )
+
+    tdo = _md;
+    tdn = _md;
+    tdo.postMult(osg::Matrixd::rotate(_q3));
+    tdn.postMultRotate(_q3);
+    OSGUTX_TEST_F( tdo == tdn )
+
+    tdo = _md;
+    tdn = _md;
+    tdo.postMult(osg::Matrixd::rotate(_q4));
+    tdn.postMultRotate(_q4);
+    OSGUTX_TEST_F( tdo == tdn )
+
+    tfo = _mf;
+    tfn = _mf;
+    tfo.postMult(osg::Matrixf::rotate(_q1));
+    tfn.postMultRotate(_q1);
+    OSGUTX_TEST_F( tfo == tfn )
+
+    tfo = _mf;
+    tfn = _mf;
+    tfo.postMult(osg::Matrixf::rotate(_q2));
+    tfn.postMultRotate(_q2);
+    OSGUTX_TEST_F( tfo == tfn )
+
+    tfo = _mf;
+    tfn = _mf;
+    tfo.postMult(osg::Matrixf::rotate(_q3));
+    tfn.postMultRotate(_q3);
+    OSGUTX_TEST_F( tfo == tfn )
+
+    tfo = _mf;
+    tfn = _mf;
+    tfo.postMult(osg::Matrixf::rotate(_q4));
+    tfn.postMultRotate(_q4);
+    OSGUTX_TEST_F( tfo == tfn )
+}
+
+OSGUTX_BEGIN_TESTSUITE(Matrix)
+    OSGUTX_ADD_TESTCASE(MatrixTestFixture, testPreMultTranslate)
+    OSGUTX_ADD_TESTCASE(MatrixTestFixture, testPostMultTranslate)
+    OSGUTX_ADD_TESTCASE(MatrixTestFixture, testPreMultScale)
+    OSGUTX_ADD_TESTCASE(MatrixTestFixture, testPostMultScale)
+    OSGUTX_ADD_TESTCASE(MatrixTestFixture, testPreMultRotate)
+    OSGUTX_ADD_TESTCASE(MatrixTestFixture, testPostMultRotate)
+OSGUTX_END_TESTSUITE
+
+OSGUTX_AUTOREGISTER_TESTSUITE_AT(Matrix, root.osg)
+
+
+}

OpenSceneGraph/trunk/examples/osgvertexprogram/osgvertexprogram.cpp

@@ -227 +227 @@
         {
             osg::Vec3 eyePointLocal = cv->getEyeLocal();
-            matrix.preMult(osg::Matrix::translate(eyePointLocal));
+            matrix.preMultTranslate(eyePointLocal);
         }
         return true;
@@ -239 +239 @@
         {
             osg::Vec3 eyePointLocal = cv->getEyeLocal();
-            matrix.postMult(osg::Matrix::translate(-eyePointLocal));
+            matrix.postMultTranslate(-eyePointLocal);
         }
         return true;

OpenSceneGraph/trunk/include/osg/AnimationPath

@@ -92 +92 @@
             inline void getMatrix(Matrixf& matrix) const
             {
-                matrix.makeScale(_scale);
-                matrix.postMult(osg::Matrixf::rotate(_rotation));
-                matrix.postMult(osg::Matrixf::translate(_position));
+                matrix.makeRotate(_rotation);
+                matrix.preMultScale(_scale);
+                matrix.postMultTranslate(_position);
             }
 
             inline void getMatrix(Matrixd& matrix) const
             {
-                matrix.makeScale(_scale);
-                matrix.postMult(osg::Matrixd::rotate(_rotation));
-                matrix.postMult(osg::Matrixd::translate(_position));
+                matrix.makeRotate(_rotation);
+                matrix.preMultScale(_scale);
+                matrix.postMultTranslate(_position);
             }
 
             inline void getInverse(Matrixf& matrix) const
             {
-                matrix.makeScale(1.0/_scale.x(),1.0/_scale.y(),1.0/_scale.z());
-                matrix.preMult(osg::Matrixf::rotate(_rotation.inverse()));
-                matrix.preMult(osg::Matrixf::translate(-_position));
+                matrix.makeRotate(_rotation.inverse());
+                matrix.postMultScale(osg::Vec3d(1.0/_scale.x(),1.0/_scale.y(),1.0/_scale.z()));
+                matrix.preMultTranslate(-_position);
             }
 
             inline void getInverse(Matrixd& matrix) const
             {
-                matrix.makeScale(1.0/_scale.x(),1.0/_scale.y(),1.0/_scale.z());
-                matrix.preMult(osg::Matrixd::rotate(_rotation.inverse()));
-                matrix.preMult(osg::Matrixd::translate(-_position));
+                matrix.makeRotate(_rotation.inverse());
+                matrix.postMultScale(osg::Vec3d(1.0/_scale.x(),1.0/_scale.y(),1.0/_scale.z()));
+                matrix.preMultTranslate(-_position);
             }
 

OpenSceneGraph/trunk/include/osg/Matrixd

@@ -348 +348 @@
         void postMult( const Matrixd& );
 
+        /** Optimized version of preMult(translate(v)); */
+        inline void preMultTranslate( const Vec3d& v );
+        inline void preMultTranslate( const Vec3f& v );
+        /** Optimized version of postMult(translate(v)); */
+        inline void postMultTranslate( const Vec3d& v );
+        inline void postMultTranslate( const Vec3f& v );
+
+        /** Optimized version of preMult(scale(v)); */
+        inline void preMultScale( const Vec3d& v );
+        inline void preMultScale( const Vec3f& v );
+        /** Optimized version of postMult(scale(v)); */
+        inline void postMultScale( const Vec3d& v );
+        inline void postMultScale( const Vec3f& v );
+
+        /** Optimized version of preMult(rotate(q)); */
+        inline void preMultRotate( const Quat& q );
+        /** Optimized version of postMult(rotate(q)); */
+        inline void postMultRotate( const Quat& q );
+
         inline void operator *= ( const Matrixd& other ) 
         {    if( this == &other ) {
@@ -648 +667 @@
 }
 
+inline void Matrixd::preMultTranslate( const Vec3d& v )
+{
+    for (unsigned i = 0; i < 3; ++i)
+    {
+        double tmp = v[i];
+        if (tmp == 0)
+            continue;
+        _mat[3][0] += tmp*_mat[i][0];
+        _mat[3][1] += tmp*_mat[i][1];
+        _mat[3][2] += tmp*_mat[i][2];
+        _mat[3][3] += tmp*_mat[i][3];
+    }
+}
+
+inline void Matrixd::preMultTranslate( const Vec3f& v )
+{
+    for (unsigned i = 0; i < 3; ++i)
+    {
+        float tmp = v[i];
+        if (tmp == 0)
+            continue;
+        _mat[3][0] += tmp*_mat[i][0];
+        _mat[3][1] += tmp*_mat[i][1];
+        _mat[3][2] += tmp*_mat[i][2];
+        _mat[3][3] += tmp*_mat[i][3];
+    }
+}
+
+inline void Matrixd::postMultTranslate( const Vec3d& v )
+{
+    for (unsigned i = 0; i < 3; ++i)
+    {
+        double tmp = v[i];
+        if (tmp == 0)
+            continue;
+        _mat[0][i] += tmp*_mat[0][3];
+        _mat[1][i] += tmp*_mat[1][3];
+        _mat[2][i] += tmp*_mat[2][3];
+        _mat[3][i] += tmp*_mat[3][3];
+    }
+}
+
+inline void Matrixd::postMultTranslate( const Vec3f& v )
+{
+    for (unsigned i = 0; i < 3; ++i)
+    {
+        float tmp = v[i];
+        if (tmp == 0)
+            continue;
+        _mat[0][i] += tmp*_mat[0][3];
+        _mat[1][i] += tmp*_mat[1][3];
+        _mat[2][i] += tmp*_mat[2][3];
+        _mat[3][i] += tmp*_mat[3][3];
+    }
+}
+
+inline void Matrixd::preMultScale( const Vec3d& v )
+{
+    _mat[0][0] *= v[0]; _mat[0][1] *= v[0]; _mat[0][2] *= v[0]; _mat[0][3] *= v[0];
+    _mat[1][0] *= v[1]; _mat[1][1] *= v[1]; _mat[1][2] *= v[1]; _mat[1][3] *= v[1];
+    _mat[2][0] *= v[2]; _mat[2][1] *= v[2]; _mat[2][2] *= v[2]; _mat[2][3] *= v[2];
+}
+
+inline void Matrixd::preMultScale( const Vec3f& v )
+{
+    _mat[0][0] *= v[0]; _mat[0][1] *= v[0]; _mat[0][2] *= v[0]; _mat[0][3] *= v[0];
+    _mat[1][0] *= v[1]; _mat[1][1] *= v[1]; _mat[1][2] *= v[1]; _mat[1][3] *= v[1];
+    _mat[2][0] *= v[2]; _mat[2][1] *= v[2]; _mat[2][2] *= v[2]; _mat[2][3] *= v[2];
+}
+
+inline void Matrixd::postMultScale( const Vec3d& v )
+{
+    _mat[0][0] *= v[0]; _mat[1][0] *= v[0]; _mat[2][0] *= v[0]; _mat[3][0] *= v[0];
+    _mat[0][1] *= v[1]; _mat[1][1] *= v[1]; _mat[2][1] *= v[1]; _mat[3][1] *= v[1];
+    _mat[0][2] *= v[2]; _mat[1][2] *= v[2]; _mat[2][2] *= v[2]; _mat[3][2] *= v[2];
+}
+
+inline void Matrixd::postMultScale( const Vec3f& v )
+{
+    _mat[0][0] *= v[0]; _mat[1][0] *= v[0]; _mat[2][0] *= v[0]; _mat[3][0] *= v[0];
+    _mat[0][1] *= v[1]; _mat[1][1] *= v[1]; _mat[2][1] *= v[1]; _mat[3][1] *= v[1];
+    _mat[0][2] *= v[2]; _mat[1][2] *= v[2]; _mat[2][2] *= v[2]; _mat[3][2] *= v[2];
+}
+
+inline void Matrixd::preMultRotate( const Quat& q )
+{
+    if (q.zeroRotation())
+        return;
+    Matrixd r;
+    r.setRotate(q);
+    preMult(r);
+}
+
+inline void Matrixd::postMultRotate( const Quat& q )
+{
+    if (q.zeroRotation())
+        return;
+    Matrixd r;
+    r.setRotate(q);
+    postMult(r);
+}
+
 inline Vec3f operator* (const Vec3f& v, const Matrixd& m )
 {

OpenSceneGraph/trunk/include/osg/Matrixf

@@ -350 +350 @@
         void postMult( const Matrixf& );
 
+        /** Optimized version of preMult(translate(v)); */
+        inline void preMultTranslate( const Vec3d& v );
+        inline void preMultTranslate( const Vec3f& v );
+        /** Optimized version of postMult(translate(v)); */
+        inline void postMultTranslate( const Vec3d& v );
+        inline void postMultTranslate( const Vec3f& v );
+
+        /** Optimized version of preMult(scale(v)); */
+        inline void preMultScale( const Vec3d& v );
+        inline void preMultScale( const Vec3f& v );
+        /** Optimized version of postMult(scale(v)); */
+        inline void postMultScale( const Vec3d& v );
+        inline void postMultScale( const Vec3f& v );
+
+        /** Optimized version of preMult(rotate(q)); */
+        inline void preMultRotate( const Quat& q );
+        /** Optimized version of postMult(rotate(q)); */
+        inline void postMultRotate( const Quat& q );
+
         inline void operator *= ( const Matrixf& other ) 
         {    if( this == &other ) {
@@ -642 +661 @@
 }
 
+inline void Matrixf::preMultTranslate( const Vec3d& v )
+{
+    for (unsigned i = 0; i < 3; ++i)
+    {
+        double tmp = v[i];
+        if (tmp == 0)
+            continue;
+        _mat[3][0] += tmp*_mat[i][0];
+        _mat[3][1] += tmp*_mat[i][1];
+        _mat[3][2] += tmp*_mat[i][2];
+        _mat[3][3] += tmp*_mat[i][3];
+    }
+}
+
+inline void Matrixf::preMultTranslate( const Vec3f& v )
+{
+    for (unsigned i = 0; i < 3; ++i)
+    {
+        float tmp = v[i];
+        if (tmp == 0)
+            continue;
+        _mat[3][0] += tmp*_mat[i][0];
+        _mat[3][1] += tmp*_mat[i][1];
+        _mat[3][2] += tmp*_mat[i][2];
+        _mat[3][3] += tmp*_mat[i][3];
+    }
+}
+
+inline void Matrixf::postMultTranslate( const Vec3d& v )
+{
+    for (unsigned i = 0; i < 3; ++i)
+    {
+        double tmp = v[i];
+        if (tmp == 0)
+            continue;
+        _mat[0][i] += tmp*_mat[0][3];
+        _mat[1][i] += tmp*_mat[1][3];
+        _mat[2][i] += tmp*_mat[2][3];
+        _mat[3][i] += tmp*_mat[3][3];
+    }
+}
+
+inline void Matrixf::postMultTranslate( const Vec3f& v )
+{
+    for (unsigned i = 0; i < 3; ++i)
+    {
+        float tmp = v[i];
+        if (tmp == 0)
+            continue;
+        _mat[0][i] += tmp*_mat[0][3];
+        _mat[1][i] += tmp*_mat[1][3];
+        _mat[2][i] += tmp*_mat[2][3];
+        _mat[3][i] += tmp*_mat[3][3];
+    }
+}
+
+inline void Matrixf::preMultScale( const Vec3d& v )
+{
+    _mat[0][0] *= v[0]; _mat[0][1] *= v[0]; _mat[0][2] *= v[0]; _mat[0][3] *= v[0];
+    _mat[1][0] *= v[1]; _mat[1][1] *= v[1]; _mat[1][2] *= v[1]; _mat[1][3] *= v[1];
+    _mat[2][0] *= v[2]; _mat[2][1] *= v[2]; _mat[2][2] *= v[2]; _mat[2][3] *= v[2];
+}
+
+inline void Matrixf::preMultScale( const Vec3f& v )
+{
+    _mat[0][0] *= v[0]; _mat[0][1] *= v[0]; _mat[0][2] *= v[0]; _mat[0][3] *= v[0];
+    _mat[1][0] *= v[1]; _mat[1][1] *= v[1]; _mat[1][2] *= v[1]; _mat[1][3] *= v[1];
+    _mat[2][0] *= v[2]; _mat[2][1] *= v[2]; _mat[2][2] *= v[2]; _mat[2][3] *= v[2];
+}
+
+inline void Matrixf::postMultScale( const Vec3d& v )
+{
+    _mat[0][0] *= v[0]; _mat[1][0] *= v[0]; _mat[2][0] *= v[0]; _mat[3][0] *= v[0];
+    _mat[0][1] *= v[1]; _mat[1][1] *= v[1]; _mat[2][1] *= v[1]; _mat[3][1] *= v[1];
+    _mat[0][2] *= v[2]; _mat[1][2] *= v[2]; _mat[2][2] *= v[2]; _mat[3][2] *= v[2];
+}
+
+inline void Matrixf::postMultScale( const Vec3f& v )
+{
+    _mat[0][0] *= v[0]; _mat[1][0] *= v[0]; _mat[2][0] *= v[0]; _mat[3][0] *= v[0];
+    _mat[0][1] *= v[1]; _mat[1][1] *= v[1]; _mat[2][1] *= v[1]; _mat[3][1] *= v[1];
+    _mat[0][2] *= v[2]; _mat[1][2] *= v[2]; _mat[2][2] *= v[2]; _mat[3][2] *= v[2];
+}
+
+
+inline void Matrixf::preMultRotate( const Quat& q )
+{
+    if (q.zeroRotation())
+        return;
+    Matrixf r;
+    r.setRotate(q);
+    preMult(r);
+}
+
+inline void Matrixf::postMultRotate( const Quat& q )
+{
+    if (q.zeroRotation())
+        return;
+    Matrixf r;
+    r.setRotate(q);
+    postMult(r);
+}
 
 inline Vec3f operator* (const Vec3f& v, const Matrixf& m )

OpenSceneGraph/trunk/src/osg/AutoTransform.cpp

@@ -84 +84 @@
 bool AutoTransform::computeWorldToLocalMatrix(Matrix& matrix,NodeVisitor*) const
 {
+    if (_scale.x() == 0.0 || _scale.y() == 0.0 || _scale.z() == 0.0)
+        return false;
+
     if (_referenceFrame==RELATIVE_RF)
     {
-        matrix.postMult(osg::Matrix::translate(-_position)*
-                        osg::Matrix::rotate(_rotation.inverse())*
-                        osg::Matrix::scale(1.0/_scale.x(),1.0/_scale.y(),1.0/_scale.z())*
-                        osg::Matrix::translate(_pivotPoint));
+        matrix.postMultTranslate(-_position);
+        matrix.postMultRotate(_rotation.inverse());
+        matrix.postMultScale(Vec3d(1.0/_scale.x(), 1.0/_scale.y(), 1.0/_scale.z()));
+        matrix.postMultTranslate(_pivotPoint);
     }
     else // absolute
     {
-        matrix = osg::Matrix::translate(-_position)*
-                 osg::Matrix::rotate(_rotation.inverse())*
-                 osg::Matrix::scale(1.0/_scale.x(),1.0/_scale.y(),1.0/_scale.z())*
-                 osg::Matrix::translate(_pivotPoint);
+        matrix.makeRotate(_rotation.inverse());
+        matrix.preMultTranslate(-_position);
+        matrix.postMultScale(Vec3d(1.0/_scale.x(), 1.0/_scale.y(), 1.0/_scale.z()));
+        matrix.postMultTranslate(_pivotPoint);
     }
     return true;
@@ -105 +108 @@
     if (!_matrixDirty) return;
     
-    _cachedMatrix.set(osg::Matrix::translate(-_pivotPoint)*
-                      osg::Matrix::scale(_scale)*
-                      osg::Matrix::rotate(_rotation)*
-                      osg::Matrix::translate(_position));
+    _cachedMatrix.makeRotate(_rotation);
+    _cachedMatrix.postMultTranslate(_position);
+    _cachedMatrix.preMultScale(_scale);
+    _cachedMatrix.preMultTranslate(-_pivotPoint);
     
     _matrixDirty = false;

OpenSceneGraph/trunk/src/osg/CameraView.cpp

@@ -26 +26 @@
     if (_referenceFrame==RELATIVE_RF)
     {
-        matrix.preMult(osg::Matrix::rotate(_attitude)*
-                       osg::Matrix::translate(_position));
+        matrix.preMultTranslate(_position);
+        matrix.preMultRotate(_attitude);
     }
     else // absolute
     {
-        matrix = osg::Matrix::rotate(_attitude)*
-                 osg::Matrix::translate(_position);
+        matrix.makeRotate(_attitude);
+        matrix.postMultTranslate(_position);
     }
     return true;
@@ -42 +42 @@
     if (_referenceFrame==RELATIVE_RF)
     {
-        matrix.postMult(osg::Matrix::translate(-_position)*
-                        osg::Matrix::rotate(_attitude.inverse()));
+        matrix.postMultTranslate(-_position);
+        matrix.postMultRotate(_attitude.inverse());
     }
     else // absolute
     {
-        matrix = osg::Matrix::translate(-_position)*
-                 osg::Matrix::rotate(_attitude.inverse());
+        matrix.makeRotate(_attitude.inverse());
+        matrix.preMultTranslate(-_position);
     }
     return true;

OpenSceneGraph/trunk/src/osg/Matrix_implementation.cpp

@@ -19 +19 @@
 #include <osg/GL>
 
+#include <limits>
 #include <stdlib.h>
 
@@ -63 +64 @@
 #define QW  q._v[3]
 
-void Matrix_implementation::setRotate(const Quat& q_in)
-{
-    Quat q(q_in);
+void Matrix_implementation::setRotate(const Quat& q)
+{
     double length2 = q.length2();
-    if (length2!=1.0 && length2!=0)
-    {
+    if (fabs(length2) <= std::numeric_limits<double>::min())
+    {
+        _mat[0][0] = 0.0; _mat[1][0] = 0.0; _mat[2][0] = 0.0;
+        _mat[0][1] = 0.0; _mat[1][1] = 0.0; _mat[2][1] = 0.0;
+        _mat[0][2] = 0.0; _mat[1][2] = 0.0; _mat[2][2] = 0.0;
+    }
+    else
+    {
+        double rlength2;
         // normalize quat if required.
-        q /= sqrt(length2);
-    }
-
-    // Source: Gamasutra, Rotating Objects Using Quaternions
-    //
-    //http://www.gamasutra.com/features/19980703/quaternions_01.htm
-
-    double wx, wy, wz, xx, yy, yz, xy, xz, zz, x2, y2, z2;
-
-    // calculate coefficients
-    x2 = QX + QX;
-    y2 = QY + QY;
-    z2 = QZ + QZ;
-
-    xx = QX * x2;
-    xy = QX * y2;
-    xz = QX * z2;
-
-    yy = QY * y2;
-    yz = QY * z2;
-    zz = QZ * z2;
-
-    wx = QW * x2;
-    wy = QW * y2;
-    wz = QW * z2;
-
-    // Note.  Gamasutra gets the matrix assignments inverted, resulting
-    // in left-handed rotations, which is contrary to OpenGL and OSG's 
-    // methodology.  The matrix assignment has been altered in the next
-    // few lines of code to do the right thing.
-    // Don Burns - Oct 13, 2001
-    _mat[0][0] = 1.0 - (yy + zz);
-    _mat[1][0] = xy - wz;
-    _mat[2][0] = xz + wy;
-
-
-    _mat[0][1] = xy + wz;
-    _mat[1][1] = 1.0 - (xx + zz);
-    _mat[2][1] = yz - wx;
-
-    _mat[0][2] = xz - wy;
-    _mat[1][2] = yz + wx;
-    _mat[2][2] = 1.0 - (xx + yy);
+        // We can avoid the expensive sqrt in this case since all 'coefficients' below are products of two q components.
+        // That is a square of a square root, so it is possible to avoid that
+        if (length2 != 1.0)
+        {
+            rlength2 = 2.0/length2;
+        }
+        else
+        {
+            rlength2 = 2.0;
+        }
+        
+        // Source: Gamasutra, Rotating Objects Using Quaternions
+        //
+        //http://www.gamasutra.com/features/19980703/quaternions_01.htm
+        
+        double wx, wy, wz, xx, yy, yz, xy, xz, zz, x2, y2, z2;
+        
+        // calculate coefficients
+        x2 = rlength2*QX;
+        y2 = rlength2*QY;
+        z2 = rlength2*QZ;
+        
+        xx = QX * x2;
+        xy = QX * y2;
+        xz = QX * z2;
+        
+        yy = QY * y2;
+        yz = QY * z2;
+        zz = QZ * z2;
+        
+        wx = QW * x2;
+        wy = QW * y2;
+        wz = QW * z2;
+        
+        // Note.  Gamasutra gets the matrix assignments inverted, resulting
+        // in left-handed rotations, which is contrary to OpenGL and OSG's 
+        // methodology.  The matrix assignment has been altered in the next
+        // few lines of code to do the right thing.
+        // Don Burns - Oct 13, 2001
+        _mat[0][0] = 1.0 - (yy + zz);
+        _mat[1][0] = xy - wz;
+        _mat[2][0] = xz + wy;
+        
+        
+        _mat[0][1] = xy + wz;
+        _mat[1][1] = 1.0 - (xx + zz);
+        _mat[2][1] = yz - wx;
+        
+        _mat[0][2] = xz - wy;
+        _mat[1][2] = yz + wx;
+        _mat[2][2] = 1.0 - (xx + yy);
+    }
 
 #if 0
@@ -904 +920 @@
         0.0,     0.0,     0.0,      1.0);
 
-    preMult(Matrix_implementation::translate(-eye));
+    preMultTranslate(-eye);
 }
 

OpenSceneGraph/trunk/src/osg/PositionAttitudeTransform.cpp

@@ -16 +16 @@
 
 PositionAttitudeTransform::PositionAttitudeTransform():
-    _scale(1.0f,1.0f,1.0f)
+    _scale(1.0,1.0,1.0)
 {
 }
@@ -24 +24 @@
     if (_referenceFrame==RELATIVE_RF)
     {
-        matrix.preMult(osg::Matrix::translate(-_pivotPoint)*
-                       osg::Matrix::scale(_scale)*
-                       osg::Matrix::rotate(_attitude)*
-                       osg::Matrix::translate(_position));
+        matrix.preMultTranslate(_position);
+        matrix.preMultRotate(_attitude);
+        matrix.preMultScale(_scale);
+        matrix.preMultTranslate(-_pivotPoint);
     }
     else // absolute
     {
-        matrix = osg::Matrix::translate(-_pivotPoint)*
-                 osg::Matrix::scale(_scale)*
-                 osg::Matrix::rotate(_attitude)*
-                 osg::Matrix::translate(_position);
+        matrix.makeRotate(_attitude);
+        matrix.postMultTranslate(_position);
+        matrix.preMultScale(_scale);
+        matrix.preMultTranslate(-_pivotPoint);
     }
     return true;
@@ -42 +42 @@
 bool PositionAttitudeTransform::computeWorldToLocalMatrix(Matrix& matrix,NodeVisitor*) const
 {
+    if (_scale.x() == 0.0 || _scale.y() == 0.0 || _scale.z() == 0.0)
+        return false;
+
     if (_referenceFrame==RELATIVE_RF)
     {
-        matrix.postMult(osg::Matrix::translate(-_position)*
-                        osg::Matrix::rotate(_attitude.inverse())*
-                        osg::Matrix::scale(1.0f/_scale.x(),1.0f/_scale.y(),1.0f/_scale.z())*
-                        osg::Matrix::translate(_pivotPoint));
+        matrix.postMultTranslate(-_position);
+        matrix.postMultRotate(_attitude.inverse());
+        matrix.postMultScale(Vec3d(1.0/_scale.x(), 1.0/_scale.y(), 1.0/_scale.z()));
+        matrix.postMultTranslate(_pivotPoint);
     }
     else // absolute
     {
-        matrix = osg::Matrix::translate(-_position)*
-                 osg::Matrix::rotate(_attitude.inverse())*
-                 osg::Matrix::scale(1.0f/_scale.x(),1.0f/_scale.y(),1.0f/_scale.z())*
-                 osg::Matrix::translate(_pivotPoint);
+        matrix.makeRotate(_attitude.inverse());
+        matrix.preMultTranslate(-_position);
+        matrix.postMultScale(Vec3d(1.0/_scale.x(), 1.0/_scale.y(), 1.0/_scale.z()));
+        matrix.postMultTranslate(_pivotPoint);
     }
     return true;

OpenSceneGraph/trunk/src/osgManipulator/AntiSquish.cpp

@@ -117 +117 @@
     if (_usePivot)
     {
-        osg::Matrix tmpPivot;
-        tmpPivot.setTrans(-_pivot);
-        unsquished.postMult(tmpPivot);
+        unsquished.postMultTranslate(-_pivot);
 
         osg::Matrix tmps, invtmps;
         so.get(tmps);
-        invtmps = osg::Matrix::inverse(tmps);
-        if (invtmps.isNaN())
-        {
+        if (!invtmps.invert(tmps))
+        {
             flag = false;
             return osg::Matrix::identity();
@@ -133 +130 @@
         unsquished.postMult(invtmps);
         //S
-        unsquished.postMult(osg::Matrix::scale(s[0], s[1], s[2]));
+        unsquished.postMultScale(s);
         //SO
         unsquished.postMult(tmps);
-        tmpPivot.makeIdentity();
-        osg::Matrix tmpr;
-        r.get(tmpr);
         //R
-        unsquished.postMult(tmpr);
+        unsquished.postMultRotate(r);
         //T
-        unsquished.postMult(osg::Matrix::translate(t[0],t[1],t[2]));
+        unsquished.postMultTranslate(t);
 
         osg::Matrix invltw;
-        invltw = osg::Matrix::inverse(LTW);
-        if (invltw.isNaN())
-        {
-            flag =false;
+        if (!invltw.invert(LTW))
+        {
+            flag = false;
             return osg::Matrix::identity();
         }
@@ -155 +148 @@
 
         // Position
-        tmpPivot.makeIdentity();
         if (_usePosition)
-            tmpPivot.setTrans(_position);
+            unsquished.postMult(_position);
         else
-            tmpPivot.setTrans(_pivot);
-
-        unsquished.postMult(tmpPivot); 
+            unsquished.postMult(_pivot);
     }
     else
@@ -167 +157 @@
         osg::Matrix tmps, invtmps;
         so.get(tmps);
-        invtmps = osg::Matrix::inverse(tmps);
+        if (!invtmps.invert(tmps))
+        {
+            flag = false;
+            return osg::Matrix::identity();
+        }
         unsquished.postMult(invtmps);
-        unsquished.postMult(osg::Matrix::scale(s[0], s[1], s[2]));
+        unsquished.postMultScale(s);
         unsquished.postMult(tmps);
-        osg::Matrix tmpr;
-        r.get(tmpr);
-        unsquished.postMult(tmpr);
-        unsquished.postMult(osg::Matrix::translate(t[0],t[1],t[2]));
-        unsquished.postMult( osg::Matrix::inverse(LTW) );
+        unsquished.postMultRotate(r);
+        unsquished.postMultTranslate(t);
+        osg::Matrix invltw;
+        if (!invltw.invert(LTW))
+        {
+            flag = false;
+            return osg::Matrix::identity();
+        }
+        unsquished.postMult( invltw );
     }
 

OpenSceneGraph/trunk/src/osgParticle/PrecipitationEffect.cpp

@@ -838 +838 @@
 
     *mymodelview = *(cv->getModelViewMatrix());
-    mymodelview->preMult(osg::Matrix::translate(position));
-    mymodelview->preMult(osg::Matrix::scale(scale));
+    mymodelview->preMultTranslate(position);
+    mymodelview->preMultScale(scale);
     
     cv->updateCalculatedNearFar(*(cv->getModelViewMatrix()),bb);

OpenSceneGraph/trunk/src/osgSim/DOFTransform.cpp

@@ -133 +133 @@
 
     //and scale:
-    current.preMult(osg::Matrix::scale(getCurrentScale()));
+    current.preMultScale(getCurrentScale());
 
     l2w.postMult(current);
@@ -202 +202 @@
 
     //and scale:
-    current.postMult(osg::Matrix::scale(1./getCurrentScale()[0], 1./getCurrentScale()[1], 1./getCurrentScale()[2]));
+    current.postMultScale(osg::Vec3d(1./getCurrentScale()[0], 1./getCurrentScale()[1], 1./getCurrentScale()[2]));
 
     w2l.postMult(current);

OpenSceneGraph/trunk/src/osgSim/Sector.cpp

@@ -235 +235 @@
   double roll    = _rollAngle;
 
-  _local_to_LP = osg::Matrixd::identity();
-  _local_to_LP.preMult(osg::Matrix::rotate(heading, 0.0, 0.0, -1.0));
-  _local_to_LP.preMult(osg::Matrix::rotate(pitch, 1.0, 0.0, 0.0));
-  _local_to_LP.preMult(osg::Matrix::rotate(roll, 0.0, 1.0, 0.0));
+  _local_to_LP.setRotate(osg::Quat(heading, 0.0, 0.0, -1.0));
+  _local_to_LP.preMultRotate(osg::Quat(pitch, 1.0, 0.0, 0.0));
+  _local_to_LP.preMultRotate(osg::Quat(roll, 0.0, 1.0, 0.0));
 }
 

OpenSceneGraph/trunk/src/osgText/Text.cpp

@@ -641 +641 @@
         }
 
-        if (!_rotation.zeroRotation() )
-        {
-            matrix.postMult(osg::Matrix::rotate(_rotation));
-        }
+        matrix.postMultRotate(_rotation);
 
         if (_characterSizeMode!=OBJECT_COORDS)
         {
 
-            osg::Matrix M(rotate_matrix*osg::Matrix::translate(_position)*atc._modelview);
+            osg::Matrix M(rotate_matrix);
+            M.postMultTranslate(_position);
+            M.postMult(atc._modelview);
             osg::Matrix& P = atc._projection;
             
@@ -694 +693 @@
                 if (P10<0)
                    scale_font_vert=-scale_font_vert;
-                matrix.postMult(osg::Matrix::scale(scale_font_hori, scale_font_vert,1.0f));
+                matrix.postMultScale(osg::Vec3f(scale_font_hori, scale_font_vert,1.0f));
             }
             else if (pixelSizeVert>getFontHeight())
             {
                 float scale_font = getFontHeight()/pixelSizeVert;
-                matrix.postMult(osg::Matrix::scale(scale_font, scale_font,1.0f));
+                matrix.postMultScale(osg::Vec3f(scale_font, scale_font,1.0f));
             }
 
@@ -709 +708 @@
         }
 
-        matrix.postMult(osg::Matrix::translate(_position));
+        matrix.postMultTranslate(_position);
     }
     else if (!_rotation.zeroRotation())
     {
-        matrix.makeTranslate(-_offset);
-        matrix.postMult(osg::Matrix::rotate(_rotation));
-        matrix.postMult(osg::Matrix::translate(_position));
+        matrix.makeRotate(_rotation);
+        matrix.preMultTranslate(-_offset);
+        matrix.postMultTranslate(_position);
     }
     else

OpenSceneGraph/trunk/src/osgText/Text3D.cpp

@@ -458 +458 @@
     
     float scale = _font->getScale();
-    osg::Matrix scaleMatrix = osg::Matrix::scale(scale * _characterHeight, 
-                                                 scale * _characterHeight / _characterAspectRatio, 
-                                                 _characterDepth);
-    if (!_rotation.zeroRotation())
-    {
-        matrix.makeTranslate(-_offset);
-        matrix.postMult(scaleMatrix);
-        matrix.postMult(osg::Matrix::rotate(_rotation));
-        matrix.postMult(osg::Matrix::translate(_position));
-    }
-    else
-    {
-        matrix.makeTranslate(-_offset);
-        matrix.postMult(scaleMatrix);
-        matrix.postMult(osg::Matrix::translate(_position));
-    }
+    osg::Vec3 scaleVec(scale * _characterHeight, scale * _characterHeight / _characterAspectRatio, _characterDepth);
+    matrix.makeTranslate(-_offset);
+    matrix.postMultScale(scaleVec);
+    matrix.postMultRotate(_rotation);
+    matrix.postMultTranslate(_position);
 
     

OpenSceneGraph/trunk/src/osgUtil/SceneGraphBuilder.cpp

@@ -87 +87 @@
 {
     if (_matrixStack.empty()) _matrixStack.push_back(osg::Matrixd());
-    _matrixStack.back().preMult(osg::Matrixd::translate(x,y,z));
+    _matrixStack.back().preMultTranslate(osg::Vec3d(x,y,z));
 
     matrixChanged();
@@ -95 +95 @@
 {
     if (_matrixStack.empty()) _matrixStack.push_back(osg::Matrixd());
-    _matrixStack.back().preMult(osg::Matrixd::scale(x,y,z));
+    _matrixStack.back().preMultScale(osg::Vec3d(x,y,z));
 
     matrixChanged();
@@ -103 +103 @@
 {
     if (_matrixStack.empty()) _matrixStack.push_back(osg::Matrixd());
-    _matrixStack.back().preMult(osg::Matrixd::rotate(osg::inDegrees(angle),x,y,z));
+    _matrixStack.back().preMultRotate(osg::Quat(osg::inDegrees(angle),osg::Vec3d(x,y,z)));
 
     matrixChanged();

OpenSceneGraph/trunk/src/osgViewer/View.cpp

@@ -97 +97 @@
                 y = osg::Matrixd::transform3x3(y,coordinateFrame);
                 z = osg::Matrixd::transform3x3(z,coordinateFrame);
-                coordinateFrame.preMult(osg::Matrixd::scale(1.0/x.length(),1.0/y.length(),1.0/z.length()));
+                coordinateFrame.preMultScale(osg::Vec3d(1.0/x.length(),1.0/y.length(),1.0/z.length()));
 
                 // reapply the position.