AnimFactory.h

#pragma once
 
#include <factories/BaseFactory.h>
#include "factories/bk64/BKHeaderExporter.h"
 
namespace BK64 {
 
typedef union { // transform structure [xx xx] -> [DE FF FF FF FF FF FF FF]
    struct {
        uint8_t unk0_15 : 1;   // bit flag 1 [D]
        uint8_t unk0_14 : 1;   // bit flag 2 [E]
        uint16_t unk0_13 : 14; // frame of transformation [FF FF FF FF FF FF FF];
                               // ends up 87.59375 (0x15E6) after the bitwise ops
        int16_t unk2;
    };
} AnimationFileData;
 
class AnimationFile {
  public:
    int16_t mBoneIndex;
    int16_t mTransformType;
    std::vector<AnimationFileData> mData;
 
    AnimationFile(int16_t boneIndex, int16_t transformType, std::vector<AnimationFileData> data)
        : mBoneIndex(boneIndex), mTransformType(transformType), mData(std::move(data)) {
    }
};
 
class AnimData : public IParsedData {
  public:
    int16_t mStartFrame;
    int16_t mEndFrame;
    std::vector<AnimationFile> mFiles;
 
    AnimData(int16_t startFrame, int16_t endFrame, std::vector<AnimationFile> files)
        : mStartFrame(startFrame), mEndFrame(endFrame), mFiles(std::move(files)) {
    }
};
 
class AnimBinaryExporter : public BaseExporter {
    ExportResult Export(std::ostream& write, std::shared_ptr<IParsedData> data, std::string& entryName,
                        YAML::Node& node, std::string* replacement) override;
};
 
class AnimCodeExporter : public BaseExporter {
    ExportResult Export(std::ostream& write, std::shared_ptr<IParsedData> data, std::string& entryName,
                        YAML::Node& node, std::string* replacement) override;
};
 
class AnimModdingExporter : public BaseExporter {
    ExportResult Export(std::ostream& write, std::shared_ptr<IParsedData> data, std::string& entryName,
                        YAML::Node& node, std::string* replacement) override;
};
 
std::shared_ptr<AnimData> ReadAnimRom(const std::vector<uint8_t>& bytes, std::string& error);
std::vector<uint8_t> WriteAnimRom(const AnimData& anim);
// A BKAnimation resource, as AnimBinaryExporter writes it.
std::shared_ptr<AnimData> ReadAnimResource(const std::vector<uint8_t>& resource, std::string& error);
std::vector<uint8_t> WriteAnimResource(const AnimData& anim);
std::string AnimToYaml(const AnimData& anim, const std::string& symbol);
bool AnimFromYaml(const std::string& text, AnimData& out, std::string& error);
 
class AnimFactory : public BaseFactory {
  public:
    std::optional<std::shared_ptr<IParsedData>> parse(std::vector<uint8_t>& buffer, YAML::Node& data) override;
    std::optional<std::shared_ptr<IParsedData>> parse_modding(std::vector<uint8_t>& buffer, YAML::Node& data) override;
    inline std::unordered_map<ExportType, std::shared_ptr<BaseExporter>> GetExporters() override {
        return { REGISTER(Code, AnimCodeExporter) REGISTER(Header, BKHeaderExporter)
                     REGISTER(Binary, AnimBinaryExporter) REGISTER(Modding, AnimModdingExporter) };
    }
    bool SupportModdedAssets() override {
        return true;
    }
};
} // namespace BK64