animation.hpp

Go to the documentation of this file.

 
#pragma once
#include "core_types.hpp"
 
#include <cmath>
#include <cstdint>
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <span>
#include <string>
#include <toast/export.hpp>
#include <unordered_map>
#include <vector>
 
namespace assets {
 
namespace _detail {
inline constexpr uint32_t animation_format_version = 3;
}

enum class Interpolation : uint8_t {
  linear,
  step,
  cubic_spline,
};

enum class TrackTarget : uint8_t {
  translation,
  rotation,
  scale,
};

struct TOAST_API AnimationTrack {
  std::string target_node;    
  TrackTarget target = TrackTarget::translation;
  Interpolation interpolation = Interpolation::linear;
 
  std::vector<float> times;
  std::vector<glm::vec3> vec3_values;
  std::vector<glm::quat> quat_values;

  [[nodiscard]]
  auto keyframeCount() const -> size_t {
    return times.size();
  }

  [[nodiscard]]
  auto sampleVec3(float time) const -> glm::vec3;
 
  [[nodiscard]]
  auto sampleQuat(float time) const -> glm::quat;
};

struct NodePose {
  glm::vec3 translation {0.0f};
  glm::quat rotation {1.0f, 0.0f, 0.0f, 0.0f};
  glm::vec3 scale {1.0f};
  bool has_translation = false;
  bool has_rotation = false;
  bool has_scale = false;
};

struct TOAST_API AnimationClip {
  std::string name;
  float duration = 0.0f;    
  std::vector<AnimationTrack> tracks;

  [[nodiscard]]
  auto sample(float time) const -> std::unordered_map<std::string, NodePose>;

  [[nodiscard]]
  auto wrap(float time) const -> float {
    if (duration <= 0.0f) {
      return 0.0f;
    }
    const float wrapped = std::fmod(time, duration);
    return wrapped < 0.0f ? wrapped + duration : wrapped;
  }
};

struct TOAST_API Skin {
  std::string name;
  std::string skeleton_root;                       
  std::vector<std::string> joints;                 
  std::vector<glm::mat4> inverse_bind_matrices;    

  [[nodiscard]]
  auto jointMatrices(std::span<const glm::mat4> joint_world_transforms) const -> std::vector<glm::mat4>;
};

class TOAST_API Animation : public Asset {
public:
  explicit Animation(std::span<const uint8_t> data);
 
  [[nodiscard]]
  auto type() const -> std::string_view override {
    return "animation";
  }
 
  [[nodiscard]]
  auto clips() const noexcept -> const std::vector<AnimationClip>& {
    return m_clips;
  }
 
  [[nodiscard]]
  auto skins() const noexcept -> const std::vector<Skin>& {
    return m_skins;
  }

  [[nodiscard]]
  auto findClip(std::string_view name) const -> const AnimationClip*;

  [[nodiscard]]
  static auto toBinary(const std::vector<AnimationClip>& clips, const std::vector<Skin>& skins) -> std::vector<uint8_t>;
 
private:
  std::vector<AnimationClip> m_clips;
  std::vector<Skin> m_skins;
};
 
}