ksys: Add ASSetting

src/KingSystem/ActorSystem/CMakeLists.txt

@@ -50,6 +50,8 @@ target_sources(uking PRIVATE
   actAiQueries.h
   actAiRoot.cpp
   actAiRoot.h
+  actASSetting.cpp
+  actASSetting.h
   actAttention.cpp
   actAttention.h
   actBaseProc.cpp

src/KingSystem/ActorSystem/actASSetting.cpp

@@ -1 +1,31 @@
 #include "KingSystem/ActorSystem/actASSetting.h"
+#include "KingSystem/Resource/resLoadRequest.h"
+#include "KingSystem/Resource/resResourceASSetting.h"
+
+namespace ksys::act {
+
+SEAD_SINGLETON_DISPOSER_IMPL(ASSetting)
+
+ASSetting::~ASSetting() = default;
+
+void ASSetting::init(const sead::SafeString& config_path) {
+    res::LoadRequest req;
+    req.mRequester = "ASSetting";
+    req._22 = true;
+    mHandle.load(config_path, &req);
+}
+
+// NON_MATCHING: sead::DirectResource to res::ASSetting cast nullptr check; branching for the return
+const res::ASSetting::BoneParams* ASSetting::getBoneParams(const sead::SafeString& key) const {
+    auto* res = sead::DynamicCast<res::ASSetting>(mHandle.getResource());
+    if (!res)
+        return nullptr;
+
+    for (const auto& bones : res->getBlenderBones()) {
+        if (key == bones.mKeyName.ref())
+            return &bones.mBoneParams;
+    }
+    return nullptr;
+}
+
+}  // namespace ksys::act

src/KingSystem/ActorSystem/actASSetting.h

@@ -1,6 +1,10 @@
 #pragma once
 
 #include <heap/seadDisposer.h>
+#include <prim/seadSafeString.h>
+#include "KingSystem/Resource/resHandle.h"
+#include "KingSystem/Resource/resResourceASSetting.h"
+#include "KingSystem/Utils/Types.h"
 
 namespace ksys::act {
 
@@ -8,6 +12,15 @@ namespace ksys::act {
 class ASSetting {
     SEAD_SINGLETON_DISPOSER(ASSetting)
     ASSetting() = default;
+    virtual ~ASSetting();
+
+public:
+    void init(const sead::SafeString& config_path);
+    const res::ASSetting::BoneParams* getBoneParams(const sead::SafeString& key) const;
+
+private:
+    res::Handle mHandle;
 };
+KSYS_CHECK_SIZE_NX150(ASSetting, 0x78);
 
 }  // namespace ksys::act

src/KingSystem/Resource/CMakeLists.txt

@@ -142,6 +142,8 @@ target_sources(uking PRIVATE
   resResourceAS.h
   resResourceASList.cpp
   resResourceASList.h
+  resResourceASSetting.cpp
+  resResourceASSetting.h
   resResourceAttClient.cpp
   resResourceAttClient.h
   resResourceAttClientList.cpp

src/KingSystem/Resource/resResourceASSetting.cpp

@@ -0,0 +1,106 @@
+#include "KingSystem/Resource/resResourceASSetting.h"
+
+namespace ksys::res {
+
+ASSetting::ASSetting() {
+    mType = "assetting";
+    mVersion = 0;
+}
+
+ASSetting::~ASSetting() {
+    mBlenderBones.freeBuffer();
+}
+
+void ASSetting::doCreate_(u8* buffer, u32 buffer_size, sead::Heap* heap) {}
+
+bool allocBlenderBones(sead::Buffer<ASSetting::BlenderBone>& buffer, int size, sead::Heap* heap,
+                       int align = sizeof(void*)) {
+    return buffer.tryAllocBuffer(size, heap, align);
+}
+
+bool ASSetting::parse_(u8* data, size_t size, sead::Heap* heap) {
+    if (!data)
+        return true;
+
+    agl::utl::ResParameterArchive archive{data};
+    const auto root = archive.getRootList();
+
+    addList(&mBlenderBoneList, "BlenderBone");
+
+    const auto lists = agl::utl::getResParameterList(root, "BlenderBone");
+    if (!lists.ptr())
+        return true;
+
+    const auto num_blender_bones = lists.getResParameterListNum();
+    if (num_blender_bones == 0)
+        return true;
+
+    if (!allocBlenderBones(mBlenderBones, num_blender_bones, heap))
+        return false;
+
+    auto res_it = lists.listBegin();
+    const auto res_it_end = lists.listEnd();
+    sead::FixedSafeString<32> list_name{"BlenderBone"};
+    const auto list_name_base_len = list_name.calcLength();
+
+    ASParamParser::ParseArgs args;
+    args.res_list = {};
+    args.heap = heap;
+
+    auto it = mBlenderBones.begin();
+    const auto end = mBlenderBones.end();
+    for (; it != end && res_it != res_it_end; ++it, ++res_it) {
+        list_name.trim(list_name_base_len);
+        list_name.appendWithFormat("%d", it.getIndex());
+        mBlenderBoneList.addList(&it->mList, list_name);
+
+        it->mKeyName.init("", "KeyName", "キー名", "", &it->mNameParamObj);
+        it->mList.addObj(&it->mNameParamObj, "NameParam");
+        it->mList.addList(&it->mBoneParams.getList(), "BoneParam");
+
+        const auto list = *res_it;
+        args.user_data = std::addressof(*it);
+        args.res_list = agl::utl::getResParameterList(list, "BoneParam");
+        if (!it->mBoneParams.parse(args))
+            return false;
+    }
+
+    applyResParameterArchive(archive);
+    return true;
+}
+
+ASSetting::BoneParams::~BoneParams() {
+    mBuffer.freeBuffer();
+}
+
+// NON_MATCHING: parameter object iteration(???)
+bool ASSetting::BoneParams::parse(const ASParamParser::ParseArgs& args) {
+    const auto num_objects = args.res_list.getResParameterObjNum();
+    if (num_objects == 0)
+        return true;
+
+    if (!mBuffer.tryAllocBuffer(num_objects, args.heap))
+        return false;
+
+    sead::FixedSafeString<32> obj_name{"BoneParam"};
+    const auto obj_name_base_len = obj_name.calcLength();
+
+    auto it = mBuffer.begin();
+    const auto end = mBuffer.end();
+
+    auto res_it = args.res_list.objBegin();
+    const auto res_end = args.res_list.objEnd();
+
+    for (; it != end && res_it != res_end; ++it, ++res_it) {
+        it->mBone.init("", "Bone", "ボーン名", "", &it->mObj);
+        it->mWeight.init(0.0, "Weight", "ウェイト値", "Min=0.f,Max=1.f", &it->mObj);
+
+        obj_name.trim(obj_name_base_len);
+        obj_name.appendWithFormat("%d", res_it.getIndex());
+        mList.addObj(&it->mObj, obj_name);
+    }
+
+    return true;
+}
+
+}  // namespace ksys::res

src/KingSystem/Resource/resResourceASSetting.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <agl/Utils/aglParameter.h>
+#include <agl/Utils/aglParameterIO.h>
+#include <agl/Utils/aglParameterList.h>
+#include <agl/Utils/aglParameterObj.h>
+#include <agl/Utils/aglResParameter.h>
+#include <basis/seadTypes.h>
+#include <container/seadBuffer.h>
+#include <prim/seadRuntimeTypeInfo.h>
+#include <prim/seadSafeString.h>
+#include "KingSystem/Resource/resResource.h"
+
+namespace ksys::res {
+
+class ASParamParser {
+    SEAD_RTTI_BASE(ASParamParser)
+public:
+    struct ParseArgs {
+        void* user_data;
+        agl::utl::ResParameterList res_list;
+        sead::Heap* heap;
+    };
+
+    virtual ~ASParamParser() = default;
+    virtual bool parse(const ParseArgs& args) { return true; }
+
+    agl::utl::ParameterList& getList() { return mList; }
+    const agl::utl::ParameterList& getList() const { return mList; }
+
+protected:
+    u32 _8 = 8;
+    agl::utl::ParameterList mList;
+};
+KSYS_CHECK_SIZE_NX150(ASParamParser, 0x58);
+
+class ASSetting : public agl::utl::IParameterIO, public Resource {
+    SEAD_RTTI_OVERRIDE(ASSetting, Resource)
+
+public:
+    struct BoneParam {
+        agl::utl::ParameterObj mObj;
+        agl::utl::Parameter<sead::SafeString> mBone;
+        agl::utl::Parameter<float> mWeight;
+    };
+    KSYS_CHECK_SIZE_NX150(BoneParam, 0x78);
+
+    class BoneParams : public ASParamParser {
+        SEAD_RTTI_OVERRIDE(BoneParams, ASParamParser)
+    public:
+        ~BoneParams() override;
+        bool parse(const ParseArgs& args) override;
+
+        sead::Buffer<BoneParam> mBuffer;
+    };
+
+    struct BlenderBone {
+        agl::utl::ParameterList mList;
+        agl::utl::ParameterObj mNameParamObj;
+        agl::utl::Parameter<sead::SafeString> mKeyName;
+        BoneParams mBoneParams;
+    };
+    KSYS_CHECK_SIZE_NX150(BlenderBone, 0x108);
+
+    ASSetting();
+    ~ASSetting() override;
+
+    void doCreate_(u8* buffer, u32 buffer_size, sead::Heap* heap) override;
+    bool needsParse() const override { return true; }
+    bool parse_(u8* data, size_t size, sead::Heap* heap) override;
+
+    const sead::Buffer<BlenderBone>& getBlenderBones() const { return mBlenderBones; }
+
+private:
+    sead::Buffer<BlenderBone> mBlenderBones;
+    agl::utl::ParameterList mBlenderBoneList;
+};
+KSYS_CHECK_SIZE_NX150(ASSetting, 0x260);
+
+}  // namespace ksys::res