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>
{
    JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, RagdollSettings)
 
public:
    bool                                Stabilize();

    void                                CalculateConstraintPriorities(uint32 inBasePriority = 0);

    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 = std::pair<int, int>;

    const Array<BodyIdxPair> &          GetConstraintIndexToBodyIdxPair() const                         { return mConstraintIndexToBodyIdxPair; }

    BodyIdxPair                         GetBodyIndicesForConstraintIndex(int inConstraintIndex) const   { return mConstraintIndexToBodyIdxPair[inConstraintIndex]; }

    class Part : public BodyCreationSettings
    {
        JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, Part)
 
    public:
        Ref<TwoBodyConstraintSettings>  mToParent;
    };

    using PartVector = Array<Part>;                                                                 

    class AdditionalConstraint
    {
        JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, AdditionalConstraint)
 
    public:
                                        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