AnimationSystem.h

#pragma once
 
#include "Components/Core/AnimationComponent.h"
 
#include "Systems/ComponentSystem.h"
 
#include "Resources/Animation.h"
#include "Resources/Skeleton.h"
 
namespace Cogs
{
  namespace Core
  {
    // Misc notes:
    // - If a mesh has the MeshFlags::Skinned set, the AnimationData::pose is pulled from
    //   the animation component of the entity that is drawing the mesh, and uploaded to
    //   the "AnimationBuffer" . This is an array of kMaxBones (=256).
    // - AnimationData::pose is updated in the end of AnimationSystem::update, and the mesh's
    //   poseIndexes are used to pull particular absolute bone matrices from the skeleton
    //   on AnimationData::skeleton. If the animation component has a master animation component,
    //   the skeleton of the master is used instead.
    // - AnimationComponent::clipIndex specifices which of the clips in AnimationComponent::animation
    //   that is used.
    // - Each clip has a set of track, where AnimationTrack::boneIndex specifies which bone in
    //   AnimationData::skeleton that the clip should animate. This is a copy of the skeleton 
    //   - Position/scale/rotation of each track is animated, and the corresponding bone's relative
    //     matrix gets updated.
    // - Bone::pos, Bone::scale, and Bone::rot is only used as default value for track evaluations,
    //   which is only used when track has no keyframes. They are not updated when animating.
    //   Bone::relative is usually used as authority.
 
 
    struct AnimationData
    {
      std::unique_ptr<Skeleton> skeleton;
      std::unique_ptr<PoseData> pose;
 
      Entity * root = nullptr;
      std::vector<ComponentModel::ComponentHandle> transformCache;
 
      AnimationCache cache;
    };
 
    class AnimationSystem : public ComponentSystemWithDataPool<AnimationComponent, AnimationData>
    {
    public:
      AnimationSystem(Memory::Allocator * allocator, SizeType capacity) : ComponentSystemWithDataPool(allocator, capacity) {}
 
      void update(AnimationComponent & animationComponent, float globalTime);
      void update(Context * context);
    };
  }
}