visanimation.hpp

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <vector>
 
#include "NNL/common/fixed_type.hpp"
#include "NNL/common/io.hpp"
#include "NNL/simple_asset/sanimation.hpp"
namespace nnl {
namespace visanimation {
struct KeyFrame {
  u16 time_tick = 0;                             
  u16 flags_enable_groups = 0b0000000000000000;  
};

struct Animation {
  std::vector<KeyFrame> left_channel;   
  std::vector<KeyFrame> right_channel;  
};

struct AnimationContainer {
  u16 flags_disable_left_channel = 0b0000000000000000;   
  u16 flags_disable_right_channel = 0b0000000000000000;  
  std::vector<Animation> animations;                     
};

AnimationContainer Convert(std::vector<SVisibilityAnimation>&& sanimations);

std::vector<SVisibilityAnimation> Convert(const AnimationContainer& animation_container);

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);


Animation Convert(SVisibilityAnimation&& sanimation);

SVisibilityAnimation Convert(const Animation& animation, u16 flags_disable_left, u16 flags_disable_right);
 
namespace raw {
constexpr u16 kMagicBytes = 0;  
 
NNL_PACK(struct RHeader {
  u16 magic_bytes = kMagicBytes;
  u16 num_animations = 0;
  u16 flags_disable_left_channel = 0b0000000000000000;
  u16 flags_disable_right_channel = 0b0000000000000000;
});
 
static_assert(sizeof(RHeader) == 0x8);
 
NNL_PACK(struct RAnimation {
  u32 offset_keyframes = 0;
  u16 num_left_channel_keyframes = 0;
  u16 num_right_channel_keyframes = 0;
});
 
static_assert(sizeof(RAnimation) == 0x8);
 
NNL_PACK(struct RKeyFrame {
  u16 time_tick = 0;
  u16 flags_enable_groups = 0b0000000000000000;
});
 
static_assert(sizeof(RKeyFrame) == 0x4);
 
struct RAnimationContainer {
  RHeader header;
  std::vector<RAnimation> animations;
 
  // Maps of offsets (used in the structures above) to their data:
  std::map<u32, std::vector<RKeyFrame>> keyframes;
};
 
AnimationContainer Convert(const RAnimationContainer& rsubanim);
 
RAnimationContainer Parse(Reader& f);
}  // namespace raw
}  // namespace visanimation

}  // namespace nnl