//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 const bool computeLocalToWorldMatrix(Matrix& matrix,NodeVisitor*) const
        {
            if (_referenceFrame==RELATIVE_TO_PARENTS)
            {
                matrix.preMult(*_matrix);
            }
            else // absolute
            {
                matrix = *_matrix;
            }
            return true;
        }

        virtual const 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