AnimationSystem.cpp

#include "AnimationSystem.h"
 
#include "Context.h"
 
#include "Resources/Animation.h"
#include "Resources/Skeleton.h"
#include "Resources/Mesh.h"
 
#include "Systems/Core/TransformSystem.h"
 
#include "Components/Core/SceneComponent.h"
#include "Components/Core/MeshComponent.h"
 
#include "Services/Time.h"
#include "Services/Variables.h"
 
#include "Utilities/Parallel.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/ComponentModel/Entity.h"
 
#include <glm/gtx/compatibility.hpp>
 
using namespace Cogs::Core;
 
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("AnimationSystem");
}
 
 
void Cogs::Core::updateSkeletonPose(Skeleton & skeleton)
{
  if (skeleton.bones.empty()) return;
 
  for (auto & bone : skeleton.bones) {
    bool isRoot = bone.parentBone == size_t(- 1);
 
    if (isRoot) {
      bone.absolute = bone.relative;
    } else {
      auto & parent = skeleton.bones[bone.parentBone];
 
      bone.absolute = parent.absolute * bone.relative;
    }
  }
}
 
template<typename T, typename Collection>
T evalTrack(Collection & keyFrames, T defaultValue, float time)
{
  if (keyFrames.empty()) return defaultValue;
 
  size_t frame = 0;
 
  for (; frame < keyFrames.size() - 1; ++frame) {
    if (time < keyFrames[frame + 1].t) break;
  }
 
  T key = keyFrames[frame].value;
 
  size_t nextFrame = frame + 1;
  if (nextFrame >= keyFrames.size()) {
    return key;
  }
 
  T nextKey = keyFrames[nextFrame].value;
 
  const float range = keyFrames[frame + 1].t - keyFrames[frame].t;
  const float diff = time - keyFrames[frame].t;
 
  float v = diff / range;
  v = glm::max(0.0f, glm::min(v, 1.0f));
 
  return glm::lerp(key, nextKey, v);
}
 
template<typename T, typename Collection>
T evalRotationTrack(Collection & keyFrames, T defaultValue, float time)
{
  if (keyFrames.empty()) return defaultValue;
 
  size_t frame = 0;
 
  for (; frame < keyFrames.size() - 1; ++frame) {
    if (time < keyFrames[frame + 1].t) break;
  }
 
  T key = keyFrames[frame].value;
 
  size_t nextFrame = frame + 1;
  if (nextFrame >= keyFrames.size()) {
    return key;
  }
 
  T nextKey = keyFrames[nextFrame].value;
 
  const float range = keyFrames[frame + 1].t - keyFrames[frame].t;
  const float diff = time - keyFrames[frame].t;
 
  float v = diff / range;
  v = glm::max(0.0f, glm::min(v, 1.0f));
 
  return glm::slerp(key, nextKey, v);
}
 
void evalClip(Skeleton & skeleton, const AnimationClip & clip, AnimationCache & cache, float time)
{
  const auto numTracks = clip.tracks.size();
  cache.tracks.resize(numTracks);
 
  for (size_t j = 0; j < numTracks; ++j) {
    auto & track = clip.tracks[j];
 
    if (track.boneIndex == uint32_t(-1)) continue;
 
    Bone & bone = skeleton.bones[track.boneIndex];
    const auto position = evalTrack(track.translations, bone.pos, time);
    const auto scale = evalTrack(track.scales, bone.scale, time);
    const auto rotation = evalRotationTrack(track.rotations, bone.rot, time);
 
    bone.relative = glm::translate(position) * glm::mat4_cast(rotation) * glm::scale(scale);
  }
}
 
Entity * findEntityByName(const Cogs::StringView & name, Entity * entity)
{
  auto sceneComponent = entity->getComponent<SceneComponent>();
 
  for (auto & child : sceneComponent->children) {
    if (name == child->getName()) {
      return child.get();
    } else {
      auto found = findEntityByName(name, child.get());
 
      if (found) return found;
    }
  }
 
  return nullptr;
}
 
void Cogs::Core::AnimationSystem::update(AnimationComponent & animationComponent, float globalTime)
{
  if (!animationComponent.animation) return;
 
  auto & animationData = getData(&animationComponent);
 
  auto animation = animationComponent.animation.resolve();
 
  if (!animationData.skeleton) {
    animationData.skeleton = std::make_unique<Skeleton>();
    animationData.pose = std::make_unique<PoseData>();
  }
 
  if (animationData.skeleton->bones.empty()) {
    *animationData.skeleton = animation->skeleton;
 
    for (size_t i = 0; i < kMaxBones; ++i) {
      animationData.pose->transforms[i] = glm::mat4(1.0f);
    }
  }
 
  if (!animationComponent.master && animationComponent.clipIndex != -1) {
    int clipIndex = animationComponent.clipIndex;
    if (clipIndex < 0 || static_cast<size_t>(clipIndex) >= animation->clips.size()) {
      LOG_WARNING(logger, "Animation clip index %d out of bounds.", clipIndex);
      return;
    }
    auto & clip = animation->clips[clipIndex];
 
    float time = (globalTime + animationComponent.timeOffset) * animationComponent.timeFactor * (clip.resolution ? clip.resolution : 1000.0f);
    time = clip.duration != 0 ? std::fmod(time, clip.duration) : 0.0f;
 
    auto & skeleton = *animationData.skeleton;
 
    evalClip(skeleton, clip, animationData.cache, time);
    updateSkeletonPose(skeleton);
 
    animationData.transformCache.resize(skeleton.bones.size());
 
    for (size_t i = 0; i < skeleton.bones.size(); ++i) {
      auto & b = skeleton.bones[i];
 
      if (b.hasOffset && b.used) {
        b.absolute = skeleton.bindPose * b.absolute * b.inverseBindPose;
      }
 
      if (b.animated) {
        if (animationData.root == nullptr) {
          if (Component* masterAnim = animationComponent.master.resolve(); masterAnim) {
            animationData.root = masterAnim->getContainer();
          }
          else {
            animationData.root = animationComponent.getContainer();
          }
        }
        assert(animationData.root);
 
        TransformComponent* trComp = nullptr;
        if (animationData.transformCache[i]) {
          auto * comp = animationData.transformCache[i].resolveComponent<TransformComponent>();
          if (animationData.transformCache[i].generation != comp->getGeneration()) {
            // Stale handle
            animationData.transformCache[i] = ComponentHandle::Empty();
          }
          else {
            trComp = comp;
          }
        }
        if (!trComp) {
          if (auto e = findEntityByName(b.name, animationData.root); e) {
            animationData.transformCache[i] = e->getComponentHandle<TransformComponent>();
            trComp = animationData.transformCache[i].resolveComponent<TransformComponent>();
          }
        }
        if(trComp) {
          trComp->transform = b.relative;
          trComp->transformFlags = 1;
          trComp->setChanged();
        }
      }
    }
  }
 
  auto * meshComponent = animationComponent.getComponent<MeshComponent>();
  if (meshComponent && meshComponent->meshHandle) {
    auto * mesh = meshComponent->meshHandle.resolve();
 
    if (mesh->getPoseIndexes().size() > kMaxBones) {
      LOG_WARNING(logger, "Bones array too large.");
      return;
    }
 
    animationData.pose->numPoses = mesh->getPoseIndexes().size();
 
    auto poseSkeleton = animationData.skeleton.get();
    if (animationComponent.master) {
      auto masterComponent = animationComponent.master.resolveComponent<AnimationComponent>();
      poseSkeleton = getData(masterComponent).skeleton.get();
    }
 
    for (size_t i = 0; i < mesh->getPoseIndexes().size(); ++i) {
      animationData.pose->transforms[i] = poseSkeleton->bones[mesh->getPoseIndexes()[i]].absolute;
    }
  }
}
 
void Cogs::Core::AnimationSystem::update(Context * context)
{
  const float globalTime = static_cast<float>(context->time->getAnimationTime());
 
  const bool workParallel = context->engine->workParallel();
 
  if (workParallel) {
    auto task = Parallel::processComponents(
      context, pool, "AnimationSystem::updateMaster", [&](AnimationComponent & animationComponent, size_t /*j*/) {
        if (!animationComponent.master) {
          update(animationComponent, globalTime);
        }
      });
 
    context->taskManager->destroy(task);
 
    task = Parallel::processComponents(
      context, pool, "AnimationSystem::update", [&](AnimationComponent & animationComponent, size_t /*j*/) {
        if (animationComponent.master) {
          update(animationComponent, globalTime);
        }
      });
 
    context->taskManager->destroy(task);
  } else {
    for (auto & animationComponent : pool) {
      update(animationComponent, globalTime);
    }
  }
}