ksys/act: Add BaseProcDeleter

src/KingSystem/ActorSystem/CMakeLists.txt

@@ -52,6 +52,8 @@ target_sources(uking PRIVATE
   actAttention.h
   actBaseProc.cpp
   actBaseProc.h
+  actBaseProcDeleter.cpp
+  actBaseProcDeleter.h
   actBaseProcHandle.cpp
   actBaseProcHandle.h
   actBaseProcHeapMgr.cpp

src/KingSystem/ActorSystem/actBaseProcDeleter.cpp

@@ -0,0 +1,71 @@
+#include "KingSystem/ActorSystem/actBaseProcDeleter.h"
+#include "KingSystem/ActorSystem/actActorParamMgr.h"
+#include "KingSystem/ActorSystem/actBaseProc.h"
+#include "KingSystem/Utils/SafeDelete.h"
+#include "KingSystem/Utils/Thread/ManagedTask.h"
+#include "KingSystem/Utils/Thread/TaskMgr.h"
+#include "KingSystem/Utils/Thread/TaskQueue.h"
+
+namespace ksys::act {
+
+BaseProcDeleter::BaseProcDeleter() = default;
+
+bool BaseProcDeleter::doPreDelete(void* proc) {
+    BaseProc::PreDeleteArg arg;
+    static_cast<BaseProc*>(proc)->doPreDelete(arg);
+    return true;
+}
+
+bool BaseProcDeleter::doUnloadParam(void* actor_param) {
+    ActorParamMgr::instance()->unloadParam(static_cast<ActorParam*>(actor_param));
+    return true;
+}
+
+BaseProcDeleter::~BaseProcDeleter() {
+    if (mTaskMgr) {
+        mTaskMgr->finalize();
+        util::safeDelete(mTaskMgr);
+    }
+}
+
+void BaseProcDeleter::init(const InitArg& arg) {
+    auto* heap = arg.heap;
+    mTaskQueue = arg.task_queue;
+    mTaskMgr = new (heap) util::TaskMgr(heap);
+    mTaskMgr->init<util::ManagedTask>(arg.task_queue_size, heap);
+}
+
+bool BaseProcDeleter::requestPreDelete(BaseProc* proc) {
+    util::TaskRequest request{false};
+    request.mSynchronous = false;
+    request.mQueue = mTaskQueue;
+    request.mDelegate = &mPreDeleteDelegate;
+    request.mUserData = proc;
+    request.mLaneId = u8(TaskLane::PreDelete);
+    request.mName = "PreDelete";
+
+    util::TaskMgrRequest req;
+    req.request = &request;
+    return mTaskMgr->trySubmitRequest(req);
+}
+
+void BaseProcDeleter::requestUnloadActorParam(ActorParam* param) {
+    util::TaskRequest request{false};
+    request.mSynchronous = false;
+    request.mQueue = mTaskQueue;
+    request.mDelegate = &mUnloadActorParamDelegate;
+    request.mUserData = param;
+    request.mLaneId = u8(TaskLane::UnloadActorParam);
+    request.mName = "UnloadActorParam";
+
+    util::TaskMgrRequest req;
+    req.request = &request;
+    mTaskMgr->submitRequest(req);
+}
+
+void BaseProcDeleter::unblockTasks() {
+    mTaskQueue->unblockTasks(u8(TaskLane::PreDelete));
+    mTaskQueue->unblockTasks(u8(TaskLane::UnloadActorParam));
+}
+
+}  // namespace ksys::act

src/KingSystem/ActorSystem/actBaseProcDeleter.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <container/seadBuffer.h>
+#include <prim/seadDelegate.h>
+#include "KingSystem/Utils/Types.h"
+
+namespace ksys::util {
+class TaskMgr;
+class TaskQueue;
+}  // namespace ksys::util
+
+namespace ksys::act {
+
+class ActorParam;
+class BaseProc;
+
+class BaseProcDeleter {
+public:
+    struct InitArg {
+        sead::Heap* heap;
+        util::TaskQueue* task_queue;
+        int task_queue_size;
+    };
+
+    BaseProcDeleter();
+    virtual ~BaseProcDeleter();
+
+    void init(const InitArg& arg);
+    bool requestPreDelete(BaseProc* proc);
+    void requestUnloadActorParam(ActorParam* param);
+    void unblockTasks();
+
+private:
+    enum class TaskLane : u8 {
+        UnloadActorParam = 3,
+        PreDelete = 4,
+    };
+
+    bool doPreDelete(void* proc);
+    bool doUnloadParam(void* actor_param);
+
+    util::TaskMgr* mTaskMgr{};
+    util::TaskQueue* mTaskQueue{};
+    sead::Buffer<void*> mBuffer;
+    sead::Delegate1R<BaseProcDeleter, void*, bool> mPreDeleteDelegate{
+        this, &BaseProcDeleter::doPreDelete};
+    sead::Delegate1R<BaseProcDeleter, void*, bool> mUnloadActorParamDelegate{
+        this, &BaseProcDeleter::doUnloadParam};
+};
+KSYS_CHECK_SIZE_NX150(BaseProcDeleter, 0x68);
+
+}  // namespace ksys::act