SO3AnimTrack.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser 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 Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser 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, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include "SO3Animation/SO3AnimTrack.h"
#include "SO3Animation/SO3Anim.h"
#include "SO3SceneGraph/SO3NodeScol.h"
 
namespace SO3
{
 
SAnimTrack::SAnimTrack(const std::string& animationTrackName, SAnim* animation, const AnimTrackType& animationTrackType) : SData(animationTrackName)
{
  type = animationTrackType;
  parentAnimation = animation;
 
  // To be initialised by a SAnimTrack derived class.
  ogreAnimationTrack = 0;
}
 
SAnimTrack::SAnimTrack() : SData(""), parentAnimation(0)
{
  //Forbiden (private)
}
 
SAnimTrack::~SAnimTrack()
{
  parentAnimation = 0;
  ogreAnimationTrack = 0;
}
 
Ogre::AnimationTrack* SAnimTrack::GetOgreAnimationTrackPointer()
{
        return ogreAnimationTrack;
}
 
SAnimTrack::AnimTrackType SAnimTrack::GetType()
{
  return type;
}
 
SAnim* SAnimTrack::GetParentAnimation()
{
  return parentAnimation;
}
 
unsigned short SAnimTrack::GetNumKeyFrames()
{
  unsigned short size = 0;
  if (ogreAnimationTrack)
    size = ogreAnimationTrack->getNumKeyFrames();
  return size;
}
 
void SAnimTrack::SetOptimise()
{
  if (ogreAnimationTrack)
    ogreAnimationTrack->optimise(); 
}
 
void SAnimTrack::Update(const float& pos)
{
}
 
void SAnimTrack::CreateKey(const float& timepos, const Ogre::Vector3& pos, const Ogre::Quaternion& quat, const Ogre::Vector3& scale)
{
}
 
void SAnimTrack::SetKeyTransform(const unsigned int& keyIndex, const Ogre::Vector3& pos, const Ogre::Quaternion& quat, const Ogre::Vector3& scale)
{
}
 
void SAnimTrack::GetKeyTransform(const unsigned int& keyIndex, Ogre::Vector3& pos, Ogre::Quaternion& quat, Ogre::Vector3& scale)
{
  pos = Ogre::Vector3::ZERO;
  quat = Ogre::Quaternion::IDENTITY;
  scale = Ogre::Vector3::ZERO;
}
 
float SAnimTrack::GetKeyPositionTime(const unsigned int& keyIndex)
{
  float postime = 0.0f;
  Ogre::KeyFrame* key = 0;
  if(((int)GetNumKeyFrames() - 1) >= (int)keyIndex)
    key = GetOgreAnimationTrackPointer()->getKeyFrame(keyIndex);
 
  if (key)
    postime = key->getTime();
 
  return postime;
}
 
void SAnimTrack::RemoveKey(const unsigned int& keyIndex)
{
        if(((int)GetNumKeyFrames() - 1) >= (int)keyIndex)
                GetOgreAnimationTrackPointer()->removeKeyFrame(keyIndex);
}
 
void SAnimTrack::RemoveAllKeyFrames()
{
}
 
Ogre::AnimationTrack* SAnimTrack::_Clone(Ogre::Animation* tanim, const unsigned short& tid)
{
  Ogre::AnimationTrack* newAnimTrack = 0;
  try
  {
    switch(type)
    {
      case SAnimTrack::SO3_NODE_TRACK:
        {
          Ogre::NodeAnimationTrack* nodeTrack = static_cast<Ogre::NodeAnimationTrack*>(ogreAnimationTrack);
          newAnimTrack = tanim->createNodeTrack(tid, nodeTrack->getAssociatedNode());
          for (int i = 0; i < nodeTrack->getNumKeyFrames(); i++)
          {
            Ogre::TransformKeyFrame* key = nodeTrack->getNodeKeyFrame(i);
            Ogre::TransformKeyFrame* nkey = static_cast<Ogre::NodeAnimationTrack*>(newAnimTrack)->createNodeKeyFrame(key->getTime());
            nkey->setRotation(key->getRotation());
            nkey->setScale(key->getScale());
            nkey->setTranslate(key->getTranslate());
          }
          break;
        }
/*
      case SAnimTrack::SO3_POSE_TRACK:
        {
          Ogre::VertexAnimationTrack* vertexTrack = static_cast<Ogre::VertexAnimationTrack*>(ogreAnimationTrack);
          newAnimTrack = tanim->createVertexTrack(tid, vertexTrack->getAssociatedVertexData(), vertexTrack->getAnimationType());
          for (int i = 0; i < vertexTrack->getNumKeyFrames(); i++)
          {
            Ogre::VertexPoseKeyFrame* key = vertexTrack->getVertexPoseKeyFrame(i);
            Ogre::VertexPoseKeyFrame* nkey = static_cast<Ogre::VertexAnimationTrack*>(newAnimTrack)->createVertexPoseKeyFrame(key->getTime());
            Ogre::VertexPoseKeyFrame::PoseRefIterator piterator = key->getPoseReferenceIterator();
            while (piterator.hasMoreElements())
            {
              Ogre::VertexPoseKeyFrame::PoseRef pref = piterator.getNext();
              key->addPoseReference(pref.poseIndex, pref.influence);
            }
          }
          break;
        }*/
 
      case SAnimTrack::SO3_VERTEX_TRACK || SAnimTrack::SO3_POSE_TRACK:
        {
          Ogre::VertexAnimationTrack* vertexTrack = static_cast<Ogre::VertexAnimationTrack*>(ogreAnimationTrack);
          newAnimTrack = tanim->createVertexTrack(tid, vertexTrack->getAssociatedVertexData(), vertexTrack->getAnimationType());
          for (int i = 0; i < vertexTrack->getNumKeyFrames(); i++)
          {
            Ogre::VertexMorphKeyFrame* key = vertexTrack->getVertexMorphKeyFrame(i);
            Ogre::VertexMorphKeyFrame* nkey = static_cast<Ogre::VertexAnimationTrack*>(newAnimTrack)->createVertexMorphKeyFrame(key->getTime());
            nkey->setVertexBuffer(key->getVertexBuffer());
          }
          break;
        }
 
      default:
        newAnimTrack = 0;
    }
  }
  catch (Ogre::Exception)
  {
  }
 
  return newAnimTrack;
}
 
}