ksys/phys: Rename flags for clarity in RigidBody

src/KingSystem/Physics/RigidBody/physRigidBody.h

@@ -69,15 +69,15 @@ public:
         Dynamic = 1 << 2,
         Keyframed = 1 << 3,
         Fixed = 1 << 4,
-        _20 = 1 << 5,
-        _40 = 1 << 6,
-        _80 = 1 << 7,
-        _100 = 1 << 8,
-        _200 = 1 << 9,
-        _400 = 1 << 10,
-        _800 = 1 << 11,
-        _1000 = 1 << 12,
-        _2000 = 1 << 13,
+        DirtyTransform = 1 << 5,
+        DirtyLinearVelocity = 1 << 6,
+        DirtyAngularVelocity = 1 << 7,
+        DirtyMaxVelOrTimeFactor = 1 << 8,
+        DirtyMiscState = 1 << 9,
+        DirtyMass = 1 << 10,
+        DirtyCenterOfMassLocal = 1 << 11,
+        DirtyInertiaLocal = 1 << 12,
+        DirtyDampingOrGravityFactor = 1 << 13,
         _4000 = 1 << 14,
         _8000 = 1 << 15,
         _10000 = 1 << 16,

src/KingSystem/Physics/RigidBody/physRigidBodyMotion.cpp

@@ -44,7 +44,7 @@ void RigidBodyMotion::setTransform(const sead::Matrix34f& mtx, bool propagate_to
     mMotion->setTransform(transform);
 
     if (mBody->isFlag8Set()) {
-        setMotionFlag(RigidBody::MotionFlag::_20);
+        setMotionFlag(RigidBody::MotionFlag::DirtyTransform);
     } else {
         getHkBody()->getMotion()->setTransform(transform);
     }
@@ -61,14 +61,14 @@ void RigidBodyMotion::setTransform(const sead::Matrix34f& mtx, bool propagate_to
 
 void RigidBodyMotion::setPosition(const sead::Vector3f& position,
                                   bool propagate_to_linked_motions) {
-    auto* motion = getMotionDependingOnFlag(RigidBody::MotionFlag::_20);
+    auto* motion = getHkBodyMotionOrLocalMotionIf(RigidBody::MotionFlag::DirtyTransform);
     const auto hk_position = toHkVec4(position);
     const auto& hk_rotate = motion->getRotation();
 
     mMotion->setPositionAndRotation(hk_position, hk_rotate);
 
     if (mBody->isFlag8Set()) {
-        setMotionFlag(RigidBody::MotionFlag::_20);
+        setMotionFlag(RigidBody::MotionFlag::DirtyTransform);
     } else {
         getHkBody()->getMotion()->setPositionAndRotation(hk_position, hk_rotate);
     }
@@ -82,18 +82,18 @@ void RigidBodyMotion::setPosition(const sead::Vector3f& position,
 }
 
 void RigidBodyMotion::getPosition(sead::Vector3f* position) {
-    auto* motion = getMotionDependingOnFlag(RigidBody::MotionFlag::_20);
+    auto* motion = getHkBodyMotionOrLocalMotionIf(RigidBody::MotionFlag::DirtyTransform);
     const auto hk_position = motion->getPosition();
     storeToVec3(position, hk_position);
 }
 
 void RigidBodyMotion::getRotation(sead::Quatf* rotation) {
-    auto* motion = getMotionDependingOnFlag(RigidBody::MotionFlag::_20);
+    auto* motion = getHkBodyMotionOrLocalMotionIf(RigidBody::MotionFlag::DirtyTransform);
     toQuat(rotation, motion->getRotation());
 }
 
 void RigidBodyMotion::getTransform(sead::Matrix34f* mtx) {
-    auto* motion = getMotionDependingOnFlag(RigidBody::MotionFlag::_20);
+    auto* motion = getHkBodyMotionOrLocalMotionIf(RigidBody::MotionFlag::DirtyTransform);
     setMtxRotation(mtx, motion->getTransform().getRotation());
     setMtxTranslation(mtx, motion->getTransform().getTranslation());
 }
@@ -103,7 +103,7 @@ void RigidBodyMotion::setCenterOfMassInLocal(const sead::Vector3f& center) {
     mMotion->setCenterOfMassInLocal(hk_center);
 
     if (mBody->isFlag8Set())
-        setMotionFlag(RigidBody::MotionFlag::_800);
+        setMotionFlag(RigidBody::MotionFlag::DirtyCenterOfMassLocal);
     else
         getHkBody()->setCenterOfMassLocal(hk_center);
 }
@@ -120,22 +120,22 @@ bool RigidBodyMotion::setLinearVelocity(const sead::Vector3f& velocity, float ep
         return false;
 
     mMotion->setLinearVelocity(toHkVec4(velocity));
-    setMotionFlag(RigidBody::MotionFlag::_40);
+    setMotionFlag(RigidBody::MotionFlag::DirtyLinearVelocity);
     return true;
 }
 
 bool RigidBodyMotion::setLinearVelocity(const hkVector4f& velocity, float epsilon) {
-    auto* motion = getMotionDependingOnFlag(RigidBody::MotionFlag::_40);
+    auto* motion = getHkBodyMotionOrLocalMotionIf(RigidBody::MotionFlag::DirtyLinearVelocity);
     if (velocity.allEqual<3>(motion->getLinearVelocity(), epsilon))
         return false;
 
     mMotion->setLinearVelocity(velocity);
-    setMotionFlag(RigidBody::MotionFlag::_40);
+    setMotionFlag(RigidBody::MotionFlag::DirtyLinearVelocity);
     return true;
 }
 
 void RigidBodyMotion::getLinearVelocity(sead::Vector3f* velocity) {
-    auto* motion = getMotionDependingOnFlag(RigidBody::MotionFlag::_40);
+    auto* motion = getHkBodyMotionOrLocalMotionIf(RigidBody::MotionFlag::DirtyLinearVelocity);
     const auto hk_vel = motion->getLinearVelocity();
     storeToVec3(velocity, hk_vel);
 }
@@ -147,29 +147,29 @@ bool RigidBodyMotion::setAngularVelocity(const sead::Vector3f& velocity, float e
         return false;
 
     mMotion->setAngularVelocity(toHkVec4(velocity));
-    setMotionFlag(RigidBody::MotionFlag::_80);
+    setMotionFlag(RigidBody::MotionFlag::DirtyAngularVelocity);
     return true;
 }
 
 bool RigidBodyMotion::setAngularVelocity(const hkVector4f& velocity, float epsilon) {
-    auto* motion = getMotionDependingOnFlag(RigidBody::MotionFlag::_80);
+    auto* motion = getHkBodyMotionOrLocalMotionIf(RigidBody::MotionFlag::DirtyAngularVelocity);
     if (velocity.allEqual<3>(motion->getAngularVelocity(), epsilon))
         return false;
 
     mMotion->setAngularVelocity(velocity);
-    setMotionFlag(RigidBody::MotionFlag::_80);
+    setMotionFlag(RigidBody::MotionFlag::DirtyAngularVelocity);
     return true;
 }
 
 void RigidBodyMotion::getAngularVelocity(sead::Vector3f* velocity) {
-    auto* motion = getMotionDependingOnFlag(RigidBody::MotionFlag::_80);
+    auto* motion = getHkBodyMotionOrLocalMotionIf(RigidBody::MotionFlag::DirtyAngularVelocity);
     const auto hk_vel = motion->getAngularVelocity();
     storeToVec3(velocity, hk_vel);
 }
 
 void RigidBodyMotion::setMaxLinearVelocity(float max) {
     mMotion->getMotionState()->m_maxLinearVelocity = max;
-    setMotionFlag(RigidBody::MotionFlag::_100);
+    setMotionFlag(RigidBody::MotionFlag::DirtyMaxVelOrTimeFactor);
 }
 
 float RigidBodyMotion::getMaxLinearVelocity() {
@@ -178,7 +178,7 @@ float RigidBodyMotion::getMaxLinearVelocity() {
 
 void RigidBodyMotion::setMaxAngularVelocity(float max) {
     mMotion->getMotionState()->m_maxAngularVelocity = max;
-    setMotionFlag(RigidBody::MotionFlag::_100);
+    setMotionFlag(RigidBody::MotionFlag::DirtyMaxVelOrTimeFactor);
 }
 
 float RigidBodyMotion::getMaxAngularVelocity() {
@@ -195,12 +195,12 @@ bool RigidBodyMotion::applyLinearImpulse(const sead::Vector3f& impulse) {
     if (impulse.equals(sead::Vector3f::zero, sImpulseEpsilon))
         return false;
 
-    if (hasMotionFlagDisabled(RigidBody::MotionFlag::_40)) {
+    if (hasMotionFlagDisabled(RigidBody::MotionFlag::DirtyLinearVelocity)) {
         mMotion->setLinearVelocity(getRigidBodyMotion()->getLinearVelocity());
     }
 
     mMotion->applyLinearImpulse(toHkVec4(impulse));
-    setMotionFlag(RigidBody::MotionFlag::_40);
+    setMotionFlag(RigidBody::MotionFlag::DirtyLinearVelocity);
     return true;
 }
 
@@ -214,17 +214,17 @@ bool RigidBodyMotion::applyAngularImpulse(const sead::Vector3f& impulse) {
     if (impulse.equals(sead::Vector3f::zero, sImpulseEpsilon))
         return false;
 
-    if (hasMotionFlagDisabled(RigidBody::MotionFlag::_20)) {
+    if (hasMotionFlagDisabled(RigidBody::MotionFlag::DirtyTransform)) {
         auto& rotation = mMotion->getMotionState()->getSweptTransform().m_rotation1;
         rotation = getRigidBodyMotion()->getRotation();
     }
 
-    if (hasMotionFlagDisabled(RigidBody::MotionFlag::_80)) {
+    if (hasMotionFlagDisabled(RigidBody::MotionFlag::DirtyAngularVelocity)) {
         mMotion->setAngularVelocity(getRigidBodyMotion()->getAngularVelocity());
     }
 
     mMotion->applyAngularImpulse(toHkVec4(impulse));
-    setMotionFlag(RigidBody::MotionFlag::_80);
+    setMotionFlag(RigidBody::MotionFlag::DirtyAngularVelocity);
     return true;
 }
 
@@ -239,11 +239,11 @@ bool RigidBodyMotion::applyPointImpulse(const sead::Vector3f& impulse,
     if (impulse.equals(sead::Vector3f::zero, sImpulseEpsilon))
         return false;
 
-    if (hasMotionFlagDisabled(RigidBody::MotionFlag::_20)) {
+    if (hasMotionFlagDisabled(RigidBody::MotionFlag::DirtyTransform)) {
         auto* state = mMotion->getMotionState();
         auto* body_state = getRigidBodyMotion()->getMotionState();
 
-        if (hasMotionFlagDisabled(RigidBody::MotionFlag::_800)) {
+        if (hasMotionFlagDisabled(RigidBody::MotionFlag::DirtyCenterOfMassLocal)) {
             state->getSweptTransform().m_centerOfMass1 =
                 body_state->getSweptTransform().m_centerOfMass1;
         }
@@ -251,49 +251,49 @@ bool RigidBodyMotion::applyPointImpulse(const sead::Vector3f& impulse,
         state->getTransform() = body_state->getTransform();
     }
 
-    if (hasMotionFlagDisabled(RigidBody::MotionFlag::_40)) {
+    if (hasMotionFlagDisabled(RigidBody::MotionFlag::DirtyLinearVelocity)) {
         mMotion->setLinearVelocity(getRigidBodyMotion()->getLinearVelocity());
     }
 
-    if (hasMotionFlagDisabled(RigidBody::MotionFlag::_80)) {
+    if (hasMotionFlagDisabled(RigidBody::MotionFlag::DirtyAngularVelocity)) {
         mMotion->setAngularVelocity(getRigidBodyMotion()->getAngularVelocity());
     }
 
     mMotion->applyPointImpulse(toHkVec4(impulse), toHkVec4(point));
-    setMotionFlag(RigidBody::MotionFlag::_40);
-    setMotionFlag(RigidBody::MotionFlag::_80);
+    setMotionFlag(RigidBody::MotionFlag::DirtyLinearVelocity);
+    setMotionFlag(RigidBody::MotionFlag::DirtyAngularVelocity);
     return true;
 }
 
 void RigidBodyMotion::setMass(float mass) {
-    if (bodyHasFlag80000()) {
+    if (arePropertyChangesBlocked()) {
         mMass = mass;
         return;
     }
 
     mMotion->setMass(mass);
     if (mBody->isFlag8Set())
-        setMotionFlag(RigidBody::MotionFlag::_400);
+        setMotionFlag(RigidBody::MotionFlag::DirtyMass);
     else if (mBody->getMotionType() == MotionType::Dynamic)
         getHkBody()->getMotion()->setMass(mass);
 }
 
 float RigidBodyMotion::getMass() const {
-    if (bodyHasFlag80000())
+    if (arePropertyChangesBlocked())
         return mMass;
 
     return mMotion->getMass();
 }
 
 float RigidBodyMotion::getMassInv() const {
-    if (bodyHasFlag80000())
+    if (arePropertyChangesBlocked())
         return 1.0f / mMass;
 
     return mMotion->getMassInv();
 }
 
 void RigidBodyMotion::getInertiaLocal(sead::Vector3f* inertia) const {
-    if (bodyHasFlag80000()) {
+    if (arePropertyChangesBlocked()) {
         inertia->e = mInertiaLocal.e;
         return;
     }
@@ -306,60 +306,60 @@ void RigidBodyMotion::getInertiaLocal(sead::Vector3f* inertia) const {
 }
 
 void RigidBodyMotion::setLinearDamping(float value) {
-    if (bodyHasFlag80000()) {
+    if (arePropertyChangesBlocked()) {
         mLinearDamping = value;
         return;
     }
 
     mMotion->setLinearDamping(value);
     if (mBody->isFlag8Set())
-        setMotionFlag(RigidBody::MotionFlag::_2000);
+        setMotionFlag(RigidBody::MotionFlag::DirtyDampingOrGravityFactor);
     else if (mBody->getMotionType() == MotionType::Dynamic)
         getHkBody()->setLinearDamping(getTimeFactor() * value);
 }
 
 float RigidBodyMotion::getLinearDamping() const {
-    if (bodyHasFlag80000())
+    if (arePropertyChangesBlocked())
         return mLinearDamping;
 
     return mMotion->getLinearDamping();
 }
 
 void RigidBodyMotion::setAngularDamping(float value) {
-    if (bodyHasFlag80000()) {
+    if (arePropertyChangesBlocked()) {
         mAngularDamping = value;
         return;
     }
 
     mMotion->setAngularDamping(value);
     if (mBody->isFlag8Set())
-        setMotionFlag(RigidBody::MotionFlag::_2000);
+        setMotionFlag(RigidBody::MotionFlag::DirtyDampingOrGravityFactor);
     else if (mBody->getMotionType() == MotionType::Dynamic)
         getHkBody()->setAngularDamping(getTimeFactor() * value);
 }
 
 float RigidBodyMotion::getAngularDamping() const {
-    if (bodyHasFlag80000())
+    if (arePropertyChangesBlocked())
         return mAngularDamping;
 
     return mMotion->getAngularDamping();
 }
 
 void RigidBodyMotion::setGravityFactor(float value) {
-    if (bodyHasFlag80000()) {
+    if (arePropertyChangesBlocked()) {
         mGravityFactor = value;
         return;
     }
 
     mMotion->setGravityFactor(value);
     if (mBody->isFlag8Set())
-        setMotionFlag(RigidBody::MotionFlag::_2000);
+        setMotionFlag(RigidBody::MotionFlag::DirtyDampingOrGravityFactor);
     else if (mBody->getMotionType() == MotionType::Dynamic)
         getHkBody()->setGravityFactor(value);
 }
 
 float RigidBodyMotion::getGravityFactor() const {
-    if (bodyHasFlag80000())
+    if (arePropertyChangesBlocked())
         return mGravityFactor;
 
     return mMotion->getGravityFactor();
@@ -367,7 +367,7 @@ float RigidBodyMotion::getGravityFactor() const {
 
 void RigidBodyMotion::setTimeFactor(float factor) {
     mMotion->setTimeFactor(factor);
-    setMotionFlag(RigidBody::MotionFlag::_100);
+    setMotionFlag(RigidBody::MotionFlag::DirtyMaxVelOrTimeFactor);
 }
 
 float RigidBodyMotion::getTimeFactor() {
@@ -375,7 +375,7 @@ float RigidBodyMotion::getTimeFactor() {
 }
 
 void RigidBodyMotion::getRotation(hkQuaternionf* quat) {
-    auto* motion = getMotionDependingOnFlag(RigidBody::MotionFlag::_20);
+    auto* motion = getHkBodyMotionOrLocalMotionIf(RigidBody::MotionFlag::DirtyTransform);
     *quat = motion->getRotation();
 }
 
@@ -383,21 +383,21 @@ void RigidBodyMotion::processUpdateFlags() {
     auto* body = getHkBody();
     auto* body_motion = body->getMotion();
 
-    if (hasMotionFlagSet(RigidBody::MotionFlag::_400)) {
+    if (hasMotionFlagSet(RigidBody::MotionFlag::DirtyMass)) {
         body_motion->setMassInv(mMotion->getMassInv());
-        disableMotionFlag(RigidBody::MotionFlag::_400);
+        disableMotionFlag(RigidBody::MotionFlag::DirtyMass);
     }
 
-    if (hasMotionFlagSet(RigidBody::MotionFlag::_1000)) {
+    if (hasMotionFlagSet(RigidBody::MotionFlag::DirtyInertiaLocal)) {
         if (!mBody->isCharacterControllerType()) {
             hkMatrix3 inertia;
             mMotion->getInertiaInvLocal(inertia);
             body_motion->setInertiaInvLocal(inertia);
         }
-        disableMotionFlag(RigidBody::MotionFlag::_1000);
+        disableMotionFlag(RigidBody::MotionFlag::DirtyInertiaLocal);
     }
 
-    if (hasMotionFlagSet(RigidBody::MotionFlag::_2000)) {
+    if (hasMotionFlagSet(RigidBody::MotionFlag::DirtyDampingOrGravityFactor)) {
         if (mBody->hasFlag(RigidBody::Flag::_20000)) {
             body->setLinearDamping(1.0);
             body->setAngularDamping(1.0);
@@ -407,12 +407,12 @@ void RigidBodyMotion::processUpdateFlags() {
             body->setAngularDamping(mMotion->getAngularDamping());
             body->setGravityFactor(mMotion->getGravityFactor());
         }
-        disableMotionFlag(RigidBody::MotionFlag::_2000);
+        disableMotionFlag(RigidBody::MotionFlag::DirtyDampingOrGravityFactor);
     }
 
-    if (hasMotionFlagSet(RigidBody::MotionFlag::_200)) {
+    if (hasMotionFlagSet(RigidBody::MotionFlag::DirtyMiscState)) {
         updateRigidBodyMotionExceptState();
-        disableMotionFlag(RigidBody::MotionFlag::_200);
+        disableMotionFlag(RigidBody::MotionFlag::DirtyMiscState);
     }
 }
 

src/KingSystem/Physics/RigidBody/physRigidBodyMotion.h

@@ -91,13 +91,14 @@ public:
     static void setMaxImpulse(float max_impulse);
 
 private:
-    hkpMotion* getMotionDependingOnFlag(RigidBody::MotionFlag use_local_motion_condition) const {
+    hkpMotion*
+    getHkBodyMotionOrLocalMotionIf(RigidBody::MotionFlag use_local_motion_condition) const {
         if (hasMotionFlagSet(use_local_motion_condition))
             return mMotion;
         return getRigidBodyMotion();
     }
 
-    bool bodyHasFlag80000() const { return mBody->hasFlag(RigidBody::Flag::_80000); }
+    bool arePropertyChangesBlocked() const { return mBody->hasFlag(RigidBody::Flag::_80000); }
 
     sead::Vector3f mLinearVelocity = sead::Vector3f::zero;
     float mLinearDamping{};

src/KingSystem/Physics/RigidBody/physRigidBodyMotionProxy.cpp

@@ -21,7 +21,7 @@ bool RigidBodyMotionProxy::init(const RigidBodyInstanceParam& params, sead::Heap
 
 KSYS_ALWAYS_INLINE void RigidBodyMotionProxy::setTransformImpl(const sead::Matrix34f& mtx) {
     if (mBody->isFlag8Set()) {  // flag 8 = block updates?
-        setMotionFlag(RigidBody::MotionFlag::_20);
+        setMotionFlag(RigidBody::MotionFlag::DirtyTransform);
         return;
     }
 
@@ -38,7 +38,7 @@ void RigidBodyMotionProxy::setTransform(const sead::Matrix34f& mtx,
 
 void RigidBodyMotionProxy::setPosition(const sead::Vector3f& position,
                                        bool propagate_to_linked_motions) {
-    if (hasMotionFlagDisabled(RigidBody::MotionFlag::_20)) {
+    if (hasMotionFlagDisabled(RigidBody::MotionFlag::DirtyTransform)) {
         getTransform(&mTransform);
     }
 
@@ -150,7 +150,7 @@ void RigidBodyMotionProxy::setTransformFromLinkedBody(const hkVector4f& hk_trans
 }
 
 void RigidBodyMotionProxy::getPosition(sead::Vector3f* position) {
-    if (hasMotionFlagSet(RigidBody::MotionFlag::_20)) {
+    if (hasMotionFlagSet(RigidBody::MotionFlag::DirtyTransform)) {
         mTransform.getTranslation(*position);
     } else {
         const auto hk_position = getRigidBodyMotion()->getPosition();
@@ -159,7 +159,7 @@ void RigidBodyMotionProxy::getPosition(sead::Vector3f* position) {
 }
 
 void RigidBodyMotionProxy::getRotation(sead::Quatf* rotation) {
-    if (hasMotionFlagSet(RigidBody::MotionFlag::_20)) {
+    if (hasMotionFlagSet(RigidBody::MotionFlag::DirtyTransform)) {
         mTransform.toQuat(*rotation);
     } else {
         toQuat(rotation, getRigidBodyMotion()->getRotation());
@@ -169,7 +169,7 @@ void RigidBodyMotionProxy::getRotation(sead::Quatf* rotation) {
 }
 
 void RigidBodyMotionProxy::getTransform(sead::Matrix34f* mtx) {
-    if (hasMotionFlagSet(RigidBody::MotionFlag::_20)) {
+    if (hasMotionFlagSet(RigidBody::MotionFlag::DirtyTransform)) {
         *mtx = mTransform;
     } else {
         const auto& transform = getRigidBodyMotion()->getTransform();
@@ -182,7 +182,7 @@ void RigidBodyMotionProxy::setCenterOfMassInLocal(const sead::Vector3f& center)
     mCenterOfMassInLocal.e = center.e;
 
     if (mBody->isFlag8Set()) {
-        setMotionFlag(RigidBody::MotionFlag::_800);
+        setMotionFlag(RigidBody::MotionFlag::DirtyCenterOfMassLocal);
         return;
     }
 
@@ -190,7 +190,7 @@ void RigidBodyMotionProxy::setCenterOfMassInLocal(const sead::Vector3f& center)
 }
 
 void RigidBodyMotionProxy::getCenterOfMassInLocal(sead::Vector3f* center) {
-    if (hasMotionFlagSet(RigidBody::MotionFlag::_800)) {
+    if (hasMotionFlagSet(RigidBody::MotionFlag::DirtyCenterOfMassLocal)) {
         center->e = mCenterOfMassInLocal.e;
     } else {
         const auto hk_center = getRigidBodyMotion()->getCenterOfMassLocal();
@@ -203,7 +203,7 @@ bool RigidBodyMotionProxy::setLinearVelocity(const sead::Vector3f& velocity, flo
         return false;
 
     mLinearVelocity.e = velocity.e;
-    setMotionFlag(RigidBody::MotionFlag::_40);
+    setMotionFlag(RigidBody::MotionFlag::DirtyLinearVelocity);
     return true;
 }
 
@@ -214,7 +214,7 @@ bool RigidBodyMotionProxy::setLinearVelocity(const hkVector4f& velocity, float e
 }
 
 void RigidBodyMotionProxy::getLinearVelocity(sead::Vector3f* velocity) {
-    if (hasMotionFlagSet(RigidBody::MotionFlag::_40)) {
+    if (hasMotionFlagSet(RigidBody::MotionFlag::DirtyLinearVelocity)) {
         velocity->e = mLinearVelocity.e;
     } else {
         const auto hk_velocity = getRigidBodyMotion()->getLinearVelocity();
@@ -227,7 +227,7 @@ bool RigidBodyMotionProxy::setAngularVelocity(const sead::Vector3f& velocity, fl
         return false;
 
     mAngularVelocity.e = velocity.e;
-    setMotionFlag(RigidBody::MotionFlag::_80);
+    setMotionFlag(RigidBody::MotionFlag::DirtyAngularVelocity);
     return true;
 }
 
@@ -238,7 +238,7 @@ bool RigidBodyMotionProxy::setAngularVelocity(const hkVector4f& velocity, float
 }
 
 void RigidBodyMotionProxy::getAngularVelocity(sead::Vector3f* velocity) {
-    if (hasMotionFlagSet(RigidBody::MotionFlag::_80)) {
+    if (hasMotionFlagSet(RigidBody::MotionFlag::DirtyAngularVelocity)) {
         velocity->e = mAngularVelocity.e;
     } else {
         const auto hk_velocity = getRigidBodyMotion()->getAngularVelocity();
@@ -248,11 +248,11 @@ void RigidBodyMotionProxy::getAngularVelocity(sead::Vector3f* velocity) {
 
 void RigidBodyMotionProxy::setMaxLinearVelocity(float max) {
     mMaxLinearVelocity = max;
-    setMotionFlag(RigidBody::MotionFlag::_100);
+    setMotionFlag(RigidBody::MotionFlag::DirtyMaxVelOrTimeFactor);
 }
 
 float RigidBodyMotionProxy::getMaxLinearVelocity() {
-    if (hasMotionFlagSet(RigidBody::MotionFlag::_100))
+    if (hasMotionFlagSet(RigidBody::MotionFlag::DirtyMaxVelOrTimeFactor))
         return mMaxLinearVelocity;
 
     return getRigidBodyMotion()->getMotionState()->m_maxLinearVelocity;
@@ -260,11 +260,11 @@ float RigidBodyMotionProxy::getMaxLinearVelocity() {
 
 void RigidBodyMotionProxy::setMaxAngularVelocity(float max) {
     mMaxAngularVelocity = max;
-    setMotionFlag(RigidBody::MotionFlag::_100);
+    setMotionFlag(RigidBody::MotionFlag::DirtyMaxVelOrTimeFactor);
 }
 
 float RigidBodyMotionProxy::getMaxAngularVelocity() {
-    if (hasMotionFlagSet(RigidBody::MotionFlag::_100))
+    if (hasMotionFlagSet(RigidBody::MotionFlag::DirtyMaxVelOrTimeFactor))
         return mMaxAngularVelocity;
 
     return getRigidBodyMotion()->getMotionState()->m_maxAngularVelocity;
@@ -328,7 +328,7 @@ void RigidBodyMotionProxy::getRotation(hkQuaternionf* quat) {
 
 void RigidBodyMotionProxy::setTimeFactor(float factor) {
     mTimeFactor = factor;
-    setMotionFlag(RigidBody::MotionFlag::_100);
+    setMotionFlag(RigidBody::MotionFlag::DirtyMaxVelOrTimeFactor);
 }
 
 float RigidBodyMotionProxy::getTimeFactor() {