Ragdoll.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/Result.h>
#include <Jolt/Physics/Body/BodyCreationSettings.h>
#include <Jolt/Physics/Constraints/TwoBodyConstraint.h>
#include <Jolt/Skeleton/Skeleton.h>
#include <Jolt/Skeleton/SkeletonPose.h>
#include <Jolt/Physics/EActivation.h>
 
JPH_NAMESPACE_BEGIN
 
class Ragdoll;
class PhysicsSystem;
 
class JPH_EXPORT RagdollSettings : public RefTarget<RagdollSettings>
{
public:
    JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, RagdollSettings)
 
    
    bool                                Stabilize();
 
    void                                DisableParentChildCollisions(const Mat44 *inJointMatrices = nullptr, float inMinSeparationDistance = 0.0f);
 
    void                                SaveBinaryState(StreamOut &inStream, bool inSaveShapes, bool inSaveGroupFilter) const;
 
    using RagdollResult = Result<Ref<RagdollSettings>>;
 
    static RagdollResult                sRestoreFromBinaryState(StreamIn &inStream);
 
    Ragdoll *                           CreateRagdoll(CollisionGroup::GroupID inCollisionGroup, uint64 inUserData, PhysicsSystem *inSystem) const;
 
    const Skeleton *                    GetSkeleton() const                                             { return mSkeleton; }
    Skeleton *                          GetSkeleton()                                                   { return mSkeleton; }
 
    void                                CalculateBodyIndexToConstraintIndex();
 
    const Array<int> &                  GetBodyIndexToConstraintIndex() const                           { return mBodyIndexToConstraintIndex; }
 
    int                                 GetConstraintIndexForBodyIndex(int inBodyIndex) const           { return mBodyIndexToConstraintIndex[inBodyIndex]; }
 
    void                                CalculateConstraintIndexToBodyIdxPair();
 
    using BodyIdxPair = pair<int, int>;
 
    const Array<BodyIdxPair> &          GetConstraintIndexToBodyIdxPair() const                         { return mConstraintIndexToBodyIdxPair; }
 
    BodyIdxPair                         GetBodyIndicesForConstraintIndex(int inConstraintIndex) const   { return mConstraintIndexToBodyIdxPair[inConstraintIndex]; }
 
    class Part : public BodyCreationSettings
    {
    public:
        JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, Part)
 
        Ref<TwoBodyConstraintSettings>  mToParent;
    };
 
    using PartVector = Array<Part>;                                                                 
 
    class AdditionalConstraint
    {
    public:
        JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, AdditionalConstraint)
 
        
                                        AdditionalConstraint() = default;
                                        AdditionalConstraint(int inBodyIdx1, int inBodyIdx2, TwoBodyConstraintSettings *inConstraint) : mBodyIdx { inBodyIdx1, inBodyIdx2 }, mConstraint(inConstraint) { }
 
        int                             mBodyIdx[2];                                                
        Ref<TwoBodyConstraintSettings>  mConstraint;                                                
    };
 
    using AdditionalConstraintVector = Array<AdditionalConstraint>;
 
    Ref<Skeleton>                       mSkeleton;
 
    PartVector                          mParts;
 
    AdditionalConstraintVector          mAdditionalConstraints;
 
private:
    Array<int>                          mBodyIndexToConstraintIndex;
 
    Array<BodyIdxPair>                  mConstraintIndexToBodyIdxPair;
};
 
class JPH_EXPORT Ragdoll : public RefTarget<Ragdoll>, public NonCopyable
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    explicit                            Ragdoll(PhysicsSystem *inSystem) : mSystem(inSystem) { }
 
                                        ~Ragdoll();
 
    void                                AddToPhysicsSystem(EActivation inActivationMode, bool inLockBodies = true);
 
    void                                RemoveFromPhysicsSystem(bool inLockBodies = true);
 
    void                                Activate(bool inLockBodies = true);
 
    bool                                IsActive(bool inLockBodies = true) const;
 
    void                                SetGroupID(CollisionGroup::GroupID inGroupID, bool inLockBodies = true);
 
    void                                SetPose(const SkeletonPose &inPose, bool inLockBodies = true);
 
    void                                SetPose(RVec3Arg inRootOffset, const Mat44 *inJointMatrices, bool inLockBodies = true);
 
    void                                GetPose(SkeletonPose &outPose, bool inLockBodies = true);
 
    void                                GetPose(RVec3 &outRootOffset, Mat44 *outJointMatrices, bool inLockBodies = true);
 
    void                                ResetWarmStart();
 
    void                                DriveToPoseUsingKinematics(const SkeletonPose &inPose, float inDeltaTime, bool inLockBodies = true);
 
    void                                DriveToPoseUsingKinematics(RVec3Arg inRootOffset, const Mat44 *inJointMatrices, float inDeltaTime, bool inLockBodies = true);
 
    void                                DriveToPoseUsingMotors(const SkeletonPose &inPose);
 
    void                                SetLinearAndAngularVelocity(Vec3Arg inLinearVelocity, Vec3Arg inAngularVelocity, bool inLockBodies = true);
 
    void                                SetLinearVelocity(Vec3Arg inLinearVelocity, bool inLockBodies = true);
 
    void                                AddLinearVelocity(Vec3Arg inLinearVelocity, bool inLockBodies = true);
 
    void                                AddImpulse(Vec3Arg inImpulse, bool inLockBodies = true);
 
    void                                GetRootTransform(RVec3 &outPosition, Quat &outRotation, bool inLockBodies = true) const;
 
    size_t                              GetBodyCount() const                                    { return mBodyIDs.size(); }
 
    BodyID                              GetBodyID(int inBodyIndex) const                        { return mBodyIDs[inBodyIndex]; }
 
    const Array<BodyID> &               GetBodyIDs() const                                      { return mBodyIDs; }
 
    size_t                              GetConstraintCount() const                              { return mConstraints.size(); }
 
    TwoBodyConstraint *                 GetConstraint(int inConstraintIndex)                    { return mConstraints[inConstraintIndex]; }
 
    const TwoBodyConstraint *           GetConstraint(int inConstraintIndex) const              { return mConstraints[inConstraintIndex]; }
 
    AABox                               GetWorldSpaceBounds(bool inLockBodies = true) const;
 
    const RagdollSettings *             GetRagdollSettings() const                              { return mRagdollSettings; }
 
private:
    friend class RagdollSettings;
 
    RefConst<RagdollSettings>           mRagdollSettings;
 
    Array<BodyID>                       mBodyIDs;
 
    Array<Ref<TwoBodyConstraint>>       mConstraints;
 
    PhysicsSystem *                     mSystem;
};
 
JPH_NAMESPACE_END