FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Synch with 20010921

Browse Source
This commit is contained in:
Don BURNS
2001-09-22 02:42:08 +00:00
parent d47b8f9c1f
commit 7ae58df42a
197 changed files with 7867 additions and 6189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

276
include/osg/Matrix
View File

@@ -14,113 +14,193 @@ using namespace std;
namespace osg {
/** 4x4 Matrix for storage & manipulation of transformations in scene graph.
Provides basic maths operations, IO and via osg::Object reference counting.
You can directly load the matrix with OpenGL's LoadMatrixf() function via
the public member _mat as the matrix is stored in the OpenGL format.
Caution: The disadvantage of this feature is, that the matrix access is
'transposed' if you compare it with the standard C/C++ 2d-array-access
convention . I.e. _mat[i][j] accesses the ith column of the jth row in the
4x4 matrix.
*/
class Quat;
class SG_EXPORT Matrix : public Object
{
// private:
public:
float _mat[4][4];
bool fully_realized;
public:
// const char* name() { return "My Matrix "; }
META_Object(Matrix);
Matrix();
Matrix(const Matrix& matrix);
Matrix( const Matrix& other );
explicit Matrix( float const * const def );
Matrix( 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& operator = (const Matrix& matrix);
virtual ~Matrix() {}
virtual ~Matrix();
Matrix& operator = (const Matrix& );
virtual Object* clone() const { return new Matrix(); }
virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const Matrix*>(obj)!=NULL; }
virtual const char* className() const { return "Matrix"; }
int compare(const Matrix& m) const { return memcmp(_mat,m._mat,sizeof(_mat)); }
void makeIdent();
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; }
void set(const float* m);
inline float& operator()(int col, int row) { return _mat[row][col]; }
inline float operator()(int col, int row) const { return _mat[row][col]; }
void set( float const * const );
void set( 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);
const float * values() { return (const float *)_mat; }
void copy(const Matrix& matrix);
void makeIdent();
void makeScale( const Vec3& );
void makeScale( float, float, float );
void makeTrans( const Vec3& );
void makeTrans( float, float, float );
//TODO: original preTrans was optimized (M=Tr*M)
// but also has the assumption that M (this) is an affine transformation Matrix
// can I still do something to optimize the same case now?
void makeScale(float sx, float sy, float sz);
void preScale( float sx, float sy, float sz, const Matrix& m );
void postScale( const Matrix& m, float sx, float sy, float sz );
void preScale( float sx, float sy, float sz );
void postScale( float sx, float sy, float sz );
void makeRot( const Vec3& from, const Vec3& to );
void makeRot( float angle, const Vec3& orientation );
void makeRot( float angle, float x, float y, float z );
void makeRot( const Quat& );
void makeRot( float, float, float ); //Euler angles
void makeTrans( float tx, float ty, float tz );
void preTrans( float tx, float ty, float tz, const Matrix& m );
void postTrans( const Matrix& m, float tx, float ty, float tz );
void preTrans( float tx, float ty, float tz );
void postTrans( float tx, float ty, float tz );
bool invert( const Matrix& );
bool invertAffine( const Matrix& );
/**
* Calc the rotation matrix which aligns vector \a old_vec with
* vector \a new_vec. Both \a old_vec and \a new_vec must have
* length 1.0.
*/
void makeRot( const Vec3& old_vec, const Vec3& new_vec );
//basic utility functions to create new matrices or vectors
inline static Matrix scale( const Vec3& );
inline static Matrix scale( float, float, float );
inline static Matrix trans( const Vec3& );
inline static Matrix trans( float, float, float );
inline static Matrix rotate( const Vec3&, const Vec3& );
inline static Matrix rotate( float, float, float, float );
inline static Matrix rotate( const Quat& );
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;
//start of Deprecated methods
void makeRot( float deg, float x, float y, float z );
void preRot( float deg, float x, float y, float z, const Matrix& m );
void postRot( const Matrix& m, float deg, float x, float y, float z );
void preRot( float deg, float x, float y, float z );
void postRot( float deg, float x, float y, float z );
void setTrans( float tx, float ty, float tz );
void setTrans( const Vec3& v );
Vec3 getTrans() const { return Vec3(_mat[3][0],_mat[3][1],_mat[3][2]); }
void preMult(const Matrix& m);
void postMult(const Matrix& m);
void mult(const Matrix& lhs,const Matrix& rhs);
Matrix operator * (const Matrix& m) const;
void copy( const Matrix& );
void preScale( float sx, float sy, float sz, const Matrix& m );
void postScale( const Matrix& m, float sx, float sy, float sz );
void preScale( float sx, float sy, float sz );
void postScale( float sx, float sy, float sz );
void preTrans( float tx, float ty, float tz, const Matrix& m );
void postTrans( const Matrix& m, float tx, float ty, float tz );
void preTrans( float tx, float ty, float tz);
void postTrans( float tx, float ty, float tz );
void preRot( float deg, float x, float y, float z, const Matrix& m );
void postRot( const Matrix& m, float deg, float x, float y, float z );
void preRot( float deg, float x, float y, float z );
void postRot( float deg, float x, float y, float z );
/** 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);
//end of Deprecated methods
/** post multipy v. ie. (m*v) */
inline Vec3 operator * (const Vec3& v) const;
/** pre multipy v. ie. (v*m) */
friend inline Vec3 operator * (const Vec3& v,const Matrix& m);
// basic Matrix multiplication, our workhorse methods.
void mult( const Matrix&, const Matrix& );
void preMult( const Matrix& );
void postMult( const Matrix& );
/** post multipy v. ie. (m*v) */
inline Vec4 operator * (const Vec4& v) const;
// Helper class to optimize product expressions somewhat
class MatrixProduct {
public:
const Matrix& A;
const Matrix& B;
/** pre multipy v. ie. (v*m) */
friend inline Vec4 operator * (const Vec4& v,const Matrix& m);
MatrixProduct( const Matrix& lhs, const Matrix& rhs ) : A(lhs), B(rhs) {}
};
friend inline ostream& operator << (ostream& output, const Matrix& matrix);
inline MatrixProduct operator * ( const Matrix& other ) const
{ return MatrixProduct(*this, other); }
bool invert(const Matrix& m);
inline void operator *= ( const Matrix& other )
{ if( this == &other ) {
Matrix temp(other);
postMult( temp );
}
else postMult( other );
}
inline void operator = ( const MatrixProduct& p )
{
if( this == &(p.A)) postMult(p.B);
else if( this == &(p.B)) preMult(p.A);
else mult( p.A, p.B );
}
public :
float _mat[4][4];
protected:
Matrix( const MatrixProduct& p ) //allows implicit evaluation of the product
{ mult( p.A, p.B ); }
};
inline Vec3 Matrix::operator * (const Vec3& v) const
//static utility methods
inline Matrix Matrix::scale(float sx, float sy, float 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::trans(float tx, float ty, float tz)
{
Matrix m;
m.makeTrans(tx,ty,tz);
return m;
}
inline Matrix Matrix::trans(const Vec3& v )
{
return trans(v.x(), v.y(), v.z() );
}
inline Matrix Matrix::rotate( const Quat& q )
{
Matrix m;
m.makeRot( q );
return m;
}
inline Matrix Matrix::rotate(float angle, float x, float y, float z )
{
Matrix m;
m.makeRot(angle,x,y,z);
return m;
}
inline Matrix Matrix::rotate(const Vec3& from, const Vec3& to )
{
Matrix m;
m.makeRot(from,to);
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,
@@ -128,16 +208,15 @@ inline Vec3 Matrix::operator * (const Vec3& v) const
(_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3])*d) ;
}
inline Vec3 operator * (const Vec3& v,const Matrix& m)
inline Vec3 Matrix::preMult( const Vec3& v ) const
{
float d = 1.0f/(m._mat[0][3]*v.x()+m._mat[1][3]*v.y()+m._mat[2][3]*v.z()+m._mat[3][3]) ;
return Vec3( (m._mat[0][0]*v.x() + m._mat[1][0]*v.y() + m._mat[2][0]*v.z() + m._mat[3][0])*d,
(m._mat[0][1]*v.x() + m._mat[1][1]*v.y() + m._mat[2][1]*v.z() + m._mat[3][1])*d,
(m._mat[0][2]*v.x() + m._mat[1][2]*v.y() + m._mat[2][2]*v.z() + m._mat[3][2])*d);
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::operator * (const Vec4& v) const
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()),
@@ -145,15 +224,13 @@ inline Vec4 Matrix::operator * (const Vec4& v) const
(_mat[3][0]*v.x() + _mat[3][1]*v.y() + _mat[3][2]*v.z() + _mat[3][3]*v.w())) ;
}
inline Vec4 operator * (const Vec4& v,const Matrix& m)
inline Vec4 Matrix::preMult( const Vec4& v ) const
{
return Vec4( (m._mat[0][0]*v.x() + m._mat[1][0]*v.y() + m._mat[2][0]*v.z() + m._mat[3][0]*v.w()),
(m._mat[0][1]*v.x() + m._mat[1][1]*v.y() + m._mat[2][1]*v.z() + m._mat[3][1]*v.w()),
(m._mat[0][2]*v.x() + m._mat[1][2]*v.y() + m._mat[2][2]*v.z() + m._mat[3][2]*v.w()),
(m._mat[0][3]*v.x() + m._mat[1][3]*v.y() + m._mat[2][3]*v.z() + m._mat[3][3]*v.w()));
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()),
@@ -168,17 +245,40 @@ inline Vec3 Matrix::transform3x3(const Matrix& m,const Vec3& v)
(m._mat[2][0]*v.x() + m._mat[2][1]*v.y() + m._mat[2][2]*v.z()) ) ;
}
inline ostream& operator << (ostream& output, const Matrix& matrix)
inline Vec3 operator* (const Vec3& v, const Matrix& m )
{
output << "{"<<endl
<< " " << matrix._mat[0][0] << " " << matrix._mat[0][1] << " " << matrix._mat[0][2] << " " << matrix._mat[0][3] << endl
<< " " << matrix._mat[1][0] << " " << matrix._mat[1][1] << " " << matrix._mat[1][2] << " " << matrix._mat[1][3] << endl
<< " " << matrix._mat[2][0] << " " << matrix._mat[2][1] << " " << matrix._mat[2][2] << " " << matrix._mat[2][3] << endl
<< " " << matrix._mat[3][0] << " " << matrix._mat[3][1] << " " << matrix._mat[3][2] << " " << matrix._mat[3][3] << endl
<< "}" << endl;
return output; // to enable cascading
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 ostream& operator<< (ostream& os, const Matrix& m )
{
os << "{"<<endl;
for(int row=0; row<4; ++row) {
os << "\t";
for(int col=0; col<4; ++col)
os << m(col,row) << " ";
os << endl;
}
os << "}" << endl;
return os;
}
}; //namespace osg
#endif