More CPhysicsActor imps

2025-12-08 21:07:42 +00:00 · 2016-09-01 02:31:18 -07:00
parent c869814da3
commit 130108070d
9 changed files with 372 additions and 74 deletions
--- a/Runtime/World/CPhysicsActor.cpp
+++ b/Runtime/World/CPhysicsActor.cpp
@@ -6,27 +6,40 @@ namespace urde
 CPhysicsActor::CPhysicsActor(TUniqueId uid, bool active, const std::string& name, const CEntityInfo& info,
                             const zeus::CTransform& xf, CModelData&& mData, const CMaterialList& matList,
                             const zeus::CAABox& box, const SMoverData& moverData, const CActorParameters& actorParms,
-                             float, float)
+                             float stepUp, float stepDown)
    : CActor(uid, active, name, info, xf, std::move(mData), matList, actorParms, kInvalidUniqueId)
+    , xe8_mass(moverData.x30_mass)
+    , xec_massRecip(moverData.x30_mass <= 0.f ? 1.f : 1.f / moverData.x30_mass)
+    , xf8_24_(true)
+    , x150_momentum(moverData.x18_)
+    , x1c0_collisionPrimitive(box, matList)
+    , x200_(xf.buildMatrix3f())
+    , x23c_stepUpHeight(stepUp)
+    , x240_stepDownHeight(stepDown)
 {
+    SetMass(moverData.x30_mass);
+    MoveCollisionPrimitive(zeus::CVector3f::skZero);
+    SetVelocityOR(moverData.x0_velocity);
+    SetAngularVelocityOR(moverData.xc_angularVelocity);
+    ComputeDerivedQuantities();
 }

-void CPhysicsActor::Render(const CStateManager &mgr)
+void CPhysicsActor::Render(const CStateManager &mgr) const
 {
    CActor::Render(mgr);
 }

-zeus::CVector3f CPhysicsActor::GetOrbitPosition(const CStateManager &)
+zeus::CVector3f CPhysicsActor::GetOrbitPosition(const CStateManager &) const
 {
    return GetBoundingBox().center();
 }

-zeus::CVector3f CPhysicsActor::GetAimPosition(const CStateManager &, float val)
+zeus::CVector3f CPhysicsActor::GetAimPosition(const CStateManager&, float dt) const
 {
-    if (val <= 0.0)
+    if (dt <= 0.0)
        return GetBoundingBox().center();
-    //zeus::CVector3f delta = PredictMotion(val);
-    return zeus::CVector3f();
+    zeus::CVector3f trans = PredictMotion(dt).x0_translation;
+    return GetBoundingBox().center() + trans;
 }

 void CPhysicsActor::CollidedWith(const TUniqueId &, const CCollisionInfoList &, CStateManager &)
@@ -100,13 +113,13 @@ zeus::CAABox CPhysicsActor::GetMotionVolume(float dt) const

 zeus::CVector3f CPhysicsActor::CalculateNewVelocityWR_UsingImpulses() const
 {
-    return x138_velocity + (xec_massRecip * (x168_ + x18c_));
+    return x138_velocity + (xec_massRecip * (x168_impulse + x18c_));
 }

-zeus::CAABox CPhysicsActor::GetBoundingBox()
+zeus::CAABox CPhysicsActor::GetBoundingBox() const
 {
    return { x1a4_baseBoundingBox.min + x1e8_primitiveOffset + x34_transform.origin,
-             x1a4_baseBoundingBox.max + x1e8_primitiveOffset + x34_transform.origin };
+                x1a4_baseBoundingBox.max + x1e8_primitiveOffset + x34_transform.origin };
 }

 const zeus::CAABox& CPhysicsActor::GetBaseBoundingBox() const
@@ -124,16 +137,27 @@ void CPhysicsActor::AddMotionState(const CMotionState& mst)
    xe4_28_ = true;
    xe4_29_ = true;

-    SetTranslation(x34_transform.origin + mst.x0_origin);
+    SetTranslation(x34_transform.origin + mst.x0_translation);

-    x108_ += mst.x1c_;
+    x108_angularMomentum += mst.x1c_velocity;

    ComputeDerivedQuantities();
 }

 CMotionState CPhysicsActor::GetMotionState() const
 {
-    return {x34_transform.origin, {x34_transform.buildMatrix3f()}, xfc_, x108_};
+    return {x34_transform.origin, {x34_transform.buildMatrix3f()}, xfc_constantForce, x108_angularMomentum};
+}
+
+void CPhysicsActor::SetMotionState(const CMotionState &mst)
+{
+    x34_transform = zeus::CTransform::Translate(x34_transform.origin) * zeus::CMatrix3f(mst.xc_orientation);
+
+    xe4_27_ = true;
+    xe4_28_ = true;
+    xe4_29_ = true;
+    SetTranslation(mst.x0_translation);
+    ComputeDerivedQuantities();
 }

 void CPhysicsActor::SetInertiaTensorScalar(float tensor)
@@ -158,7 +182,7 @@ void CPhysicsActor::SetMass(float mass)
 void CPhysicsActor::SetAngularVelocityOR(const zeus::CAxisAngle& angVel)
 {
    x144_angularVelocity = x34_transform.rotate(angVel);
-    x108_ = xf0_inertiaTensor * x144_angularVelocity;
+    x108_angularMomentum = xf0_inertiaTensor * x144_angularVelocity;
 }

 zeus::CAxisAngle CPhysicsActor::GetAngularVelocityOR() const
@@ -169,13 +193,13 @@ zeus::CAxisAngle CPhysicsActor::GetAngularVelocityOR() const
 void CPhysicsActor::SetAngularVelocityWR(const zeus::CAxisAngle& angVel)
 {
    x144_angularVelocity = angVel;
-    x108_ = xf0_inertiaTensor * x144_angularVelocity;
+    x108_angularMomentum = xf0_inertiaTensor * x144_angularVelocity;
 }

 void CPhysicsActor::SetVelocityWR(const zeus::CVector3f &vel)
 {
    x138_velocity = vel;
-    xfc_ = xe8_mass * x138_velocity;
+    xfc_constantForce = xe8_mass * x138_velocity;
 }

 void CPhysicsActor::SetVelocityOR(const zeus::CVector3f& vel)
@@ -185,7 +209,7 @@ void CPhysicsActor::SetVelocityOR(const zeus::CVector3f& vel)

 zeus::CVector3f CPhysicsActor::GetTotalForcesWR() const
 {
-    return x15c_ + x150_;
+    return x15c_force + x150_momentum;
 }

 void CPhysicsActor::RotateInOneFrameOR(const zeus::CQuaternion &q, float d)
@@ -193,52 +217,254 @@ void CPhysicsActor::RotateInOneFrameOR(const zeus::CQuaternion &q, float d)
    x198_ += GetRotateToORAngularMomentumWR(q, d);
 }

-zeus::CVector3f CPhysicsActor::GetRotateToORAngularMomentumWR(const zeus::CQuaternion& q, float d) const
+void CPhysicsActor::MoveInOneFrameOR(const zeus::CVector3f &trans, float d)
+{
+    x18c_ += GetMoveToORImpulseWR(trans, d);
+}
+
+void CPhysicsActor::RotateToOR(const zeus::CQuaternion& q, float d)
+{
+    x108_angularMomentum = GetRotateToORAngularMomentumWR(q, d);
+    ComputeDerivedQuantities();
+}
+
+void CPhysicsActor::MoveToOR(const zeus::CVector3f& trans, float d)
+{
+    xfc_constantForce = GetMoveToORImpulseWR(trans, d);
+    ComputeDerivedQuantities();
+}
+
+void CPhysicsActor::sub_8011B098(const zeus::CVector3f& trans, float d)
+{
+    x18c_ +=  xe8_mass * (trans - x34_transform.origin) * (1.f / d);
+}
+
+void CPhysicsActor::MoveToWR(const zeus::CVector3f& trans, float d)
+{
+    xfc_constantForce = xe8_mass * (trans - x34_transform.origin) * (1.f / d);
+    ComputeDerivedQuantities();
+}
+
+zeus::CAxisAngle CPhysicsActor::GetRotateToORAngularMomentumWR(const zeus::CQuaternion& q, float d) const
 {
    if (q.w > 0.99999976)
-        return zeus::CVector3f::skZero;
+        return zeus::CAxisAngle::skZero;
    return (xf0_inertiaTensor * (((2.f * std::acos(q.w)) * (1.f / d)) *
                                 x34_transform.rotate({q.x, q.y, q.z}).normalized()));
 }

+zeus::CVector3f CPhysicsActor::GetMoveToORImpulseWR(const zeus::CVector3f &trans, float d) const
+{
+    return (xe8_mass * x34_transform.rotate(trans)) * (1.f / d);
+}
+
 void CPhysicsActor::ClearImpulses()
 {
-    x18c_ = x168_ = zeus::CVector3f::skZero;
-    x198_ = x180_ = zeus::CAxisAngle::skZero;
+    x18c_ = x168_impulse = zeus::CVector3f::skZero;
+    x198_ = x180_angularImpulse = zeus::CAxisAngle::skZero;
 }

 void CPhysicsActor::ClearForcesAndTorques()
 {
-    x18c_ = x168_ = x15c_ = zeus::CVector3f::skZero;
-    x198_ = x180_ = x174_ = zeus::CAxisAngle::skZero;
+    x18c_ = x168_impulse = x15c_force = zeus::CVector3f::skZero;
+    x198_ = x180_angularImpulse = x174_torque = zeus::CAxisAngle::skZero;
 }

 void CPhysicsActor::Stop()
 {
    ClearForcesAndTorques();
-    xfc_ = zeus::CVector3f::skZero;
-    x108_ = zeus::CAxisAngle::skZero;
+    xfc_constantForce = zeus::CVector3f::skZero;
+    x108_angularMomentum = zeus::CAxisAngle::skZero;
    ComputeDerivedQuantities();
 }

 void CPhysicsActor::ComputeDerivedQuantities()
 {
-    x138_velocity = xec_massRecip * xfc_;
+    x138_velocity = xec_massRecip * xfc_constantForce;
    x114_ = x34_transform.buildMatrix3f();
-    x144_angularVelocity = xf0_inertiaTensor * x108_;
+    x144_angularVelocity = xf0_inertiaTensor * x108_angularMomentum;
 }

 bool CPhysicsActor::WillMove(const CStateManager&)
 {
    if (!zeus::close_enough(zeus::CVector3f::skZero, x138_velocity) ||
-        !zeus::close_enough(zeus::CVector3f::skZero, x168_) ||
-        !zeus::close_enough(zeus::CVector3f::skZero, x18c_) ||
-        !zeus::close_enough(zeus::CVector3f::skZero, x144_angularVelocity) ||
-        !zeus::close_enough(zeus::CVector3f::skZero, x180_) ||
-        !zeus::close_enough(zeus::CVector3f::skZero, GetTotalForcesWR()))
+            !zeus::close_enough(zeus::CVector3f::skZero, x168_impulse) ||
+            !zeus::close_enough(zeus::CVector3f::skZero, x18c_) ||
+            !zeus::close_enough(zeus::CVector3f::skZero, x144_angularVelocity) ||
+            !zeus::close_enough(zeus::CVector3f::skZero, x180_angularImpulse) ||
+            !zeus::close_enough(zeus::CVector3f::skZero, GetTotalForcesWR()))
        return true;

    return false;
 }

+void CPhysicsActor::SetPhysicsState(const CPhysicsState &state)
+{
+    SetTranslation(state.GetTranslation());
+    x34_transform = zeus::CTransform::Translate(x34_transform.origin) * zeus::CMatrix3f(state.GetOrientation());
+    xe4_27_ = true;
+    xe4_28_ = true;
+    xe4_29_ = true;
+
+    xfc_constantForce = state.GetConstantForceWR();
+    x108_angularMomentum = state.GetAngularMomentumWR();;
+    x150_momentum = state.GetMomentumWR();
+    x15c_force = state.GetForceWR();
+    x168_impulse = state.GetImpulseWR();
+    x174_torque = state.GetTorque();
+    x180_angularImpulse = state.GetAngularImpulseWR();
+    ComputeDerivedQuantities();
+}
+
+CPhysicsState CPhysicsActor::GetPhysicsState() const
+{
+    return {x34_transform.origin, {x34_transform.buildMatrix3f()}, xfc_constantForce, x108_angularMomentum,
+            x150_momentum, x15c_force, x168_impulse, x174_torque, x180_angularImpulse};
+}
+
+CMotionState CPhysicsActor::PredictMotion_Internal(float dt) const
+{
+    if (xf8_25_)
+        return PredictMotion(dt);
+
+    CMotionState msl = PredictLinearMotion(dt);
+    CMotionState msa = PredictAngularMotion(dt);
+    return {msl.x0_translation, msa.xc_orientation, msl.x1c_velocity, msa.x28_angularVelocity};
+}
+
+CMotionState CPhysicsActor::PredictMotion(float dt) const
+{
+    CMotionState msl = PredictLinearMotion(dt);
+    CMotionState msa = PredictAngularMotion(dt);
+    return {msl.x0_translation, msa.xc_orientation, msl.x1c_velocity, msa.x28_angularVelocity};
+}
+
+CMotionState CPhysicsActor::PredictLinearMotion(float dt) const
+{
+    zeus::CVector3f velocity = CalculateNewVelocityWR_UsingImpulses();
+    return {velocity * dt, zeus::CNUQuaternion::skNoRotation,
+                ((x15c_force + x150_momentum) * dt) + x168_impulse,
+                zeus::CAxisAngle::skZero};
+}
+
+CMotionState CPhysicsActor::PredictAngularMotion(float dt) const
+{
+    const zeus::CVector3f v1 = xf4_inertiaTensorRecip * (x180_angularImpulse + x198_);
+    zeus::CNUQuaternion q = 0.5f * zeus::CNUQuaternion({0.f, x144_angularVelocity + v1});
+    return {zeus::CVector3f::skZero,
+                q * zeus::CNUQuaternion(x34_transform.buildMatrix3f()) * dt,
+                zeus::CVector3f::skZero,
+                (x174_torque * dt) + x180_angularImpulse};
+}
+
+void CPhysicsActor::ApplyForceOR(const zeus::CVector3f& force, const zeus::CAxisAngle& torque)
+{
+    x15c_force += x34_transform.rotate(force);
+    x174_torque += x34_transform.rotate(torque);
+}
+
+void CPhysicsActor::ApplyForceWR(const zeus::CVector3f &force, const zeus::CAxisAngle& torque)
+{
+    x15c_force += force;
+    x174_torque += torque;
+}
+
+void CPhysicsActor::ApplyImpulseOR(const zeus::CVector3f &impulse, const zeus::CAxisAngle &angle)
+{
+    x168_impulse += x34_transform.rotate(impulse);
+    x180_angularImpulse += x34_transform.rotate(angle);
+}
+
+void CPhysicsActor::ApplyImpulseWR(const zeus::CVector3f &impulse, const zeus::CAxisAngle& angleImp)
+{
+    x168_impulse += impulse;
+    x180_angularImpulse += angleImp;
+}
+
+void CPhysicsActor::ApplyTorqueWR(const zeus::CVector3f& torque)
+{
+    x174_torque += torque;
+}
+
+void CPhysicsActor::UseCollisionImpulses()
+{
+    xfc_constantForce += x168_impulse;
+    x108_angularMomentum += x180_angularImpulse;
+
+    x168_impulse = zeus::CVector3f::skZero;
+    x180_angularImpulse = zeus::CAxisAngle::skZero;
+    ComputeDerivedQuantities();
+}
+
+CPhysicsState::CPhysicsState(const zeus::CVector3f& translation, const zeus::CQuaternion& orient,
+                             const zeus::CVector3f& v2, const zeus::CAxisAngle& a1,
+                             const zeus::CVector3f& v3, const zeus::CVector3f& v4,
+                             const zeus::CVector3f& v5, const zeus::CAxisAngle& a2, const zeus::CAxisAngle& a3)
+    : x0_translation(translation)
+    , xc_orientation(orient)
+    , x1c_constantForce(v2)
+    , x28_angularMomentum(a1)
+    , x34_momentum(v3)
+    , x40_force(v4)
+    , x4c_impulse(v5)
+    , x58_torque(a2)
+    , x64_angularImpulse(a3)
+{
+}
+
+void CPhysicsState::SetOrientation(const zeus::CQuaternion& orient)
+{
+    xc_orientation = orient;
+}
+
+const zeus::CQuaternion& CPhysicsState::GetOrientation() const
+{
+    return xc_orientation;
+}
+
+void CPhysicsState::SetTranslation(const zeus::CVector3f& tr)
+{
+    x0_translation = tr;
+}
+
+const zeus::CVector3f& CPhysicsState::GetTranslation() const
+{
+    return x0_translation;
+}
+
+const zeus::CVector3f& CPhysicsState::GetConstantForceWR() const
+{
+    return x1c_constantForce;
+}
+
+const zeus::CAxisAngle& CPhysicsState::GetAngularMomentumWR() const
+{
+    return x28_angularMomentum;
+}
+
+const zeus::CVector3f& CPhysicsState::GetMomentumWR() const
+{
+    return x34_momentum;
+}
+
+const zeus::CVector3f& CPhysicsState::GetForceWR() const
+{
+    return x40_force;
+}
+
+const zeus::CVector3f& CPhysicsState::GetImpulseWR() const
+{
+    return x4c_impulse;
+}
+
+const zeus::CAxisAngle& CPhysicsState::GetTorque() const
+{
+    return x58_torque;
+}
+
+const zeus::CAxisAngle& CPhysicsState::GetAngularImpulseWR() const
+{
+    return x64_angularImpulse;
+}
+
 }