116 lines
3.6 KiB
Plaintext
116 lines
3.6 KiB
Plaintext
//C++ header - Open Scene Graph - Copyright (C) 1998-2002 Robert Osfield
|
|
//Distributed under the terms of the GNU Library General Public License (LGPL)
|
|
//as published by the Free Software Foundation.
|
|
|
|
#ifndef OSG_MATRIXTRANSFORM
|
|
#define OSG_MATRIXTRANSFORM 1
|
|
|
|
#include <osg/Transform>
|
|
#include <osg/AnimationPath>
|
|
|
|
namespace osg {
|
|
|
|
/** MatrixTransform - is a subclass of Transform which has an osg::Matrix
|
|
* which represent a 4x4 transformation of its children from local cordinates
|
|
* into the Transform's parent coordinates.
|
|
*/
|
|
class SG_EXPORT MatrixTransform : public Transform
|
|
{
|
|
public :
|
|
|
|
|
|
MatrixTransform();
|
|
|
|
/** Copy constructor using CopyOp to manage deep vs shallow copy.*/
|
|
MatrixTransform(const MatrixTransform&,const CopyOp& copyop=CopyOp::SHALLOW_COPY);
|
|
|
|
MatrixTransform(const Matrix& matix);
|
|
|
|
META_Node(osg, MatrixTransform);
|
|
|
|
/** Set the transform's matrix.*/
|
|
void setMatrix(const Matrix& mat) { (*_matrix) = mat; _inverseDirty=true; dirtyBound(); }
|
|
|
|
/** Get the matrix. */
|
|
inline const Matrix& getMatrix() const { return *_matrix; }
|
|
|
|
/** pre multiply the transforms matrix.*/
|
|
void preMult(const Matrix& mat) { _matrix->preMult(mat); _inverseDirty=true; dirtyBound(); }
|
|
|
|
/** post multiply the transforms matrix.*/
|
|
void postMult(const Matrix& mat) { _matrix->postMult(mat); _inverseDirty=true; dirtyBound(); }
|
|
|
|
/** Get the inverse matrix. */
|
|
inline const Matrix& getInverseMatrix() const
|
|
{
|
|
if (_inverseDirty)
|
|
{
|
|
_inverse->invert(*_matrix);
|
|
_inverseDirty = false;
|
|
}
|
|
return *_inverse;
|
|
}
|
|
|
|
virtual bool computeLocalToWorldMatrix(Matrix& matrix,NodeVisitor*) const
|
|
{
|
|
if (_referenceFrame==RELATIVE_TO_PARENTS)
|
|
{
|
|
matrix.preMult(*_matrix);
|
|
}
|
|
else // absolute
|
|
{
|
|
matrix = *_matrix;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
virtual bool computeWorldToLocalMatrix(Matrix& matrix,NodeVisitor*) const
|
|
{
|
|
const Matrix& inverse = getInverseMatrix();
|
|
|
|
if (_referenceFrame==RELATIVE_TO_PARENTS)
|
|
{
|
|
matrix.postMult(inverse);
|
|
}
|
|
else // absolute
|
|
{
|
|
matrix = inverse;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/** Callback which can be attached to a MatrixTransform as an app
|
|
* callback to allow it to follow the path defined by a AnimationPath.*/
|
|
class SG_EXPORT AnimationPathCallback : public NodeCallback
|
|
{
|
|
public:
|
|
|
|
AnimationPathCallback(AnimationPath* ap,double timeOffset=0.0f,double timeMultiplier=1.0f):
|
|
_animationPath(ap),
|
|
_timeOffset(timeOffset),
|
|
_timeMultiplier(timeMultiplier),
|
|
_firstTime(0.0) {}
|
|
|
|
/** implements the callback*/
|
|
virtual void operator()(Node* node, NodeVisitor* nv);
|
|
|
|
ref_ptr<AnimationPath> _animationPath;
|
|
double _timeOffset;
|
|
double _timeMultiplier;
|
|
double _firstTime;
|
|
};
|
|
|
|
protected :
|
|
|
|
virtual ~MatrixTransform();
|
|
|
|
ref_ptr<Matrix> _matrix;
|
|
mutable ref_ptr<Matrix> _inverse;
|
|
mutable bool _inverseDirty;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|