SliderConstraint.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/MotorSettings.h>
#include <Jolt/Physics/Constraints/ConstraintPart/DualAxisConstraintPart.h>
#include <Jolt/Physics/Constraints/ConstraintPart/RotationEulerConstraintPart.h>
#include <Jolt/Physics/Constraints/ConstraintPart/AxisConstraintPart.h>
 
JPH_NAMESPACE_BEGIN
 
class SliderConstraintSettings final : public TwoBodyConstraintSettings
{
public:
    JPH_DECLARE_SERIALIZABLE_VIRTUAL(SliderConstraintSettings)
 
    // See: ConstraintSettings::SaveBinaryState
    virtual void                SaveBinaryState(StreamOut &inStream) const override;
 
    virtual TwoBodyConstraint * Create(Body &inBody1, Body &inBody2) const override;
 
    void                        SetSliderAxis(Vec3Arg inSliderAxis);
 
    EConstraintSpace            mSpace = EConstraintSpace::WorldSpace;
 
    bool                        mAutoDetectPoint = false;
 
    RVec3                       mPoint1 = RVec3::sZero();
    Vec3                        mSliderAxis1 = Vec3::sAxisX();
    Vec3                        mNormalAxis1 = Vec3::sAxisY();
    
    RVec3                       mPoint2 = RVec3::sZero();
    Vec3                        mSliderAxis2 = Vec3::sAxisX();
    Vec3                        mNormalAxis2 = Vec3::sAxisY();
 
    float                       mLimitsMin = -FLT_MAX;
    float                       mLimitsMax = FLT_MAX;
 
    float                       mFrequency = 0.0f;
    float                       mDamping = 0.0f;
 
    float                       mMaxFrictionForce = 0.0f;
 
    MotorSettings               mMotorSettings;
 
protected:
    // See: ConstraintSettings::RestoreBinaryState
    virtual void                RestoreBinaryState(StreamIn &inStream) override;
};
 
class SliderConstraint final : public TwoBodyConstraint
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
                                SliderConstraint(Body &inBody1, Body &inBody2, const SliderConstraintSettings &inSettings);
 
    // Generic interface of a constraint
    virtual EConstraintSubType  GetSubType() const override                             { return EConstraintSubType::Slider; }
    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;
    virtual void                DrawConstraintLimits(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;
    virtual Mat44               GetConstraintToBody2Matrix() const override;
 
    float                       GetCurrentPosition() const;
 
    void                        SetMaxFrictionForce(float inFrictionForce)              { mMaxFrictionForce = inFrictionForce; }
    float                       GetMaxFrictionForce() const                             { return mMaxFrictionForce; }
 
    MotorSettings &             GetMotorSettings()                                      { return mMotorSettings; }
    const MotorSettings &       GetMotorSettings() const                                { return mMotorSettings; }
 
    // Motor controls
    void                        SetMotorState(EMotorState inState)                      { JPH_ASSERT(inState == EMotorState::Off || mMotorSettings.IsValid()); mMotorState = inState; }
    EMotorState                 GetMotorState() const                                   { return mMotorState; }
    void                        SetTargetVelocity(float inVelocity)                     { mTargetVelocity = inVelocity; }
    float                       GetTargetVelocity() const                               { return mTargetVelocity; }
    void                        SetTargetPosition(float inPosition)                     { mTargetPosition = mHasLimits? Clamp(inPosition, mLimitsMin, mLimitsMax) : inPosition; }
    float                       GetTargetPosition() const                               { return mTargetPosition; }
 
    void                        SetLimits(float inLimitsMin, float inLimitsMax);
    float                       GetLimitsMin() const                                    { return mLimitsMin; }
    float                       GetLimitsMax() const                                    { return mLimitsMax; }
    bool                        HasLimits() const                                       { return mHasLimits; }
 
    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 Vector<2>            GetTotalLambdaPosition() const                          { return mPositionConstraintPart.GetTotalLambda(); }
    inline float                GetTotalLambdaPositionLimits() const                    { return mPositionLimitsConstraintPart.GetTotalLambda(); }
    inline Vec3                 GetTotalLambdaRotation() const                          { return mRotationConstraintPart.GetTotalLambda(); }
    inline float                GetTotalLambdaMotor() const                             { return mMotorConstraintPart.GetTotalLambda(); }
 
private:
    // Internal helper function to calculate the values below
    void                        CalculateR1R2U(Mat44Arg inRotation1, Mat44Arg inRotation2);
    void                        CalculateSlidingAxisAndPosition(Mat44Arg inRotation1);
    void                        CalculatePositionConstraintProperties(Mat44Arg inRotation1, Mat44Arg inRotation2);
    void                        CalculatePositionLimitsConstraintProperties(float inDeltaTime);
    void                        CalculateMotorConstraintProperties(float inDeltaTime);
 
    // CONFIGURATION PROPERTIES FOLLOW
 
    // Local space constraint positions
    Vec3                        mLocalSpacePosition1;
    Vec3                        mLocalSpacePosition2;
 
    // Local space sliding direction
    Vec3                        mLocalSpaceSliderAxis1;
 
    // Local space normals to the sliding direction (in body 1 space)
    Vec3                        mLocalSpaceNormal1;
    Vec3                        mLocalSpaceNormal2;
 
    // Inverse of initial rotation from body 1 to body 2 in body 1 space
    Quat                        mInvInitialOrientation;
        
    // Slider limits
    bool                        mHasLimits;
    float                       mLimitsMin;
    float                       mLimitsMax;
 
    // Soft slider limits
    float                       mFrequency;
    float                       mDamping;
 
    // Friction
    float                       mMaxFrictionForce;
 
    // Motor controls
    MotorSettings               mMotorSettings;
    EMotorState                 mMotorState = EMotorState::Off;
    float                       mTargetVelocity = 0.0f;
    float                       mTargetPosition = 0.0f;
 
    // RUN TIME PROPERTIES FOLLOW
 
    // Positions where the point constraint acts on (middle point between center of masses)
    Vec3                        mR1;
    Vec3                        mR2;
 
    // X2 + R2 - X1 - R1
    Vec3                        mU;
 
    // World space sliding direction
    Vec3                        mWorldSpaceSliderAxis;
 
    // Normals to the slider axis
    Vec3                        mN1;
    Vec3                        mN2;
 
    // Distance along the slide axis
    float                       mD = 0.0f;
 
    // The constraint parts
    DualAxisConstraintPart      mPositionConstraintPart;
    RotationEulerConstraintPart mRotationConstraintPart;
    AxisConstraintPart          mPositionLimitsConstraintPart;
    AxisConstraintPart          mMotorConstraintPart;
};
 
JPH_NAMESPACE_END