SO3SequenceAnimationTrack.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/SO3SequenceAnimation.h"
#include "SO3Animation/SO3SequenceAnimationTrack.h"
 
namespace SO3
{
 
SSequenceAnimationTrack::SSequenceAnimationTrack(const std::string& animationTrackName, SSequenceAnimation* animation, const unsigned short& trackAnimationId) : SAnimTrack(animationTrackName, animation, SAnimTrack::SO3_SEQUENCE_TRACK)
{
  mLength = 0.0f;
}
 
SSequenceAnimationTrack::~SSequenceAnimationTrack()
{
  EnableTrackKeys(false);
  const SAnimSequenceKeyList keylistCpy = keyList;
  SAnimSequenceKeyList::const_iterator it = keylistCpy.begin();
  while (it != keylistCpy.end())
  {
    RemoveKey(*it, false);
    it++;
  }
}
 
SSequenceAnimationTrack::SSequenceAnimationTrack() : SAnimTrack("", 0, SAnimTrack::SO3_NODE_TRACK)
{
}
 
SSequenceAnimationKey* SSequenceAnimationTrack::AddKey(SAnim* anim, const float& length, const float& transtime, const float& decaltime)
{
  // do not add an SAnim from an another scene
  if (anim->GetParentScene() != GetParentAnimation()->GetParentScene())
    return 0;
 
  SSequenceAnimationKey* key = new SSequenceAnimationKey(anim, GetLength() - transtime + decaltime, length, transtime, decaltime);
  SetLength(GetLength() + length - transtime + decaltime);
  
  //update animation length
  static_cast<SSequenceAnimation*>(GetParentAnimation())->UpdateAnimationLength();
  
  keyList.push_back(key);
  return key;
}
 
void SSequenceAnimationTrack::UpdateTrackTime()
{
  float length = 0.0f;
  SAnimSequenceKeyList::iterator it = keyList.begin();
 
  while (it != keyList.end())
  {
    SAnim* anim = (*it)->GetAnim();
    float klength = (*it)->GetLength();
    float decaltime = (*it)->GetDecalTime();
    float transtime = (*it)->GetTransitionTime();
    (*it)->SetPosition(length - transtime + decaltime);
    length = length + klength - transtime + decaltime;
    it++;
  }
 
  //update track length
  SetLength(length);
 
  //update animation length
  static_cast<SSequenceAnimation*>(GetParentAnimation())->UpdateAnimationLength();
}
 
void SSequenceAnimationTrack::RemoveKey(SSequenceAnimationKey* key, const bool& reset)
{
  //DO NOT CALL THIS ON key anim DESTRUCTION
  if (reset && key->IsUsed())
  {
    SAnim* anim = key->GetAnim();
    anim->SetSequenceUpdated(false);
    key->SetUsed(false);
 
    if (!anim->IsSequenceUpdated())
    {
      anim->SetEnable(false);
      anim->SetLoop(anim->GetInitialLoop());
      anim->SetTimePosition(0.0f);
      anim->SetWeight(anim->GetInitialWeight());
    }
  }
 
  SAnimSequenceKeyList::iterator it = std::find(keyList.begin(), keyList.end(), key);
  if (it != keyList.end())
    keyList.erase(it);
 
  SO3_SAFE_DELETE(key);
  UpdateTrackTime();
}
 
void SSequenceAnimationTrack::SetKey(const unsigned int& index, const float& length, const float& transition, const float& decaltime)
{
  SSequenceAnimationKey* key = GetKeyFromIndex(index);
  if (key)
  {
    key->SetLength(length);
    key->SetTransitionTime(transition);
    key->SetDecalTime(decaltime);
    UpdateTrackTime();
  }
}
 
SSequenceAnimationKey* SSequenceAnimationTrack::GetKeyFromIndex(const unsigned int& index)
{
  if (((int)(keyList.size()) - 1) < (int)index)
    return 0;
 
  return keyList.at(index);
}
 
bool SSequenceAnimationTrack::MoveKeyFromIndex(const unsigned int& index, const unsigned int& newindex)
{
  if (((keyList.size() - 1) < index) || ((keyList.size() - 1) < newindex) || (index == newindex))
    return false;
  
  SSequenceAnimationKey* mvkey = keyList[newindex];
  keyList[newindex] = keyList.at(index);
  keyList[index] = mvkey;
  
  UpdateTrackTime();
  return true;
}
 
SAnimSequenceKeyList SSequenceAnimationTrack::GetKeysFromAnim(SAnim* anim)
{
  SAnimSequenceKeyList list;
 
  SAnimSequenceKeyList::iterator it = keyList.begin();
  while (it != keyList.end())
  {
    if ((*it)->GetAnim() == anim)
      list.push_back(*it);
    it++;
  }
 
  return list;
}
 
void SSequenceAnimationTrack::RemoveKeysWithAnim(SAnim* anim, const bool& reset)
{
  const SAnimSequenceKeyList keylistCpy = keyList;
  SAnimSequenceKeyList::const_iterator it = keylistCpy.begin();
  while (it != keylistCpy.end())
  {
    if ((*it)->GetAnim() == anim)
      RemoveKey(*it, reset);
    it++;
  }
}
 
void SSequenceAnimationTrack::SetLength(const float& length)
{
  mLength = length;
}
 
float SSequenceAnimationTrack::GetLength()
{
  return mLength;
}
 
void SSequenceAnimationTrack::EnableTrackKeys(const bool& enable)
{
  SAnimSequenceKeyList::iterator ikey = keyList.begin();
  while (ikey != keyList.end())
  {
    SAnim* anim = (*ikey)->GetAnim();
    if (!enable && ((*ikey)->IsUsed() == true))
    {
      anim->SetSequenceUpdated(false);
      (*ikey)->SetUsed(false);
 
      if (!anim->IsSequenceUpdated())
      {
        anim->SetEnable(false);
        anim->SetLoop(anim->GetInitialLoop());
        anim->SetTimePosition(0.0f);
        anim->SetWeight(anim->GetInitialWeight());
      }
    }
 
    ikey++;
  }
}
 
unsigned short SSequenceAnimationTrack::GetNumKeyFrames()
{
  return (unsigned short)keyList.size();
}
 
float SSequenceAnimationTrack::GetKeyPositionTime(const unsigned int& keyIndex)
{
  float postime = 0.0f;
  SSequenceAnimationKey* key = 0;
  if(((int)GetNumKeyFrames() - 1) >= (int)keyIndex)
    key = GetKeyFromIndex(keyIndex);
 
  if (key)
    postime = key->GetPosition();
 
  return postime;
}
 
void SSequenceAnimationTrack::RemoveKey(const unsigned int& keyIndex)
{
        if(((int)GetNumKeyFrames() - 1) >= (int)keyIndex)
  {
                SSequenceAnimationKey* key = GetKeyFromIndex(keyIndex);
    RemoveKey(key, true);
  }
}
 
void SSequenceAnimationTrack::RemoveAllKeyFrames()
{
  EnableTrackKeys(false);
 
  const SAnimSequenceKeyList keylistCpy = keyList;
  SAnimSequenceKeyList::const_iterator it = keylistCpy.begin();
  while (it != keylistCpy.end())
  {
    RemoveKey(*it, true);
    it++;
  }
}
 
void SSequenceAnimationTrack::Update(const float& pos)
{
  float lastPos = static_cast<SSequenceAnimation*>(GetParentAnimation())->GetLastPos();
  bool stopIterate = false;
 
  //Manage skipped keys
  //reset missed animations next to the position before
  if (pos < lastPos)
  {
    SAnimSequenceKeyList::reverse_iterator nextKeyIt = keyList.rbegin();
    while ((nextKeyIt != keyList.rend()) && !stopIterate)
    {
      SAnim* anim = (*nextKeyIt)->GetAnim();
      float spos = (*nextKeyIt)->GetPosition();
      float klength = (*nextKeyIt)->GetLength();
      if ((spos > pos) && (spos < lastPos))
      {
        anim->SetEnable(true);
        anim->Apply(0.0f);
 
        if (((*nextKeyIt)->IsUsed() == true) && anim->IsSequenceUpdated())
        {
          anim->SetSequenceUpdated(false);
          (*nextKeyIt)->SetUsed(false);
        }
 
        if (!anim->IsSequenceUpdated())
        {
          anim->SetEnable(false);
          anim->SetLoop(anim->GetInitialLoop());
          //anim->SetTimePosition(0.0f);
          anim->SetWeight(anim->GetInitialWeight());
        }
      }
      else if (spos <= pos)
      {
        stopIterate = true;
      }
      
      if (((*nextKeyIt)->IsUsed() == true) && anim->IsSequenceUpdated())
      {
        anim->SetSequenceUpdated(false);
        (*nextKeyIt)->SetUsed(false);
 
        if (!anim->IsSequenceUpdated())
        {
          anim->SetEnable(false);
          anim->SetLoop(anim->GetInitialLoop());
          //anim->SetTimePosition(0.0f);
          anim->SetWeight(anim->GetInitialWeight());
        }
      }
 
      nextKeyIt++;
    }
 
    stopIterate = false;
  }
  //reset missed animations previous to the position to their end position
  else if (pos > lastPos) 
  {
    SAnimSequenceKeyList::iterator prevKeyIt = keyList.begin();
    while ((prevKeyIt != keyList.end()) && !stopIterate)
    {
      SAnim* anim = (*prevKeyIt)->GetAnim();
      float spos = (*prevKeyIt)->GetPosition();
      float klength = (*prevKeyIt)->GetLength();
      if (((spos + klength) > lastPos) && ((spos + klength) < pos))
      {
        anim->SetEnable(true);
        
        // anim fade out
        if ((prevKeyIt + 1) != keyList.end())
        {
          prevKeyIt++;
          SSequenceAnimationKey* nextkey = (*prevKeyIt);
          if (nextkey->GetTransitionTime() != 0.0f)
            anim->SetWeight(0.0);
          prevKeyIt--;
        }
        
        if (anim->GetLength() <= klength)
          anim->SetLoop(false);
 
        anim->Apply(klength);
 
        if (((*prevKeyIt)->IsUsed() == true) && anim->IsSequenceUpdated())
        {
          anim->SetSequenceUpdated(false);
          (*prevKeyIt)->SetUsed(false);
        }
 
        if (!anim->IsSequenceUpdated())
        {
          anim->SetEnable(false);
          anim->SetLoop(anim->GetInitialLoop());
          //anim->SetTimePosition(0.0f);
          anim->SetWeight(anim->GetInitialWeight());
        }
      }
      else if ((spos + klength) >= pos)
      {
        stopIterate = true;
      }
 
      if (((*prevKeyIt)->IsUsed() == true) && anim->IsSequenceUpdated())
      {
        anim->SetSequenceUpdated(false);
        (*prevKeyIt)->SetUsed(false);
 
        if (!anim->IsSequenceUpdated())
        {
          anim->SetEnable(false);
          anim->SetLoop(anim->GetInitialLoop());
          //anim->SetTimePosition(0.0f);
          anim->SetWeight(anim->GetInitialWeight());
        }
      }
 
      prevKeyIt++;
    }
 
    stopIterate = false;
  }
 
  //update current animations
  SAnimSequenceKeyList::iterator keyIt = keyList.begin();
  while ((keyIt != keyList.end()) && !stopIterate)
  {
    SAnim* anim = (*keyIt)->GetAnim();
    float spos = (*keyIt)->GetPosition();
    float klength = (*keyIt)->GetLength();
    float transtime = (*keyIt)->GetTransitionTime();
    float endpos = spos + klength;
    float updpos = pos - spos;
    float transStep = 1.0f;
 
    if ((pos >= spos) && (pos <= endpos))
    {
      if ((*keyIt)->IsUsed() == false)
      {
        anim->SetSequenceUpdated(true);
        (*keyIt)->SetUsed(true);
      }
      
      anim->SetEnable(true);
      anim->SetLoop(true);
      
      // anim fade in
      if (((pos - spos) < transtime) && (transtime != 0.0f))
      {
        transStep = (pos - spos) / transtime;
        
        // anim fade out
        if (keyIt != keyList.begin())
        {
          keyIt--;
          SSequenceAnimationKey* prevkey = (*keyIt);
          if ((pos >= prevkey->GetPosition()) && (pos < (prevkey->GetPosition() + prevkey->GetLength())))
          {
            prevkey->GetAnim()->SetWeight(GetParentAnimation()->GetWeight() * prevkey->GetAnim()->GetInitialWeight() * (1.0f - transStep));
            // force update by setting the time position (for sequence animation key type)
            prevkey->GetAnim()->SetTimePosition(prevkey->GetAnim()->GetTimePosition());
          }
          keyIt++;
        }
      }
      
      anim->SetWeight(GetParentAnimation()->GetWeight() * anim->GetInitialWeight() * transStep);
      anim->SetTimePosition(updpos);
    }
    else if (spos + klength > pos)
    {
      stopIterate = true;
    }
 
    keyIt++;
  }  
}
 
}