PulleyConstraint.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2022 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Physics/Constraints/TwoBodyConstraint.h>
#include <Jolt/Physics/Constraints/ConstraintPart/IndependentAxisConstraintPart.h>
 
JPH_NAMESPACE_BEGIN
 
class PulleyConstraintSettings final : public TwoBodyConstraintSettings
{
public:
    JPH_DECLARE_SERIALIZABLE_VIRTUAL(PulleyConstraintSettings)
 
    // See: ConstraintSettings::SaveBinaryState
    virtual void                SaveBinaryState(StreamOut &inStream) const override;
 
    virtual TwoBodyConstraint * Create(Body &inBody1, Body &inBody2) const override;
 
    EConstraintSpace            mSpace = EConstraintSpace::WorldSpace;
 
    RVec3                       mBodyPoint1 = RVec3::sZero();
 
    RVec3                       mFixedPoint1 = RVec3::sZero();
 
    RVec3                       mBodyPoint2 = RVec3::sZero();
 
    RVec3                       mFixedPoint2 = RVec3::sZero();
 
    float                       mRatio = 1.0f;
 
    float                       mMinLength = 0.0f;
 
    float                       mMaxLength = -1.0f;
 
protected:
    // See: ConstraintSettings::RestoreBinaryState
    virtual void                RestoreBinaryState(StreamIn &inStream) override;
};
 
class PulleyConstraint final : public TwoBodyConstraint
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
                                PulleyConstraint(Body &inBody1, Body &inBody2, const PulleyConstraintSettings &inSettings);
 
    // Generic interface of a constraint
    virtual EConstraintSubType  GetSubType() const override                                 { return EConstraintSubType::Pulley; }
    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                        SetLength(float inMinLength, float inMaxLength)             { JPH_ASSERT(inMinLength >= 0.0f && inMinLength <= inMaxLength); mMinLength = inMinLength; mMaxLength = inMaxLength; }
    float                       GetMinLength() const                                        { return mMinLength; }
    float                       GetMaxLength() const                                        { return mMaxLength; }
 
    float                       GetCurrentLength() const                                    { return Vec3(mWorldSpacePosition1 - mFixedPosition1).Length() + mRatio * Vec3(mWorldSpacePosition2 - mFixedPosition2).Length(); }
 
    inline float                GetTotalLambdaPosition() const                              { return mIndependentAxisConstraintPart.GetTotalLambda(); }
 
private:
    // Calculates world positions and normals and returns current length
    float                       CalculatePositionsNormalsAndLength();
 
    // Internal helper function to calculate the values below
    void                        CalculateConstraintProperties();
 
    // CONFIGURATION PROPERTIES FOLLOW
 
    // Local space constraint positions on the bodies
    Vec3                        mLocalSpacePosition1;
    Vec3                        mLocalSpacePosition2;
 
    // World space fixed positions
    RVec3                       mFixedPosition1;
    RVec3                       mFixedPosition2;
 
    float                       mRatio;
 
    // The minimum/maximum length of the line segments
    float                       mMinLength;
    float                       mMaxLength;
 
    // RUN TIME PROPERTIES FOLLOW
 
    // World space positions and normal
    RVec3                       mWorldSpacePosition1;
    RVec3                       mWorldSpacePosition2;
    Vec3                        mWorldSpaceNormal1;
    Vec3                        mWorldSpaceNormal2;
 
    // Depending on if the length < min or length > max we can apply forces to prevent further violations
    float                       mMinLambda;
    float                       mMaxLambda;
 
    // The constraint part
    IndependentAxisConstraintPart mIndependentAxisConstraintPart;
};
 
JPH_NAMESPACE_END