ksys/res: Start adding ResourceMgrTask

Adds data members and simple functions.

data/uking_functions.csv

@@ -38901,7 +38901,7 @@
 0x000000710065a298,sub_710065A298,48,
 0x000000710065a2c8,sub_710065A2C8,92,
 0x000000710065a324,sub_710065A324,8,
-0x000000710065a32c,sub_710065A32C,8,
+0x000000710065a32c,sub_710065A32C,8,_ZNK4sead10IDelegate2IPNS_6ThreadElE5cloneEPNS_4HeapE
 0x000000710065a334,sub_710065A334,48,
 0x000000710065a364,sub_710065A364,92,
 0x000000710065a3c0,sub_710065A3C0,8,
@@ -47326,7 +47326,7 @@
 0x0000007100799d28,j__ZdlPv_323,4,
 0x0000007100799d2c,sub_7100799D2C,52,
 0x0000007100799d60,sub_7100799D60,92,
-0x0000007100799dbc,sub_7100799DBC,8,
+0x0000007100799dbc,sub_7100799DBC,8,_ZNK4sead11IDelegate1RIPvbE9isNoDummyEv
 0x0000007100799dc4,sub_7100799DC4,8,
 0x0000007100799dcc,sub_7100799DCC,404,
 0x0000007100799f60,sub_7100799F60,252,
@@ -56391,11 +56391,11 @@
 0x00000071009cce64,sub_71009CCE64,92,
 0x00000071009ccec0,sub_71009CCEC0,48,
 0x00000071009ccef0,sub_71009CCEF0,92,
-0x00000071009ccf4c,sub_71009CCF4C,8,
+0x00000071009ccf4c,sub_71009CCF4C,8,_ZNK4sead10IDelegate2IPN4ksys4util17TaskPostRunResultERKNS2_18TaskPostRunContextEE9isNoDummyEv
 0x00000071009ccf54,sub_71009CCF54,8,
 0x00000071009ccf5c,sub_71009CCF5C,48,
 0x00000071009ccf8c,sub_71009CCF8C,92,
-0x00000071009ccfe8,sub_71009CCFE8,8,
+0x00000071009ccfe8,sub_71009CCFE8,8,_ZNK4sead10IDelegate1IRKN4ksys4util25TaskRemoveCallbackContextEE9isNoDummyEv
 0x00000071009ccff0,sub_71009CCFF0,8,
 0x00000071009ccff8,ResourceJpg::ctor,100,
 0x00000071009cd05c,sub_71009CD05C,8,
@@ -90855,11 +90855,11 @@
 0x00000071012038c4,sub_71012038C4,76,_GLOBAL__sub_I_resCacheCriticalSection.cpp
 0x0000007101203910,nullsub_5571,4,
 0x0000007101203914,sub_7101203914,228,
-0x00000071012039f8,res::ResourceMgrTask::setInstance,32,
-0x0000007101203a18,res::ResourceMgrTask::ctor,1572,
+0x00000071012039f8,res::ResourceMgrTask::setInstance,32,_ZN4ksys3res15ResourceMgrTask11setInstanceEPS1_
+0x0000007101203a18,res::ResourceMgrTask::ctor,1572,_ZN4ksys3res15ResourceMgrTaskC1ERKN4sead16TaskConstructArgE
 0x000000710120403c,res::System::calc,24,
-0x0000007101204054,res::ResourceMgrTask::dtor,1492,
-0x0000007101204628,res::ResourceMgrTask::dtorDelete,36,
+0x0000007101204054,res::ResourceMgrTask::dtor,1492,_ZN4ksys3res15ResourceMgrTaskD1Ev
+0x0000007101204628,res::ResourceMgrTask::dtorDelete,36,_ZN4ksys3res15ResourceMgrTaskD0Ev
 0x000000710120464c,res::ResourceMgrTask::prepare,4876,
 0x0000007101205958,res::ResourceMgrTask::insertOverlayArena,136,
 0x00000071012059e0,sub_71012059E0,720,
@@ -90974,20 +90974,20 @@
 0x000000710120cae4,sub_710120CAE4,184,
 0x000000710120cb9c,sub_710120CB9C,80,
 0x000000710120cbec,j__ZdlPv_1240,4,
-0x000000710120cbf0,nullsub_4702,4,
-0x000000710120cbf4,sub_710120CBF4,8,
+0x000000710120cbf0,nullsub_4702,4,_ZN4sead12AnyDelegate2IPNS_6ThreadElE11UnbindDummy6invokeES2_l
+0x000000710120cbf4,sub_710120CBF4,8,_ZNK4sead12AnyDelegate2IPNS_6ThreadElE11UnbindDummy9isNoDummyEv
 0x000000710120cbfc,sub_710120CBFC,36,_ZN4ksys3res7CounterD0Ev?
 0x000000710120cc20,sub_710120CC20,16,_ZN4ksys3res7Counter10doSetData_ERKNS0_11CounterBase4DataE
-0x000000710120cc30,ResourceMgrInvoker::invoke,24,
-0x000000710120cc48,ResourceMgrInvoker::clone,76,
-0x000000710120cc94,ResourceMgrInvoker2::invoke,24,
-0x000000710120ccac,ResourceMgrInvoker2::clone,76,
-0x000000710120ccf8,sub_710120CCF8,52,
-0x000000710120cd2c,sub_710120CD2C,92,
-0x000000710120cd88,sub_710120CD88,48,
-0x000000710120cdb8,sub_710120CDB8,92,
-0x000000710120ce14,sub_710120CE14,48,
-0x000000710120ce44,sub_710120CE44,92,
+0x000000710120cc30,ResourceMgrInvoker::invoke,24,_ZN4sead14Delegate1RFuncIPvbE6invokeES1_
+0x000000710120cc48,ResourceMgrInvoker::clone,76,_ZNK4sead14Delegate1RFuncIPvbE5cloneEPNS_4HeapE
+0x000000710120cc94,ResourceMgrInvoker2::invoke,24,_ZN4sead13Delegate2FuncIPN4ksys4util17TaskPostRunResultERKNS2_18TaskPostRunContextEE6invokeES4_S7_
+0x000000710120ccac,ResourceMgrInvoker2::clone,76,_ZNK4sead13Delegate2FuncIPN4ksys4util17TaskPostRunResultERKNS2_18TaskPostRunContextEE5cloneEPNS_4HeapE
+0x000000710120ccf8,sub_710120CCF8,52,_ZN4sead10Delegate1RIN4ksys3res15ResourceMgrTaskEPvbE6invokeES4_
+0x000000710120cd2c,sub_710120CD2C,92,_ZNK4sead10Delegate1RIN4ksys3res15ResourceMgrTaskEPvbE5cloneEPNS_4HeapE
+0x000000710120cd88,sub_710120CD88,48,_ZN4sead9Delegate2IN4ksys3res15ResourceMgrTaskEPNS1_4util17TaskPostRunResultERKNS4_18TaskPostRunContextEE6invokeES6_S9_
+0x000000710120cdb8,sub_710120CDB8,92,_ZNK4sead9Delegate2IN4ksys3res15ResourceMgrTaskEPNS1_4util17TaskPostRunResultERKNS4_18TaskPostRunContextEE5cloneEPNS_4HeapE
+0x000000710120ce14,sub_710120CE14,48,_ZN4sead9Delegate1IN4ksys3res15ResourceMgrTaskERKNS1_4util25TaskRemoveCallbackContextEE6invokeES7_
+0x000000710120ce44,sub_710120CE44,92,_ZNK4sead9Delegate1IN4ksys3res15ResourceMgrTaskERKNS1_4util25TaskRemoveCallbackContextEE5cloneEPNS_4HeapE
 0x000000710120cea0,makeEventResourceLoadArg,60,
 0x000000710120cedc,sub_710120CEDC,60,
 0x000000710120cf18,sub_710120CF18,48,
@@ -93226,7 +93226,7 @@
 0x00000071012bc86c,sub_71012BC86C,76,
 0x00000071012bc8b8,nullsub_4787,4,
 0x00000071012bc8bc,sub_71012BC8BC,76,
-0x00000071012bc908,sub_71012BC908,32,_ZN4ksys3res11CounterBaseC2Ev
+0x00000071012bc908,sub_71012BC908,32,_ZN4ksys3res11CounterBaseC2EPN4sead4HeapE
 0x00000071012bc928,nullsub_4788,4,_ZN4ksys3res11CounterBaseD1Ev
 0x00000071012bc92c,j__ZdlPv_1297,4,_ZN4ksys3res11CounterBaseD0Ev
 0x00000071012bc930,sub_71012BC930,12,_ZN4ksys3res11CounterBase7setDataERKNS1_4DataE

lib/sead

@@ -1 +1 @@
-Subproject commit de2d50951821f4b16e211a6f5042a3fe094e7b73
+Subproject commit b19dff3386d866b32f05d92bd1eb7ca93f1a398a

src/KingSystem/Resource/CMakeLists.txt

@@ -86,6 +86,8 @@ target_sources(uking PRIVATE
   resCache.h
   resCacheCriticalSection.cpp
   resCacheCriticalSection.h
+  resCompactedHeap.cpp
+  resCompactedHeap.h
   resControlTask.cpp
   resControlTask.h
   resCounter.cpp
@@ -110,6 +112,10 @@ target_sources(uking PRIVATE
   resSystem.h
   resTaskRequest.cpp
   resTaskRequest.h
+  resTextureHandleList.cpp
+  resTextureHandleList.h
+  resTextureHandleMgr.cpp
+  resTextureHandleMgr.h
   resUnit.cpp
   resUnit.h
   resUnitPool.cpp

src/KingSystem/Resource/resCompactedHeap.cpp

@@ -0,0 +1 @@
+#include "KingSystem/Resource/resCompactedHeap.h"

src/KingSystem/Resource/resCompactedHeap.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <prim/seadSafeString.h>
+
+namespace ksys::res {
+
+// TODO: very incomplete
+class CompactedHeap {
+public:
+    static CompactedHeap* tryCreate(const sead::SafeString& name, void* buffer, size_t buffer_size,
+                                    u32 x);
+    static CompactedHeap* create(const sead::SafeString& name, void* buffer, size_t buffer_size,
+                                 u32 x);
+
+    void destroy();
+
+private:
+    virtual ~CompactedHeap();
+};
+
+}  // namespace ksys::res

src/KingSystem/Resource/resCounter.cpp

@@ -2,7 +2,7 @@
 
 namespace ksys::res {
 
-CounterBase::CounterBase() = default;
+CounterBase::CounterBase(sead::Heap*) {}
 
 CounterBase::~CounterBase() = default;
 

src/KingSystem/Resource/resCounter.h

@@ -5,6 +5,10 @@
 #include <thread/seadAtomic.h>
 #include "KingSystem/Utils/Types.h"
 
+namespace sead {
+class Heap;
+}
+
 namespace ksys::res {
 
 class CounterBase {
@@ -21,7 +25,7 @@ public:
         void* mData;
     };
 
-    CounterBase();
+    explicit CounterBase(sead::Heap* heap);
     virtual ~CounterBase();
 
     bool setData(const Data& data);
@@ -42,7 +46,7 @@ private:
 
 class Counter : public CounterBase {
 public:
-    Counter() = default;
+    using CounterBase::CounterBase;
     ~Counter() override = default;
 
 private:

src/KingSystem/Resource/resResourceMgrTask.cpp

@@ -1,10 +1,81 @@
 #include "KingSystem/Resource/resResourceMgrTask.h"
+#include <framework/seadHeapPolicies.h>
+#include <framework/seadTaskID.h>
 #include <thread/seadThreadUtil.h>
+#include "KingSystem/Resource/resCompactedHeap.h"
+#include "KingSystem/Resource/resEntryFactory.h"
+#include "KingSystem/Resource/resTextureHandleList.h"
+#include "KingSystem/Resource/resTextureHandleMgr.h"
+#include "KingSystem/Utils/SafeDelete.h"
 #include "KingSystem/Utils/Thread/GameTaskThread.h"
+#include "KingSystem/Utils/Thread/TaskMgr.h"
 #include "KingSystem/Utils/Thread/TaskThread.h"
 
 namespace ksys::res {
 
+void ResourceMgrTask::setInstance(ResourceMgrTask* task) {
+    if (!sInstance) {
+        sInstance = task;
+        task->mInstancePtrClearer.mClearOnDestruction = true;
+    }
+}
+
+ResourceMgrTask::ResourceMgrTask(const sead::TaskConstructArg& arg)
+    : sead::CalculateTask(arg, "res::ResourceMgrTask"),
+      mSzsDecompressorCS(arg.heap_array->getPrimaryHeap()),
+      mCounter(arg.heap_array->getPrimaryHeap()), mTask(arg.heap_array->getPrimaryHeap()) {
+    mArenas.initOffset(OverlayArena::getListNodeOffset());
+    mUnits.initOffset(ResourceUnit::getResMgrUnitListNodeOffset());
+    mSomeList.initOffset(0x188);  // TODO: replace this with a "get offset" call
+    mSystemCalcFn.bind(this, &ResourceMgrTask::callSystemCalc_);
+    mFileDevicePrefixes.initOffset(FileDevicePrefix::getListNodeOffset());
+}
+
+ResourceMgrTask::~ResourceMgrTask() {
+    util::safeDelete(mTexHandleList);
+    util::safeDelete(mTexHandleMgr);
+    util::safeDeleteThread(mCompactionThread);
+
+    if (mCompactedHeapMip0) {
+        mCompactedHeapMip0->destroy();
+        util::safeDeleteArray(mCompactedHeapMip0Buffer);
+    }
+
+    if (mCompactedHeapMain) {
+        mCompactedHeapMain->destroy();
+        util::safeDeleteArray(mCompactedHeapMainBuffer);
+        mCompactedHeapMainSeadHeap->destroy();
+    }
+
+    util::safeDeleteArray(mCompactedHeapMainBuffer2);
+    util::safeDeleteArray(mOffsetReadBuf);
+    mExtensions2.freeBuffer();
+    mExtensions1.freeBuffer();
+
+    util::safeDeleteThread(mMovableMemoryThread);
+    util::safeDeleteThread(mResourceMemoryThread);
+    util::safeDeleteThread(mResourceControlThread);
+    util::safeDeleteThread(mResourceLoadingThread);
+    util::safeDelete(mTask3);
+    util::safeDelete(mTask2);
+    util::safeDelete(mTask1);
+    util::safeDelete(mControlTask);
+
+    if (mResourceMemoryTaskMgr) {
+        mResourceMemoryTaskMgr->finalize();
+        util::safeDelete(mResourceMemoryTaskMgr);
+    }
+
+    if (mResourceControlTaskMgr) {
+        mResourceControlTaskMgr->finalize();
+        util::safeDelete(mResourceControlTaskMgr);
+    }
+
+    util::safeDelete(mEntryFactoryBase);
+
+    mResSystemHeap->destroy();
+}
+
 util::TaskThread* ResourceMgrTask::makeResourceLoadingThread(sead::Heap* heap,
                                                              bool use_game_task_thread) {
     if (use_game_task_thread) {

src/KingSystem/Resource/resResourceMgrTask.h

@@ -1,8 +1,27 @@
 #pragma once
 
+#include <basis/seadTypes.h>
+#include <container/seadBuffer.h>
+#include <container/seadListImpl.h>
+#include <container/seadObjArray.h>
+#include <container/seadOffsetList.h>
+#include <container/seadPtrArray.h>
+#include <filedevice/seadArchiveFileDevice.h>
 #include <framework/seadCalculateTask.h>
 #include <hostio/seadHostIONode.h>
+#include <prim/seadDelegate.h>
+#include <prim/seadTypedBitFlag.h>
+#include <thread/seadAtomic.h>
+#include <thread/seadCriticalSection.h>
+#include <thread/seadDelegateThread.h>
+#include <thread/seadReadWriteLock.h>
+#include <time/seadTickTime.h>
+#include "KingSystem/Resource/resControlTask.h"
+#include "KingSystem/Resource/resCounter.h"
+#include "KingSystem/Resource/resInfoContainer.h"
 #include "KingSystem/Resource/resUnit.h"
+#include "KingSystem/Resource/resUnitPool.h"
+#include "KingSystem/System/OverlayArena.h"
 
 namespace sead {
 class Heap;
@@ -12,17 +31,50 @@ namespace ksys {
 class OverlayArena;
 
 namespace util {
+class TaskMgr;
+class TaskPostRunResult;
 class TaskThread;
-}
+}  // namespace util
 }  // namespace ksys
 
 namespace ksys::res {
 
+class Cache;
+class CompactedHeap;
+class ControlTaskData;
+class EntryFactoryBase;
+class MemoryTaskData;
+class OffsetReadFileDevice;
+class TextureHandleList;
+class TextureHandleMgr;
+
+class FileDevicePrefix {
+public:
+    FileDevicePrefix() = default;
+
+    sead::FileDevice* getFileDevice() { return mFileDevice; }
+    void setFileDevice(sead::FileDevice* device) { mFileDevice = device; }
+
+    const sead::SafeString& getPrefix() { return mPrefix; }
+    void setPrefix(const sead::SafeString& prefix) { mPrefix = prefix; }
+
+    static constexpr size_t getListNodeOffset() { return offsetof(FileDevicePrefix, mListNode); }
+
+private:
+    sead::ListNode mListNode;
+    sead::FileDevice* mFileDevice = nullptr;
+    sead::SafeString mPrefix;
+};
+KSYS_CHECK_SIZE_NX150(FileDevicePrefix, 0x28);
+
 // FIXME: very, very incomplete.
 class ResourceMgrTask : public sead::CalculateTask, public sead::hostio::Node {
+    SEAD_RTTI_OVERRIDE(ResourceMgrTask, sead::CalculateTask)
 public:
     static ResourceMgrTask* instance() { return sInstance; }
 
+    void prepare() override;
+
     void insertOverlayArena(OverlayArena* arena);
     OverlayArena* getSomeArena() const;
 
@@ -46,9 +98,147 @@ public:
                                     const sead::SafeString& extension);
 
 private:
+    enum class Flag {
+
+    };
+
+    using ResourceUnitDelegate = sead::Delegate1RFunc<void*, bool>;
+    using TaskCallback =
+        sead::Delegate2Func<util::TaskPostRunResult*, const util::TaskPostRunContext&>;
+    using MemoryTaskDelegate = sead::Delegate1R<ResourceMgrTask, void*, bool>;
+
+    struct ResourceUnitDelegatePair {
+        ResourceUnitDelegate fn;
+        TaskCallback cb;
+    };
+
+    explicit ResourceMgrTask(const sead::TaskConstructArg& arg);
+    ~ResourceMgrTask();
+
+    bool callSystemCalc_(void* userdata);
+    static void setInstance(ResourceMgrTask* task);
+
     static ResourceMgrTask* sInstance;
+
+    struct InstancePtrClearer {
+        ~InstancePtrClearer() {
+            if (mClearOnDestruction)
+                ResourceMgrTask::sInstance = nullptr;
+        }
+
+        bool mClearOnDestruction = false;
+    };
+    InstancePtrClearer mInstancePtrClearer;
+
+    sead::TypedBitFlag<Flag> mFlags;
+    bool mClearAllCachesRequested = false;
+    u32 _17c = 0;
+    sead::Heap* mResSystemHeap = nullptr;
+    util::TaskThread* mResourceLoadingThread = nullptr;
+    util::TaskThread* mResourceControlThread = nullptr;
+    util::TaskThread* mResourceMemoryThread = nullptr;
+    util::TaskThread* mMovableMemoryThread = nullptr;
+    sead::PtrArray<util::TaskThread>* mActorCreateInitializerThreads = nullptr;
+    util::TaskMgr* mResourceControlTaskMgr = nullptr;
+    util::TaskMgr* mResourceMemoryTaskMgr;
+    ControlTask* mControlTask = nullptr;
+    util::Task* mTask1 = nullptr;
+    util::Task* mTask2 = nullptr;
+    util::Task* mTask3 = nullptr;
+
+    EntryFactoryBase* mEntryFactoryBase = nullptr;
+    EntryFactoryBase* mDefaultEntryFactory = nullptr;
+
+    sead::Buffer<Cache> mCaches;
+    sead::FixedObjArray<s32, 4> mThreadIds;
+    u8* mOffsetReadBuf = nullptr;
+    sead::CriticalSection mSzsDecompressorCS;
+    sead::CriticalSection mFactoryCS;
+
+    ResourceUnitDelegatePair mUnitInitLoadFn;
+    ResourceUnitDelegate mUnitPrepareLoadFn;
+    ResourceUnitDelegate mUnitAdjustHeapFn;
+    ResourceUnitDelegatePair mDelegate2;  // TODO: rename
+    ResourceUnitDelegatePair mUnitUnloadFn;
+    ResourceUnitDelegatePair mUnitClearCacheForSyncFn;
+    ResourceUnitDelegatePair mUnitClearCacheFn;
+
+    MemoryTaskDelegate mClearAllCachesFn;
+    MemoryTaskDelegate mClearCachesFn;
+    MemoryTaskDelegate mDefragAllMemoryMgrFn;
+
+    MemoryTaskDelegate mLoadFn;
+    sead::Delegate2<ResourceMgrTask, util::TaskPostRunResult*, const util::TaskPostRunContext&>
+        mLoadCb;
+    sead::Delegate1<ResourceMgrTask, const util::TaskRemoveCallbackContext&> mLoadTaskRemoveCb;
+
+    MemoryTaskDelegate mCalcFn;
+    MemoryTaskDelegate mCalcArenaHeapSizeFn;
+    ResourceUnitDelegate mUnitDelegate17;  // TODO: rename
+    ResourceUnitDelegate mUnitDeleteFn;
+
+    s32 _4c8 = -1;
+    u32 _4cc = 0;
+
+    ResourceUnitPool mUnitPool;
+    sead::CriticalSection mCritSection;
+    sead::OffsetList<ResourceUnit> mUnits;
+    sead::OffsetList<bool> mSomeList;  // TODO: fix the type and rename
+
+    sead::FileDevice* mSeadMainFileDevice = nullptr;
+    OffsetReadFileDevice* mOffsetReadFileDevice = nullptr;
+    Handle* mPackHandle = nullptr;
+    sead::ArchiveFileDevice mArchiveFileDev1{nullptr};  // TODO: rename
+    sead::ArchiveFileDevice mArchiveFileDev2{nullptr};  // TODO: rename
+    sead::ArchiveFileDevice mArchiveFileDev3{nullptr};  // TODO: rename
+    sead::CriticalSection mCritSection2;                // TODO: rename
+
+    u32 _9c08d0 = 0;
+    sead::ObjArray<sead::SafeString> mExtensions1;  // TODO: rename
+    sead::ObjArray<sead::SafeString> mExtensions2;  // TODO: rename
+
+    sead::OffsetList<OverlayArena> mArenas;
+    sead::CriticalSection mArenasCS;
+
+    OverlayArena mArenaForResourceS;
+    OverlayArena mArenaForResourceL;
+
+    ResourceInfoContainer mResourceInfoContainer;
+
+    sead::OffsetList<FileDevicePrefix> mFileDevicePrefixes;
+    sead::ReadWriteLock mFileDevicePrefixesLock;
+
+    TextureHandleMgr* mTexHandleMgr = nullptr;
+    TextureHandleList* mTexHandleList = nullptr;
+    sead::CriticalSection mCritSection3;  // TODO: rename
+
+    sead::Heap* mCompactedHeapMainSeadHeap = nullptr;
+    u8* mCompactedHeapMainBuffer = nullptr;
+    CompactedHeap* mCompactedHeapMain = nullptr;
+    u8* mCompactedHeapMip0Buffer = nullptr;
+    CompactedHeap* mCompactedHeapMip0 = nullptr;
+    u8* mCompactedHeapMainBuffer2 = nullptr;
+    sead::Atomic<u32> mCompactionStopped = 0;
+    sead::Atomic<u32> _9c0d3c = 0;
+    sead::Atomic<u32> _9c0d40 = 0;
+    sead::AnyDelegate2<sead::Thread*, sead::MessageQueue::Element> mCompactionThreadFn;
+    sead::DelegateThread* mCompactionThread = nullptr;
+    Counter mCounter;
+
+    u32 _9c0d88 = 1;
+    u32 _9c0d8c = 0;
+    u32 _9c0d90 = 0;
+    u32 _9c0d94;
+    u8 _9c0d98 = 1;
+    size_t _9c0da0 = 500;
+
+    util::Task mTask;                     // TODO: rename
+    sead::CriticalSection mCritSection4;  // TODO: rename
+    sead::TickTime mTickTime;
+    MemoryTaskDelegate mSystemCalcFn;
 };
 KSYS_CHECK_SIZE_NX150(sead::TaskBase, 0xd0);
 KSYS_CHECK_SIZE_NX150(sead::MethodTreeNode, 0x98);
+KSYS_CHECK_SIZE_NX150(ResourceMgrTask, 0x9c0eb8);
 
 }  // namespace ksys::res

src/KingSystem/Resource/resTextureHandleList.cpp

@@ -0,0 +1 @@
+#include "KingSystem/Resource/resTextureHandleList.h"

src/KingSystem/Resource/resTextureHandleList.h

@@ -0,0 +1,11 @@
+#pragma once
+
+namespace ksys::res {
+
+// TODO: very incomplete
+class TextureHandleList {
+public:
+    virtual ~TextureHandleList();
+};
+
+}  // namespace ksys::res

src/KingSystem/Resource/resTextureHandleMgr.cpp

@@ -0,0 +1 @@
+#include "KingSystem/Resource/resTextureHandleMgr.h"

src/KingSystem/Resource/resTextureHandleMgr.h

@@ -0,0 +1,11 @@
+#pragma once
+
+namespace ksys::res {
+
+// TODO: very incomplete
+class TextureHandleMgr {
+public:
+    virtual ~TextureHandleMgr();
+};
+
+}  // namespace ksys::res

src/KingSystem/System/OverlayArena.h

@@ -45,6 +45,8 @@ public:
     bool init(const InitArg& arg);
     void destroy();
 
+    static constexpr size_t getListNodeOffset() { return offsetof(OverlayArena, mListNode); }
+
 private:
     friend class OverlayArenaSystem;
 

src/KingSystem/Utils/CMakeLists.txt

@@ -33,6 +33,7 @@ target_sources(uking PRIVATE
   HeapUtil.h
   InitTimeInfo.h
   ParamIO.h
+  SafeDelete.h
   StrTreeMap.h
   Types.h
 )

src/KingSystem/Utils/SafeDelete.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <thread/seadThread.h>
+
+namespace ksys::util {
+
+template <typename T>
+inline void safeDelete(T*& pointer) {
+    if (pointer)
+        delete pointer;
+    pointer = nullptr;
+}
+
+template <typename T>
+inline void safeDeleteArray(T*& pointer) {
+    if (pointer)
+        delete[] pointer;
+    pointer = nullptr;
+}
+
+template <typename T>
+inline void safeDeleteThread(T*& thread, bool is_jam = false) {
+    if (!thread)
+        return;
+
+    thread->quitAndWaitDoneSingleThread(is_jam);
+    safeDelete(thread);
+}
+
+}  // namespace ksys::util