metaforce/DataSpec/DNAMP1/ANIM.hpp

#pragma once

#include "DNAMP1.hpp"
#include "DataSpec/DNACommon/ANIM.hpp"
#include "DataSpec/DNACommon/RigInverter.hpp"
#include "CINF.hpp"
#include "EVNT.hpp"
#include "DataSpec/DNACommon/ANCS.hpp"

namespace DataSpec::DNAMP1
{

struct ANIM : BigDNA
{
    AT_DECL_EXPLICIT_DNA

    static UniqueID32 GetEVNTId(athena::io::IStreamReader& r);

    struct IANIM : BigDNAV
    {
        Delete expl;
        atUint32 m_version;
        IANIM(atUint32 version) : m_version(version) {}

        std::vector<std::pair<atUint32, bool>> bones;
        std::vector<atUint32> frames;
        std::vector<DNAANIM::Channel> channels;
        std::vector<std::vector<DNAANIM::Value>> chanKeys;
        float mainInterval = 0.0;
        UniqueID32Zero evnt;
        bool looping = false;

        void sendANIMToBlender(hecl::blender::PyOutStream&, const DNAANIM::RigInverter<CINF>& rig) const;
    };

    struct ANIM0 : IANIM
    {
        AT_DECL_EXPLICIT_DNA
        AT_DECL_DNAV
        ANIM0() : IANIM(0) {}

        struct Header : BigDNA
        {
            AT_DECL_DNA
            Value<float> duration;
            Value<atUint32> unk0;
            Value<float> interval;
            Value<atUint32> unk1;
            Value<atUint32> keyCount;
            Value<atUint32> unk2;
            Value<atUint32> boneSlotCount;
        };
    };

    struct ANIM2 : IANIM
    {
        AT_DECL_EXPLICIT_DNA
        AT_DECL_DNAV
        ANIM2(bool pc) : IANIM(pc ? 3 : 2) {}

        struct Header : BigDNA
        {
            AT_DECL_DNA
            Value<atUint32> scratchSize;
            UniqueID32Zero evnt;
            Value<atUint32> unk0 = 1;
            Value<float> duration;
            Value<float> interval;
            Value<atUint32> rootBoneId = 3;
            Value<atUint32> looping = 0;
            Value<atUint32> rotDiv;
            Value<float> translationMult;
            Value<atUint32> boneChannelCount;
            Value<atUint32> unk3;
            Value<atUint32> keyBitmapBitCount;
        };

        struct ChannelDesc : BigDNA
        {
            Delete expl;
            Value<atUint32> id = 0;
            Value<atUint16> keyCount1 = 0;
            Value<atInt16> initRX = 0;
            Value<atUint8> qRX = 0;
            Value<atInt16> initRY = 0;
            Value<atUint8> qRY = 0;
            Value<atInt16> initRZ = 0;
            Value<atUint8> qRZ = 0;
            Value<atUint16> keyCount2 = 0;
            Value<atInt16> initTX = 0;
            Value<atUint8> qTX = 0;
            Value<atInt16> initTY = 0;
            Value<atUint8> qTY = 0;
            Value<atInt16> initTZ = 0;
            Value<atUint8> qTZ = 0;

            void read(athena::io::IStreamReader& reader)
            {
                id = reader.readUint32Big();
                keyCount1 = reader.readUint16Big();
                initRX = reader.readInt16Big();
                qRX = reader.readUByte();
                initRY = reader.readInt16Big();
                qRY = reader.readUByte();
                initRZ = reader.readInt16Big();
                qRZ = reader.readUByte();
                keyCount2 = reader.readUint16Big();
                if (keyCount2)
                {
                    initTX = reader.readInt16Big();
                    qTX = reader.readUByte();
                    initTY = reader.readInt16Big();
                    qTY = reader.readUByte();
                    initTZ = reader.readInt16Big();
                    qTZ = reader.readUByte();
                }
            }
            void write(athena::io::IStreamWriter& writer) const
            {
                writer.writeUint32Big(id);
                writer.writeUint16Big(keyCount1);
                writer.writeInt16Big(initRX);
                writer.writeUByte(qRX);
                writer.writeInt16Big(initRY);
                writer.writeUByte(qRY);
                writer.writeInt16Big(initRZ);
                writer.writeUByte(qRZ);
                writer.writeUint16Big(keyCount2);
                if (keyCount2)
                {
                    writer.writeInt16Big(initTX);
                    writer.writeUByte(qTX);
                    writer.writeInt16Big(initTY);
                    writer.writeUByte(qTY);
                    writer.writeInt16Big(initTZ);
                    writer.writeUByte(qTZ);
                }
            }
            void binarySize(size_t& __isz) const
            {
                __isz += 17;
                if (keyCount2)
                    __isz += 9;
            }
        };

        struct ChannelDescPC : BigDNA
        {
            Delete expl;
            Value<atUint32> id = 0;
            Value<atUint32> keyCount1 = 0;
            Value<atUint32> QinitRX = 0;
            Value<atUint32> QinitRY = 0;
            Value<atUint32> QinitRZ = 0;
            Value<atUint32> keyCount2 = 0;
            Value<atUint32> QinitTX = 0;
            Value<atUint32> QinitTY = 0;
            Value<atUint32> QinitTZ = 0;

            void read(athena::io::IStreamReader& reader)
            {
                id = reader.readUint32Big();
                keyCount1 = reader.readUint32Big();
                QinitRX = reader.readUint32Big();
                QinitRY = reader.readUint32Big();
                QinitRZ = reader.readUint32Big();
                keyCount2 = reader.readUint32Big();
                if (keyCount2)
                {
                    QinitTX = reader.readUint32Big();
                    QinitTY = reader.readUint32Big();
                    QinitTZ = reader.readUint32Big();
                }
            }
            void write(athena::io::IStreamWriter& writer) const
            {
                writer.writeUint32Big(id);
                writer.writeUint32Big(keyCount1);
                writer.writeUint32Big(QinitRX);
                writer.writeUint32Big(QinitRY);
                writer.writeUint32Big(QinitRZ);
                writer.writeUint32Big(keyCount2);
                if (keyCount2)
                {
                    writer.writeUint32Big(QinitTX);
                    writer.writeUint32Big(QinitTY);
                    writer.writeUint32Big(QinitTZ);
                }
            }
            void binarySize(size_t& __isz) const
            {
                __isz += 24;
                if (keyCount2)
                    __isz += 12;
            }
        };
    };

    std::unique_ptr<IANIM> m_anim;

    void sendANIMToBlender(hecl::blender::PyOutStream& os, const DNAANIM::RigInverter<CINF>& rig, bool) const
    {
        m_anim->sendANIMToBlender(os, rig);
    }

    bool isLooping() const
    {
        if (!m_anim)
            return false;
        return m_anim->looping;
    }

    void extractEVNT(const DNAANCS::AnimationResInfo<UniqueID32>& animInfo,
                     const hecl::ProjectPath& outPath, PAKRouter<PAKBridge>& pakRouter, bool force) const
    {
        if (m_anim->evnt)
        {
            hecl::SystemStringConv sysStr(animInfo.name);
            hecl::ProjectPath evntYamlPath = outPath.getWithExtension((hecl::SystemString(_SYS_STR(".")) +
                                                                       sysStr.c_str() +
                                                                       _SYS_STR(".evnt.yaml")).c_str(), true);
            hecl::ProjectPath::Type evntYamlType = evntYamlPath.getPathType();

            if (force || evntYamlType == hecl::ProjectPath::Type::None)
            {
                EVNT evnt;
                if (pakRouter.lookupAndReadDNA(m_anim->evnt, evnt, true))
                {
                    athena::io::FileWriter writer(evntYamlPath.getAbsolutePath());
                    athena::io::ToYAMLStream(evnt, writer);
                }
            }
        }
    }

    using BlenderAction = hecl::blender::Action;

    ANIM() = default;
    ANIM(const BlenderAction& act,
         const std::unordered_map<std::string, atInt32>& idMap,
         const DNAANIM::RigInverter<CINF>& rig,
         bool pc);
};

}