12226e4371
and passed as paramters into straight forward non const built in types, i.e. const bool foogbar(const int) becomes bool foobar(int).
112 lines
3.3 KiB
Plaintext
112 lines
3.3 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):
|
|
_animationPath(ap),
|
|
_firstTime(0.0) {}
|
|
|
|
/** implements the callback*/
|
|
virtual void operator()(Node* node, NodeVisitor* nv);
|
|
|
|
ref_ptr<AnimationPath> _animationPath;
|
|
double _firstTime;
|
|
};
|
|
|
|
protected :
|
|
|
|
virtual ~MatrixTransform();
|
|
|
|
ref_ptr<Matrix> _matrix;
|
|
mutable ref_ptr<Matrix> _inverse;
|
|
mutable bool _inverseDirty;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|