Constraint.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/Core/Reference.h>
#include <Jolt/Core/NonCopyable.h>
#include <Jolt/Core/Result.h>
#include <Jolt/ObjectStream/SerializableObject.h>
 
JPH_NAMESPACE_BEGIN
 
class BodyID;
class IslandBuilder;
class LargeIslandSplitter;
class BodyManager;
class StateRecorder;
class StreamIn;
class StreamOut;
#ifdef JPH_DEBUG_RENDERER
class DebugRenderer;
#endif // JPH_DEBUG_RENDERER
 
enum class EConstraintType
{
    Constraint,
    TwoBodyConstraint,
};
 
enum class EConstraintSubType
{
    Fixed,
    Point,
    Hinge,
    Slider,
    Distance,
    Cone,
    SwingTwist,
    SixDOF,
    Path,
    Vehicle,
    RackAndPinion,
    Gear,
    Pulley,
 
    User1,
    User2,
    User3,
    User4
};
 
enum class EConstraintSpace
{
    LocalToBodyCOM,             
    WorldSpace,                 
};
 
class JPH_EXPORT ConstraintSettings : public SerializableObject, public RefTarget<ConstraintSettings>
{
    JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, ConstraintSettings)
 
public:
    using ConstraintResult = Result<Ref<ConstraintSettings>>;
 
    virtual void                SaveBinaryState(StreamOut &inStream) const;
 
    static ConstraintResult     sRestoreFromBinaryState(StreamIn &inStream);
 
    bool                        mEnabled = true;
 
    uint32                      mConstraintPriority = 0;
 
    uint                        mNumVelocityStepsOverride = 0;
 
    uint                        mNumPositionStepsOverride = 0;
 
    float                       mDrawConstraintSize = 1.0f;
 
    uint64                      mUserData = 0;
 
protected:
                                ConstraintSettings() = default;
                                ConstraintSettings(const ConstraintSettings &) = default;
    ConstraintSettings &        operator = (const ConstraintSettings &) = default;
 
    virtual void                RestoreBinaryState(StreamIn &inStream);
};
 
class JPH_EXPORT Constraint : public RefTarget<Constraint>, public NonCopyable
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    explicit                    Constraint(const ConstraintSettings &inSettings) :
#ifdef JPH_DEBUG_RENDERER
        mDrawConstraintSize(inSettings.mDrawConstraintSize),
#endif // JPH_DEBUG_RENDERER
        mConstraintPriority(inSettings.mConstraintPriority),
        mNumVelocityStepsOverride(uint8(inSettings.mNumVelocityStepsOverride)),
        mNumPositionStepsOverride(uint8(inSettings.mNumPositionStepsOverride)),
        mEnabled(inSettings.mEnabled),
        mUserData(inSettings.mUserData)
    {
        JPH_ASSERT(inSettings.mNumVelocityStepsOverride < 256);
        JPH_ASSERT(inSettings.mNumPositionStepsOverride < 256);
    }
 
    virtual                     ~Constraint() = default;
 
    virtual EConstraintType     GetType() const                             { return EConstraintType::Constraint; }
 
    virtual EConstraintSubType  GetSubType() const = 0;
 
    uint32                      GetConstraintPriority() const               { return mConstraintPriority; }
    void                        SetConstraintPriority(uint32 inPriority)    { mConstraintPriority = inPriority; }
 
    void                        SetNumVelocityStepsOverride(uint inN)       { JPH_ASSERT(inN < 256); mNumVelocityStepsOverride = uint8(inN); }
    uint                        GetNumVelocityStepsOverride() const         { return mNumVelocityStepsOverride; }
 
    void                        SetNumPositionStepsOverride(uint inN)       { JPH_ASSERT(inN < 256); mNumPositionStepsOverride = uint8(inN); }
    uint                        GetNumPositionStepsOverride() const         { return mNumPositionStepsOverride; }
 
    void                        SetEnabled(bool inEnabled)                  { mEnabled = inEnabled; }
 
    bool                        GetEnabled() const                          { return mEnabled; }
 
    uint64                      GetUserData() const                         { return mUserData; }
    void                        SetUserData(uint64 inUserData)              { mUserData = inUserData; }
 
    virtual void                NotifyShapeChanged(const BodyID &inBodyID, Vec3Arg inDeltaCOM) = 0;
 
    virtual void                ResetWarmStart() = 0;
 
    virtual bool                IsActive() const                            { return mEnabled; }
    virtual void                SetupVelocityConstraint(float inDeltaTime) = 0;
    virtual void                WarmStartVelocityConstraint(float inWarmStartImpulseRatio) = 0;
    virtual bool                SolveVelocityConstraint(float inDeltaTime) = 0;
    virtual bool                SolvePositionConstraint(float inDeltaTime, float inBaumgarte) = 0;
 
    virtual void                BuildIslands(uint32 inConstraintIndex, IslandBuilder &ioBuilder, BodyManager &inBodyManager) = 0;
 
    virtual uint                BuildIslandSplits(LargeIslandSplitter &ioSplitter) const = 0;
 
#ifdef JPH_DEBUG_RENDERER
    // Drawing interface
    virtual void                DrawConstraint(DebugRenderer *inRenderer) const = 0;
    virtual void                DrawConstraintLimits([[maybe_unused]] DebugRenderer *inRenderer) const { }
    virtual void                DrawConstraintReferenceFrame([[maybe_unused]] DebugRenderer *inRenderer) const { }
 
    float                       GetDrawConstraintSize() const               { return mDrawConstraintSize; }
    void                        SetDrawConstraintSize(float inSize)         { mDrawConstraintSize = inSize; }
#endif // JPH_DEBUG_RENDERER
 
    virtual void                SaveState(StateRecorder &inStream) const;
 
    virtual void                RestoreState(StateRecorder &inStream);
 
    virtual Ref<ConstraintSettings> GetConstraintSettings() const = 0;
 
protected:
    void                        ToConstraintSettings(ConstraintSettings &outSettings) const;
 
#ifdef JPH_DEBUG_RENDERER
    float                       mDrawConstraintSize;
#endif // JPH_DEBUG_RENDERER
 
private:
    friend class ConstraintManager;
 
    static constexpr uint32     cInvalidConstraintIndex = 0xffffffff;
 
    uint32                      mConstraintIndex = cInvalidConstraintIndex;
 
    uint32                      mConstraintPriority = 0;
 
    uint8                       mNumVelocityStepsOverride = 0;
 
    uint8                       mNumPositionStepsOverride = 0;
 
    bool                        mEnabled = true;
 
    uint64                      mUserData;
};
 
JPH_NAMESPACE_END