src/AnimationPathTimedCallback.cpp

Go to the documentation of this file.

/*

Traplas visualisation.

Copyright (C) 2006 Herbert de Vos & Willem Drost

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

This program 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 GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

(For full Licence see ../GPL-Licence.txt)

*/

#include "Globals.h"


#include "AnimationPathTimedCallback.h"
#include <osg/NodeVisitor>
#include "Dispatcher.h"
#include <stdio.h>
#include <iostream>

#include <osg/AnimationPath>
#include <osg/MatrixTransform>
#include <osg/PositionAttitudeTransform>
#include <osg/CameraNode>
#include <osg/CameraView>
#include <osg/io_utils>

using namespace std;
using namespace osg;

class AnimationPathCallbackVisitor : public NodeVisitor
{
    public:

        AnimationPathCallbackVisitor(const AnimationPath::ControlPoint& cp, const osg::Vec3d& pivotPoint, bool useInverseMatrix):
            _cp(cp),
            _pivotPoint(pivotPoint),
            _useInverseMatrix(useInverseMatrix) {}

        virtual void apply(CameraNode& camera)
        {
            Matrix matrix;
            if (_useInverseMatrix)
                _cp.getInverse(matrix);
            else
                _cp.getMatrix(matrix);
                
            camera.setViewMatrix(osg::Matrix::translate(-_pivotPoint)*matrix);
        }
        

        virtual void apply(CameraView& cv)
        {
            if (_useInverseMatrix)
            {
                Matrix matrix;
                _cp.getInverse(matrix);
                cv.setPosition(matrix.getTrans());
                cv.setAttitude(_cp.getRotation().inverse());
                cv.setFocalLength(1.0f/_cp.getScale().x());
                
            }
            else
            {
                cv.setPosition(_cp.getPosition());
                cv.setAttitude(_cp.getRotation());
                cv.setFocalLength(_cp.getScale().x());
            }
        }

        virtual void apply(MatrixTransform& mt)
        {
            Matrix matrix;
            if (_useInverseMatrix)
                _cp.getInverse(matrix);
            else
                _cp.getMatrix(matrix);
                
            mt.setMatrix(osg::Matrix::translate(-_pivotPoint)*matrix);
        }
        
        virtual void apply(PositionAttitudeTransform& pat)
        {
            if (_useInverseMatrix)
            {
                Matrix matrix;
                _cp.getInverse(matrix);
                pat.setPosition(matrix.getTrans());
                pat.setAttitude(_cp.getRotation().inverse());
                pat.setScale(osg::Vec3(1.0f/_cp.getScale().x(),1.0f/_cp.getScale().y(),1.0f/_cp.getScale().z()));
                pat.setPivotPoint(_pivotPoint);
                
            }
            else
            {
                pat.setPosition(_cp.getPosition());
                pat.setAttitude(_cp.getRotation());
                pat.setScale(_cp.getScale());
                pat.setPivotPoint(_pivotPoint);
            }
        }
        
        AnimationPath::ControlPoint _cp;
        osg::Vec3d _pivotPoint;
        bool _useInverseMatrix;      
};

AnimationPathTimedCallback::AnimationPathTimedCallback()
: osg::AnimationPathCallback()
{
        elapsed = 0;
}

double AnimationPathTimedCallback::getAnimationTime () const
{
        return elapsed;
}

void AnimationPathTimedCallback::update(osg::Node& node)
{
    osg::AnimationPath::ControlPoint cp;
    if (_animationPath->getInterpolatedControlPoint(getAnimationTime(),cp))
    {
        AnimationPathCallbackVisitor apcv(cp,_pivotPoint,_useInverseMatrix);
        node.accept(apcv);
    }
}

void AnimationPathTimedCallback::operator()(osg::Node* node, osg::NodeVisitor* nv){
//Copy of the contents of the update operator() of the superclass, with modifications:
        

        double timeScale = timeKeeper->getTimeFlow();
        
        if ( AnimationPathTimedCallback::_timeMultiplier != timeScale ) {
                AnimationPathTimedCallback::_timeMultiplier = timeScale;                
        }
        

        if (_animationPath.valid() && nv->getVisitorType()==osg::NodeVisitor::UPDATE_VISITOR && nv->getFrameStamp()){
                double time = nv->getFrameStamp()->getReferenceTime();
                elapsed += (time - _latestTime) * _timeMultiplier;
                _latestTime = time;
                if (!_pause){
                        // Only update _firstTime the first time, when its value is still DBL_MAX
                        if (_firstTime==DBL_MAX) {
                                _firstTime = time;
                                elapsed = 0;
                        }
                        update(*node);
                }
        }
        // must call any nested node callbacks and continue subgraph traversal.
        NodeCallback::traverse(node,nv);
}

void AnimationPathTimedCallback::setTimeReference(Dispatcher* dp){
        timeKeeper = dp;
}

---