CharacterGroundConstraint.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Chaos/Character/CharacterGroundConstraintSettings.h"
#include "Chaos/PBDConstraintBaseData.h"
#include "Chaos/ParticleDirtyFlags.h"
#include "PhysicsProxy/SingleParticlePhysicsProxy.h"
 
namespace Chaos
{
    class FCharacterGroundConstraint : public FConstraintBase
    {
    public:
        using Base = FConstraintBase;
        friend class FCharacterGroundConstraintProxy; // For setting the output data
 
        CHAOS_API FCharacterGroundConstraint();
        virtual ~FCharacterGroundConstraint() override {}
 
        // The constraint requires a character body, which is fixed, but the ground body is
        // optional and can be changed dynamically using SetGroundParticleProxy
        CHAOS_API void Init(FSingleParticlePhysicsProxy* InCharacterProxy);
 
        // Particle proxy
 
        FSingleParticlePhysicsProxy* GetCharacterParticleProxy() const
        {
            return CharacterProxy.Read().ParticleProxy;
        }
 
        FSingleParticlePhysicsProxy* GetGroundParticleProxy() const
        {
            return GroundProxy.Read().ParticleProxy;
        }
 
        void SetGroundParticleProxy(FSingleParticlePhysicsProxy* InGroundProxy)
        {
            GroundProxy.Modify(/*bInvalidate=*/true, DirtyFlags, Proxy, [InGroundProxy](FParticleProxyProperty& Data)
                {
                    Data.ParticleProxy = InGroundProxy;
                });
            if (InGroundProxy)
            {
                WakeGroundBody();
            }
        }
 
        // Settings accessors
 
        void SetGroundNormal(const FVec3& Normal)
        {
            FVec3 Tmp = Normal;
            FReal SizeSq = Tmp.SizeSquared();
            if (!FMath::IsNearlyEqual(SizeSq, FReal(1.0)))
            {
                Tmp *= FMath::InvSqrt(SizeSq);
            }
            ConstraintData.Modify(true, DirtyFlags, Proxy, [&Tmp](FCharacterGroundConstraintDynamicData& Data) {
                Data.GroundNormal = Tmp;
                });
        }
        FVec3 GetGroundNormal() const { return ConstraintData.Read().GroundNormal; }
 
        void SetVerticalAxis(const FVec3& Axis)
        {
            FVec3 Tmp = Axis;
            FReal SizeSq = Tmp.SizeSquared();
            if (!FMath::IsNearlyEqual(SizeSq, FReal(1.0)))
            {
                Tmp *= FMath::InvSqrt(SizeSq);
            }
            ConstraintSettings.Modify(true, DirtyFlags, Proxy, [&Tmp](FCharacterGroundConstraintSettings& Data) {
                Data.VerticalAxis = Tmp;
                });
        }
        FVec3 GetVerticalAxis() const { return ConstraintSettings.Read().VerticalAxis; }
 
        void SetGroundDistance(const FReal& Value)
        {
            ConstraintData.Modify(true, DirtyFlags, Proxy, [&Value](FCharacterGroundConstraintDynamicData& Data) {
                Data.GroundDistance = Value > FReal(0.0) ? Value : FReal(0.0);
                });
            WakeCharacterBody();
        }
        FReal GetGroundDistance() const { return ConstraintData.Read().GroundDistance; }
 
        void SetTargetHeight(const FReal& Value)
        {
            ConstraintSettings.Modify(true, DirtyFlags, Proxy, [&Value](FCharacterGroundConstraintSettings& Data) {
                Data.TargetHeight = Value > FReal(0.0) ? Value : FReal(0.0);
                });
        }
        FReal GetTargetHeight() const { return ConstraintSettings.Read().TargetHeight; }
 
        void SetDampingFactor(const FReal& Value)
        {
            ConstraintSettings.Modify(true, DirtyFlags, Proxy, [&Value](FCharacterGroundConstraintSettings& Data) {
                Data.DampingFactor = Value > FReal(0.0) ? Value : FReal(0.0);
                });
        }
        FReal GetDampingFactor() const { return ConstraintSettings.Read().DampingFactor; }
 
        void SetMotionTargetMassBias(const FReal& Value)
        {
            ConstraintSettings.Modify(true, DirtyFlags, Proxy, [&Value](FCharacterGroundConstraintSettings& Data) {
                Data.MotionTargetMassBias = FMath::Clamp(Value, 0.0, 1.0);
                });
        }
        FReal GetMotionTargetMassBias() const { return ConstraintSettings.Read().MotionTargetMassBias; }
 
        void SetRadialForceMotionTargetScaling(const FReal& Value)
        {
            ConstraintSettings.Modify(true, DirtyFlags, Proxy, [&Value](FCharacterGroundConstraintSettings& Data) {
                Data.RadialForceMotionTargetScaling = FMath::Clamp(Value, 0.0, 1.0);
                });
        }
        FReal GetRadialForceMotionTargetScaling() const { return ConstraintSettings.Read().RadialForceMotionTargetScaling; }
 
        void SetAssumedOnGroundHeight(const FReal& Value)
        {
            ConstraintSettings.Modify(true, DirtyFlags, Proxy, [&Value](FCharacterGroundConstraintSettings& Data) {
                Data.AssumedOnGroundHeight = Value > FReal(0.0) ? Value : FReal(0.0);
                });
        }
        FReal GetAssumedOnGroundHeight() const { return ConstraintSettings.Read().AssumedOnGroundHeight; }
 
        void SetMaxWalkableSlopeAngle(const FReal& Value)
        {
            ConstraintSettings.Modify(true, DirtyFlags, Proxy, [&Value](FCharacterGroundConstraintSettings& Data) {
                FReal Angle = FMath::Clamp(Value, 0.0, UE_HALF_PI);
                Data.CosMaxWalkableSlopeAngle = FMath::Cos(Angle);
                });
        }
        FReal GetMaxWalkableSlopeAngle() const { return FMath::Acos(ConstraintSettings.Read().CosMaxWalkableSlopeAngle); }
 
        void SetCosMaxWalkableSlopeAngle(const FReal& Value)
        {
            ConstraintSettings.Modify(true, DirtyFlags, Proxy, [&Value](FCharacterGroundConstraintSettings& Data) {
                FReal CosAngle = FMath::Clamp(Value, -1.0, 1.0);
                Data.CosMaxWalkableSlopeAngle = CosAngle;
                });
        }
        FReal GetCosMaxWalkableSlopeAngle() const { return ConstraintSettings.Read().CosMaxWalkableSlopeAngle; }
 
        void SetTargetDeltaPosition(const FVec3& Value)
        {
            ConstraintData.Modify(true, DirtyFlags, Proxy, [&Value](FCharacterGroundConstraintDynamicData& Data) {
                Data.TargetDeltaPosition = Value;
                });
            WakeCharacterBody();
        }
        FVec3 GetTargetDeltaPosition() const { return ConstraintData.Read().TargetDeltaPosition; }
 
        void SetTargetDeltaFacing(const FReal& Value)
        {
            ConstraintData.Modify(true, DirtyFlags, Proxy, [&Value](FCharacterGroundConstraintDynamicData& Data) {
                Data.TargetDeltaFacing = Value;
                });
            WakeCharacterBody();
        }
        FReal GetTargetDeltaFacing() const { return ConstraintData.Read().TargetDeltaFacing; }
 
        void SetMotionTarget(const FVector& TargetDeltaPosition, const FReal& TargetDeltaFacing)
        {
            ConstraintData.Modify(true, DirtyFlags, Proxy, [&TargetDeltaPosition, &TargetDeltaFacing](FCharacterGroundConstraintDynamicData& Data) {
                Data.TargetDeltaPosition = TargetDeltaPosition;
                Data.TargetDeltaFacing = TargetDeltaFacing;
                });
            WakeCharacterBody();
        }
 
        void SetRadialForceLimit(const FReal& Value)
        {
            ConstraintSettings.Modify(true, DirtyFlags, Proxy, [&Value](FCharacterGroundConstraintSettings& Data) {
                Data.RadialForceLimit = Value > FReal(0.0) ? Value : FReal(0.0);
                });
        }
        FReal GetRadialForceLimit() const { return ConstraintSettings.Read().RadialForceLimit; }
 
        void SetFrictionForceLimit(const FReal& Value)
        {
            ConstraintSettings.Modify(true, DirtyFlags, Proxy, [&Value](FCharacterGroundConstraintSettings& Data) {
                Data.FrictionForceLimit = Value > FReal(0.0) ? Value : FReal(0.0);
                });
        }
        FReal GetFrictionForceLimit() const { return ConstraintSettings.Read().FrictionForceLimit; }
 
        void SetTwistTorqueLimit(const FReal& Value)
        {
            ConstraintSettings.Modify(true, DirtyFlags, Proxy, [&Value](FCharacterGroundConstraintSettings& Data) {
                Data.TwistTorqueLimit = Value > FReal(0.0) ? Value : FReal(0.0);
                });
        }
        FReal GetTwistTorqueLimit() const { return ConstraintSettings.Read().TwistTorqueLimit; }
 
        void SetSwingTorqueLimit(const FReal& Value)
        {
            ConstraintSettings.Modify(true, DirtyFlags, Proxy, [&Value](FCharacterGroundConstraintSettings& Data) {
                Data.SwingTorqueLimit = Value > FReal(0.0) ? Value : FReal(0.0);
                });
        }
        FReal GetSwingTorqueLimit() const { return ConstraintSettings.Read().SwingTorqueLimit; }
 
        void SetUserData(void* Value)
        {
            ConstraintSettings.Modify(true, DirtyFlags, Proxy, [&Value](FCharacterGroundConstraintSettings& Data) {
                Data.UserData = Value;
                });
        }
        void* GetUserData() const { return ConstraintSettings.Read().UserData; }
 
        void SetMaxCharacterGroundMassRatio(const FReal& Value)
        {
            ConstraintSettings.Modify(true, DirtyFlags, Proxy, [&Value](FCharacterGroundConstraintSettings& Data) {
                Data.MaxCharacterGroundMassRatio = Value;
                });
        }
        FReal GetMaxCharacterGroundMassRatio() const { return ConstraintSettings.Read().MaxCharacterGroundMassRatio; }
 
        // Output
 
        // Get the force applied by the solver due to this constraint. Units are ML/T^2
        FVector GetSolverAppliedForce() const { return SolverAppliedForce; }
 
        // Get the torque applied by the solver due to this constraint. Units are ML^2/T^2
        FVector GetSolverAppliedTorque() const { return SolverAppliedTorque; }
 
    private:
        void WakeCharacterBody()
        {
            if (FSingleParticlePhysicsProxy* Character = CharacterProxy.Read().ParticleProxy)
            {
                FRigidBodyHandle_External& Body = Character->GetGameThreadAPI();
                if (Body.ObjectState() == EObjectStateType::Sleeping)
                {
                    Body.SetObjectState(EObjectStateType::Dynamic);
                }
            }
        }
 
        void WakeGroundBody()
        {
            if (FSingleParticlePhysicsProxy* Ground = GroundProxy.Read().ParticleProxy)
            {
                FRigidBodyHandle_External& Body = Ground->GetGameThreadAPI();
                if (Body.ObjectState() == EObjectStateType::Sleeping)
                {
                    Body.SetObjectState(EObjectStateType::Dynamic);
                }
            }
        }
 
        // FConstraintBase implementation
        CHAOS_API virtual void SyncRemoteDataImp(FDirtyPropertiesManager& Manager, int32 DataIdx, FDirtyChaosProperties& RemoteData) override;
 
        TChaosProperty<FParticleProxyProperty, EChaosProperty::CharacterParticleProxy> CharacterProxy;
        TChaosProperty<FParticleProxyProperty, EChaosProperty::GroundParticleProxy> GroundProxy;
        TChaosProperty<FCharacterGroundConstraintSettings, EChaosProperty::CharacterGroundConstraintSettings> ConstraintSettings;
        TChaosProperty<FCharacterGroundConstraintDynamicData, EChaosProperty::CharacterGroundConstraintDynamicData> ConstraintData;
 
        friend class FCharacterGroundConstraintProxy; // for setting the force and torque from the physics thread data
        FVector SolverAppliedForce;
        FVector SolverAppliedTorque;
    };
 
} // namespace Chaos