PathConstraint.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/PathConstraintPath.h>
#include <Jolt/Physics/Constraints/MotorSettings.h>
#include <Jolt/Physics/Constraints/ConstraintPart/AxisConstraintPart.h>
#include <Jolt/Physics/Constraints/ConstraintPart/DualAxisConstraintPart.h>
#include <Jolt/Physics/Constraints/ConstraintPart/HingeRotationConstraintPart.h>
#include <Jolt/Physics/Constraints/ConstraintPart/RotationEulerConstraintPart.h>
 
JPH_NAMESPACE_BEGIN
 
JPH_SUPPRESS_WARNING_PUSH
JPH_GCC_SUPPRESS_WARNING("-Wshadow") // GCC complains about the 'Free' value conflicting with the 'Free' method
 
 
enum class EPathRotationConstraintType
{
    Free,                           
    ConstrainAroundTangent,         
    ConstrainAroundNormal,          
    ConstrainAroundBinormal,        
    ConstrainToPath,                
    FullyConstrained,               
};
 
JPH_SUPPRESS_WARNING_POP
 
class JPH_EXPORT PathConstraintSettings final : public TwoBodyConstraintSettings
{
    JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, PathConstraintSettings)
 
public:
    // See: ConstraintSettings::SaveBinaryState
    virtual void                    SaveBinaryState(StreamOut &inStream) const override;
 
    virtual TwoBodyConstraint *     Create(Body &inBody1, Body &inBody2) const override;
 
    RefConst<PathConstraintPath>    mPath;
 
    Vec3                            mPathPosition = Vec3::sZero();
 
    Quat                            mPathRotation = Quat::sIdentity();
 
    float                           mPathFraction = 0.0f;
 
    float                           mMaxFrictionForce = 0.0f;
 
    MotorSettings                   mPositionMotorSettings;
 
    EPathRotationConstraintType     mRotationConstraintType = EPathRotationConstraintType::Free;
 
protected:
    // See: ConstraintSettings::RestoreBinaryState
    virtual void                    RestoreBinaryState(StreamIn &inStream) override;
};
 
class JPH_EXPORT PathConstraint final : public TwoBodyConstraint
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
                                    PathConstraint(Body &inBody1, Body &inBody2, const PathConstraintSettings &inSettings);
 
    // Generic interface of a constraint
    virtual EConstraintSubType      GetSubType() const override                             { return EConstraintSubType::Path; }
    virtual void                    NotifyShapeChanged(const BodyID &inBodyID, Vec3Arg inDeltaCOM) override;
    virtual void                    SetupVelocityConstraint(float inDeltaTime) override;
    virtual void                    ResetWarmStart() 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 bool                    IsActive() const override                               { return TwoBodyConstraint::IsActive() && mPath != nullptr; }
    virtual Ref<ConstraintSettings> GetConstraintSettings() const override;
 
    // See: TwoBodyConstraint
    virtual Mat44                   GetConstraintToBody1Matrix() const override             { return mPathToBody1; }
    virtual Mat44                   GetConstraintToBody2Matrix() const override             { return mPathToBody2; }
 
    void                            SetPath(const PathConstraintPath *inPath, float inPathFraction);
 
    const PathConstraintPath *      GetPath() const                                         { return mPath; }
 
    float                           GetPathFraction() const                                 { return mPathFraction; }
 
    void                            SetMaxFrictionForce(float inFrictionForce)              { mMaxFrictionForce = inFrictionForce; }
    float                           GetMaxFrictionForce() const                             { return mMaxFrictionForce; }
 
    MotorSettings &                 GetPositionMotorSettings()                              { return mPositionMotorSettings; }
    const MotorSettings &           GetPositionMotorSettings() const                        { return mPositionMotorSettings; }
 
    // Position motor controls (drives body 2 along the path)
    void                            SetPositionMotorState(EMotorState inState)              { JPH_ASSERT(inState == EMotorState::Off || mPositionMotorSettings.IsValid()); mPositionMotorState = inState; }
    EMotorState                     GetPositionMotorState() const                           { return mPositionMotorState; }
    void                            SetTargetVelocity(float inVelocity)                     { mTargetVelocity = inVelocity; }
    float                           GetTargetVelocity() const                               { return mTargetVelocity; }
    void                            SetTargetPathFraction(float inFraction)                 { JPH_ASSERT(mPath->IsLooping() || (inFraction >= 0.0f && inFraction <= mPath->GetPathMaxFraction())); mTargetPathFraction = inFraction; }
    float                           GetTargetPathFraction() const                           { return mTargetPathFraction; }
 
    inline Vector<2>                GetTotalLambdaPosition() const                          { return mPositionConstraintPart.GetTotalLambda(); }
    inline float                    GetTotalLambdaPositionLimits() const                    { return mPositionLimitsConstraintPart.GetTotalLambda(); }
    inline float                    GetTotalLambdaMotor() const                             { return mPositionMotorConstraintPart.GetTotalLambda(); }
    inline Vector<2>                GetTotalLambdaRotationHinge() const                     { return mHingeConstraintPart.GetTotalLambda(); }
    inline Vec3                     GetTotalLambdaRotation() const                          { return mRotationConstraintPart.GetTotalLambda(); }
 
private:
    // Internal helper function to calculate the values below
    void                            CalculateConstraintProperties(float inDeltaTime);
 
    // CONFIGURATION PROPERTIES FOLLOW
 
    RefConst<PathConstraintPath>    mPath;                                                  
    Mat44                           mPathToBody1;                                           
    Mat44                           mPathToBody2;                                           
    EPathRotationConstraintType     mRotationConstraintType;                                
 
    // Friction
    float                           mMaxFrictionForce;
 
    // Motor controls
    MotorSettings                   mPositionMotorSettings;
    EMotorState                     mPositionMotorState = EMotorState::Off;
    float                           mTargetVelocity = 0.0f;
    float                           mTargetPathFraction = 0.0f;
 
    // RUN TIME PROPERTIES FOLLOW
 
    // Positions where the point constraint acts on in world space
    Vec3                            mR1;
    Vec3                            mR2;
 
    // X2 + R2 - X1 - R1
    Vec3                            mU;
 
    // World space path tangent
    Vec3                            mPathTangent;
 
    // Normals to the path tangent
    Vec3                            mPathNormal;
    Vec3                            mPathBinormal;
 
    // Inverse of initial rotation from body 1 to body 2 in body 1 space (only used when rotation constraint type is FullyConstrained)
    Quat                            mInvInitialOrientation;
 
    // Current fraction along the path where body 2 is attached
    float                           mPathFraction = 0.0f;
 
    // Translation constraint parts
    DualAxisConstraintPart          mPositionConstraintPart;                                
    AxisConstraintPart              mPositionLimitsConstraintPart;                          
    AxisConstraintPart              mPositionMotorConstraintPart;                           
 
    // Rotation constraint parts
    HingeRotationConstraintPart     mHingeConstraintPart;                                   
    RotationEulerConstraintPart     mRotationConstraintPart;                                
};
 
JPH_NAMESPACE_END