AngleConstraintPart.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Physics/Body/Body.h>
#include <Jolt/Physics/Constraints/ConstraintPart/SpringPart.h>
#include <Jolt/Physics/Constraints/SpringSettings.h>
#include <Jolt/Physics/StateRecorder.h>
 
JPH_NAMESPACE_BEGIN
 
class AngleConstraintPart
{
    JPH_INLINE bool             ApplyVelocityStep(Body &ioBody1, Body &ioBody2, float inLambda) const
    {
        // Apply impulse if delta is not zero
        if (inLambda != 0.0f)
        {
            // Calculate velocity change due to constraint
            //
            // Impulse:
            // P = J^T lambda
            //
            // Euler velocity integration:
            // v' = v + M^-1 P
            if (ioBody1.IsDynamic())
                ioBody1.GetMotionProperties()->SubAngularVelocityStep(inLambda * mInvI1_Axis);
            if (ioBody2.IsDynamic())
                ioBody2.GetMotionProperties()->AddAngularVelocityStep(inLambda * mInvI2_Axis);
            return true;
        }
 
        return false;
    }
 
    JPH_INLINE float                CalculateInverseEffectiveMass(const Body &inBody1, const Body &inBody2, Vec3Arg inWorldSpaceAxis)
    {
        JPH_ASSERT(inWorldSpaceAxis.IsNormalized(1.0e-4f));
 
        // Calculate properties used below
        mInvI1_Axis = inBody1.IsDynamic()? inBody1.GetMotionProperties()->MultiplyWorldSpaceInverseInertiaByVector(inBody1.GetRotation(), inWorldSpaceAxis) : Vec3::sZero();
        mInvI2_Axis = inBody2.IsDynamic()? inBody2.GetMotionProperties()->MultiplyWorldSpaceInverseInertiaByVector(inBody2.GetRotation(), inWorldSpaceAxis) : Vec3::sZero();
 
        // Calculate inverse effective mass: K = J M^-1 J^T
        return inWorldSpaceAxis.Dot(mInvI1_Axis + mInvI2_Axis);
    }
 
public:
    inline void                 CalculateConstraintProperties(const Body &inBody1, const Body &inBody2, Vec3Arg inWorldSpaceAxis, float inBias = 0.0f)
    {
        float inv_effective_mass = CalculateInverseEffectiveMass(inBody1, inBody2, inWorldSpaceAxis);
 
        if (inv_effective_mass == 0.0f)
            Deactivate();
        else
        {
            mEffectiveMass = 1.0f / inv_effective_mass;
            mSpringPart.CalculateSpringPropertiesWithBias(inBias);
        }
    }
 
    inline void                 CalculateConstraintPropertiesWithFrequencyAndDamping(float inDeltaTime, const Body &inBody1, const Body &inBody2, Vec3Arg inWorldSpaceAxis, float inBias, float inC, float inFrequency, float inDamping)
    {
        float inv_effective_mass = CalculateInverseEffectiveMass(inBody1, inBody2, inWorldSpaceAxis);
 
        if (inv_effective_mass == 0.0f)
            Deactivate();
        else
            mSpringPart.CalculateSpringPropertiesWithFrequencyAndDamping(inDeltaTime, inv_effective_mass, inBias, inC, inFrequency, inDamping, mEffectiveMass);
    }
 
    inline void                 CalculateConstraintPropertiesWithStiffnessAndDamping(float inDeltaTime, const Body &inBody1, const Body &inBody2, Vec3Arg inWorldSpaceAxis, float inBias, float inC, float inStiffness, float inDamping)
    {
        float inv_effective_mass = CalculateInverseEffectiveMass(inBody1, inBody2, inWorldSpaceAxis);
 
        if (inv_effective_mass == 0.0f)
            Deactivate();
        else
            mSpringPart.CalculateSpringPropertiesWithStiffnessAndDamping(inDeltaTime, inv_effective_mass, inBias, inC, inStiffness, inDamping, mEffectiveMass);
    }
 
    inline void                 CalculateConstraintPropertiesWithSettings(float inDeltaTime, const Body &inBody1, const Body &inBody2, Vec3Arg inWorldSpaceAxis, float inBias, float inC, const SpringSettings &inSpringSettings)
    {
        float inv_effective_mass = CalculateInverseEffectiveMass(inBody1, inBody2, inWorldSpaceAxis);
 
        if (inv_effective_mass == 0.0f)
            Deactivate();
        else if (inSpringSettings.mMode == ESpringMode::FrequencyAndDamping)
            mSpringPart.CalculateSpringPropertiesWithFrequencyAndDamping(inDeltaTime, inv_effective_mass, inBias, inC, inSpringSettings.mFrequency, inSpringSettings.mDamping, mEffectiveMass);
        else
            mSpringPart.CalculateSpringPropertiesWithStiffnessAndDamping(inDeltaTime, inv_effective_mass, inBias, inC, inSpringSettings.mStiffness, inSpringSettings.mDamping, mEffectiveMass);
    }
 
    inline void                 Deactivate()
    {
        mEffectiveMass = 0.0f;
        mTotalLambda = 0.0f;
    }
 
    inline bool                 IsActive() const
    {
        return mEffectiveMass != 0.0f;
    }
 
    inline void                 WarmStart(Body &ioBody1, Body &ioBody2, float inWarmStartImpulseRatio)
    {
        mTotalLambda *= inWarmStartImpulseRatio;
        ApplyVelocityStep(ioBody1, ioBody2, mTotalLambda);
    }
 
    inline bool                 SolveVelocityConstraint(Body &ioBody1, Body &ioBody2, Vec3Arg inWorldSpaceAxis, float inMinLambda, float inMaxLambda)
    {
        // Lagrange multiplier is:
        //
        // lambda = -K^-1 (J v + b)
        float lambda = mEffectiveMass * (inWorldSpaceAxis.Dot(ioBody1.GetAngularVelocity() - ioBody2.GetAngularVelocity()) - mSpringPart.GetBias(mTotalLambda));
        float new_lambda = Clamp(mTotalLambda + lambda, inMinLambda, inMaxLambda); // Clamp impulse
        lambda = new_lambda - mTotalLambda; // Lambda potentially got clamped, calculate the new impulse to apply
        mTotalLambda = new_lambda; // Store accumulated impulse
 
        return ApplyVelocityStep(ioBody1, ioBody2, lambda);
    }
 
    float                       GetTotalLambda() const
    {
        return mTotalLambda;
    }
 
    inline bool                 SolvePositionConstraint(Body &ioBody1, Body &ioBody2, float inC, float inBaumgarte) const
    {
        // Only apply position constraint when the constraint is hard, otherwise the velocity bias will fix the constraint
        if (inC != 0.0f && !mSpringPart.IsActive())
        {
            // Calculate lagrange multiplier (lambda) for Baumgarte stabilization:
            //
            // lambda = -K^-1 * beta / dt * C
            //
            // We should divide by inDeltaTime, but we should multiply by inDeltaTime in the Euler step below so they're cancelled out
            float lambda = -mEffectiveMass * inBaumgarte * inC;
 
            // Directly integrate velocity change for one time step
            //
            // Euler velocity integration:
            // dv = M^-1 P
            //
            // Impulse:
            // P = J^T lambda
            //
            // Euler position integration:
            // x' = x + dv * dt
            //
            // Note we don't accumulate velocities for the stabilization. This is using the approach described in 'Modeling and
            // Solving Constraints' by Erin Catto presented at GDC 2007. On slide 78 it is suggested to split up the Baumgarte
            // stabilization for positional drift so that it does not actually add to the momentum. We combine an Euler velocity
            // integrate + a position integrate and then discard the velocity change.
            if (ioBody1.IsDynamic())
                ioBody1.SubRotationStep(lambda * mInvI1_Axis);
            if (ioBody2.IsDynamic())
                ioBody2.AddRotationStep(lambda * mInvI2_Axis);
            return true;
        }
 
        return false;
    }
 
    void                        SaveState(StateRecorder &inStream) const
    {
        inStream.Write(mTotalLambda);
    }
 
    void                        RestoreState(StateRecorder &inStream)
    {
        inStream.Read(mTotalLambda);
    }
 
private:
    Vec3                        mInvI1_Axis;
    Vec3                        mInvI2_Axis;
    float                       mEffectiveMass = 0.0f;
    SpringPart                  mSpringPart;
    float                       mTotalLambda = 0.0f;
};
 
JPH_NAMESPACE_END