DistanceConstraint.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/Constraints/TwoBodyConstraint.h>
#include <Jolt/Physics/Constraints/ConstraintPart/AxisConstraintPart.h>
 
JPH_NAMESPACE_BEGIN
 
class DistanceConstraintSettings final : public TwoBodyConstraintSettings
{
public:
    JPH_DECLARE_SERIALIZABLE_VIRTUAL(DistanceConstraintSettings)
 
    // See: ConstraintSettings::SaveBinaryState
    virtual void                SaveBinaryState(StreamOut &inStream) const override;
 
    virtual TwoBodyConstraint * Create(Body &inBody1, Body &inBody2) const override;
 
    EConstraintSpace            mSpace = EConstraintSpace::WorldSpace;
 
    RVec3                       mPoint1 = RVec3::sZero();
 
    RVec3                       mPoint2 = RVec3::sZero();
 
    float                       mMinDistance = -1.0f;
    float                       mMaxDistance = -1.0f;
 
    float                       mFrequency = 0.0f;
    float                       mDamping = 0.0f;
 
protected:
    // See: ConstraintSettings::RestoreBinaryState
    virtual void                RestoreBinaryState(StreamIn &inStream) override;
};
 
class DistanceConstraint final : public TwoBodyConstraint
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
                                DistanceConstraint(Body &inBody1, Body &inBody2, const DistanceConstraintSettings &inSettings);
 
    // Generic interface of a constraint
    virtual EConstraintSubType  GetSubType() const override                                 { return EConstraintSubType::Distance; }
    virtual void                NotifyShapeChanged(const BodyID &inBodyID, Vec3Arg inDeltaCOM) override;
    virtual void                SetupVelocityConstraint(float inDeltaTime) override;
    virtual void                WarmStartVelocityConstraint(float inWarmStartImpulseRatio) override;
    virtual bool                SolveVelocityConstraint(float inDeltaTime) override;
    virtual bool                SolvePositionConstraint(float inDeltaTime, float inBaumgarte) override;
#ifdef JPH_DEBUG_RENDERER
    virtual void                DrawConstraint(DebugRenderer *inRenderer) const override;
#endif // JPH_DEBUG_RENDERER
    virtual void                SaveState(StateRecorder &inStream) const override;
    virtual void                RestoreState(StateRecorder &inStream) override;
    virtual Ref<ConstraintSettings> GetConstraintSettings() const override;
 
    // See: TwoBodyConstraint
    virtual Mat44               GetConstraintToBody1Matrix() const override                 { return Mat44::sTranslation(mLocalSpacePosition1); }
    virtual Mat44               GetConstraintToBody2Matrix() const override                 { return Mat44::sTranslation(mLocalSpacePosition2); } // Note: Incorrect rotation as we don't track the original rotation difference, should not matter though as the constraint is not limiting rotation.
 
    void                        SetDistance(float inMinDistance, float inMaxDistance)       { JPH_ASSERT(inMinDistance <= inMaxDistance); mMinDistance = inMinDistance; mMaxDistance = inMaxDistance; }
    float                       GetMinDistance() const                                      { return mMinDistance; }
    float                       GetMaxDistance() const                                      { return mMaxDistance; }
 
    void                        SetFrequency(float inFrequency)                             { JPH_ASSERT(inFrequency >= 0.0f); mFrequency = inFrequency; }
    float                       GetFrequency() const                                        { return mFrequency; }
 
    void                        SetDamping(float inDamping)                                 { JPH_ASSERT(inDamping >= 0.0f); mDamping = inDamping; }
    float                       GetDamping() const                                          { return mDamping; }
 
    inline float                GetTotalLambdaPosition() const                              { return mAxisConstraint.GetTotalLambda(); }
 
private:
    // Internal helper function to calculate the values below
    void                        CalculateConstraintProperties(float inDeltaTime);
 
    // CONFIGURATION PROPERTIES FOLLOW
 
    // Local space constraint positions
    Vec3                        mLocalSpacePosition1;
    Vec3                        mLocalSpacePosition2;
 
    // Min/max distance that must be kept between the world space points
    float                       mMinDistance;
    float                       mMaxDistance;
 
    // Soft constraint properties (see DistanceConstraintSettings)
    float                       mFrequency;
    float                       mDamping;
 
    // RUN TIME PROPERTIES FOLLOW
 
    // World space positions and normal
    RVec3                       mWorldSpacePosition1;
    RVec3                       mWorldSpacePosition2;
    Vec3                        mWorldSpaceNormal;
 
    // Depending on if the distance < min or distance > max we can apply forces to prevent further violations
    float                       mMinLambda;
    float                       mMaxLambda;
 
    // The constraint part
    AxisConstraintPart          mAxisConstraint;
};
 
JPH_NAMESPACE_END