ksys/phys: Rename RagdollController to RagdollInstance

RagdollController is a different thing!

11 files changed, 172 insertions, 172 deletions

diff --git a/src/KingSystem/Physics/CMakeLists.txt b/src/KingSystem/Physics/CMakeLists.txt
index d33780f4..1c682ccc 100644
--- a/src/KingSystem/Physics/CMakeLists.txt
+++ b/src/KingSystem/Physics/CMakeLists.txt
@@ -13,10 +13,10 @@ target_sources(uking PRIVATE
     Ragdoll/physRagdollConfig.h
     Ragdoll/physRagdollControllerKeyList.h
     Ragdoll/physRagdollControllerKeyList.cpp
-    Ragdoll/physRagdollController.cpp
-    Ragdoll/physRagdollController.h
-    Ragdoll/physRagdollControllerMgr.cpp
-    Ragdoll/physRagdollControllerMgr.h
+    Ragdoll/physRagdollInstance.cpp
+    Ragdoll/physRagdollInstance.h
+    Ragdoll/physRagdollInstanceMgr.cpp
+    Ragdoll/physRagdollInstanceMgr.h
     Ragdoll/physRagdollParam.cpp
     Ragdoll/physRagdollParam.h
     Ragdoll/physRagdollResource.cpp
diff --git a/src/KingSystem/Physics/Ragdoll/physRagdollControllerMgr.cpp b/src/KingSystem/Physics/Ragdoll/physRagdollControllerMgr.cpp
deleted file mode 100644
index c74ad207..00000000
--- a/src/KingSystem/Physics/Ragdoll/physRagdollControllerMgr.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#include "KingSystem/Physics/Ragdoll/physRagdollControllerMgr.h"
-#include <prim/seadScopedLock.h>
-#include "KingSystem/Physics/Ragdoll/physRagdollController.h"
-#include "KingSystem/Physics/System/physSystem.h"
-
-namespace ksys::phys {
-
-RagdollControllerMgr::RagdollControllerMgr() = default;
-
-RagdollControllerMgr::~RagdollControllerMgr() {
-    mControllers.freeBuffer();
-}
-
-void RagdollControllerMgr::init(sead::Heap* heap) {
-    mControllers.alloc(0x400, heap);
-}
-
-bool RagdollControllerMgr::addController(RagdollController* controller) {
-    return mControllers.push(controller);
-}
-
-void RagdollControllerMgr::removeController(RagdollController* controller) {
-    auto lock = sead::makeScopedLock(mCS);
-    mControllers.erase(controller);
-}
-
-void RagdollControllerMgr::calc() {
-    ScopedWorldLock world_lock{ContactLayerType::Entity};
-    auto lock = sead::makeScopedLock(mCS);
-
-    RagdollController* first_processed = nullptr;
-
-    while (auto* ctrl = mControllers.pop()) {
-        mControllers.push(ctrl);
-
-        // If we have processed the entire buffer and wrapped around, stop.
-        if (first_processed == ctrl)
-            break;
-
-        ctrl->update();
-
-        if (first_processed == nullptr)
-            first_processed = ctrl;
-    }
-}
-
-void RagdollControllerMgr::calc1() {}
-
-}  // namespace ksys::phys
diff --git a/src/KingSystem/Physics/Ragdoll/physRagdollController.cpp b/src/KingSystem/Physics/Ragdoll/physRagdollInstance.cpp
index 93611e42..7922e9fc 100644
--- a/src/KingSystem/Physics/Ragdoll/physRagdollController.cpp
+++ b/src/KingSystem/Physics/Ragdoll/physRagdollInstance.cpp
@@ -1,4 +1,4 @@
-#include "KingSystem/Physics/Ragdoll/physRagdollController.h"
+#include "KingSystem/Physics/Ragdoll/physRagdollInstance.h"
 #include <Havok/Animation/Animation/Mapper/hkaSkeletonMapper.h>
 #include <Havok/Animation/Animation/Rig/hkaPose.h>
 #include <Havok/Animation/Physics2012Bridge/Instance/hkaRagdollInstance.h>
@@ -14,7 +14,7 @@
 #include <math/seadMathCalcCommon.h>
 #include <memory>
 #include <resource/seadResource.h>
-#include "KingSystem/Physics/Ragdoll/physRagdollControllerMgr.h"
+#include "KingSystem/Physics/Ragdoll/physRagdollInstanceMgr.h"
 #include "KingSystem/Physics/Ragdoll/physRagdollRigidBody.h"
 #include "KingSystem/Physics/Rig/physModelBoneAccessor.h"
 #include "KingSystem/Physics/Rig/physSkeletonMapper.h"
@@ -30,23 +30,23 @@
 
 namespace ksys::phys {
 
-static u8 sRagdollCtrlUnk1 = 15;
-static RagdollController::Config sRagdollCtrlConfig;
+static u8 sRagdollInstanceUnk1 = 15;
+static RagdollInstance::Config sRagdollInstanceConfig;
 
-RagdollController::RagdollController(SystemGroupHandler* handler)
-    : mGroupHandler(handler), _e8(sRagdollCtrlUnk1), _e9(sRagdollCtrlUnk1) {}
+RagdollInstance::RagdollInstance(SystemGroupHandler* handler)
+    : mGroupHandler(handler), _e8(sRagdollInstanceUnk1), _e9(sRagdollInstanceUnk1) {}
 
-RagdollController::~RagdollController() {
+RagdollInstance::~RagdollInstance() {
     finalize();
 }
 
-bool RagdollController::init(const RagdollParam* param, sead::DirectResource* res,
-                             gsys::Model* model, sead::Heap* heap) {
+bool RagdollInstance::init(const RagdollParam* param, sead::DirectResource* res, gsys::Model* model,
+                           sead::Heap* heap) {
     return doInit(param, res, model, heap);
 }
 
-bool RagdollController::doInit(const RagdollParam* param, sead::DirectResource* res,
-                               gsys::Model* model, sead::Heap* heap) {
+bool RagdollInstance::doInit(const RagdollParam* param, sead::DirectResource* res,
+                             gsys::Model* model, sead::Heap* heap) {
     if (!res)
         return false;
 
@@ -152,7 +152,7 @@ bool RagdollController::doInit(const RagdollParam* param, sead::DirectResource*
     return true;
 }
 
-void RagdollController::allocateBoneTransforms(int num_bones, sead::Heap* heap) {
+void RagdollInstance::allocateBoneTransforms(int num_bones, sead::Heap* heap) {
     static constexpr size_t Alignment = 0x20;
     mBoneTransformsByteSize =
         sead::Mathu::roundUpPow2(sizeof(hkQsTransformf) * num_bones, Alignment);
@@ -160,19 +160,19 @@ void RagdollController::allocateBoneTransforms(int num_bones, sead::Heap* heap)
     mBoneTransforms.setBuffer(num_bones, new (buffer) hkQsTransformf[num_bones]);
 }
 
-void RagdollController::registerSelf() {
-    const bool registered = System::instance()->getRagdollControllerMgr()->addController(this);
+void RagdollInstance::registerSelf() {
+    const bool registered = System::instance()->getRagdollInstanceMgr()->addInstance(this);
     mFlags.change(Flag::IsRegistered, registered);
 }
 
-void RagdollController::unregisterSelf() {
+void RagdollInstance::unregisterSelf() {
     if (mFlags.isOn(Flag::IsRegistered)) {
-        System::instance()->getRagdollControllerMgr()->removeController(this);
+        System::instance()->getRagdollInstanceMgr()->removeInstance(this);
         mFlags.reset(Flag::IsRegistered);
     }
 }
 
-void RagdollController::finalize() {
+void RagdollInstance::finalize() {
     for (auto body : util::indexIter(mBoneRigidBodies)) {
         body.get()->setCollisionInfo(nullptr);
         body.get()->setContactPointInfo(nullptr);
@@ -217,7 +217,7 @@ void RagdollController::finalize() {
     }
 }
 
-void RagdollController::removeConstraints() {
+void RagdollInstance::removeConstraints() {
     for (int i = 0, n = mRagdollInstance->m_constraints.getSize(); i < n; ++i) {
         auto* constraint = mRagdollInstance->m_constraints[i];
         if (constraint->getOwner() != nullptr) {
@@ -227,11 +227,11 @@ void RagdollController::removeConstraints() {
     }
 }
 
-bool RagdollController::isAddedToWorld() const {
+bool RagdollInstance::isAddedToWorld() const {
     return mBoneRigidBodies.size() > 0 && mBoneRigidBodies.back()->isAddedToWorld();
 }
 
-void RagdollController::removeFromWorldImmediately() {
+void RagdollInstance::removeFromWorldImmediately() {
     ScopedPhysicsLock lock{this};
 
     removeConstraints();
@@ -239,12 +239,12 @@ void RagdollController::removeFromWorldImmediately() {
         body.get()->removeFromWorldImmediately();
 }
 
-void RagdollController::removeFromWorld() {
+void RagdollInstance::removeFromWorld() {
     for (auto body : util::indexIter(mBoneRigidBodies))
         body.get()->removeFromWorld();
 }
 
-bool RagdollController::removeFromWorldAndResetLinks() {
+bool RagdollInstance::removeFromWorldAndResetLinks() {
     bool removed = true;
     for (auto body : util::indexIter(mBoneRigidBodies))
         removed &= body.get()->removeFromWorldAndResetLinks();
@@ -254,17 +254,17 @@ bool RagdollController::removeFromWorldAndResetLinks() {
     return removed;
 }
 
-bool RagdollController::isAddingToWorld() const {
+bool RagdollInstance::isAddingToWorld() const {
     return mBoneRigidBodies.size() > 0 && mBoneRigidBodies.back()->isAddingBodyToWorld();
 }
 
-void RagdollController::setTransform(const sead::Matrix34f& transform) {
+void RagdollInstance::setTransform(const sead::Matrix34f& transform) {
     hkQsTransformf hk_transform;
     toHkQsTransform(&hk_transform, transform, sead::Vector3f::ones);
     setTransform(hk_transform);
 }
 
-void RagdollController::setTransform(const hkQsTransformf& transform) {
+void RagdollInstance::setTransform(const hkQsTransformf& transform) {
     ScopedPhysicsLock lock{this};
 
     if (mSkeletonMapper)
@@ -285,7 +285,7 @@ void RagdollController::setTransform(const hkQsTransformf& transform) {
     }
 }
 
-void RagdollController::setScale(float scale) {
+void RagdollInstance::setScale(float scale) {
     if (sead::Mathf::equalsEpsilon(scale, 1.0))
         return;
 
@@ -332,92 +332,92 @@ void RagdollController::setScale(float scale) {
         mSkeletonMapper->getBoneAccessor().setScale(scale);
 }
 
-void RagdollController::setFixedAndPreserveImpulse(Fixed fixed,
-                                                   MarkLinearVelAsDirty mark_linear_vel_as_dirty) {
+void RagdollInstance::setFixedAndPreserveImpulse(Fixed fixed,
+                                                 MarkLinearVelAsDirty mark_linear_vel_as_dirty) {
     for (auto* body : mBoneRigidBodies)
         body->setFixedAndPreserveImpulse(fixed, mark_linear_vel_as_dirty);
 }
 
-void RagdollController::resetFrozenState() {
+void RagdollInstance::resetFrozenState() {
     for (auto* body : mBoneRigidBodies)
         body->resetFrozenState();
 }
 
-void RagdollController::setUseSystemTimeFactor(bool use) {
+void RagdollInstance::setUseSystemTimeFactor(bool use) {
     for (auto* body : mBoneRigidBodies)
         body->setUseSystemTimeFactor(use);
 }
 
-void RagdollController::clearFlag400000(bool clear) {
+void RagdollInstance::clearFlag400000(bool clear) {
     for (auto* body : mBoneRigidBodies)
         body->clearFlag400000(clear);
 }
 
-void RagdollController::setEntityMotionFlag200(bool set) {
+void RagdollInstance::setEntityMotionFlag200(bool set) {
     for (auto* body : mBoneRigidBodies)
         body->setEntityMotionFlag200(set);
 }
 
-void RagdollController::setFixed(Fixed fixed, PreserveVelocities preserve_velocities) {
+void RagdollInstance::setFixed(Fixed fixed, PreserveVelocities preserve_velocities) {
     for (auto* body : mBoneRigidBodies)
         body->setFixed(fixed, preserve_velocities);
 }
 
-ModelBoneAccessor* RagdollController::getModelBoneAccessor() const {
+ModelBoneAccessor* RagdollInstance::getModelBoneAccessor() const {
     if (mSkeletonMapper)
         return &mSkeletonMapper->getModelBoneAccessor();
 
     return mModelBoneAccessor;
 }
 
-void RagdollController::m3() {}
+void RagdollInstance::m3() {}
 
-void RagdollController::setUserTag(UserTag* tag) {
+void RagdollInstance::setUserTag(UserTag* tag) {
     for (auto* body : mBoneRigidBodies)
         body->setUserTag(tag);
 }
 
-void RagdollController::setSystemGroupHandler(SystemGroupHandler* handler) {
+void RagdollInstance::setSystemGroupHandler(SystemGroupHandler* handler) {
     for (auto* body : mBoneRigidBodies)
         body->setSystemGroupHandler(handler);
 
     mGroupHandler = handler;
 }
 
-void RagdollController::setContactPointInfo(ContactPointInfo* info) {
+void RagdollInstance::setContactPointInfo(ContactPointInfo* info) {
     for (auto* body : mBoneRigidBodies)
         body->setContactPointInfo(info);
 }
 
-void RagdollController::enableContactLayer(ContactLayer layer) {
+void RagdollInstance::enableContactLayer(ContactLayer layer) {
     for (auto* body : mBoneRigidBodies)
         body->enableContactLayer(layer, false);
 }
 
-void RagdollController::disableContactLayer(ContactLayer layer) {
+void RagdollInstance::disableContactLayer(ContactLayer layer) {
     for (auto* body : mBoneRigidBodies)
         body->disableContactLayer(layer, false);
 }
 
-void RagdollController::setContactAll() {
+void RagdollInstance::setContactAll() {
     for (auto* body : mBoneRigidBodies)
         body->setContactAll(false);
 }
 
-void RagdollController::setContactNone() {
+void RagdollInstance::setContactNone() {
     for (auto* body : mBoneRigidBodies)
         body->setContactNone(false);
 }
 
-void RagdollController::setContactAll(int bone_index) {
+void RagdollInstance::setContactAll(int bone_index) {
     mBoneRigidBodies[bone_index]->setContactAll(false);
 }
 
-void RagdollController::setContactNone(int bone_index) {
+void RagdollInstance::setContactNone(int bone_index) {
     mBoneRigidBodies[bone_index]->setContactNone(false);
 }
 
-void RagdollController::changeWorldState(RagdollController::WorldState state) {
+void RagdollInstance::changeWorldState(RagdollInstance::WorldState state) {
     if (getWorldState() == state)
         return;
 
@@ -471,21 +471,21 @@ void RagdollController::changeWorldState(RagdollController::WorldState state) {
     }
 }
 
-RagdollController::WorldState RagdollController::getWorldState() const {
+RagdollInstance::WorldState RagdollInstance::getWorldState() const {
     return mFlags.isOn(Flag::AddedToWorld) ? WorldState::AddedToWorld : WorldState::NotAddedToWorld;
 }
 
-void RagdollController::setExtraRigidBody(RigidBody* body, int bone_index) {
+void RagdollInstance::setExtraRigidBody(RigidBody* body, int bone_index) {
     mExtraRigidBody = body;
     mBoneIndexForExtraRigidBody = bone_index;
 }
 
-void RagdollController::setGravityFactor(float factor) {
+void RagdollInstance::setGravityFactor(float factor) {
     for (auto* body : mBoneRigidBodies)
         body->setGravityFactor(factor);
 }
 
-RagdollRigidBody* RagdollController::getBoneRigidBodyByName(const sead::SafeString& name) const {
+RagdollRigidBody* RagdollInstance::getBoneRigidBodyByName(const sead::SafeString& name) const {
     const int index = getBoneIndexByName(name);
     if (index < 0)
         return nullptr;
@@ -493,7 +493,7 @@ RagdollRigidBody* RagdollController::getBoneRigidBodyByName(const sead::SafeStri
     return mBoneRigidBodies[index];
 }
 
-int RagdollController::getBoneIndexByModelKey(const gsys::BoneAccessKey& key) const {
+int RagdollInstance::getBoneIndexByModelKey(const gsys::BoneAccessKey& key) const {
     const int model_bone_index = getModelBoneAccessor()->findBoneIndex(key);
 
     const char* bone_name = getModelBoneAccessor()->getBoneName(model_bone_index);
@@ -503,7 +503,7 @@ int RagdollController::getBoneIndexByModelKey(const gsys::BoneAccessKey& key) co
     return getBoneIndexByName(sead::FormatFixedSafeString<256>("Ragdoll_%s", bone_name));
 }
 
-int RagdollController::getBoneIndexByName(const sead::SafeString& name) const {
+int RagdollInstance::getBoneIndexByName(const sead::SafeString& name) const {
     int index = 0;
     for (auto* body : mBoneRigidBodies) {
         if (name == body->getHkBodyName())
@@ -513,23 +513,23 @@ int RagdollController::getBoneIndexByName(const sead::SafeString& name) const {
     return -1;
 }
 
-int RagdollController::getParentOfBone(int index) const {
+int RagdollInstance::getParentOfBone(int index) const {
     return mRagdollInstance->getParentOfBone(index);
 }
 
-RagdollRigidBody* RagdollController::getParentBoneRigidBody(const RigidBody* body) const {
+RagdollRigidBody* RagdollInstance::getParentBoneRigidBody(const RigidBody* body) const {
     return sead::DynamicCast<const RagdollRigidBody>(body)->getParentBody_();
 }
 
-int RagdollController::getNumChildBones(const RigidBody* body) const {
+int RagdollInstance::getNumChildBones(const RigidBody* body) const {
     return sead::DynamicCast<const RagdollRigidBody>(body)->getChildBodies_().size();
 }
 
-RagdollRigidBody* RagdollController::getChildBoneRigidBody(const RigidBody* body, int index) const {
+RagdollRigidBody* RagdollInstance::getChildBoneRigidBody(const RigidBody* body, int index) const {
     return sead::DynamicCast<const RagdollRigidBody>(body)->getChildBodies_()[index];
 }
 
-sead::Matrix34f RagdollController::getTransform(int bone_index) const {
+sead::Matrix34f RagdollInstance::getTransform(int bone_index) const {
     if (mFlags.isOff(Flag::_40)) {
         if (util::isMatrixInvalid(mModel->getMatrix()))
             return sead::Matrix34f::ident;
@@ -556,8 +556,8 @@ sead::Matrix34f RagdollController::getTransform(int bone_index) const {
     return out;
 }
 
-sead::Matrix34f RagdollController::getTransformWithCustomYAxis(int bone_index,
-                                                               const sead::Vector3f& y_axis) const {
+sead::Matrix34f RagdollInstance::getTransformWithCustomYAxis(int bone_index,
+                                                             const sead::Vector3f& y_axis) const {
     if (mFlags.isOff(Flag::_40)) {
         if (util::isMatrixInvalid(mModel->getMatrix()))
             return sead::Matrix34f::ident;
@@ -611,7 +611,7 @@ sead::Matrix34f RagdollController::getTransformWithCustomYAxis(int bone_index,
     return out;
 }
 
-int RagdollController::getConstraintIndexByName(const sead::SafeString& name) const {
+int RagdollInstance::getConstraintIndexByName(const sead::SafeString& name) const {
     for (int i = 0, n = getNumConstraints(); i < n; ++i) {
         if (name == mRagdollInstance->m_constraints[i]->getName())
             return i;
@@ -619,19 +619,19 @@ int RagdollController::getConstraintIndexByName(const sead::SafeString& name) co
     return -1;
 }
 
-int RagdollController::getNumConstraints() const {
+int RagdollInstance::getNumConstraints() const {
     return mRagdollInstance->m_constraints.size();
 }
 
-void RagdollController::enableConstraint(int index, bool enable) {
+void RagdollInstance::enableConstraint(int index, bool enable) {
     mDisabledConstraints.changeBit(index, !enable);
 }
 
-bool RagdollController::isConstraintEnabled(int index) const {
+bool RagdollInstance::isConstraintEnabled(int index) const {
     return mDisabledConstraints.isOffBit(index);
 }
 
-void RagdollController::setContactLayer(ContactLayer layer) {
+void RagdollInstance::setContactLayer(ContactLayer layer) {
     if (mContactLayer.value() == layer)
         return;
 
@@ -645,8 +645,8 @@ void RagdollController::setContactLayer(ContactLayer layer) {
     mContactLayer = layer;
 }
 
-void RagdollController::setKeyframed(int bone_index, bool keyframed,
-                                     SyncToThisBone sync_to_this_bone) {
+void RagdollInstance::setKeyframed(int bone_index, bool keyframed,
+                                   SyncToThisBone sync_to_this_bone) {
     mKeyframedBones.changeBit(bone_index, keyframed);
 
     if (keyframed) {
@@ -660,17 +660,17 @@ void RagdollController::setKeyframed(int bone_index, bool keyframed,
     mKeyframedBonesToSyncTo.changeBit(bone_index, keyframed && bool(sync_to_this_bone));
 }
 
-void RagdollController::setUnk1(u8 value) {
-    value = sead::Mathi::clamp(value, 0, sRagdollCtrlUnk1);
+void RagdollInstance::setUnk1(u8 value) {
+    value = sead::Mathi::clamp(value, 0, sRagdollInstanceUnk1);
     _e9 = value;
     _e8 = value;
 }
 
-void RagdollController::setMaximumUnk1(u8 value) {
-    sRagdollCtrlUnk1 = value;
+void RagdollInstance::setMaximumUnk1(u8 value) {
+    sRagdollInstanceUnk1 = value;
 }
 
-void RagdollController::stopForcingKeyframing() {
+void RagdollInstance::stopForcingKeyframing() {
     if (mFlags.isOn(Flag::AddedToWorld)) {
         for (int i = 0, n = mBoneRigidBodies.size(); i < n; ++i) {
             setKeyframed(i, false, {});
@@ -681,7 +681,7 @@ void RagdollController::stopForcingKeyframing() {
     }
 }
 
-void RagdollController::update() {
+void RagdollInstance::update() {
     if (!isAddedToWorld()) {
         for (int i = 0, n = getNumConstraints(); i < n; ++i) {
             auto* constraint = mRagdollInstance->m_constraints[i];
@@ -715,11 +715,11 @@ void RagdollController::update() {
     updateGravityFactorOverride();
 }
 
-RagdollController::Config& RagdollController::getConfig() {
-    return sRagdollCtrlConfig;
+RagdollInstance::Config& RagdollInstance::getConfig() {
+    return sRagdollInstanceConfig;
 }
 
-void RagdollController::updateGravityFactorOverride() {
+void RagdollInstance::updateGravityFactorOverride() {
     if (mFlags.isOff(Flag::_200))
         return;
 
@@ -732,18 +732,18 @@ void RagdollController::updateGravityFactorOverride() {
     }
 }
 
-RagdollController::ScopedPhysicsLock::ScopedPhysicsLock(const RagdollController* ctrl)
-    : mCtrl{ctrl}, mWorldLock{ctrl->isAddedToWorld(), ContactLayerType::Entity} {
-    for (auto body : util::indexIter(ctrl->mBoneRigidBodies))
+RagdollInstance::ScopedPhysicsLock::ScopedPhysicsLock(const RagdollInstance* instance)
+    : mInstance{instance}, mWorldLock{instance->isAddedToWorld(), ContactLayerType::Entity} {
+    for (auto body : util::indexIter(instance->mBoneRigidBodies))
         body.get()->lock(RigidBody::AlsoLockWorld::No);
 }
 
-RagdollController::ScopedPhysicsLock::~ScopedPhysicsLock() {
-    for (auto body : util::indexIter(mCtrl->mBoneRigidBodies))
+RagdollInstance::ScopedPhysicsLock::~ScopedPhysicsLock() {
+    for (auto body : util::indexIter(mInstance->mBoneRigidBodies))
         body.get()->unlock(RigidBody::AlsoLockWorld::No);
 }
 
-BoneAccessor* RagdollController::getBoneAccessor() const {
+BoneAccessor* RagdollInstance::getBoneAccessor() const {
     if (mSkeletonMapper)
         return &mSkeletonMapper->getBoneAccessor();
 
diff --git a/src/KingSystem/Physics/Ragdoll/physRagdollController.h b/src/KingSystem/Physics/Ragdoll/physRagdollInstance.h
index 7528e59e..5e9423e5 100644
--- a/src/KingSystem/Physics/Ragdoll/physRagdollController.h
+++ b/src/KingSystem/Physics/Ragdoll/physRagdollInstance.h
@@ -39,7 +39,7 @@ enum class MarkLinearVelAsDirty : bool;
 enum class PreserveVelocities : bool;
 
 // TODO
-class RagdollController : public sead::hostio::Node {
+class RagdollInstance : public sead::hostio::Node {
 public:
     enum class SyncToThisBone : bool;
 
@@ -53,8 +53,8 @@ public:
         hkpConstraintInstance::ConstraintPriority priority = hkpConstraintInstance::PRIORITY_TOI;
     };
 
-    explicit RagdollController(SystemGroupHandler* handler);
-    virtual ~RagdollController();
+    explicit RagdollInstance(SystemGroupHandler* handler);
+    virtual ~RagdollInstance();
 
     bool init(const RagdollParam* param, sead::DirectResource* res, gsys::Model* model,
               sead::Heap* heap);
@@ -134,11 +134,11 @@ public:
 private:
     class ScopedPhysicsLock {
     public:
-        explicit ScopedPhysicsLock(const RagdollController* ctrl);
+        explicit ScopedPhysicsLock(const RagdollInstance* instance);
         ~ScopedPhysicsLock();
 
     private:
-        const RagdollController* mCtrl;
+        const RagdollInstance* mInstance;
         ScopedWorldLock mWorldLock;
     };
 
@@ -150,7 +150,7 @@ private:
         _20 = 0x20,
         _40 = 0x40,
         _80 = 0x80,
-        /// Whether this controller has been registered with the RagdollControllerMgr.
+        /// Whether this instance has been registered with the RagdollInstanceMgr.
         IsRegistered = 0x100,
         _200 = 0x200,
     };
@@ -211,6 +211,6 @@ private:
     u8 mBoneIndexForExtraRigidBody = 0;
     ContactLayer mContactLayer = ContactLayer::EntityRagdoll;
 };
-KSYS_CHECK_SIZE_NX150(RagdollController, 0xf0);
+KSYS_CHECK_SIZE_NX150(RagdollInstance, 0xf0);
 
 }  // namespace ksys::phys
diff --git a/src/KingSystem/Physics/Ragdoll/physRagdollInstanceMgr.cpp b/src/KingSystem/Physics/Ragdoll/physRagdollInstanceMgr.cpp
new file mode 100644
index 00000000..92c35886
--- /dev/null
+++ b/src/KingSystem/Physics/Ragdoll/physRagdollInstanceMgr.cpp
@@ -0,0 +1,49 @@
+#include "KingSystem/Physics/Ragdoll/physRagdollInstanceMgr.h"
+#include <prim/seadScopedLock.h>
+#include "KingSystem/Physics/Ragdoll/physRagdollInstance.h"
+#include "KingSystem/Physics/System/physSystem.h"
+
+namespace ksys::phys {
+
+RagdollInstanceMgr::RagdollInstanceMgr() = default;
+
+RagdollInstanceMgr::~RagdollInstanceMgr() {
+    mInstances.freeBuffer();
+}
+
+void RagdollInstanceMgr::init(sead::Heap* heap) {
+    mInstances.alloc(0x400, heap);
+}
+
+bool RagdollInstanceMgr::addInstance(RagdollInstance* instance) {
+    return mInstances.push(instance);
+}
+
+void RagdollInstanceMgr::removeInstance(RagdollInstance* instance) {
+    auto lock = sead::makeScopedLock(mCS);
+    mInstances.erase(instance);
+}
+
+void RagdollInstanceMgr::calc() {
+    ScopedWorldLock world_lock{ContactLayerType::Entity};
+    auto lock = sead::makeScopedLock(mCS);
+
+    RagdollInstance* first_processed = nullptr;
+
+    while (auto* instance = mInstances.pop()) {
+        mInstances.push(instance);
+
+        // If we have processed the entire buffer and wrapped around, stop.
+        if (first_processed == instance)
+            break;
+
+        instance->update();
+
+        if (first_processed == nullptr)
+            first_processed = instance;
+    }
+}
+
+void RagdollInstanceMgr::calc1() {}
+
+}  // namespace ksys::phys
diff --git a/src/KingSystem/Physics/Ragdoll/physRagdollControllerMgr.h b/src/KingSystem/Physics/Ragdoll/physRagdollInstanceMgr.h
index 54e89219..6a9c90e8 100644
--- a/src/KingSystem/Physics/Ragdoll/physRagdollControllerMgr.h
+++ b/src/KingSystem/Physics/Ragdoll/physRagdollInstanceMgr.h
@@ -9,23 +9,23 @@ class Heap;
 
 namespace ksys::phys {
 
-class RagdollController;
+class RagdollInstance;
 
-class RagdollControllerMgr {
+class RagdollInstanceMgr {
 public:
-    RagdollControllerMgr();
-    virtual ~RagdollControllerMgr();
+    RagdollInstanceMgr();
+    virtual ~RagdollInstanceMgr();
 
     void init(sead::Heap* heap);
 
-    bool addController(RagdollController* controller);
-    void removeController(RagdollController* controller);
+    bool addInstance(RagdollInstance* instance);
+    void removeInstance(RagdollInstance* instance);
 
     void calc();
     void calc1();
 
 private:
-    util::LockFreeQueue<RagdollController> mControllers;
+    util::LockFreeQueue<RagdollInstance> mInstances;
     sead::CriticalSection mCS;
 };
 
diff --git a/src/KingSystem/Physics/Ragdoll/physRagdollRigidBody.cpp b/src/KingSystem/Physics/Ragdoll/physRagdollRigidBody.cpp
index bcc942aa..9c3c4de1 100644
--- a/src/KingSystem/Physics/Ragdoll/physRagdollRigidBody.cpp
+++ b/src/KingSystem/Physics/Ragdoll/physRagdollRigidBody.cpp
@@ -1,16 +1,16 @@
 #include "KingSystem/Physics/Ragdoll/physRagdollRigidBody.h"
 #include "Havok/Physics2012/Collide/Shape/Convex/Capsule/hkpCapsuleShape.h"
 #include "Havok/Physics2012/Dynamics/Entity/hkpRigidBody.h"
-#include "KingSystem/Physics/Ragdoll/physRagdollController.h"
+#include "KingSystem/Physics/Ragdoll/physRagdollInstance.h"
 #include "KingSystem/Physics/physMaterialMask.h"
 
 namespace ksys::phys {
 
-RagdollRigidBody::RagdollRigidBody(const sead::SafeString& name, RagdollController* ctrl,
+RagdollRigidBody::RagdollRigidBody(const sead::SafeString& name, RagdollInstance* instance,
                                    int bone_index, hkpRigidBody* hkp_rigid_body, sead::Heap* heap)
     : RigidBody(RigidBody::Type::Ragdoll, ContactLayerType::Entity, hkp_rigid_body, name, heap,
                 true),
-      mCtrl(ctrl), mBoneIndex(bone_index) {
+      mInstance(instance), mBoneIndex(bone_index) {
     updateCollidableQualityType(true);
     mFlags.set(Flag::NoCharStandingOn);
 }
@@ -20,22 +20,22 @@ RagdollRigidBody::~RagdollRigidBody() {
 }
 
 void RagdollRigidBody::init(sead::Heap* heap) {
-    const int parent_index = mCtrl->getParentOfBone(mBoneIndex);
+    const int parent_index = mInstance->getParentOfBone(mBoneIndex);
     if (parent_index >= 0)
-        mParentBody = mCtrl->getRigidBodies_()[parent_index];
+        mParentBody = mInstance->getRigidBodies_()[parent_index];
 
     int num_children = 0;
-    for (int i = 0, n = mCtrl->getRigidBodies_().size(); i < n; ++i) {
-        if (mCtrl->getParentOfBone(i) == mBoneIndex)
+    for (int i = 0, n = mInstance->getRigidBodies_().size(); i < n; ++i) {
+        if (mInstance->getParentOfBone(i) == mBoneIndex)
             ++num_children;
     }
 
     if (num_children > 0) {
         mChildBodies.allocBufferAssert(num_children, heap);
         int child_index = 0;
-        for (int i = 0, n = mCtrl->getRigidBodies_().size(); i < n; ++i) {
-            if (mCtrl->getParentOfBone(i) == mBoneIndex) {
-                mChildBodies[child_index] = mCtrl->getRigidBodies_()[i];
+        for (int i = 0, n = mInstance->getRigidBodies_().size(); i < n; ++i) {
+            if (mInstance->getParentOfBone(i) == mBoneIndex) {
+                mChildBodies[child_index] = mInstance->getRigidBodies_()[i];
                 ++child_index;
             }
         }
diff --git a/src/KingSystem/Physics/Ragdoll/physRagdollRigidBody.h b/src/KingSystem/Physics/Ragdoll/physRagdollRigidBody.h
index 9f3f1c79..14de6eb8 100644
--- a/src/KingSystem/Physics/Ragdoll/physRagdollRigidBody.h
+++ b/src/KingSystem/Physics/Ragdoll/physRagdollRigidBody.h
@@ -5,13 +5,13 @@
 
 namespace ksys::phys {
 
-class RagdollController;
+class RagdollInstance;
 
 /// The rigid body for a ragdoll bone.
 class RagdollRigidBody : public RigidBody {
     SEAD_RTTI_OVERRIDE(RagdollRigidBody, RigidBody)
 public:
-    RagdollRigidBody(const sead::SafeString& name, RagdollController* ctrl, int bone_index,
+    RagdollRigidBody(const sead::SafeString& name, RagdollInstance* instance, int bone_index,
                      hkpRigidBody* hkp_rigid_body, sead::Heap* heap);
     ~RagdollRigidBody() override;
 
@@ -32,7 +32,7 @@ public:
 private:
     void updateContactMask();
 
-    RagdollController* mCtrl{};
+    RagdollInstance* mInstance{};
     int mBoneIndex{};
     RagdollRigidBody* mParentBody{};
     sead::Buffer<RagdollRigidBody*> mChildBodies{};
diff --git a/src/KingSystem/Physics/System/physInstanceSet.cpp b/src/KingSystem/Physics/System/physInstanceSet.cpp
index 6e5269c8..5054c2ec 100644
--- a/src/KingSystem/Physics/System/physInstanceSet.cpp
+++ b/src/KingSystem/Physics/System/physInstanceSet.cpp
@@ -1,6 +1,6 @@
 #include "KingSystem/Physics/System/physInstanceSet.h"
 #include "KingSystem/Physics/CharacterController/physCharacterController.h"
-#include "KingSystem/Physics/Ragdoll/physRagdollController.h"
+#include "KingSystem/Physics/Ragdoll/physRagdollInstance.h"
 #include "KingSystem/Physics/RigidBody/physRigidBodySet.h"
 #include "KingSystem/Physics/System/physCollisionInfo.h"
 #include "KingSystem/Physics/System/physContactPointInfo.h"
@@ -103,8 +103,8 @@ void InstanceSet::sub_7100FBACE0(phys::ContactLayer layer) {
     if (sensor)
         return;
 
-    if (mRagdollController != nullptr)
-        mRagdollController->disableContactLayer(layer);
+    if (mRagdollInstance != nullptr)
+        mRagdollInstance->disableContactLayer(layer);
 
     if (mCharacterController != nullptr)
         mCharacterController->disableContactLayer(layer);
@@ -114,8 +114,8 @@ void InstanceSet::sub_7100FBAD74() {
     for (auto& rb : mRigidBodySets) {
         rb.disableAllContactLayers();
     }
-    if (mRagdollController != nullptr) {
-        mRagdollController->setContactNone();
+    if (mRagdollInstance != nullptr) {
+        mRagdollInstance->setContactNone();
     }
     if (mCharacterController != nullptr) {
         mCharacterController->sub_7100F60604();
@@ -189,10 +189,10 @@ void InstanceSet::sub_7100FBD284(const sead::Matrix34f& mtx) {
     }
     mFlags.reset(Flag::_80000000);
 
-    if (mRagdollController == nullptr)
+    if (mRagdollInstance == nullptr)
         return;
 
-    if (mRagdollController->getWorldState() == RagdollController::WorldState::AddedToWorld)
+    if (mRagdollInstance->getWorldState() == RagdollInstance::WorldState::AddedToWorld)
         sub_7100FBC890(mtx, false, false);
 }
 
diff --git a/src/KingSystem/Physics/System/physInstanceSet.h b/src/KingSystem/Physics/System/physInstanceSet.h
index 877e14b6..58e6e138 100644
--- a/src/KingSystem/Physics/System/physInstanceSet.h
+++ b/src/KingSystem/Physics/System/physInstanceSet.h
@@ -32,7 +32,7 @@ class CollisionInfo;
 class ContactPointInfo;
 class NavMeshCharacter;
 class ParamSet;
-class RagdollController;
+class RagdollInstance;
 class RigidBodySet;
 class SystemGroupHandler;
 class UserTag;
@@ -102,7 +102,7 @@ private:
     CharacterController* mCharacterController{};
     CharacterFormSet* mCharacterFormSet{};
 
-    RagdollController* mRagdollController{};
+    RagdollInstance* mRagdollInstance{};
     sead::Buffer<void*> _98;
     ContactPointInfo* mRagdollContactPointInfo{};
     res::Handle* mRagdollResHandle{};
diff --git a/src/KingSystem/Physics/System/physSystem.h b/src/KingSystem/Physics/System/physSystem.h
index 436e4727..a8c94b0b 100644
--- a/src/KingSystem/Physics/System/physSystem.h
+++ b/src/KingSystem/Physics/System/physSystem.h
@@ -20,7 +20,7 @@ class GroupFilter;
 class LayerContactPointInfo;
 class MaterialTable;
 class RayCastForRequest;
-class RagdollControllerMgr;
+class RagdollInstanceMgr;
 class RigidBody;
 class RigidBodyRequestMgr;
 class StaticCompoundMgr;
@@ -47,7 +47,7 @@ public:
     ContactMgr* getContactMgr() const { return mContactMgr; }
     StaticCompoundMgr* getStaticCompoundMgr() const { return mStaticCompoundMgr; }
     RigidBodyRequestMgr* getRigidBodyRequestMgr() const { return mRigidBodyRequestMgr; }
-    RagdollControllerMgr* getRagdollControllerMgr() const { return mRagdollControllerMgr; }
+    RagdollInstanceMgr* getRagdollInstanceMgr() const { return mRagdollInstanceMgr; }
     SystemData* getSystemData() const { return mSystemData; }
     MaterialTable* getMaterialTable() const { return mMaterialTable; }
 
@@ -151,7 +151,7 @@ private:
     void* _150;
     StaticCompoundMgr* mStaticCompoundMgr;
     RigidBodyRequestMgr* mRigidBodyRequestMgr;
-    RagdollControllerMgr* mRagdollControllerMgr;
+    RagdollInstanceMgr* mRagdollInstanceMgr;
     void* mRigidBodyDividedMeshShapeMgr;
     SystemData* mSystemData;
     MaterialTable* mMaterialTable;