animation.hpp

Go to the documentation of this file.

#pragma once
 
#include "NNL/common/fixed_type.hpp"
#include "NNL/common/io.hpp"
#include "NNL/simple_asset/sanimation.hpp"
 
namespace nnl {
namespace animation {

struct KeyFrame {
  u16 time_tick{0};       
  glm::vec3 value{0.0f};  
};

struct BoneAnimation {
  std::vector<KeyFrame> scale_keys;        
  std::vector<KeyFrame> rotation_keys;     
  std::vector<KeyFrame> translation_keys;  
};

struct Animation {
  u16 duration_ticks = 1;                         
  std::vector<BoneAnimation> animation_channels;  
};

struct AnimationContainer {
  bool move_with_root = false;        
  std::vector<Animation> animations;  
};

std::vector<SAnimation> Convert(const AnimationContainer& animations);
struct ConvertParam {
  bool unbake = true;  
};

AnimationContainer Convert(std::vector<SAnimation>&& sanimations, const ConvertParam& anim_params = {},
                           bool move_with_root = false);
 
AnimationContainer Convert(std::vector<SAnimation>&& sanimations, const std::vector<ConvertParam>& anim_params,
                           bool move_with_root = false);

bool IsOfType(BufferView buffer);
 
bool IsOfType(const std::filesystem::path& path);
 
bool IsOfType(Reader& f);

AnimationContainer Import(BufferView buffer);
 
AnimationContainer Import(const std::filesystem::path& path);
 
AnimationContainer Import(Reader& f);
[[nodiscard]] Buffer Export(const AnimationContainer& animation_container);
 
void Export(const AnimationContainer& animation_container, const std::filesystem::path& path);
 
void Export(const AnimationContainer& animation_container, Writer& f);  // Main


SAnimation Convert(const Animation& animation);

Animation Convert(SAnimation&& sanimation, const ConvertParam& anim_param = {});  // Auxiliary
 
namespace raw {

constexpr u32 kMagicBytes = 0x86'00'00'01;
 
NNL_PACK(struct RHeader {
  u32 magic_bytes = kMagicBytes;          // 0x0
  u16 num_animations = 0;                 // 0x4
  u16 num_bones_per_animation = 0;        // 0x6
  u16 move_with_root = 0;                 // 0x8
  u16 padding = 0;                        // 0xA
  u32 offset_duration_table = 0;          // 0xC
  u32 offset_keyframe_table = 0;          // 0x10
  u32 offset_rotation_table = 0;          // 0x14
  u32 offset_scale_traslation_table = 0;  // 0x18
});
 
static_assert(sizeof(RHeader) == 0x1C);
 
NNL_PACK(struct RBoneAnimation {
  u32 index_keyframe_scale = 0;        // 0x0 index to keyframe table
  u32 index_keyframe_translation = 0;  // 0x8
  u32 index_keyframe_rotation = 0;     // 0x4
  u32 index_scale_table = 0;           // 0xC
  u32 index_rotation_table = 0;        // 0x10
  u32 index_translation_table = 0;     // 0x14 uses the same table as scale values
  u16 num_scale_transforms = 0;        // 0x18 how many subsequent keys to play
  u16 num_rotation_transforms = 0;     // 0x1A even if 0, the value at the index is still used
  u16 num_translation_transforms = 0;  // 0x1C
  u16 padding = 0;                     // padding
});
 
static_assert(sizeof(RBoneAnimation) == 0x20);
 
struct RAnimationContainer {
  RHeader header;
  std::vector<RBoneAnimation> bone_animations;
  std::vector<Vec3<f32>> scale_translation_table;
  std::vector<Vec3<i16>> rotation_table;  // normalized ints
  std::vector<u16> keyframe_table;
  std::vector<u16> duration_table;
};
 
AnimationContainer Convert(const RAnimationContainer& ranimation_container);
 
RAnimationContainer Parse(Reader& f);
}  // namespace raw
}  // namespace animation

}  // namespace nnl