Library/Yaml: Implement ParameterArray, ParameterList and ParameterObj (#572)

2026-04-23 09:04:21 +00:00 · 2025-05-21 12:14:29 -06:00 · 2025-05-21 12:14:29 -06:00 · cf534ac646
parent e485132256
commit cf534ac646
5 changed files with 659 additions and 30 deletions
--- a/data/file_list.yml
+++ b/data/file_list.yml
@ -70229,7 +70229,7 @@ Library/Yaml/MacroUtil.o:
  - 0x7100a3309c: _ZNK15alYamlMacroUtil13IUseYamlParam16isEqualParamNameEPKc
  - 0x7100a330ac: _ZN15alYamlMacroUtil14YamlParamGroup13readyToSetPtrEv
  - 0x7100a330e4: _ZN15alYamlMacroUtil14YamlParamGroup9readParamERKN2al9ByamlIterE
-Library/Yaml/ParameterObj.o:
+Library/Yaml/ParameterBase.o:
  .text:
  - 0x7100a3321c: _ZN2al13ParameterBaseC2ERKN4sead14SafeStringBaseIcEES5_S5_PNS_12ParameterObjEb
  - 0x7100a332dc: _ZN2al13ParameterBase18initializeListNodeERKN4sead14SafeStringBaseIcEES5_S5_PNS_12ParameterObjEb
@ -70246,6 +70246,8 @@ Library/Yaml/ParameterObj.o:
  - 0x7100a33e28: _ZN2al13ParameterBase7isEqualERKS0_
  - 0x7100a341ec: _ZN2al13ParameterBase4copyERKS0_
  - 0x7100a3434c: _ZN2al13ParameterBase8copyLerpERKS0_S2_f
+Library/Yaml/ParameterObj.o:
+  .text:
  - 0x7100a346f4: _ZN2al12ParameterObjC2Ev
  - 0x7100a34768: _ZN2al12ParameterObj11tryGetParamERKNS_9ByamlIterE
  - 0x7100a34824: _ZN2al14ParameterArray11tryGetParamERKNS_9ByamlIterE
--- a/data/odyssey_functions.csv
+++ b/data/odyssey_functions.csv
@ -65238,8 +65238,8 @@ Address,Quality,Size,Name
 0x0000007100a33548,U,000436,_ZN2al13ParameterBase18initializeListNodeERKN4sead14SafeStringBaseIcEES5_S5_PNS_13ParameterListEb
 0x0000007100a336fc,U,000388,_ZN2al13ParameterBase10initializeERKN4sead14SafeStringBaseIcEES5_S5_b
 0x0000007100a33880,U,000160,_ZN2al13ParameterBase8calcHashERKN4sead14SafeStringBaseIcEE
-0x0000007100a33920,U,000028,_ZN2al12ParameterObj16pushBackListNodeEPNS_13ParameterBaseE
-0x0000007100a3393c,U,000036,_ZN2al13ParameterList8addParamEPNS_13ParameterBaseE
+0x0000007100a33920,O,000028,_ZN2al12ParameterObj16pushBackListNodeEPNS_13ParameterBaseE
+0x0000007100a3393c,O,000036,_ZN2al13ParameterList8addParamEPNS_13ParameterBaseE
 0x0000007100a33960,U,000920,_ZN2al13ParameterBase11tryGetParamERKNS_9ByamlIterE
 0x0000007100a33cf8,U,000068,_ZNK2al13ParameterBase8isEqual_IPKcEEbRKS0_
 0x0000007100a33d3c,U,000116,_ZN2al13ParameterBase9copyLerp_IfEEvRKS0_S3_f
@ -65247,33 +65247,33 @@ Address,Quality,Size,Name
 0x0000007100a33e28,U,000964,_ZN2al13ParameterBase7isEqualERKS0_
 0x0000007100a341ec,U,000352,_ZN2al13ParameterBase4copyERKS0_
 0x0000007100a3434c,U,000936,_ZN2al13ParameterBase8copyLerpERKS0_S2_f
-0x0000007100a346f4,U,000116,_ZN2al12ParameterObjC2Ev
-0x0000007100a34768,U,000188,_ZN2al12ParameterObj11tryGetParamERKNS_9ByamlIterE
-0x0000007100a34824,U,000200,_ZN2al14ParameterArray11tryGetParamERKNS_9ByamlIterE
-0x0000007100a348ec,U,000272,_ZN2al12ParameterObj8addArrayEPNS_14ParameterArrayERKN4sead14SafeStringBaseIcEE
-0x0000007100a349fc,U,000232,_ZNK2al12ParameterObj7isEqualERKS0_
-0x0000007100a34ae4,U,000116,_ZNK2al14ParameterArray7isEqualERKS0_
-0x0000007100a34b58,U,000172,_ZN2al12ParameterObj4copyERKS0_
-0x0000007100a34c04,U,000072,_ZN2al14ParameterArray4copyERKS0_
-0x0000007100a34c4c,U,000368,_ZN2al12ParameterObj8copyLerpERKS0_S2_f
-0x0000007100a34dbc,U,000116,_ZN2al14ParameterArray8copyLerpERKS0_S2_f
-0x0000007100a34e30,U,000064,_ZNK2al12ParameterObj13findParameterEPKc
-0x0000007100a34e70,U,000116,_ZN2al14ParameterArrayC2Ev
-0x0000007100a34ee4,U,000276,_ZN2al14ParameterArray6addObjEPNS_12ParameterObjE
-0x0000007100a34ff8,U,000032,_ZN2al14ParameterArray8clearObjEv
-0x0000007100a35018,U,000072,_ZN2al14ParameterArray9removeObjEPNS_12ParameterObjE
-0x0000007100a35060,U,000048,_ZN2al14ParameterArray10isExistObjEPNS_12ParameterObjE
-0x0000007100a35090,U,000120,_ZN2al13ParameterListC2Ev
-0x0000007100a35108,U,000272,_ZN2al13ParameterList7addListEPS0_RKN4sead14SafeStringBaseIcEE
-0x0000007100a35218,U,000272,_ZN2al13ParameterList6addObjEPNS_12ParameterObjERKN4sead14SafeStringBaseIcEE
-0x0000007100a35328,U,000272,_ZN2al13ParameterList8addArrayEPNS_14ParameterArrayERKN4sead14SafeStringBaseIcEE
-0x0000007100a35438,U,000032,_ZN2al13ParameterList9clearListEv
-0x0000007100a35458,U,000032,_ZN2al13ParameterList8clearObjEv
-0x0000007100a35478,U,000072,_ZN2al13ParameterList10removeListEPS0_
-0x0000007100a354c0,U,000072,_ZN2al13ParameterList9removeObjEPNS_12ParameterObjE
-0x0000007100a35508,U,000048,_ZN2al13ParameterList10isExistObjEPNS_12ParameterObjE
-0x0000007100a35538,U,000152,_ZN2al13ParameterList11tryGetParamERKNS_9ByamlIterE
-0x0000007100a355d0,U,000120,_ZN2al11ParameterIoC2Ev
+0x0000007100a346f4,O,000116,_ZN2al12ParameterObjC2Ev
+0x0000007100a34768,O,000188,_ZN2al12ParameterObj11tryGetParamERKNS_9ByamlIterE
+0x0000007100a34824,O,000200,_ZN2al14ParameterArray11tryGetParamERKNS_9ByamlIterE
+0x0000007100a348ec,O,000272,_ZN2al12ParameterObj8addArrayEPNS_14ParameterArrayERKN4sead14SafeStringBaseIcEE
+0x0000007100a349fc,O,000232,_ZNK2al12ParameterObj7isEqualERKS0_
+0x0000007100a34ae4,O,000116,_ZNK2al14ParameterArray7isEqualERKS0_
+0x0000007100a34b58,O,000172,_ZN2al12ParameterObj4copyERKS0_
+0x0000007100a34c04,O,000072,_ZN2al14ParameterArray4copyERKS0_
+0x0000007100a34c4c,O,000368,_ZN2al12ParameterObj8copyLerpERKS0_S2_f
+0x0000007100a34dbc,O,000116,_ZN2al14ParameterArray8copyLerpERKS0_S2_f
+0x0000007100a34e30,O,000064,_ZNK2al12ParameterObj13findParameterEPKc
+0x0000007100a34e70,O,000116,_ZN2al14ParameterArrayC2Ev
+0x0000007100a34ee4,O,000276,_ZN2al14ParameterArray6addObjEPNS_12ParameterObjE
+0x0000007100a34ff8,O,000032,_ZN2al14ParameterArray8clearObjEv
+0x0000007100a35018,O,000072,_ZN2al14ParameterArray9removeObjEPNS_12ParameterObjE
+0x0000007100a35060,O,000048,_ZN2al14ParameterArray10isExistObjEPNS_12ParameterObjE
+0x0000007100a35090,O,000120,_ZN2al13ParameterListC2Ev
+0x0000007100a35108,O,000272,_ZN2al13ParameterList7addListEPS0_RKN4sead14SafeStringBaseIcEE
+0x0000007100a35218,O,000272,_ZN2al13ParameterList6addObjEPNS_12ParameterObjERKN4sead14SafeStringBaseIcEE
+0x0000007100a35328,O,000272,_ZN2al13ParameterList8addArrayEPNS_14ParameterArrayERKN4sead14SafeStringBaseIcEE
+0x0000007100a35438,O,000032,_ZN2al13ParameterList9clearListEv
+0x0000007100a35458,O,000032,_ZN2al13ParameterList8clearObjEv
+0x0000007100a35478,O,000072,_ZN2al13ParameterList10removeListEPS0_
+0x0000007100a354c0,O,000072,_ZN2al13ParameterList9removeObjEPNS_12ParameterObjE
+0x0000007100a35508,O,000048,_ZN2al13ParameterList10isExistObjEPNS_12ParameterObjE
+0x0000007100a35538,O,000152,_ZN2al13ParameterList11tryGetParamERKNS_9ByamlIterE
+0x0000007100a355d0,O,000120,_ZN2al11ParameterIoC2Ev
 0x0000007100a35648,U,000320,_ZN2al14ActionAnimCtrl9tryCreateEPNS_9LiveActorEPKNS_13ActorResourceEPKcS7_
 0x0000007100a35788,U,000360,_ZN2al14ActionAnimCtrl4initEPKNS_13ActorResourceEPKcS5_
 0x0000007100a358f0,U,000996,_ZN2al14ActionAnimCtrl5startEPKc
--- a/lib/al/Library/Yaml/ParameterBase.h
+++ b/lib/al/Library/Yaml/ParameterBase.h
@ -0,0 +1,125 @@
+#pragma once
+
+#include <gfx/seadColor.h>
+#include <math/seadVector.h>
+#include <prim/seadEnum.h>
+#include <prim/seadSafeString.h>
+
+namespace al {
+class ByamlIter;
+class ParameterObj;
+class ParameterList;
+
+SEAD_ENUM(YamlParamType,
+    Invalid,
+    Bool,
+    F32,
+    S32,
+    U32,
+    V2f,
+    V2s32,
+    V3f,
+    V4f,
+    Q4f,
+    C4f,
+    StringRef,
+    String32,
+    String64,
+    String128,
+    String256,
+    String512,
+    String1024,
+    String2048,
+    String4096,
+);
+
+#define PARAM_TYPE_DEF(Name, Type)                                                                 \
+    class Parameter##Name : public Parameter<Type> {                                               \
+    public:                                                                                        \
+        const char* getParamTypeStr() const override {                                             \
+            return getParamType().text();                                                          \
+        }                                                                                          \
+                                                                                                   \
+        YamlParamType getParamType() const override {                                              \
+            return YamlParamType::Name;                                                            \
+        }                                                                                          \
+    };
+
+class ParameterBase {
+public:
+    ParameterBase(const sead::SafeString&, const sead::SafeString&, const sead::SafeString&,
+                  ParameterObj*, bool);
+
+    ParameterBase(const sead::SafeString&, const sead::SafeString&, const sead::SafeString&,
+                  ParameterList*, bool);
+
+    virtual const char* getParamTypeStr() const = 0;
+    virtual YamlParamType getParamType() const = 0;
+    virtual const void* ptr() const = 0;
+    virtual void* ptr() = 0;
+    virtual void afterGetParam();
+    virtual s32 getParamSize() const = 0;
+    virtual bool isEqual(const ParameterBase&);
+    virtual bool copy(const ParameterBase&);
+    virtual bool copyLerp(const ParameterBase&, const ParameterBase&, f32);
+
+    void initializeListNode(const sead::SafeString&, const sead::SafeString&,
+                            const sead::SafeString&, ParameterObj*, bool);
+    void initializeListNode(const sead::SafeString&, const sead::SafeString&,
+                            const sead::SafeString&, ParameterList*, bool);
+    void initialize(const sead::SafeString&, const sead::SafeString&, const sead::SafeString&,
+                    bool);
+    u32 calcHash(const sead::SafeString&);
+    void tryGetParam(const ByamlIter&);
+
+    ParameterBase* getNext() const { return mNext; }
+
+    void setNext(ParameterBase* param) { mNext = param; }
+
+    const sead::SafeString& getParamName() const { return mName; }
+
+    u32 getHash() const { return mHash; }
+
+    template <typename T>
+    T* getValuePtr() {
+        return (T*)ptr();
+    }
+
+private:
+    ParameterBase* mNext = nullptr;
+    sead::FixedSafeString<0x40> mName;
+    u32 mHash;
+};
+
+template <typename T>
+class Parameter : public ParameterBase {
+public:
+    const void* ptr() const { return mValue; };
+
+    void* ptr() { return mValue; };
+
+    s32 getParamSize() const { return sizeof(T); }
+
+private:
+    T* mValue;
+};
+
+PARAM_TYPE_DEF(Bool, bool)
+PARAM_TYPE_DEF(F32, f32)
+PARAM_TYPE_DEF(S32, s32)
+PARAM_TYPE_DEF(U32, u32)
+PARAM_TYPE_DEF(V2f, sead::Vector2f)
+PARAM_TYPE_DEF(V3f, sead::Vector3f)
+PARAM_TYPE_DEF(V4f, sead::Vector4f)
+PARAM_TYPE_DEF(C4f, sead::Color4f)
+PARAM_TYPE_DEF(StringRef, const char*)
+PARAM_TYPE_DEF(String32, sead::FixedSafeString<32>)
+PARAM_TYPE_DEF(String64, sead::FixedSafeString<64>)
+PARAM_TYPE_DEF(String128, sead::FixedSafeString<128>)
+PARAM_TYPE_DEF(String256, sead::FixedSafeString<256>)
+PARAM_TYPE_DEF(String512, sead::FixedSafeString<512>)
+PARAM_TYPE_DEF(String1024, sead::FixedSafeString<1024>)
+PARAM_TYPE_DEF(String2048, sead::FixedSafeString<2048>)
+PARAM_TYPE_DEF(String4096, sead::FixedSafeString<4096>)
+
+}  // namespace al
--- a/lib/al/Library/Yaml/ParameterObj.cpp
+++ b/lib/al/Library/Yaml/ParameterObj.cpp
@ -0,0 +1,397 @@
+#include "Library/Yaml/ParameterObj.h"
+
+#include "Library/Base/StringUtil.h"
+#include "Library/Yaml/ByamlIter.h"
+#include "Library/Yaml/ParameterBase.h"
+
+namespace al {
+ParameterObj::ParameterObj() = default;
+
+void ParameterObj::pushBackListNode(ParameterBase* param) {
+    if (!mTailParam) {
+        mRootParam = param;
+        mTailParam = param;
+        return;
+    }
+    mTailParam->setNext(param);
+    mTailParam = param;
+}
+
+void ParameterObj::tryGetParam(const ByamlIter& iter) {
+    const ByamlIter* i = &iter;
+    ByamlIter iterEntry;
+
+    if (!mKey.isEmpty()) {
+        iter.tryGetIterByKey(&iterEntry, mKey.cstr());
+        i = &iterEntry;
+        if (!iterEntry.isValid())
+            return;
+    }
+
+    for (ParameterBase* paramEntry = mRootParam; paramEntry; paramEntry = paramEntry->getNext())
+        paramEntry->tryGetParam(*i);
+
+    for (ParameterArray* arrayEntry = mParamArray; arrayEntry; arrayEntry = arrayEntry->getNext())
+        arrayEntry->tryGetParam(*i);
+}
+
+void ParameterObj::addArray(ParameterArray* array, const sead::SafeString& key) {
+    array->setKey(key);
+
+    if (!mParamArray) {
+        mParamArray = array;
+        return;
+    }
+
+    ParameterArray* arrayEntry = mParamArray;
+    while (arrayEntry->getNext())
+        arrayEntry = arrayEntry->getNext();
+    arrayEntry->setNext(array);
+}
+
+bool ParameterObj::isEqual(const ParameterObj& obj) const {
+    ParameterBase* paramEntry = mRootParam;
+    ParameterBase* param = obj.getRootParam();
+
+    if (!paramEntry) {
+        if (param)
+            return false;
+    } else {
+        // BUG: Also succeeds if paramEntry != null and param == null
+        while (paramEntry && param) {
+            if (!paramEntry->isEqual(*param))
+                return false;
+            paramEntry = paramEntry->getNext();
+            param = param->getNext();
+        }
+    }
+
+    ParameterArray* arrayEntry = mParamArray;
+    ParameterArray* array = obj.getParamArray();
+    if (!arrayEntry) {
+        if (array)
+            return false;
+    } else {
+        if (!array)
+            return false;
+        while (arrayEntry && array) {
+            if (!arrayEntry->isEqual(*array))
+                return false;
+            arrayEntry = arrayEntry->getNext();
+            array = array->getNext();
+        }
+    }
+    return true;
+}
+
+void ParameterObj::copy(const ParameterObj& obj) {
+    ParameterBase* paramEntry = mRootParam;
+    ParameterBase* param = obj.getRootParam();
+
+    if (paramEntry)
+        while (paramEntry && param) {
+            paramEntry->copy(*param);
+            paramEntry = paramEntry->getNext();
+            param = param->getNext();
+        }
+
+    ParameterArray* array = obj.getParamArray();
+    ParameterArray* arrayEntry = mParamArray;
+    if (arrayEntry)
+        while (arrayEntry && array) {
+            arrayEntry->copy(*array);
+            arrayEntry = arrayEntry->getNext();
+            array = array->getNext();
+        }
+}
+
+void ParameterObj::copyLerp(const ParameterObj& objA, const ParameterObj& objB, f32 rate) {
+    ParameterBase* paramEntry = mRootParam;
+    ParameterBase* paramA = objA.getRootParam();
+    ParameterBase* paramB = objB.getRootParam();
+
+    if (paramEntry) {
+        if (rate <= 0.0f) {
+            while (paramEntry && paramA) {
+                paramEntry->copy(*paramA);
+                paramEntry = paramEntry->getNext();
+                paramA = paramA->getNext();
+            }
+        } else if (rate >= 1.0f) {
+            while (paramEntry && paramB) {
+                paramEntry->copy(*paramB);
+                paramEntry = paramEntry->getNext();
+                paramB = paramB->getNext();
+            }
+        } else {
+            while (paramEntry && paramA && paramB) {
+                paramEntry->copyLerp(*paramA, *paramB, rate);
+                paramEntry = paramEntry->getNext();
+                paramA = paramA->getNext();
+                paramB = paramB->getNext();
+            }
+        }
+    }
+
+    ParameterArray* arrayB = objB.getParamArray();
+    ParameterArray* arrayA = objA.getParamArray();
+    ParameterArray* arrayEntry = mParamArray;
+    while (arrayEntry && arrayA && arrayB) {
+        arrayEntry->copyLerp(*arrayA, *arrayB, rate);
+        arrayEntry = arrayEntry->getNext();
+        arrayA = arrayA->getNext();
+        arrayB = arrayB->getNext();
+    }
+}
+
+ParameterBase* ParameterObj::findParameter(const char* name) const {
+    for (ParameterBase* paramEntry = mRootParam; paramEntry; paramEntry = paramEntry->getNext())
+        if (isEqualString(name, paramEntry->getParamName().getStringTop()))
+            return paramEntry;
+    return nullptr;
+}
+
+ParameterArray::ParameterArray() = default;
+
+void ParameterArray::tryGetParam(const ByamlIter& iter) {
+    ByamlIter arrayIter;
+    iter.tryGetIterByKey(&arrayIter, mKey.cstr());
+
+    if (!arrayIter.isValid() || !arrayIter.isTypeArray())
+        return;
+
+    mSize = arrayIter.getSize();
+
+    s32 index = 0;
+    for (ParameterObj* objEntry = mRootObjNode; objEntry; objEntry = objEntry->getNext()) {
+        ByamlIter paramIter;
+        arrayIter.tryGetIterByIndex(&paramIter, index);
+        if (!paramIter.isValid())
+            continue;
+        objEntry->tryGetParam(paramIter);
+        index++;
+    }
+}
+
+bool ParameterArray::isEqual(const ParameterArray& array) const {
+    if (mSize != array.getSize())
+        return false;
+
+    ParameterObj* objEntry = mRootObjNode;
+    ParameterObj* obj = array.getRootObjNode();
+
+    if (!objEntry || !obj)
+        return !objEntry && !obj;
+
+    while (objEntry && obj) {
+        if (!objEntry->isEqual(*obj))
+            return false;
+        objEntry = objEntry->getNext();
+        obj = obj->getNext();
+    }
+    return true;
+}
+
+void ParameterArray::copy(const ParameterArray& array) {
+    ParameterObj* obj = array.getRootObjNode();
+    ParameterObj* objEntry = mRootObjNode;
+
+    while (objEntry && obj) {
+        objEntry->copy(*obj);
+        objEntry = objEntry->getNext();
+        obj = obj->getNext();
+    }
+}
+
+void ParameterArray::copyLerp(const ParameterArray& arrayA, const ParameterArray& arrayB,
+                              f32 rate) {
+    ParameterObj* objBEntry = arrayB.getRootObjNode();
+    ParameterObj* objAEntry = arrayA.getRootObjNode();
+    ParameterObj* objEntry = mRootObjNode;
+
+    while (objEntry && objAEntry && objBEntry) {
+        objEntry->copyLerp(*objAEntry, *objBEntry, rate);
+        objEntry = objEntry->getNext();
+        objAEntry = objAEntry->getNext();
+        objBEntry = objBEntry->getNext();
+    }
+}
+
+void ParameterArray::addObj(ParameterObj* obj) {
+    obj->setKey(sead::SafeString::cEmptyString);
+
+    if (!mRootObjNode) {
+        mRootObjNode = obj;
+        return;
+    }
+
+    ParameterObj* objEntry = mRootObjNode;
+    while (objEntry->getNext())
+        objEntry = objEntry->getNext();
+    objEntry->setNext(obj);
+}
+
+void ParameterArray::clearObj() {
+    ParameterObj* objEntry = mRootObjNode;
+    while (objEntry) {
+        ParameterObj* next = objEntry->getNext();
+        objEntry->setNext(nullptr);
+        objEntry = next;
+    }
+    mRootObjNode = nullptr;
+}
+
+void ParameterArray::removeObj(ParameterObj* obj) {
+    ParameterObj* prevObjEntry = nullptr;
+    for (ParameterObj* objEntry = mRootObjNode; objEntry; objEntry = objEntry->getNext()) {
+        if (objEntry == obj) {
+            if (prevObjEntry)
+                prevObjEntry->setNext(obj->getNext());
+            else
+                mRootObjNode = obj->getNext();
+            objEntry->setNext(nullptr);
+            return;
+        }
+        prevObjEntry = objEntry;
+    }
+}
+
+bool ParameterArray::isExistObj(ParameterObj* obj) {
+    for (ParameterObj* objEntry = mRootObjNode; objEntry; objEntry = objEntry->getNext())
+        if (objEntry == obj)
+            return true;
+    return false;
+}
+
+ParameterList::ParameterList() = default;
+
+void ParameterList::addParam(ParameterBase* param) {
+    if (!mRootParamNode) {
+        mRootParamNode = param;
+        return;
+    }
+
+    ParameterBase* arrayParam = mRootParamNode;
+    while (arrayParam->getNext())
+        arrayParam = arrayParam->getNext();
+    arrayParam->setNext(param);
+}
+
+void ParameterList::addList(ParameterList* list, const sead::SafeString& key) {
+    list->setKey(key);
+
+    if (!mRootListNode) {
+        mRootListNode = list;
+        return;
+    }
+
+    ParameterList* listEntry = mRootListNode;
+    while (listEntry->getNext())
+        listEntry = listEntry->getNext();
+    listEntry->setNext(list);
+}
+
+void ParameterList::addObj(ParameterObj* obj, const sead::SafeString& key) {
+    obj->setKey(key);
+
+    if (!mRootObjNode) {
+        mRootObjNode = obj;
+        return;
+    }
+
+    ParameterObj* objEntry = mRootObjNode;
+    while (objEntry->getNext())
+        objEntry = objEntry->getNext();
+    objEntry->setNext(obj);
+}
+
+void ParameterList::addArray(ParameterArray* array, const sead::SafeString& key) {
+    array->setKey(key);
+
+    if (!mRootArrayNode) {
+        mRootArrayNode = array;
+        return;
+    }
+
+    ParameterArray* arrayEntry = mRootArrayNode;
+    while (arrayEntry->getNext())
+        arrayEntry = arrayEntry->getNext();
+    arrayEntry->setNext(array);
+}
+
+void ParameterList::clearList() {
+    ParameterList* listEntry = mRootListNode;
+    while (listEntry) {
+        ParameterList* next = listEntry->getNext();
+        listEntry->setNext(nullptr);
+        listEntry = next;
+    }
+    mRootListNode = nullptr;
+}
+
+void ParameterList::clearObj() {
+    ParameterObj* objEntry = mRootObjNode;
+    while (objEntry) {
+        ParameterObj* next = objEntry->getNext();
+        objEntry->setNext(nullptr);
+        objEntry = next;
+    }
+    mRootObjNode = nullptr;
+}
+
+void ParameterList::removeList(ParameterList* list) {
+    ParameterList* prevlistEntry = nullptr;
+    for (ParameterList* listEntry = mRootListNode; listEntry; listEntry = listEntry->getNext()) {
+        if (listEntry == list) {
+            if (prevlistEntry)
+                prevlistEntry->setNext(list->getNext());
+            else
+                mRootListNode = list->getNext();
+            listEntry->setNext(nullptr);
+            return;
+        }
+        prevlistEntry = listEntry;
+    }
+}
+
+void ParameterList::removeObj(ParameterObj* obj) {
+    ParameterObj* prevObjEntry = nullptr;
+    for (ParameterObj* objEntry = mRootObjNode; objEntry; objEntry = objEntry->getNext()) {
+        if (objEntry == obj) {
+            if (prevObjEntry)
+                prevObjEntry->setNext(obj->getNext());
+            else
+                mRootObjNode = obj->getNext();
+            objEntry->setNext(nullptr);
+            return;
+        }
+        prevObjEntry = objEntry;
+    }
+}
+
+bool ParameterList::isExistObj(ParameterObj* obj) {
+    for (ParameterObj* objEntry = mRootObjNode; objEntry; objEntry = objEntry->getNext())
+        if (objEntry == obj)
+            return true;
+    return false;
+}
+
+void ParameterList::tryGetParam(const ByamlIter& iter) {
+    for (ParameterBase* paramEntry = mRootParamNode; paramEntry; paramEntry = paramEntry->getNext())
+        paramEntry->tryGetParam(iter);
+
+    for (ParameterObj* objEntry = mRootObjNode; objEntry; objEntry = objEntry->getNext())
+        objEntry->tryGetParam(iter);
+
+    for (ParameterArray* arrayEntry = mRootArrayNode; arrayEntry;
+         arrayEntry = arrayEntry->getNext()) {
+        arrayEntry->tryGetParam(iter);
+    }
+
+    for (ParameterList* listEntry = mRootListNode; listEntry; listEntry = listEntry->getNext())
+        listEntry->tryGetParam(iter);
+}
+
+ParameterIo::ParameterIo() = default;
+
+}  // namespace al
--- a/lib/al/Library/Yaml/ParameterObj.h
+++ b/lib/al/Library/Yaml/ParameterObj.h
@ -0,0 +1,105 @@
+#pragma once
+
+#include <basis/seadTypes.h>
+#include <prim/seadSafeString.h>
+
+namespace al {
+class ParameterBase;
+class ByamlIter;
+class ParameterArray;
+
+class ParameterObj {
+public:
+    ParameterObj();
+
+    void pushBackListNode(ParameterBase* param);
+    void tryGetParam(const ByamlIter& iter);
+    void addArray(ParameterArray* array, const sead::SafeString& key);
+    bool isEqual(const ParameterObj& obj) const;
+    void copy(const ParameterObj& obj);
+    void copyLerp(const ParameterObj& objA, const ParameterObj& objB, f32 rate);
+    ParameterBase* findParameter(const char* name) const;
+
+    ParameterBase* getRootParam() const { return mRootParam; }
+
+    ParameterObj* getNext() const { return mNext; }
+
+    ParameterArray* getParamArray() const { return mParamArray; }
+
+    void setNext(ParameterObj* obj) { mNext = obj; }
+
+    void setKey(const sead::SafeString& key) { mKey = key; }
+
+private:
+    ParameterBase* mRootParam = nullptr;
+    ParameterBase* mTailParam = nullptr;
+    ParameterObj* mNext = nullptr;
+    ParameterArray* mParamArray = nullptr;
+    sead::FixedSafeString<0x40> mKey;
+};
+
+class ParameterArray {
+public:
+    ParameterArray();
+    void tryGetParam(const ByamlIter& iter);
+    bool isEqual(const ParameterArray& array) const;
+    void copy(const ParameterArray& array);
+    void copyLerp(const ParameterArray& arrayA, const ParameterArray& arrayB, f32 rate);
+    void addObj(ParameterObj* obj);
+    void clearObj();
+    void removeObj(ParameterObj* obj);
+    bool isExistObj(ParameterObj* obj);
+
+    ParameterObj* getRootObjNode() const { return mRootObjNode; }
+
+    ParameterArray* getNext() const { return mNext; }
+
+    void setNext(ParameterArray* array) { mNext = array; }
+
+    void setKey(const sead::SafeString& key) { mKey = key; }
+
+    s32 getSize() const { return mSize; }
+
+private:
+    ParameterObj* mRootObjNode = nullptr;
+    ParameterArray* mNext = nullptr;
+    sead::FixedSafeString<0x40> mKey;
+    s32 mSize = 0;
+};
+
+class ParameterList {
+public:
+    ParameterList();
+
+    void addParam(ParameterBase* param);
+    void addList(ParameterList* list, const sead::SafeString& key);
+    void addObj(ParameterObj* obj, const sead::SafeString& key);
+    void addArray(ParameterArray* array, const sead::SafeString& key);
+    void clearList();
+    void clearObj();
+    void removeList(ParameterList* list);
+    void removeObj(ParameterObj* obj);
+    bool isExistObj(ParameterObj* obj);
+    void tryGetParam(const ByamlIter& iter);
+
+    ParameterList* getNext() const { return mNext; }
+
+    void setNext(ParameterList* list) { mNext = list; }
+
+    void setKey(const sead::SafeString& key) { mKey = key; }
+
+private:
+    ParameterBase* mRootParamNode = nullptr;
+    ParameterObj* mRootObjNode = nullptr;
+    ParameterList* mRootListNode = nullptr;
+    ParameterArray* mRootArrayNode = nullptr;
+    ParameterList* mNext = nullptr;
+    sead::FixedSafeString<0x40> mKey;
+};
+
+class ParameterIo : public ParameterList {
+public:
+    ParameterIo();
+};
+
+}  // namespace al