SO3Engine/SO3Animation/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) 2010 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

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

#include "SO3AnimTrack.h"
#include "SO3Anim.h"
#include "../SO3SceneGraph/SO3NodeScol.h"

namespace SO3
{

SAnimTrack::SAnimTrack(std::string animationTrackName, SAnim* animation, 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(float pos)
{
}

void SAnimTrack::CreateKey(float timepos, Ogre::Vector3 pos, Ogre::Quaternion quat, Ogre::Vector3 scale)
{
}

void SAnimTrack::SetKeyTransform(unsigned int keyIndex, Ogre::Vector3 pos, Ogre::Quaternion quat, Ogre::Vector3 scale)
{
}

void SAnimTrack::GetKeyTransform(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(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(unsigned int keyIndex)
{
        if(((int)GetNumKeyFrames() - 1) >= (int)keyIndex)
                GetOgreAnimationTrackPointer()->removeKeyFrame(keyIndex);
}

void SAnimTrack::RemoveAllKeyFrames()
{
}

Ogre::AnimationTrack* SAnimTrack::_Clone(Ogre::Animation* tanim, 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;
}

}

---