From Cedric Pinson, Pulled in osgAnimation from OpenSceneGraph-osgWidget-dev into svn/trunk.

src/osgAnimation/UpdateCallback.cpp

@@ -0,0 +1,170 @@
+/*  -*-c++-*- 
+ *  Copyright (C) 2008 Cedric Pinson <mornifle@plopbyte.net>
+ *
+ * This library is open source and may be redistributed and/or modified under  
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ * 
+ * This library 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 
+ * OpenSceneGraph Public License for more details.
+*/
+
+#include <osgAnimation/UpdateCallback>
+#include <osg/MatrixTransform>
+#include <osg/PositionAttitudeTransform>
+
+using namespace osgAnimation;
+
+osgAnimation::AnimationManagerBase* AnimationUpdateCallback::getAnimationManager() { return _manager.get(); }
+
+AnimationUpdateCallback::AnimationUpdateCallback(const AnimationUpdateCallback& apc,const osg::CopyOp& copyop):
+    osg::NodeCallback(apc, copyop),
+    _manager(apc._manager) {}
+
+int AnimationUpdateCallback::link(osgAnimation::Animation* animation)
+{
+    int nbLinks = 0;
+    for (osgAnimation::ChannelList::iterator it = animation->getChannels().begin();
+         it != animation->getChannels().end();
+         it++)
+    {
+        std::string targetName = (*it)->getTargetName();
+        if (targetName == getName()) 
+        {
+            link((*it).get());
+            nbLinks++;
+        }
+    }
+    return nbLinks;
+}
+    
+void AnimationUpdateCallback::updateLink()
+{
+    if (_manager.valid())
+    {
+        if (needLink()) 
+        {
+            /** this item is not linked yet then we do it for all animation
+                registered in the manager.
+                Maybe this function should be on the manager side like
+                _manager->linkItem(Bone);
+            */
+            AnimationMap map = _manager->getAnimationMap();
+            for (AnimationMap::iterator it = map.begin(); it != map.end(); it++)
+                link(it->second.get());
+            _manager->buildTargetReference();
+        }
+    }
+}
+
+
+
+
+UpdateTransform::UpdateTransform(const UpdateTransform& apc,const osg::CopyOp& copyop) 
+    : AnimationUpdateCallback(apc, copyop),
+      _euler(apc._euler),
+      _position(apc._position),
+      _scale(apc._scale)
+{
+}
+
+UpdateTransform::UpdateTransform(const std::string& name) : AnimationUpdateCallback(name) 
+{
+    _euler = new osgAnimation::Vec3Target;
+    _position = new osgAnimation::Vec3Target;
+    _scale = new osgAnimation::Vec3Target(osg::Vec3(1,1,1));
+}
+
+/** Callback method called by the NodeVisitor when visiting a node.*/
+void UpdateTransform::operator()(osg::Node* node, osg::NodeVisitor* nv)
+{
+    if (nv && nv->getVisitorType() == osg::NodeVisitor::UPDATE_VISITOR) 
+    {
+        osg::MatrixTransform* matrix = dynamic_cast<osg::MatrixTransform*>(node);
+        if (matrix) 
+        {
+            update(*matrix);
+        }
+        else 
+        {
+            osg::PositionAttitudeTransform* pat = dynamic_cast<osg::PositionAttitudeTransform*>(node);
+            if (pat)
+                update(*pat);
+        }
+    }
+    traverse(node,nv);
+}
+
+void UpdateTransform::update(osg::MatrixTransform& mat) 
+{
+    float z = _euler->getValue()[2];
+    float x = _euler->getValue()[0];
+    float y = _euler->getValue()[1];
+    osg::Matrix m = 
+        osg::Matrix::rotate(x,1.0,0.0,0.0) * 
+        osg::Matrix::rotate(y,0.0,1.0,0.0) *
+        osg::Matrix::rotate(z,0.0,0.0,1.0);
+    mat.setMatrix(osg::Matrix::scale(_scale->getValue()) * 
+                  m *
+                  osg::Matrix::translate(_position->getValue()));
+    mat.dirtyBound();
+}
+
+void UpdateTransform::update(osg::PositionAttitudeTransform& pat) 
+{
+    float heading = _euler->getValue()[0];
+    float pitch = _euler->getValue()[1];
+    float roll = _euler->getValue()[2];
+    osg::Matrix m = osg::Matrix::rotate(roll,0.0,1.0,0.0) * osg::Matrix::rotate(pitch,1.0,0.0,0.0) * osg::Matrix::rotate(-heading,0.0,0.0,1.0);
+    osg::Quat q = m.getRotate();
+
+    pat.setPosition(_position->getValue());
+    pat.setScale(_scale->getValue());
+    pat.setAttitude(q);
+    pat.dirtyBound();
+}
+
+bool UpdateTransform::needLink() const
+{
+    // the idea is to return true if nothing is linked
+    return !((_position->getCount() + _euler->getCount() + _scale->getCount()) > 3);
+}
+
+bool UpdateTransform::link(osgAnimation::Channel* channel)
+{
+    if (channel->getName().find("euler") != std::string::npos) 
+    {
+        osgAnimation::Vec3LinearChannel* qc = dynamic_cast<osgAnimation::Vec3LinearChannel*>(channel);
+        if (qc) 
+        {
+            qc->setTarget(_euler.get());
+            return true;
+        }
+    }
+    else if (channel->getName().find("position") != std::string::npos) 
+    {
+        osgAnimation::Vec3LinearChannel* vc = dynamic_cast<osgAnimation::Vec3LinearChannel*>(channel);
+        if (vc) 
+        {
+            vc->setTarget(_position.get());
+            return true;
+        }
+    }
+    else if (channel->getName().find("scale") != std::string::npos) 
+    {
+        osgAnimation::Vec3LinearChannel* vc = dynamic_cast<osgAnimation::Vec3LinearChannel*>(channel);
+        if (vc) 
+        {
+            vc->setTarget(_scale.get());
+            return true;
+        }
+    } 
+    else 
+    {
+        std::cerr << "Channel " << channel->getName() << " does not contain a valid symbolic name for this class" << std::endl;
+    }
+    return false;
+}