PhysicsReplication.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    PhysicsReplication.h
    Manage replication of physics bodies
=============================================================================*/
 
#pragma once
 
#include "Engine/EngineTypes.h"
#include "Engine/ReplicatedState.h"
#include "PhysicsReplicationInterface.h"
#include "Physics/PhysicsInterfaceDeclares.h"
#include "PhysicsProxy/SingleParticlePhysicsProxyFwd.h"
#include "Chaos/PhysicsObject.h"
#include "Chaos/ParticleDirtyFlags.h"
#include "Chaos/SimCallbackObject.h"
#include "Physics/PhysicsInterfaceUtils.h"
#include "Physics/NetworkPhysicsSettingsComponent.h"
 
namespace Chaos
{
    namespace Private
    {
        class FPBDIsland;
    }
}
 
namespace CharacterMovementCVars
{
    extern ENGINE_API int32 SkipPhysicsReplication;
    extern ENGINE_API float NetPingExtrapolation;
    extern ENGINE_API float NetPingLimit;
    extern ENGINE_API float ErrorPerLinearDifference;
    extern ENGINE_API float ErrorPerAngularDifference;
    extern ENGINE_API float ErrorAccumulationSeconds;
    extern ENGINE_API float ErrorAccumulationDistanceSq;
    extern ENGINE_API float ErrorAccumulationSimilarity;
    extern ENGINE_API float MaxLinearHardSnapDistance;
    extern ENGINE_API float MaxRestoredStateError;
    extern ENGINE_API float PositionLerp;
    extern ENGINE_API float LinearVelocityCoefficient;
    extern ENGINE_API float AngleLerp;
    extern ENGINE_API float AngularVelocityCoefficient;
    extern ENGINE_API int32 AlwaysHardSnap;
    extern ENGINE_API int32 AlwaysResetPhysics;
    extern ENGINE_API int32 ApplyAsyncSleepState;
}
 
#if !UE_BUILD_SHIPPING
namespace PhysicsReplicationCVars
{
    extern ENGINE_API int32 LogPhysicsReplicationHardSnaps;
}
#endif
 
#pragma region FPhysicsReplicationAsync
 
struct FPhysicsRepErrorCorrectionData
{
    float LinearVelocityCoefficient;
    float AngularVelocityCoefficient;
    float PositionLerp;
    float AngleLerp;
};
 
struct FPhysicsRepAsyncInputData
{
    FRigidBodyState TargetState;
    Chaos::FSingleParticlePhysicsProxy* Proxy; // Used for legacy (BodyInstance) flow
    Chaos::FConstPhysicsObjectHandle PhysicsObject;
    TOptional<FPhysicsRepErrorCorrectionData> ErrorCorrection;
    EPhysicsReplicationMode RepMode;
    int32 ServerFrame;
    TOptional<int32> FrameOffset;
    float LatencyOneWay;
 
    FPhysicsRepAsyncInputData(Chaos::FConstPhysicsObjectHandle POHandle)
        : Proxy(nullptr)
        , PhysicsObject(POHandle)
        , RepMode(EPhysicsReplicationMode::Default)
    {};
};
 
struct FPhysicsReplicationAsyncInput : public Chaos::FSimCallbackInput
{
    FPhysicsRepErrorCorrectionData ErrorCorrection;
    TArray<FPhysicsRepAsyncInputData> InputData;
    void Reset()
    {
        InputData.Reset();
    }
};
 
 
struct FReplicatedPhysicsTargetAsync
{
    FReplicatedPhysicsTargetAsync()
        : TargetState()
        , AccumulatedErrorSeconds(0.0f)
        , TickCount(0)
        , ServerFrame(INDEX_NONE)
        , FrameOffset(0)
        , ReceiveFrame(INDEX_NONE)
        , ReceiveInterval(5)
        , AverageReceiveInterval(5.0f)
        , RepMode(EPhysicsReplicationMode::Default)
        , RepModeOverride(EPhysicsReplicationMode::Default)
        , PrevPosTarget()
        , PrevRotTarget()
        , PrevPos()
        , PrevLinVel()
        , AccumulatedSleepSeconds(0.0f)
        , bAllowTargetAltering(false)
        , WaitForServerFrame(INDEX_NONE)
    { }
 
    FRigidBodyState TargetState;
 
    float AccumulatedErrorSeconds;
 
    int32 TickCount;
 
    int32 ServerFrame;
 
    int32 FrameOffset;
 
    int32 ReceiveFrame;
 
    int32 ReceiveInterval;
    float AverageReceiveInterval;
 
    EPhysicsReplicationMode RepMode;
    EPhysicsReplicationMode RepModeOverride;
 
    FVector PrevPosTarget;
    FQuat PrevRotTarget;
    FVector PrevPos;
    FVector PrevLinVel;
 
    float AccumulatedSleepSeconds;
 
    bool bAllowTargetAltering;
 
    int32 WaitForServerFrame;
 
public:
    const bool IsWaiting() const { return WaitForServerFrame > INDEX_NONE; }
 
    void SetWaiting(int32 InWaitForServerFrame, EPhysicsReplicationMode InRepModeOverride)
    {
        SetWaiting(InWaitForServerFrame);
        RepModeOverride = InRepModeOverride;
    }
 
    void SetWaiting(int32 InWaitForServerFrame)
    {
        RepModeOverride = RepMode;
        WaitForServerFrame = InWaitForServerFrame;
    }
 
    void UpdateWaiting(int32 InServerFrame)
    {
        if (InServerFrame > WaitForServerFrame)
        {
            SetWaiting(INDEX_NONE);
        }
    }
};
 
class FPhysicsReplicationAsync : public IPhysicsReplicationAsync,
    public Chaos::TSimCallbackObject<
    FPhysicsReplicationAsyncInput,
    Chaos::FSimCallbackNoOutput,
    Chaos::ESimCallbackOptions::Presimulate | Chaos::ESimCallbackOptions::PhysicsObjectUnregister>
{
    virtual FName GetFNameForStatId() const override;
    virtual void OnPostInitialize_Internal() override;
    virtual void OnPreSimulate_Internal() override;
    virtual void OnPhysicsObjectUnregistered_Internal(Chaos::FConstPhysicsObjectHandle PhysicsObject) override;
 
    virtual void ApplyTargetStatesAsync(const float DeltaSeconds);
    UE_DEPRECATED(5.6, "Deprecated, call the function with just @param DeltaSeconds instead.")
    virtual void ApplyTargetStatesAsync(const float DeltaSeconds, const FPhysicsRepErrorCorrectionData& ErrorCorrection, const TArray<FPhysicsRepAsyncInputData>& TargetStates) { ApplyTargetStatesAsync(DeltaSeconds); };
 
    // Replication functions
    virtual void DefaultReplication_DEPRECATED(Chaos::FRigidBodyHandle_Internal* Handle, const FPhysicsRepAsyncInputData& State, const float DeltaSeconds, const FPhysicsRepErrorCorrectionData& ErrorCorrection);
    virtual bool DefaultReplication(Chaos::FPBDRigidParticleHandle* Handle, FReplicatedPhysicsTargetAsync& Target, const float DeltaSeconds);
    virtual bool PredictiveInterpolation(Chaos::FPBDRigidParticleHandle* Handle, FReplicatedPhysicsTargetAsync& Target, const float DeltaSeconds);
    virtual bool ResimulationReplication(Chaos::FPBDRigidParticleHandle* Handle, FReplicatedPhysicsTargetAsync& Target, const float DeltaSeconds);
 
public:
    virtual void RegisterSettings(Chaos::FConstPhysicsObjectHandle PhysicsObject, TWeakPtr<const FNetworkPhysicsSettingsData> InSettings) override;
 
private:
    float LatencyOneWay;
    FRigidBodyErrorCorrection ErrorCorrectionDefault;
    FNetworkPhysicsSettingsData SettingsCurrent;
    FNetworkPhysicsSettingsData SettingsDefault;
    TMap<Chaos::FConstPhysicsObjectHandle, FReplicatedPhysicsTargetAsync> ObjectToTarget;
    TMap<Chaos::FConstPhysicsObjectHandle, TWeakPtr<const FNetworkPhysicsSettingsData>> ObjectToSettings;
    TArray<const Chaos::Private::FPBDIsland*> ResimIslands;
    TArray<const Chaos::FGeometryParticleHandle*> ResimIslandsParticles;
    TArray<int32> ParticlesInResimIslands;
    TArray<Chaos::FParticleID> ReplicatedParticleIDs;
 
    int32 ResimOutOfBoundsCounter = 0;
    float ResimErrorLogTimer = 0.0f;
 
private:
    FReplicatedPhysicsTargetAsync* AddObjectToReplication(Chaos::FConstPhysicsObjectHandle PhysicsObject);
    void RemoveObjectFromReplication(Chaos::FConstPhysicsObjectHandle PhysicsObject);
    void UpdateAsyncTarget(const FPhysicsRepAsyncInputData& Input, Chaos::FPBDRigidsSolver* RigidsSolver);
    void UpdateRewindDataTarget(const FPhysicsRepAsyncInputData& Input);
    void CacheResimInteractions();
    // Sets SettingsCurrent to either the objects custom settings or to the default settings
    void FetchObjectSettings(Chaos::FConstPhysicsObjectHandle PhysicsObject); 
    bool UsePhysicsReplicationLOD();
    void CheckTargetResimValidity(FReplicatedPhysicsTargetAsync& Target);
    void ApplyPhysicsReplicationLOD(Chaos::FConstPhysicsObjectHandle PhysicsObjectHandle, FReplicatedPhysicsTargetAsync& Target, const uint32 LODFlags);
    void DebugDrawReplicationMode(const FPhysicsRepAsyncInputData& Input);
 
    static void ExtrapolateTarget(FReplicatedPhysicsTargetAsync& Target, const int32 ExtrapolateFrames, const float DeltaSeconds);
    static void ExtrapolateTarget(FReplicatedPhysicsTargetAsync& Target, const float ExtrapolationTime);
 
public:
    void Setup(FRigidBodyErrorCorrection ErrorCorrection)
    {
        ErrorCorrectionDefault = ErrorCorrection;
    }
};
 
#pragma endregion // FPhysicsReplicationAsync
 
 
 
struct FReplicatedPhysicsTarget
{
    FReplicatedPhysicsTarget(Chaos::FConstPhysicsObjectHandle POHandle = nullptr)
        : ArrivedTimeSeconds(0.0f)
        , AccumulatedErrorSeconds(0.0f)
        , ServerFrame(0)
        , PhysicsObject(POHandle)
    { }
 
    FRigidBodyState TargetState;
 
    FName BoneName;
 
    float ArrivedTimeSeconds;
 
    float AccumulatedErrorSeconds;
 
    FVector PrevPosTarget;
    FVector PrevPos;
 
    int32 ServerFrame;
 
    Chaos::FConstPhysicsObjectHandle PhysicsObject;
 
    EPhysicsReplicationMode ReplicationMode;
 
#if !UE_BUILD_SHIPPING
    FDebugFloatHistory ErrorHistory;
#endif
};
 
class FPhysicsReplication : public IPhysicsReplication
{
public:
    ENGINE_API FPhysicsReplication(FPhysScene* PhysScene);
    ENGINE_API virtual ~FPhysicsReplication();
 
    static ENGINE_API bool ShouldSkipPhysicsReplication();
 
    ENGINE_API virtual void Tick(float DeltaSeconds) override;
 
    ENGINE_API virtual void SetReplicatedTarget(UPrimitiveComponent* Component, FName BoneName, const FRigidBodyState& ReplicatedTarget, int32 ServerFrame) override;
private:
    ENGINE_API void SetReplicatedTarget(Chaos::FConstPhysicsObjectHandle PhysicsObject, const FRigidBodyState& ReplicatedTarget, int32 ServerFrame, EPhysicsReplicationMode ReplicationMode = EPhysicsReplicationMode::Default);
 
public:
    ENGINE_API virtual void RemoveReplicatedTarget(UPrimitiveComponent* Component) override;
 
protected:
 
    ENGINE_API virtual void OnTick(float DeltaSeconds, TMap<TWeakObjectPtr<UPrimitiveComponent>, FReplicatedPhysicsTarget>& ComponentsToTargets);
    virtual void OnTargetRestored(TWeakObjectPtr<UPrimitiveComponent> Component, const FReplicatedPhysicsTarget& Target) {}
    virtual void OnSetReplicatedTarget(UPrimitiveComponent* Component, FName BoneName, const FRigidBodyState& ReplicatedTarget, int32 ServerFrame, FReplicatedPhysicsTarget& Target) {}
 
    ENGINE_API virtual bool ApplyRigidBodyState(float DeltaSeconds, FBodyInstance* BI, FReplicatedPhysicsTarget& PhysicsTarget, const FRigidBodyErrorCorrection& ErrorCorrection, const float PingSecondsOneWay, int32 LocalFrame, int32 NumPredictedFrames);
    ENGINE_API virtual bool ApplyRigidBodyState(float DeltaSeconds, FBodyInstance* BI, FReplicatedPhysicsTarget& PhysicsTarget, const FRigidBodyErrorCorrection& ErrorCorrection, const float PingSecondsOneWay, bool* bDidHardSnap = nullptr); // deprecated path with no localframe/numpredicted
 
    ENGINE_API UWorld* GetOwningWorld();
    ENGINE_API const UWorld* GetOwningWorld() const;
 
private:
 
    ENGINE_API float GetLocalPing() const;
 
    ENGINE_API float GetOwnerPing(const AActor* const Owner, const FReplicatedPhysicsTarget& Target) const;
 
private:
    TMap<TWeakObjectPtr<UPrimitiveComponent>, FReplicatedPhysicsTarget> ComponentToTargets_DEPRECATED; // This collection is keeping the legacy flow working until fully deprecated in a future release
    TArray<FReplicatedPhysicsTarget> ReplicatedTargetsQueue;
    FPhysScene* PhysScene;
    TWeakObjectPtr<UNetworkPhysicsSettingsComponent> SettingsCurrent;
 
 
    FPhysicsReplicationAsync* PhysicsReplicationAsync;
    FPhysicsReplicationAsyncInput* AsyncInput;  //async data being written into before we push into callback
 
    ENGINE_API void PrepareAsyncData_External(const FRigidBodyErrorCorrection& ErrorCorrection);    //prepare async data for writing. Call on external thread (i.e. game thread)
};