Added support for Matrixd and Matrixf implementations, with the default
Matrix typedef's to either Matrixd or Matrixf.
This commit is contained in:
Robert Osfield
@@ -74,14 +74,14 @@ class SG_EXPORT AnimationPath : public virtual osg::Object
|
||||
inline void getMatrix(Matrix& matrix) const
|
||||
{
|
||||
matrix.makeScale(_scale);
|
||||
matrix.postMult(_rotation.getMatrix());
|
||||
matrix.postMult(osg::Matrix::rotate(_rotation));
|
||||
matrix.postMult(osg::Matrix::translate(_position));
|
||||
}
|
||||
|
||||
inline void getInverse(Matrix& matrix) const
|
||||
{
|
||||
matrix.makeScale(1.0f/_scale.x(),1.0f/_scale.y(),1.0f/_scale.y());
|
||||
matrix.postMult(_rotation.inverse().getMatrix());
|
||||
matrix.postMult(osg::Matrix::rotate(_rotation.inverse()));
|
||||
matrix.postMult(osg::Matrix::translate(-_position));
|
||||
}
|
||||
};
|
||||
|
||||
@@ -90,4 +90,10 @@
|
||||
|
||||
#endif // WIN32
|
||||
|
||||
inline void glLoadMatrix(const float* mat) { glLoadMatrixf((GLfloat*)mat); }
|
||||
inline void glLoadMatrix(const double* mat) { glLoadMatrixd((GLdouble*)mat); }
|
||||
inline void glMultMatrix(const float* mat) { glMultMatrixf((GLfloat*)mat); }
|
||||
inline void glMultMatrix(const double* mat) { glMultMatrixd((GLdouble*)mat); }
|
||||
|
||||
|
||||
#endif // __osgGL_h
|
||||
|
||||
@@ -14,454 +14,14 @@
|
||||
#ifndef OSG_MATRIX
|
||||
#define OSG_MATRIX 1
|
||||
|
||||
#include <osg/Object>
|
||||
#include <osg/Vec3>
|
||||
#include <osg/Vec4>
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <osg/Matrixd>
|
||||
#include <osg/Matrixf>
|
||||
|
||||
namespace osg {
|
||||
|
||||
class Quat;
|
||||
|
||||
class SG_EXPORT Matrix
|
||||
{
|
||||
|
||||
public:
|
||||
|
||||
typedef float value_type;
|
||||
|
||||
inline Matrix() { makeIdentity(); }
|
||||
inline Matrix( const Matrix& other) { set(other.ptr()); }
|
||||
inline explicit Matrix( float const * const ptr ) { set(ptr); }
|
||||
inline explicit Matrix( double const * const ptr ) { set(ptr); }
|
||||
|
||||
Matrix( value_type a00, value_type a01, value_type a02, value_type a03,
|
||||
value_type a10, value_type a11, value_type a12, value_type a13,
|
||||
value_type a20, value_type a21, value_type a22, value_type a23,
|
||||
value_type a30, value_type a31, value_type a32, value_type a33);
|
||||
|
||||
~Matrix() {}
|
||||
|
||||
int compare(const Matrix& m) const { return memcmp(_mat,m._mat,sizeof(_mat)); }
|
||||
|
||||
bool operator < (const Matrix& m) const { return compare(m)<0; }
|
||||
bool operator == (const Matrix& m) const { return compare(m)==0; }
|
||||
bool operator != (const Matrix& m) const { return compare(m)!=0; }
|
||||
|
||||
inline value_type& operator()(int row, int col) { return _mat[row][col]; }
|
||||
inline value_type operator()(int row, int col) const { return _mat[row][col]; }
|
||||
|
||||
inline bool valid() const { return !isNaN(); }
|
||||
inline bool isNaN() const { return osg::isNaN(_mat[0][0]) || osg::isNaN(_mat[0][1]) || osg::isNaN(_mat[0][2]) || osg::isNaN(_mat[0][3]) ||
|
||||
osg::isNaN(_mat[1][0]) || osg::isNaN(_mat[1][1]) || osg::isNaN(_mat[1][2]) || osg::isNaN(_mat[1][3]) ||
|
||||
osg::isNaN(_mat[2][0]) || osg::isNaN(_mat[2][1]) || osg::isNaN(_mat[2][2]) || osg::isNaN(_mat[2][3]) ||
|
||||
osg::isNaN(_mat[3][0]) || osg::isNaN(_mat[3][1]) || osg::isNaN(_mat[3][2]) || osg::isNaN(_mat[3][3]); }
|
||||
|
||||
inline Matrix& operator = (const Matrix& other)
|
||||
{
|
||||
if( &other == this ) return *this;
|
||||
set(other.ptr());
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline void set(const Matrix& other)
|
||||
{
|
||||
set(other.ptr());
|
||||
}
|
||||
|
||||
inline void set(float const * const ptr)
|
||||
{
|
||||
std::copy(ptr,ptr+16,(value_type*)_mat);
|
||||
}
|
||||
|
||||
inline void set(double const * const ptr)
|
||||
{
|
||||
std::copy(ptr,ptr+16,(value_type*)_mat);
|
||||
}
|
||||
|
||||
void set( value_type a00, value_type a01, value_type a02, value_type a03,
|
||||
value_type a10, value_type a11, value_type a12, value_type a13,
|
||||
value_type a20, value_type a21, value_type a22, value_type a23,
|
||||
value_type a30, value_type a31, value_type a32, value_type a33);
|
||||
|
||||
value_type * ptr() { return (value_type*)_mat; }
|
||||
const value_type * ptr() const { return (const value_type *)_mat; }
|
||||
|
||||
void makeIdentity();
|
||||
|
||||
void makeScale( const Vec3& );
|
||||
void makeScale( value_type, value_type, value_type );
|
||||
|
||||
void makeTranslate( const Vec3& );
|
||||
void makeTranslate( value_type, value_type, value_type );
|
||||
|
||||
void makeRotate( const Vec3& from, const Vec3& to );
|
||||
void makeRotate( float angle, const Vec3& axis );
|
||||
void makeRotate( float angle, float x, float y, float z );
|
||||
void makeRotate( const Quat& );
|
||||
void makeRotate( float angle1, const Vec3& axis1,
|
||||
float angle2, const Vec3& axis2,
|
||||
float angle3, const Vec3& axis3);
|
||||
|
||||
|
||||
|
||||
/** Set to a orthographic projection. See glOrtho for further details.*/
|
||||
void makeOrtho(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Get the othorgraphic settings of the orthographic projection matrix.
|
||||
* Note, if matrix is not an orthographic matrix then invalid values will be returned.*/
|
||||
void getOrtho(double& left, double& right,
|
||||
double& bottom, double& top,
|
||||
double& zNear, double& zFar);
|
||||
|
||||
/** Set to a 2D orthographic projection. See glOrtho2D for further details.*/
|
||||
inline void makeOrtho2D(double left, double right,
|
||||
double bottom, double top)
|
||||
{
|
||||
makeOrtho(left,right,bottom,top,-1.0,1.0);
|
||||
}
|
||||
|
||||
|
||||
/** Set to a perspective projection. See glFrustum for further details.*/
|
||||
void makeFrustum(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Get the frustum setting of a perspective projection matrix.
|
||||
* Note, if matrix is not an perspective matrix then invalid values will be returned.*/
|
||||
void getFrustum(double& left, double& right,
|
||||
double& bottom, double& top,
|
||||
double& zNear, double& zFar);
|
||||
|
||||
/** Set to a symmetrical perspective projection, See gluPerspective for further details.
|
||||
* Aspect ratio is defined as width/height.*/
|
||||
void makePerspective(double fovy,double aspectRatio,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Set to the position and orientation modelview matrix, using the same convention as gluLookAt. */
|
||||
void makeLookAt(const Vec3& eye,const Vec3& center,const Vec3& up);
|
||||
|
||||
/** Get to the position and orientation of a modelview matrix, using the same convention as gluLookAt. */
|
||||
void getLookAt(Vec3& eye,Vec3& center,Vec3& up,float lookDistance=1.0f);
|
||||
|
||||
bool invert( const Matrix& );
|
||||
|
||||
//basic utility functions to create new matrices
|
||||
inline static Matrix identity( void );
|
||||
inline static Matrix scale( const Vec3& sv);
|
||||
inline static Matrix scale( value_type sx, value_type sy, value_type sz);
|
||||
inline static Matrix translate( const Vec3& dv);
|
||||
inline static Matrix translate( value_type x, value_type y, value_type z);
|
||||
inline static Matrix rotate( const Vec3& from, const Vec3& to);
|
||||
inline static Matrix rotate( float angle, float x, float y, float z);
|
||||
inline static Matrix rotate( float angle, const Vec3& axis);
|
||||
inline static Matrix rotate( float angle1, const Vec3& axis1,
|
||||
float angle2, const Vec3& axis2,
|
||||
float angle3, const Vec3& axis3);
|
||||
inline static Matrix rotate( const Quat& quat);
|
||||
inline static Matrix inverse( const Matrix& matrix);
|
||||
|
||||
/** Create a orthographic projection. See glOrtho for further details.*/
|
||||
inline static Matrix ortho(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Create a 2D orthographic projection. See glOrtho for further details.*/
|
||||
inline static Matrix ortho2D(double left, double right,
|
||||
double bottom, double top);
|
||||
|
||||
/** Create a perspective projection. See glFrustum for further details.*/
|
||||
inline static Matrix frustum(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Create a symmetrical perspective projection, See gluPerspective for further details.
|
||||
* Aspect ratio is defined as width/height.*/
|
||||
inline static Matrix perspective(double fovy,double aspectRatio,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Create the position and orientation as per a camera, using the same convention as gluLookAt. */
|
||||
inline static Matrix lookAt(const Vec3& eye,const Vec3& center,const Vec3& up);
|
||||
|
||||
|
||||
|
||||
|
||||
inline Vec3 preMult( const Vec3& v ) const;
|
||||
inline Vec3 postMult( const Vec3& v ) const;
|
||||
inline Vec3 operator* ( const Vec3& v ) const;
|
||||
inline Vec4 preMult( const Vec4& v ) const;
|
||||
inline Vec4 postMult( const Vec4& v ) const;
|
||||
inline Vec4 operator* ( const Vec4& v ) const;
|
||||
|
||||
void setTrans( value_type tx, value_type ty, value_type tz );
|
||||
void setTrans( const Vec3& v );
|
||||
inline Vec3 getTrans() const { return Vec3(_mat[3][0],_mat[3][1],_mat[3][2]); }
|
||||
|
||||
inline Vec3 getScale() const { return Vec3(_mat[0][0],_mat[1][1],_mat[2][2]); }
|
||||
|
||||
/** apply apply an 3x3 transform of v*M[0..2,0..2] */
|
||||
inline static Vec3 transform3x3(const Vec3& v,const Matrix& m);
|
||||
/** apply apply an 3x3 transform of M[0..2,0..2]*v */
|
||||
inline static Vec3 transform3x3(const Matrix& m,const Vec3& v);
|
||||
|
||||
|
||||
// basic Matrix multiplication, our workhorse methods.
|
||||
void mult( const Matrix&, const Matrix& );
|
||||
void preMult( const Matrix& );
|
||||
void postMult( const Matrix& );
|
||||
|
||||
inline void operator *= ( const Matrix& other )
|
||||
{ if( this == &other ) {
|
||||
Matrix temp(other);
|
||||
postMult( temp );
|
||||
}
|
||||
else postMult( other );
|
||||
}
|
||||
|
||||
inline Matrix operator * ( const Matrix &m ) const
|
||||
{
|
||||
osg::Matrix r;
|
||||
r.mult(*this,m);
|
||||
return r;
|
||||
}
|
||||
|
||||
/** call glLoadMatixf with this matrix.*/
|
||||
void glLoadMatrix() const;
|
||||
|
||||
/** call glMultMatixf with this matrix.*/
|
||||
void glMultMatrix() const;
|
||||
|
||||
protected:
|
||||
value_type _mat[4][4];
|
||||
|
||||
};
|
||||
|
||||
class RefMatrix : public Object, public Matrix
|
||||
{
|
||||
public:
|
||||
|
||||
RefMatrix():Matrix() {}
|
||||
RefMatrix( const Matrix& other) : Matrix(other) {}
|
||||
RefMatrix( const RefMatrix& other) : Object(other), Matrix(other) {}
|
||||
explicit RefMatrix( float const * const def ):Matrix(def) {}
|
||||
RefMatrix( float a00, float a01, float a02, float a03,
|
||||
float a10, float a11, float a12, float a13,
|
||||
float a20, float a21, float a22, float a23,
|
||||
float a30, float a31, float a32, float a33):
|
||||
Matrix(a00, a01, a02, a03,
|
||||
a10, a11, a12, a13,
|
||||
a20, a21, a22, a23,
|
||||
a30, a31, a32, a33) {}
|
||||
|
||||
virtual Object* cloneType() const { return new RefMatrix(); }
|
||||
virtual Object* clone(const CopyOp&) const { return new RefMatrix(*this); }
|
||||
virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const RefMatrix*>(obj)!=NULL; }
|
||||
virtual const char* libraryName() const { return "osg"; }
|
||||
virtual const char* className() const { return "Matrix"; }
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
virtual ~RefMatrix() {}
|
||||
};
|
||||
|
||||
|
||||
//static utility methods
|
||||
inline Matrix Matrix::identity(void)
|
||||
{
|
||||
Matrix m;
|
||||
m.makeIdentity();
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrix Matrix::scale(value_type sx, value_type sy, value_type sz)
|
||||
{
|
||||
Matrix m;
|
||||
m.makeScale(sx,sy,sz);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrix Matrix::scale(const Vec3& v )
|
||||
{
|
||||
return scale(v.x(), v.y(), v.z() );
|
||||
}
|
||||
|
||||
inline Matrix Matrix::translate(value_type tx, value_type ty, value_type tz)
|
||||
{
|
||||
Matrix m;
|
||||
m.makeTranslate(tx,ty,tz);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrix Matrix::translate(const Vec3& v )
|
||||
{
|
||||
return translate(v.x(), v.y(), v.z() );
|
||||
}
|
||||
|
||||
inline Matrix Matrix::rotate( const Quat& q )
|
||||
{
|
||||
Matrix m;
|
||||
m.makeRotate( q );
|
||||
return m;
|
||||
}
|
||||
inline Matrix Matrix::rotate(float angle, float x, float y, float z )
|
||||
{
|
||||
Matrix m;
|
||||
m.makeRotate(angle,x,y,z);
|
||||
return m;
|
||||
}
|
||||
inline Matrix Matrix::rotate(float angle, const Vec3& axis )
|
||||
{
|
||||
Matrix m;
|
||||
m.makeRotate(angle,axis);
|
||||
return m;
|
||||
}
|
||||
inline Matrix Matrix::rotate( float angle1, const Vec3& axis1,
|
||||
float angle2, const Vec3& axis2,
|
||||
float angle3, const Vec3& axis3)
|
||||
{
|
||||
Matrix m;
|
||||
m.makeRotate(angle1,axis1,angle2,axis2,angle3,axis3);
|
||||
return m;
|
||||
}
|
||||
inline Matrix Matrix::rotate(const Vec3& from, const Vec3& to )
|
||||
{
|
||||
Matrix m;
|
||||
m.makeRotate(from,to);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrix Matrix::inverse( const Matrix& matrix)
|
||||
{
|
||||
Matrix m;
|
||||
m.invert(matrix);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrix Matrix::ortho(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar)
|
||||
{
|
||||
Matrix m;
|
||||
m.makeOrtho(left,right,bottom,top,zNear,zFar);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrix Matrix::ortho2D(double left, double right,
|
||||
double bottom, double top)
|
||||
{
|
||||
Matrix m;
|
||||
m.makeOrtho2D(left,right,bottom,top);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrix Matrix::frustum(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar)
|
||||
{
|
||||
Matrix m;
|
||||
m.makeFrustum(left,right,bottom,top,zNear,zFar);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrix Matrix::perspective(double fovy,double aspectRatio,
|
||||
double zNear, double zFar)
|
||||
{
|
||||
Matrix m;
|
||||
m.makePerspective(fovy,aspectRatio,zNear,zFar);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrix Matrix::lookAt(const Vec3& eye,const Vec3& center,const Vec3& up)
|
||||
{
|
||||
Matrix m;
|
||||
m.makeLookAt(eye,center,up);
|
||||
return m;
|
||||
}
|
||||
|
||||
|
||||
inline Vec3 Matrix::postMult( const Vec3& v ) const
|
||||
{
|
||||
float d = 1.0f/(_mat[3][0]*v.x()+_mat[3][1]*v.y()+_mat[3][2]*v.z()+_mat[3][3]) ;
|
||||
return Vec3( (_mat[0][0]*v.x() + _mat[0][1]*v.y() + _mat[0][2]*v.z() + _mat[0][3])*d,
|
||||
(_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3])*d,
|
||||
(_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3])*d) ;
|
||||
}
|
||||
|
||||
inline Vec3 Matrix::preMult( const Vec3& v ) const
|
||||
{
|
||||
float d = 1.0f/(_mat[0][3]*v.x()+_mat[1][3]*v.y()+_mat[2][3]*v.z()+_mat[3][3]) ;
|
||||
return Vec3( (_mat[0][0]*v.x() + _mat[1][0]*v.y() + _mat[2][0]*v.z() + _mat[3][0])*d,
|
||||
(_mat[0][1]*v.x() + _mat[1][1]*v.y() + _mat[2][1]*v.z() + _mat[3][1])*d,
|
||||
(_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2])*d);
|
||||
}
|
||||
|
||||
inline Vec4 Matrix::postMult( const Vec4& v ) const
|
||||
{
|
||||
return Vec4( (_mat[0][0]*v.x() + _mat[0][1]*v.y() + _mat[0][2]*v.z() + _mat[0][3]*v.w()),
|
||||
(_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3]*v.w()),
|
||||
(_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3]*v.w()),
|
||||
(_mat[3][0]*v.x() + _mat[3][1]*v.y() + _mat[3][2]*v.z() + _mat[3][3]*v.w())) ;
|
||||
}
|
||||
|
||||
inline Vec4 Matrix::preMult( const Vec4& v ) const
|
||||
{
|
||||
return Vec4( (_mat[0][0]*v.x() + _mat[1][0]*v.y() + _mat[2][0]*v.z() + _mat[3][0]*v.w()),
|
||||
(_mat[0][1]*v.x() + _mat[1][1]*v.y() + _mat[2][1]*v.z() + _mat[3][1]*v.w()),
|
||||
(_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2]*v.w()),
|
||||
(_mat[0][3]*v.x() + _mat[1][3]*v.y() + _mat[2][3]*v.z() + _mat[3][3]*v.w()));
|
||||
}
|
||||
inline Vec3 Matrix::transform3x3(const Vec3& v,const Matrix& m)
|
||||
{
|
||||
return Vec3( (m._mat[0][0]*v.x() + m._mat[1][0]*v.y() + m._mat[2][0]*v.z()),
|
||||
(m._mat[0][1]*v.x() + m._mat[1][1]*v.y() + m._mat[2][1]*v.z()),
|
||||
(m._mat[0][2]*v.x() + m._mat[1][2]*v.y() + m._mat[2][2]*v.z()));
|
||||
}
|
||||
|
||||
inline Vec3 Matrix::transform3x3(const Matrix& m,const Vec3& v)
|
||||
{
|
||||
return Vec3( (m._mat[0][0]*v.x() + m._mat[0][1]*v.y() + m._mat[0][2]*v.z()),
|
||||
(m._mat[1][0]*v.x() + m._mat[1][1]*v.y() + m._mat[1][2]*v.z()),
|
||||
(m._mat[2][0]*v.x() + m._mat[2][1]*v.y() + m._mat[2][2]*v.z()) ) ;
|
||||
}
|
||||
|
||||
|
||||
inline Vec3 operator* (const Vec3& v, const Matrix& m )
|
||||
{
|
||||
return m.preMult(v);
|
||||
}
|
||||
inline Vec4 operator* (const Vec4& v, const Matrix& m )
|
||||
{
|
||||
return m.preMult(v);
|
||||
}
|
||||
|
||||
inline Vec3 Matrix::operator* (const Vec3& v) const
|
||||
{
|
||||
return postMult(v);
|
||||
}
|
||||
inline Vec4 Matrix::operator* (const Vec4& v) const
|
||||
{
|
||||
return postMult(v);
|
||||
}
|
||||
|
||||
inline std::ostream& operator<< (std::ostream& os, const Matrix& m )
|
||||
{
|
||||
os << "{"<<std::endl;
|
||||
for(int row=0; row<4; ++row) {
|
||||
os << "\t";
|
||||
for(int col=0; col<4; ++col)
|
||||
os << m(row,col) << " ";
|
||||
os << std::endl;
|
||||
}
|
||||
os << "}" << std::endl;
|
||||
return os;
|
||||
}
|
||||
typedef Matrixd Matrix;
|
||||
typedef RefMatrixd RefMatrix;
|
||||
|
||||
|
||||
} //namespace osg
|
||||
|
||||
468
include/osg/Matrixd
Normal file
468
include/osg/Matrixd
Normal file
@@ -0,0 +1,468 @@
|
||||
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield
|
||||
*
|
||||
* This library is open source and may be redistributed and/or modified under
|
||||
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
|
||||
* (at your option) any later version. The full license is in LICENSE file
|
||||
* included with this distribution, and on the openscenegraph.org website.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* OpenSceneGraph Public License for more details.
|
||||
*/
|
||||
|
||||
#ifndef OSG_MATRIXD
|
||||
#define OSG_MATRIXD 1
|
||||
|
||||
#include <osg/Object>
|
||||
#include <osg/Vec3>
|
||||
#include <osg/Vec4>
|
||||
#include <osg/Quat>
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
|
||||
namespace osg {
|
||||
|
||||
class SG_EXPORT Matrixd
|
||||
{
|
||||
|
||||
public:
|
||||
|
||||
typedef double value_type;
|
||||
|
||||
inline Matrixd() { makeIdentity(); }
|
||||
inline Matrixd( const Matrixd& other) { set(other.ptr()); }
|
||||
inline explicit Matrixd( float const * const ptr ) { set(ptr); }
|
||||
inline explicit Matrixd( double const * const ptr ) { set(ptr); }
|
||||
inline explicit Matrixd( const Quat& quat ) { set(quat); }
|
||||
|
||||
Matrixd( value_type a00, value_type a01, value_type a02, value_type a03,
|
||||
value_type a10, value_type a11, value_type a12, value_type a13,
|
||||
value_type a20, value_type a21, value_type a22, value_type a23,
|
||||
value_type a30, value_type a31, value_type a32, value_type a33);
|
||||
|
||||
~Matrixd() {}
|
||||
|
||||
int compare(const Matrixd& m) const { return memcmp(_mat,m._mat,sizeof(_mat)); }
|
||||
|
||||
bool operator < (const Matrixd& m) const { return compare(m)<0; }
|
||||
bool operator == (const Matrixd& m) const { return compare(m)==0; }
|
||||
bool operator != (const Matrixd& m) const { return compare(m)!=0; }
|
||||
|
||||
inline value_type& operator()(int row, int col) { return _mat[row][col]; }
|
||||
inline value_type operator()(int row, int col) const { return _mat[row][col]; }
|
||||
|
||||
inline bool valid() const { return !isNaN(); }
|
||||
inline bool isNaN() const { return osg::isNaN(_mat[0][0]) || osg::isNaN(_mat[0][1]) || osg::isNaN(_mat[0][2]) || osg::isNaN(_mat[0][3]) ||
|
||||
osg::isNaN(_mat[1][0]) || osg::isNaN(_mat[1][1]) || osg::isNaN(_mat[1][2]) || osg::isNaN(_mat[1][3]) ||
|
||||
osg::isNaN(_mat[2][0]) || osg::isNaN(_mat[2][1]) || osg::isNaN(_mat[2][2]) || osg::isNaN(_mat[2][3]) ||
|
||||
osg::isNaN(_mat[3][0]) || osg::isNaN(_mat[3][1]) || osg::isNaN(_mat[3][2]) || osg::isNaN(_mat[3][3]); }
|
||||
|
||||
inline Matrixd& operator = (const Matrixd& other)
|
||||
{
|
||||
if( &other == this ) return *this;
|
||||
set(other.ptr());
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline void set(const Matrixd& other)
|
||||
{
|
||||
set(other.ptr());
|
||||
}
|
||||
|
||||
inline void set(float const * const ptr)
|
||||
{
|
||||
std::copy(ptr,ptr+16,(value_type*)_mat);
|
||||
}
|
||||
|
||||
inline void set(double const * const ptr)
|
||||
{
|
||||
std::copy(ptr,ptr+16,(value_type*)_mat);
|
||||
}
|
||||
|
||||
void set( value_type a00, value_type a01, value_type a02, value_type a03,
|
||||
value_type a10, value_type a11, value_type a12, value_type a13,
|
||||
value_type a20, value_type a21, value_type a22, value_type a23,
|
||||
value_type a30, value_type a31, value_type a32, value_type a33);
|
||||
|
||||
void set(const Quat& q);
|
||||
|
||||
void get(Quat& q) const;
|
||||
|
||||
value_type * ptr() { return (value_type*)_mat; }
|
||||
const value_type * ptr() const { return (const value_type *)_mat; }
|
||||
|
||||
void makeIdentity();
|
||||
|
||||
void makeScale( const Vec3& );
|
||||
void makeScale( value_type, value_type, value_type );
|
||||
|
||||
void makeTranslate( const Vec3& );
|
||||
void makeTranslate( value_type, value_type, value_type );
|
||||
|
||||
void makeRotate( const Vec3& from, const Vec3& to );
|
||||
void makeRotate( float angle, const Vec3& axis );
|
||||
void makeRotate( float angle, float x, float y, float z );
|
||||
void makeRotate( const Quat& );
|
||||
void makeRotate( float angle1, const Vec3& axis1,
|
||||
float angle2, const Vec3& axis2,
|
||||
float angle3, const Vec3& axis3);
|
||||
|
||||
|
||||
|
||||
/** Set to a orthographic projection. See glOrtho for further details.*/
|
||||
void makeOrtho(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Get the othorgraphic settings of the orthographic projection matrix.
|
||||
* Note, if matrix is not an orthographic matrix then invalid values will be returned.*/
|
||||
void getOrtho(double& left, double& right,
|
||||
double& bottom, double& top,
|
||||
double& zNear, double& zFar);
|
||||
|
||||
/** Set to a 2D orthographic projection. See glOrtho2D for further details.*/
|
||||
inline void makeOrtho2D(double left, double right,
|
||||
double bottom, double top)
|
||||
{
|
||||
makeOrtho(left,right,bottom,top,-1.0,1.0);
|
||||
}
|
||||
|
||||
|
||||
/** Set to a perspective projection. See glFrustum for further details.*/
|
||||
void makeFrustum(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Get the frustum setting of a perspective projection matrix.
|
||||
* Note, if matrix is not an perspective matrix then invalid values will be returned.*/
|
||||
void getFrustum(double& left, double& right,
|
||||
double& bottom, double& top,
|
||||
double& zNear, double& zFar);
|
||||
|
||||
/** Set to a symmetrical perspective projection, See gluPerspective for further details.
|
||||
* Aspect ratio is defined as width/height.*/
|
||||
void makePerspective(double fovy,double aspectRatio,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Set to the position and orientation modelview matrix, using the same convention as gluLookAt. */
|
||||
void makeLookAt(const Vec3& eye,const Vec3& center,const Vec3& up);
|
||||
|
||||
/** Get to the position and orientation of a modelview matrix, using the same convention as gluLookAt. */
|
||||
void getLookAt(Vec3& eye,Vec3& center,Vec3& up,float lookDistance=1.0f);
|
||||
|
||||
bool invert( const Matrixd& );
|
||||
|
||||
//basic utility functions to create new matrices
|
||||
inline static Matrixd identity( void );
|
||||
inline static Matrixd scale( const Vec3& sv);
|
||||
inline static Matrixd scale( value_type sx, value_type sy, value_type sz);
|
||||
inline static Matrixd translate( const Vec3& dv);
|
||||
inline static Matrixd translate( value_type x, value_type y, value_type z);
|
||||
inline static Matrixd rotate( const Vec3& from, const Vec3& to);
|
||||
inline static Matrixd rotate( float angle, float x, float y, float z);
|
||||
inline static Matrixd rotate( float angle, const Vec3& axis);
|
||||
inline static Matrixd rotate( float angle1, const Vec3& axis1,
|
||||
float angle2, const Vec3& axis2,
|
||||
float angle3, const Vec3& axis3);
|
||||
inline static Matrixd rotate( const Quat& quat);
|
||||
inline static Matrixd inverse( const Matrixd& matrix);
|
||||
|
||||
/** Create a orthographic projection. See glOrtho for further details.*/
|
||||
inline static Matrixd ortho(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Create a 2D orthographic projection. See glOrtho for further details.*/
|
||||
inline static Matrixd ortho2D(double left, double right,
|
||||
double bottom, double top);
|
||||
|
||||
/** Create a perspective projection. See glFrustum for further details.*/
|
||||
inline static Matrixd frustum(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Create a symmetrical perspective projection, See gluPerspective for further details.
|
||||
* Aspect ratio is defined as width/height.*/
|
||||
inline static Matrixd perspective(double fovy,double aspectRatio,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Create the position and orientation as per a camera, using the same convention as gluLookAt. */
|
||||
inline static Matrixd lookAt(const Vec3& eye,const Vec3& center,const Vec3& up);
|
||||
|
||||
|
||||
|
||||
|
||||
inline Vec3 preMult( const Vec3& v ) const;
|
||||
inline Vec3 postMult( const Vec3& v ) const;
|
||||
inline Vec3 operator* ( const Vec3& v ) const;
|
||||
inline Vec4 preMult( const Vec4& v ) const;
|
||||
inline Vec4 postMult( const Vec4& v ) const;
|
||||
inline Vec4 operator* ( const Vec4& v ) const;
|
||||
|
||||
void setTrans( value_type tx, value_type ty, value_type tz );
|
||||
void setTrans( const Vec3& v );
|
||||
inline Vec3 getTrans() const { return Vec3(_mat[3][0],_mat[3][1],_mat[3][2]); }
|
||||
|
||||
inline Vec3 getScale() const { return Vec3(_mat[0][0],_mat[1][1],_mat[2][2]); }
|
||||
|
||||
/** apply apply an 3x3 transform of v*M[0..2,0..2] */
|
||||
inline static Vec3 transform3x3(const Vec3& v,const Matrixd& m);
|
||||
/** apply apply an 3x3 transform of M[0..2,0..2]*v */
|
||||
inline static Vec3 transform3x3(const Matrixd& m,const Vec3& v);
|
||||
|
||||
|
||||
// basic Matrixd multiplication, our workhorse methods.
|
||||
void mult( const Matrixd&, const Matrixd& );
|
||||
void preMult( const Matrixd& );
|
||||
void postMult( const Matrixd& );
|
||||
|
||||
inline void operator *= ( const Matrixd& other )
|
||||
{ if( this == &other ) {
|
||||
Matrixd temp(other);
|
||||
postMult( temp );
|
||||
}
|
||||
else postMult( other );
|
||||
}
|
||||
|
||||
inline Matrixd operator * ( const Matrixd &m ) const
|
||||
{
|
||||
osg::Matrixd r;
|
||||
r.mult(*this,m);
|
||||
return r;
|
||||
}
|
||||
|
||||
protected:
|
||||
value_type _mat[4][4];
|
||||
|
||||
};
|
||||
|
||||
class RefMatrixd : public Object, public Matrixd
|
||||
{
|
||||
public:
|
||||
|
||||
RefMatrixd():Matrixd() {}
|
||||
RefMatrixd( const Matrixd& other) : Matrixd(other) {}
|
||||
RefMatrixd( const RefMatrixd& other) : Object(other), Matrixd(other) {}
|
||||
explicit RefMatrixd( Matrixd::value_type const * const def ):Matrixd(def) {}
|
||||
RefMatrixd( Matrixd::value_type a00, Matrixd::value_type a01, Matrixd::value_type a02, Matrixd::value_type a03,
|
||||
Matrixd::value_type a10, Matrixd::value_type a11, Matrixd::value_type a12, Matrixd::value_type a13,
|
||||
Matrixd::value_type a20, Matrixd::value_type a21, Matrixd::value_type a22, Matrixd::value_type a23,
|
||||
Matrixd::value_type a30, Matrixd::value_type a31, Matrixd::value_type a32, Matrixd::value_type a33):
|
||||
Matrixd(a00, a01, a02, a03,
|
||||
a10, a11, a12, a13,
|
||||
a20, a21, a22, a23,
|
||||
a30, a31, a32, a33) {}
|
||||
|
||||
virtual Object* cloneType() const { return new RefMatrixd(); }
|
||||
virtual Object* clone(const CopyOp&) const { return new RefMatrixd(*this); }
|
||||
virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const RefMatrixd*>(obj)!=NULL; }
|
||||
virtual const char* libraryName() const { return "osg"; }
|
||||
virtual const char* className() const { return "Matrix"; }
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
virtual ~RefMatrixd() {}
|
||||
};
|
||||
|
||||
|
||||
//static utility methods
|
||||
inline Matrixd Matrixd::identity(void)
|
||||
{
|
||||
Matrixd m;
|
||||
m.makeIdentity();
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixd Matrixd::scale(value_type sx, value_type sy, value_type sz)
|
||||
{
|
||||
Matrixd m;
|
||||
m.makeScale(sx,sy,sz);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixd Matrixd::scale(const Vec3& v )
|
||||
{
|
||||
return scale(v.x(), v.y(), v.z() );
|
||||
}
|
||||
|
||||
inline Matrixd Matrixd::translate(value_type tx, value_type ty, value_type tz)
|
||||
{
|
||||
Matrixd m;
|
||||
m.makeTranslate(tx,ty,tz);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixd Matrixd::translate(const Vec3& v )
|
||||
{
|
||||
return translate(v.x(), v.y(), v.z() );
|
||||
}
|
||||
|
||||
inline Matrixd Matrixd::rotate( const Quat& q )
|
||||
{
|
||||
Matrixd m;
|
||||
m.makeRotate( q );
|
||||
return m;
|
||||
}
|
||||
inline Matrixd Matrixd::rotate(float angle, float x, float y, float z )
|
||||
{
|
||||
Matrixd m;
|
||||
m.makeRotate(angle,x,y,z);
|
||||
return m;
|
||||
}
|
||||
inline Matrixd Matrixd::rotate(float angle, const Vec3& axis )
|
||||
{
|
||||
Matrixd m;
|
||||
m.makeRotate(angle,axis);
|
||||
return m;
|
||||
}
|
||||
inline Matrixd Matrixd::rotate( float angle1, const Vec3& axis1,
|
||||
float angle2, const Vec3& axis2,
|
||||
float angle3, const Vec3& axis3)
|
||||
{
|
||||
Matrixd m;
|
||||
m.makeRotate(angle1,axis1,angle2,axis2,angle3,axis3);
|
||||
return m;
|
||||
}
|
||||
inline Matrixd Matrixd::rotate(const Vec3& from, const Vec3& to )
|
||||
{
|
||||
Matrixd m;
|
||||
m.makeRotate(from,to);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixd Matrixd::inverse( const Matrixd& matrix)
|
||||
{
|
||||
Matrixd m;
|
||||
m.invert(matrix);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixd Matrixd::ortho(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar)
|
||||
{
|
||||
Matrixd m;
|
||||
m.makeOrtho(left,right,bottom,top,zNear,zFar);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixd Matrixd::ortho2D(double left, double right,
|
||||
double bottom, double top)
|
||||
{
|
||||
Matrixd m;
|
||||
m.makeOrtho2D(left,right,bottom,top);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixd Matrixd::frustum(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar)
|
||||
{
|
||||
Matrixd m;
|
||||
m.makeFrustum(left,right,bottom,top,zNear,zFar);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixd Matrixd::perspective(double fovy,double aspectRatio,
|
||||
double zNear, double zFar)
|
||||
{
|
||||
Matrixd m;
|
||||
m.makePerspective(fovy,aspectRatio,zNear,zFar);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixd Matrixd::lookAt(const Vec3& eye,const Vec3& center,const Vec3& up)
|
||||
{
|
||||
Matrixd m;
|
||||
m.makeLookAt(eye,center,up);
|
||||
return m;
|
||||
}
|
||||
|
||||
|
||||
inline Vec3 Matrixd::postMult( const Vec3& v ) const
|
||||
{
|
||||
float d = 1.0f/(_mat[3][0]*v.x()+_mat[3][1]*v.y()+_mat[3][2]*v.z()+_mat[3][3]) ;
|
||||
return Vec3( (_mat[0][0]*v.x() + _mat[0][1]*v.y() + _mat[0][2]*v.z() + _mat[0][3])*d,
|
||||
(_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3])*d,
|
||||
(_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3])*d) ;
|
||||
}
|
||||
|
||||
inline Vec3 Matrixd::preMult( const Vec3& v ) const
|
||||
{
|
||||
float d = 1.0f/(_mat[0][3]*v.x()+_mat[1][3]*v.y()+_mat[2][3]*v.z()+_mat[3][3]) ;
|
||||
return Vec3( (_mat[0][0]*v.x() + _mat[1][0]*v.y() + _mat[2][0]*v.z() + _mat[3][0])*d,
|
||||
(_mat[0][1]*v.x() + _mat[1][1]*v.y() + _mat[2][1]*v.z() + _mat[3][1])*d,
|
||||
(_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2])*d);
|
||||
}
|
||||
|
||||
inline Vec4 Matrixd::postMult( const Vec4& v ) const
|
||||
{
|
||||
return Vec4( (_mat[0][0]*v.x() + _mat[0][1]*v.y() + _mat[0][2]*v.z() + _mat[0][3]*v.w()),
|
||||
(_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3]*v.w()),
|
||||
(_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3]*v.w()),
|
||||
(_mat[3][0]*v.x() + _mat[3][1]*v.y() + _mat[3][2]*v.z() + _mat[3][3]*v.w())) ;
|
||||
}
|
||||
|
||||
inline Vec4 Matrixd::preMult( const Vec4& v ) const
|
||||
{
|
||||
return Vec4( (_mat[0][0]*v.x() + _mat[1][0]*v.y() + _mat[2][0]*v.z() + _mat[3][0]*v.w()),
|
||||
(_mat[0][1]*v.x() + _mat[1][1]*v.y() + _mat[2][1]*v.z() + _mat[3][1]*v.w()),
|
||||
(_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2]*v.w()),
|
||||
(_mat[0][3]*v.x() + _mat[1][3]*v.y() + _mat[2][3]*v.z() + _mat[3][3]*v.w()));
|
||||
}
|
||||
inline Vec3 Matrixd::transform3x3(const Vec3& v,const Matrixd& m)
|
||||
{
|
||||
return Vec3( (m._mat[0][0]*v.x() + m._mat[1][0]*v.y() + m._mat[2][0]*v.z()),
|
||||
(m._mat[0][1]*v.x() + m._mat[1][1]*v.y() + m._mat[2][1]*v.z()),
|
||||
(m._mat[0][2]*v.x() + m._mat[1][2]*v.y() + m._mat[2][2]*v.z()));
|
||||
}
|
||||
|
||||
inline Vec3 Matrixd::transform3x3(const Matrixd& m,const Vec3& v)
|
||||
{
|
||||
return Vec3( (m._mat[0][0]*v.x() + m._mat[0][1]*v.y() + m._mat[0][2]*v.z()),
|
||||
(m._mat[1][0]*v.x() + m._mat[1][1]*v.y() + m._mat[1][2]*v.z()),
|
||||
(m._mat[2][0]*v.x() + m._mat[2][1]*v.y() + m._mat[2][2]*v.z()) ) ;
|
||||
}
|
||||
|
||||
|
||||
inline Vec3 operator* (const Vec3& v, const Matrixd& m )
|
||||
{
|
||||
return m.preMult(v);
|
||||
}
|
||||
inline Vec4 operator* (const Vec4& v, const Matrixd& m )
|
||||
{
|
||||
return m.preMult(v);
|
||||
}
|
||||
|
||||
inline Vec3 Matrixd::operator* (const Vec3& v) const
|
||||
{
|
||||
return postMult(v);
|
||||
}
|
||||
inline Vec4 Matrixd::operator* (const Vec4& v) const
|
||||
{
|
||||
return postMult(v);
|
||||
}
|
||||
|
||||
inline std::ostream& operator<< (std::ostream& os, const Matrixd& m )
|
||||
{
|
||||
os << "{"<<std::endl;
|
||||
for(int row=0; row<4; ++row) {
|
||||
os << "\t";
|
||||
for(int col=0; col<4; ++col)
|
||||
os << m(row,col) << " ";
|
||||
os << std::endl;
|
||||
}
|
||||
os << "}" << std::endl;
|
||||
return os;
|
||||
}
|
||||
|
||||
|
||||
} //namespace osg
|
||||
|
||||
|
||||
#endif
|
||||
466
include/osg/Matrixf
Normal file
466
include/osg/Matrixf
Normal file
@@ -0,0 +1,466 @@
|
||||
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield
|
||||
*
|
||||
* This library is open source and may be redistributed and/or modified under
|
||||
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
|
||||
* (at your option) any later version. The full license is in LICENSE file
|
||||
* included with this distribution, and on the openscenegraph.org website.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* OpenSceneGraph Public License for more details.
|
||||
*/
|
||||
|
||||
#ifndef OSG_MATRIXF
|
||||
#define OSG_MATRIXF 1
|
||||
|
||||
#include <osg/Object>
|
||||
#include <osg/Vec3>
|
||||
#include <osg/Vec4>
|
||||
#include <osg/Quat>
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
|
||||
namespace osg {
|
||||
|
||||
class SG_EXPORT Matrixf
|
||||
{
|
||||
|
||||
public:
|
||||
|
||||
typedef float value_type;
|
||||
|
||||
inline Matrixf() { makeIdentity(); }
|
||||
inline Matrixf( const Matrixf& other) { set(other.ptr()); }
|
||||
inline explicit Matrixf( float const * const ptr ) { set(ptr); }
|
||||
inline explicit Matrixf( double const * const ptr ) { set(ptr); }
|
||||
inline explicit Matrixf( const Quat& quat ) { set(quat); }
|
||||
|
||||
Matrixf( value_type a00, value_type a01, value_type a02, value_type a03,
|
||||
value_type a10, value_type a11, value_type a12, value_type a13,
|
||||
value_type a20, value_type a21, value_type a22, value_type a23,
|
||||
value_type a30, value_type a31, value_type a32, value_type a33);
|
||||
|
||||
~Matrixf() {}
|
||||
|
||||
int compare(const Matrixf& m) const { return memcmp(_mat,m._mat,sizeof(_mat)); }
|
||||
|
||||
bool operator < (const Matrixf& m) const { return compare(m)<0; }
|
||||
bool operator == (const Matrixf& m) const { return compare(m)==0; }
|
||||
bool operator != (const Matrixf& m) const { return compare(m)!=0; }
|
||||
|
||||
inline value_type& operator()(int row, int col) { return _mat[row][col]; }
|
||||
inline value_type operator()(int row, int col) const { return _mat[row][col]; }
|
||||
|
||||
inline bool valid() const { return !isNaN(); }
|
||||
inline bool isNaN() const { return osg::isNaN(_mat[0][0]) || osg::isNaN(_mat[0][1]) || osg::isNaN(_mat[0][2]) || osg::isNaN(_mat[0][3]) ||
|
||||
osg::isNaN(_mat[1][0]) || osg::isNaN(_mat[1][1]) || osg::isNaN(_mat[1][2]) || osg::isNaN(_mat[1][3]) ||
|
||||
osg::isNaN(_mat[2][0]) || osg::isNaN(_mat[2][1]) || osg::isNaN(_mat[2][2]) || osg::isNaN(_mat[2][3]) ||
|
||||
osg::isNaN(_mat[3][0]) || osg::isNaN(_mat[3][1]) || osg::isNaN(_mat[3][2]) || osg::isNaN(_mat[3][3]); }
|
||||
|
||||
inline Matrixf& operator = (const Matrixf& other)
|
||||
{
|
||||
if( &other == this ) return *this;
|
||||
set(other.ptr());
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline void set(const Matrixf& other)
|
||||
{
|
||||
set(other.ptr());
|
||||
}
|
||||
|
||||
inline void set(float const * const ptr)
|
||||
{
|
||||
std::copy(ptr,ptr+16,(value_type*)_mat);
|
||||
}
|
||||
|
||||
inline void set(double const * const ptr)
|
||||
{
|
||||
std::copy(ptr,ptr+16,(value_type*)_mat);
|
||||
}
|
||||
|
||||
void set( value_type a00, value_type a01, value_type a02, value_type a03,
|
||||
value_type a10, value_type a11, value_type a12, value_type a13,
|
||||
value_type a20, value_type a21, value_type a22, value_type a23,
|
||||
value_type a30, value_type a31, value_type a32, value_type a33);
|
||||
|
||||
void set(const Quat& q);
|
||||
|
||||
void get(Quat& q) const;
|
||||
|
||||
value_type * ptr() { return (value_type*)_mat; }
|
||||
const value_type * ptr() const { return (const value_type *)_mat; }
|
||||
|
||||
void makeIdentity();
|
||||
|
||||
void makeScale( const Vec3& );
|
||||
void makeScale( value_type, value_type, value_type );
|
||||
|
||||
void makeTranslate( const Vec3& );
|
||||
void makeTranslate( value_type, value_type, value_type );
|
||||
|
||||
void makeRotate( const Vec3& from, const Vec3& to );
|
||||
void makeRotate( float angle, const Vec3& axis );
|
||||
void makeRotate( float angle, float x, float y, float z );
|
||||
void makeRotate( const Quat& );
|
||||
void makeRotate( float angle1, const Vec3& axis1,
|
||||
float angle2, const Vec3& axis2,
|
||||
float angle3, const Vec3& axis3);
|
||||
|
||||
|
||||
|
||||
/** Set to a orthographic projection. See glOrtho for further details.*/
|
||||
void makeOrtho(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Get the othorgraphic settings of the orthographic projection matrix.
|
||||
* Note, if matrix is not an orthographic matrix then invalid values will be returned.*/
|
||||
void getOrtho(double& left, double& right,
|
||||
double& bottom, double& top,
|
||||
double& zNear, double& zFar);
|
||||
|
||||
/** Set to a 2D orthographic projection. See glOrtho2D for further details.*/
|
||||
inline void makeOrtho2D(double left, double right,
|
||||
double bottom, double top)
|
||||
{
|
||||
makeOrtho(left,right,bottom,top,-1.0,1.0);
|
||||
}
|
||||
|
||||
|
||||
/** Set to a perspective projection. See glFrustum for further details.*/
|
||||
void makeFrustum(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Get the frustum setting of a perspective projection matrix.
|
||||
* Note, if matrix is not an perspective matrix then invalid values will be returned.*/
|
||||
void getFrustum(double& left, double& right,
|
||||
double& bottom, double& top,
|
||||
double& zNear, double& zFar);
|
||||
|
||||
/** Set to a symmetrical perspective projection, See gluPerspective for further details.
|
||||
* Aspect ratio is defined as width/height.*/
|
||||
void makePerspective(double fovy,double aspectRatio,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Set to the position and orientation modelview matrix, using the same convention as gluLookAt. */
|
||||
void makeLookAt(const Vec3& eye,const Vec3& center,const Vec3& up);
|
||||
|
||||
/** Get to the position and orientation of a modelview matrix, using the same convention as gluLookAt. */
|
||||
void getLookAt(Vec3& eye,Vec3& center,Vec3& up,float lookDistance=1.0f);
|
||||
|
||||
bool invert( const Matrixf& );
|
||||
|
||||
//basic utility functions to create new matrices
|
||||
inline static Matrixf identity( void );
|
||||
inline static Matrixf scale( const Vec3& sv);
|
||||
inline static Matrixf scale( value_type sx, value_type sy, value_type sz);
|
||||
inline static Matrixf translate( const Vec3& dv);
|
||||
inline static Matrixf translate( value_type x, value_type y, value_type z);
|
||||
inline static Matrixf rotate( const Vec3& from, const Vec3& to);
|
||||
inline static Matrixf rotate( float angle, float x, float y, float z);
|
||||
inline static Matrixf rotate( float angle, const Vec3& axis);
|
||||
inline static Matrixf rotate( float angle1, const Vec3& axis1,
|
||||
float angle2, const Vec3& axis2,
|
||||
float angle3, const Vec3& axis3);
|
||||
inline static Matrixf rotate( const Quat& quat);
|
||||
inline static Matrixf inverse( const Matrixf& matrix);
|
||||
|
||||
/** Create a orthographic projection. See glOrtho for further details.*/
|
||||
inline static Matrixf ortho(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Create a 2D orthographic projection. See glOrtho for further details.*/
|
||||
inline static Matrixf ortho2D(double left, double right,
|
||||
double bottom, double top);
|
||||
|
||||
/** Create a perspective projection. See glFrustum for further details.*/
|
||||
inline static Matrixf frustum(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Create a symmetrical perspective projection, See gluPerspective for further details.
|
||||
* Aspect ratio is defined as width/height.*/
|
||||
inline static Matrixf perspective(double fovy,double aspectRatio,
|
||||
double zNear, double zFar);
|
||||
|
||||
/** Create the position and orientation as per a camera, using the same convention as gluLookAt. */
|
||||
inline static Matrixf lookAt(const Vec3& eye,const Vec3& center,const Vec3& up);
|
||||
|
||||
|
||||
|
||||
|
||||
inline Vec3 preMult( const Vec3& v ) const;
|
||||
inline Vec3 postMult( const Vec3& v ) const;
|
||||
inline Vec3 operator* ( const Vec3& v ) const;
|
||||
inline Vec4 preMult( const Vec4& v ) const;
|
||||
inline Vec4 postMult( const Vec4& v ) const;
|
||||
inline Vec4 operator* ( const Vec4& v ) const;
|
||||
|
||||
void setTrans( value_type tx, value_type ty, value_type tz );
|
||||
void setTrans( const Vec3& v );
|
||||
inline Vec3 getTrans() const { return Vec3(_mat[3][0],_mat[3][1],_mat[3][2]); }
|
||||
|
||||
inline Vec3 getScale() const { return Vec3(_mat[0][0],_mat[1][1],_mat[2][2]); }
|
||||
|
||||
/** apply apply an 3x3 transform of v*M[0..2,0..2] */
|
||||
inline static Vec3 transform3x3(const Vec3& v,const Matrixf& m);
|
||||
/** apply apply an 3x3 transform of M[0..2,0..2]*v */
|
||||
inline static Vec3 transform3x3(const Matrixf& m,const Vec3& v);
|
||||
|
||||
|
||||
// basic Matrixf multiplication, our workhorse methods.
|
||||
void mult( const Matrixf&, const Matrixf& );
|
||||
void preMult( const Matrixf& );
|
||||
void postMult( const Matrixf& );
|
||||
|
||||
inline void operator *= ( const Matrixf& other )
|
||||
{ if( this == &other ) {
|
||||
Matrixf temp(other);
|
||||
postMult( temp );
|
||||
}
|
||||
else postMult( other );
|
||||
}
|
||||
|
||||
inline Matrixf operator * ( const Matrixf &m ) const
|
||||
{
|
||||
osg::Matrixf r;
|
||||
r.mult(*this,m);
|
||||
return r;
|
||||
}
|
||||
|
||||
protected:
|
||||
value_type _mat[4][4];
|
||||
|
||||
};
|
||||
|
||||
class RefMatrixf : public Object, public Matrixf
|
||||
{
|
||||
public:
|
||||
|
||||
RefMatrixf():Matrixf() {}
|
||||
RefMatrixf( const Matrixf& other) : Matrixf(other) {}
|
||||
RefMatrixf( const RefMatrixf& other) : Object(other), Matrixf(other) {}
|
||||
explicit RefMatrixf( Matrixf::value_type const * const def ):Matrixf(def) {}
|
||||
RefMatrixf( Matrixf::value_type a00, Matrixf::value_type a01, Matrixf::value_type a02, Matrixf::value_type a03,
|
||||
Matrixf::value_type a10, Matrixf::value_type a11, Matrixf::value_type a12, Matrixf::value_type a13,
|
||||
Matrixf::value_type a20, Matrixf::value_type a21, Matrixf::value_type a22, Matrixf::value_type a23,
|
||||
Matrixf::value_type a30, Matrixf::value_type a31, Matrixf::value_type a32, Matrixf::value_type a33):
|
||||
Matrixf(a00, a01, a02, a03,
|
||||
a10, a11, a12, a13,
|
||||
a20, a21, a22, a23,
|
||||
a30, a31, a32, a33) {}
|
||||
|
||||
virtual Object* cloneType() const { return new RefMatrixf(); }
|
||||
virtual Object* clone(const CopyOp&) const { return new RefMatrixf(*this); }
|
||||
virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const RefMatrixf*>(obj)!=NULL; }
|
||||
virtual const char* libraryName() const { return "osg"; }
|
||||
virtual const char* className() const { return "Matrix"; }
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
virtual ~RefMatrixf() {}
|
||||
};
|
||||
|
||||
|
||||
//static utility methods
|
||||
inline Matrixf Matrixf::identity(void)
|
||||
{
|
||||
Matrixf m;
|
||||
m.makeIdentity();
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixf Matrixf::scale(value_type sx, value_type sy, value_type sz)
|
||||
{
|
||||
Matrixf m;
|
||||
m.makeScale(sx,sy,sz);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixf Matrixf::scale(const Vec3& v )
|
||||
{
|
||||
return scale(v.x(), v.y(), v.z() );
|
||||
}
|
||||
|
||||
inline Matrixf Matrixf::translate(value_type tx, value_type ty, value_type tz)
|
||||
{
|
||||
Matrixf m;
|
||||
m.makeTranslate(tx,ty,tz);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixf Matrixf::translate(const Vec3& v )
|
||||
{
|
||||
return translate(v.x(), v.y(), v.z() );
|
||||
}
|
||||
|
||||
inline Matrixf Matrixf::rotate( const Quat& q )
|
||||
{
|
||||
return Matrixf(q);
|
||||
}
|
||||
inline Matrixf Matrixf::rotate(float angle, float x, float y, float z )
|
||||
{
|
||||
Matrixf m;
|
||||
m.makeRotate(angle,x,y,z);
|
||||
return m;
|
||||
}
|
||||
inline Matrixf Matrixf::rotate(float angle, const Vec3& axis )
|
||||
{
|
||||
Matrixf m;
|
||||
m.makeRotate(angle,axis);
|
||||
return m;
|
||||
}
|
||||
inline Matrixf Matrixf::rotate( float angle1, const Vec3& axis1,
|
||||
float angle2, const Vec3& axis2,
|
||||
float angle3, const Vec3& axis3)
|
||||
{
|
||||
Matrixf m;
|
||||
m.makeRotate(angle1,axis1,angle2,axis2,angle3,axis3);
|
||||
return m;
|
||||
}
|
||||
inline Matrixf Matrixf::rotate(const Vec3& from, const Vec3& to )
|
||||
{
|
||||
Matrixf m;
|
||||
m.makeRotate(from,to);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixf Matrixf::inverse( const Matrixf& matrix)
|
||||
{
|
||||
Matrixf m;
|
||||
m.invert(matrix);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixf Matrixf::ortho(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar)
|
||||
{
|
||||
Matrixf m;
|
||||
m.makeOrtho(left,right,bottom,top,zNear,zFar);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixf Matrixf::ortho2D(double left, double right,
|
||||
double bottom, double top)
|
||||
{
|
||||
Matrixf m;
|
||||
m.makeOrtho2D(left,right,bottom,top);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixf Matrixf::frustum(double left, double right,
|
||||
double bottom, double top,
|
||||
double zNear, double zFar)
|
||||
{
|
||||
Matrixf m;
|
||||
m.makeFrustum(left,right,bottom,top,zNear,zFar);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixf Matrixf::perspective(double fovy,double aspectRatio,
|
||||
double zNear, double zFar)
|
||||
{
|
||||
Matrixf m;
|
||||
m.makePerspective(fovy,aspectRatio,zNear,zFar);
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Matrixf Matrixf::lookAt(const Vec3& eye,const Vec3& center,const Vec3& up)
|
||||
{
|
||||
Matrixf m;
|
||||
m.makeLookAt(eye,center,up);
|
||||
return m;
|
||||
}
|
||||
|
||||
|
||||
inline Vec3 Matrixf::postMult( const Vec3& v ) const
|
||||
{
|
||||
float d = 1.0f/(_mat[3][0]*v.x()+_mat[3][1]*v.y()+_mat[3][2]*v.z()+_mat[3][3]) ;
|
||||
return Vec3( (_mat[0][0]*v.x() + _mat[0][1]*v.y() + _mat[0][2]*v.z() + _mat[0][3])*d,
|
||||
(_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3])*d,
|
||||
(_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3])*d) ;
|
||||
}
|
||||
|
||||
inline Vec3 Matrixf::preMult( const Vec3& v ) const
|
||||
{
|
||||
float d = 1.0f/(_mat[0][3]*v.x()+_mat[1][3]*v.y()+_mat[2][3]*v.z()+_mat[3][3]) ;
|
||||
return Vec3( (_mat[0][0]*v.x() + _mat[1][0]*v.y() + _mat[2][0]*v.z() + _mat[3][0])*d,
|
||||
(_mat[0][1]*v.x() + _mat[1][1]*v.y() + _mat[2][1]*v.z() + _mat[3][1])*d,
|
||||
(_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2])*d);
|
||||
}
|
||||
|
||||
inline Vec4 Matrixf::postMult( const Vec4& v ) const
|
||||
{
|
||||
return Vec4( (_mat[0][0]*v.x() + _mat[0][1]*v.y() + _mat[0][2]*v.z() + _mat[0][3]*v.w()),
|
||||
(_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3]*v.w()),
|
||||
(_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3]*v.w()),
|
||||
(_mat[3][0]*v.x() + _mat[3][1]*v.y() + _mat[3][2]*v.z() + _mat[3][3]*v.w())) ;
|
||||
}
|
||||
|
||||
inline Vec4 Matrixf::preMult( const Vec4& v ) const
|
||||
{
|
||||
return Vec4( (_mat[0][0]*v.x() + _mat[1][0]*v.y() + _mat[2][0]*v.z() + _mat[3][0]*v.w()),
|
||||
(_mat[0][1]*v.x() + _mat[1][1]*v.y() + _mat[2][1]*v.z() + _mat[3][1]*v.w()),
|
||||
(_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2]*v.w()),
|
||||
(_mat[0][3]*v.x() + _mat[1][3]*v.y() + _mat[2][3]*v.z() + _mat[3][3]*v.w()));
|
||||
}
|
||||
inline Vec3 Matrixf::transform3x3(const Vec3& v,const Matrixf& m)
|
||||
{
|
||||
return Vec3( (m._mat[0][0]*v.x() + m._mat[1][0]*v.y() + m._mat[2][0]*v.z()),
|
||||
(m._mat[0][1]*v.x() + m._mat[1][1]*v.y() + m._mat[2][1]*v.z()),
|
||||
(m._mat[0][2]*v.x() + m._mat[1][2]*v.y() + m._mat[2][2]*v.z()));
|
||||
}
|
||||
|
||||
inline Vec3 Matrixf::transform3x3(const Matrixf& m,const Vec3& v)
|
||||
{
|
||||
return Vec3( (m._mat[0][0]*v.x() + m._mat[0][1]*v.y() + m._mat[0][2]*v.z()),
|
||||
(m._mat[1][0]*v.x() + m._mat[1][1]*v.y() + m._mat[1][2]*v.z()),
|
||||
(m._mat[2][0]*v.x() + m._mat[2][1]*v.y() + m._mat[2][2]*v.z()) ) ;
|
||||
}
|
||||
|
||||
|
||||
inline Vec3 operator* (const Vec3& v, const Matrixf& m )
|
||||
{
|
||||
return m.preMult(v);
|
||||
}
|
||||
inline Vec4 operator* (const Vec4& v, const Matrixf& m )
|
||||
{
|
||||
return m.preMult(v);
|
||||
}
|
||||
|
||||
inline Vec3 Matrixf::operator* (const Vec3& v) const
|
||||
{
|
||||
return postMult(v);
|
||||
}
|
||||
inline Vec4 Matrixf::operator* (const Vec4& v) const
|
||||
{
|
||||
return postMult(v);
|
||||
}
|
||||
|
||||
inline std::ostream& operator<< (std::ostream& os, const Matrixf& m )
|
||||
{
|
||||
os << "{"<<std::endl;
|
||||
for(int row=0; row<4; ++row) {
|
||||
os << "\t";
|
||||
for(int col=0; col<4; ++col)
|
||||
os << m(row,col) << " ";
|
||||
os << std::endl;
|
||||
}
|
||||
os << "}" << std::endl;
|
||||
return os;
|
||||
}
|
||||
|
||||
|
||||
} //namespace osg
|
||||
|
||||
|
||||
#endif
|
||||
@@ -14,9 +14,9 @@
|
||||
#ifndef OSG_QUAT
|
||||
#define OSG_QUAT 1
|
||||
|
||||
#include <osg/Export>
|
||||
#include <osg/Vec3>
|
||||
#include <osg/Vec4>
|
||||
#include <osg/Matrix>
|
||||
|
||||
namespace osg {
|
||||
|
||||
@@ -265,21 +265,7 @@ class SG_EXPORT Quat
|
||||
/** Spherical Linear Interpolation.
|
||||
As t goes from 0 to 1, the Quat object goes from "from" to "to". */
|
||||
void slerp ( float t, const Quat& from, const Quat& to);
|
||||
|
||||
/** Set quaternion to be equivalent to specified matrix.*/
|
||||
void set( const Matrix& m );
|
||||
|
||||
/** Get the equivalent matrix for this quaternion.*/
|
||||
void get( Matrix& m ) const;
|
||||
|
||||
/** Get the equivalent matrix for this quaternion.*/
|
||||
Matrix getMatrix() const
|
||||
{
|
||||
Matrix matrix;
|
||||
get(matrix);
|
||||
return matrix;
|
||||
}
|
||||
|
||||
|
||||
friend inline std::ostream& operator << (std::ostream& output, const Quat& vec);
|
||||
|
||||
protected:
|
||||
|
||||
@@ -218,7 +218,7 @@ class Box : public Shape
|
||||
|
||||
inline void setRotation(const Quat& quat) { _rotation = quat; }
|
||||
inline const Quat& getRotation() const { return _rotation; }
|
||||
inline Matrix getRotationMatrix() const { Matrix matrix; _rotation.get(matrix); return matrix; }
|
||||
inline Matrix getRotationMatrix() const { return Matrix(_rotation); }
|
||||
inline bool zeroRotation() const { return _rotation.zeroRotation(); }
|
||||
|
||||
protected:
|
||||
@@ -276,7 +276,7 @@ class Cone : public Shape
|
||||
|
||||
inline void setRotation(const Quat& quat) { _rotation = quat; }
|
||||
inline const Quat& getRotation() const { return _rotation; }
|
||||
inline Matrix getRotationMatrix() const { Matrix matrix; _rotation.get(matrix); return matrix; }
|
||||
inline Matrix getRotationMatrix() const { return Matrix(_rotation); }
|
||||
inline bool zeroRotation() const { return _rotation.zeroRotation(); }
|
||||
|
||||
inline float getBaseOffsetFactor() const { return 0.25f; }
|
||||
@@ -336,7 +336,7 @@ class Cylinder : public Shape
|
||||
|
||||
inline void setRotation(const Quat& quat) { _rotation = quat; }
|
||||
inline const Quat& getRotation() const { return _rotation; }
|
||||
inline Matrix getRotationMatrix() const { Matrix matrix; _rotation.get(matrix); return matrix; }
|
||||
inline Matrix getRotationMatrix() const { return Matrix(_rotation); }
|
||||
bool zeroRotation() const { return _rotation.zeroRotation(); }
|
||||
|
||||
protected:
|
||||
@@ -452,7 +452,7 @@ class SG_EXPORT HeightField : public Shape
|
||||
|
||||
inline void setRotation(const Quat& quat) { _rotation = quat; }
|
||||
inline const Quat& getRotation() const { return _rotation; }
|
||||
inline Matrix getRotationMatrix() const { Matrix matrix; _rotation.get(matrix); return matrix; }
|
||||
inline Matrix getRotationMatrix() const { return Matrix(_rotation); }
|
||||
inline bool zeroRotation() const { return _rotation.zeroRotation(); }
|
||||
|
||||
protected:
|
||||
|
||||
@@ -100,7 +100,7 @@ class SG_EXPORT State : public Referenced
|
||||
if (matrix)
|
||||
{
|
||||
_projection=matrix;
|
||||
matrix->glLoadMatrix();
|
||||
glLoadMatrix(matrix->ptr());
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -123,7 +123,7 @@ class SG_EXPORT State : public Referenced
|
||||
if (matrix)
|
||||
{
|
||||
_modelView=matrix;
|
||||
matrix->glLoadMatrix();
|
||||
glLoadMatrix(matrix->ptr());
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
@@ -71,6 +71,11 @@ class OSGPRODUCER_EXPORT Viewer : public OsgCameraGroup, public osgGA::GUIAction
|
||||
|
||||
void setUpViewer(unsigned int options=STANDARD_SETTINGS);
|
||||
|
||||
|
||||
void setDone(bool done) { _done = done; }
|
||||
|
||||
bool getDone() const { return _done; }
|
||||
|
||||
/** return true if the application is done and should exit.*/
|
||||
virtual bool done() const;
|
||||
|
||||
|
||||
@@ -19,6 +19,7 @@
|
||||
#include <osg/Quat>
|
||||
#include <osg/Vec3>
|
||||
#include <osg/Vec4>
|
||||
#include <osg/Object>
|
||||
#include <osg/ref_ptr>
|
||||
|
||||
#include <vector>
|
||||
|
||||
@@ -20,6 +20,7 @@
|
||||
#include <osg/Vec3>
|
||||
#include <osg/Vec4>
|
||||
#include <osg/Math>
|
||||
#include <osg/Object>
|
||||
|
||||
namespace osgSim {
|
||||
|
||||
|
||||
Reference in New Issue
Block a user