PhysicsSettings.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    PhysicsSettings.h: Declares the PhysicsSettings class.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Engine/EngineTypes.h"
#include "Templates/Casts.h"
#include "Engine/DeveloperSettings.h"
#include "PhysicsSettingsEnums.h"
#include "BodySetupEnums.h"
#include "Chaos/ChaosEngineInterface.h"
#include "GameFramework/WorldSettings.h"
#include "PhysicsCoreTypes.h"
#include "PhysicsSettingsCore.h"
 
#include "PhysicsSettings.generated.h"
 
USTRUCT()
struct FPhysicalSurfaceName
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    TEnumAsByte<enum EPhysicalSurface> Type;
 
    UPROPERTY()
    FName Name;
 
    FPhysicalSurfaceName()
        : Type(SurfaceType_Max)
    {}
    FPhysicalSurfaceName(EPhysicalSurface InType, const FName& InName)
        : Type(InType)
        , Name(InName)
    {}
};
 
USTRUCT()
struct FChaosPhysicsSettings
{
    GENERATED_BODY()
 
    ENGINE_API FChaosPhysicsSettings();
 
    UPROPERTY(EditAnywhere, Category = ChaosPhysics)
    EChaosThreadingMode DefaultThreadingModel;
 
    UPROPERTY(EditAnywhere, Category = Framerate)
    EChaosSolverTickMode DedicatedThreadTickMode;
 
    UPROPERTY(EditAnywhere, Category = Framerate)
    EChaosBufferMode DedicatedThreadBufferMode;
 
    ENGINE_API void OnSettingsUpdated();
};
 
UENUM()
namespace ESettingsDOF
{
    enum Type : int
    {
        Full3D,
        YZPlane,
        XZPlane,
        XYPlane,
    };
}
 
USTRUCT()
struct FPhysicsReplicationResimulationSettings
{
    GENERATED_BODY();
 
    UPROPERTY(config, EditDefaultsOnly, Category = "Replication", Meta = (InlineEditConditionToggle))
    bool bEnableResimulationErrorPositionThreshold;
 
    UPROPERTY(EditAnywhere, Category = "Replication", meta = (editcondition = "bEnableResimulationErrorPositionThreshold"))
    float ResimulationErrorPositionThreshold;
 
    UPROPERTY(config, EditDefaultsOnly, Category = "Replication", Meta = (InlineEditConditionToggle))
    bool bEnableResimulationErrorRotationThreshold;
 
    UPROPERTY(EditAnywhere, Category = "Replication", meta = (editcondition = "bEnableResimulationErrorRotationThreshold"))
    float ResimulationErrorRotationThreshold;
 
    UPROPERTY(config, EditDefaultsOnly, Category = "Replication", Meta = (InlineEditConditionToggle))
    bool bEnableResimulationErrorLinearVelocityThreshold;
 
    UPROPERTY(EditAnywhere, Category = "Replication", meta = (editcondition = "bEnableResimulationErrorLinearVelocityThreshold"))
    float ResimulationErrorLinearVelocityThreshold;
 
    UPROPERTY(config, EditDefaultsOnly, Category = "Replication", Meta = (InlineEditConditionToggle))
    bool bEnableResimulationErrorAngularVelocityThreshold;
 
    UPROPERTY(EditAnywhere, Category = "Replication", meta = (editcondition = "bEnableResimulationErrorAngularVelocityThreshold"))
    float ResimulationErrorAngularVelocityThreshold;
 
    FPhysicsReplicationResimulationSettings()
        : bEnableResimulationErrorPositionThreshold(true)
        , ResimulationErrorPositionThreshold(10.0f)
        , bEnableResimulationErrorRotationThreshold(true)
        , ResimulationErrorRotationThreshold(4.0f)
        , bEnableResimulationErrorLinearVelocityThreshold(false)
        , ResimulationErrorLinearVelocityThreshold(5.0f)
        , bEnableResimulationErrorAngularVelocityThreshold(false)
        , ResimulationErrorAngularVelocityThreshold(2.0f)
    { }
};
 
USTRUCT()
struct FPhysicsReplicationLODSettings
{
    GENERATED_BODY();
 
    UPROPERTY(config, EditDefaultsOnly, Category = "Replication")
    bool bEnablePhysicsReplicationLOD;
 
    UPROPERTY(EditAnywhere, Category = "Replication", meta = (ClampMin = "0.0", UIMin = "0.0"))
    float MinimumBaseDistance;
 
    UPROPERTY(EditAnywhere, Category = "Replication", meta = (ClampMin = "0.0", UIMin = "0.0"))
    float BaseDistanceRadiusMultiplier;
 
    UPROPERTY(EditAnywhere, Category = "Replication", meta = (ClampMin = "0.0", UIMin = "0.0"))
    float BaseDistancesForResimulationMode;
 
    UPROPERTY(EditAnywhere, Category = "Replication", meta = (ClampMin = "0.0", UIMin = "0.0"))
    float BaseDistancesForFullPrediction;
 
 
    UPROPERTY(EditAnywhere, Category = "Replication", meta = (ClampMin = "0.0", UIMin = "0.0"))
    float TimeOverDistance;
 
    FPhysicsReplicationLODSettings()
        : bEnablePhysicsReplicationLOD(false)
        , MinimumBaseDistance(200.0f)
        , BaseDistanceRadiusMultiplier(0.75f)
        , BaseDistancesForResimulationMode(0.25f)
        , BaseDistancesForFullPrediction(0.8f)
        , TimeOverDistance(0.15f)
    { }
};
 
USTRUCT()
struct FPhysicsPredictionSettings
{
    GENERATED_BODY();
 
    UPROPERTY(config)
    bool bEnablePhysicsResimulation_DEPRECATED;
 
    UPROPERTY(config)
    float ResimulationErrorThreshold_DEPRECATED;
 
    UPROPERTY(EditAnywhere, Category = "Replication")
    bool bEnablePhysicsPrediction;
 
    UPROPERTY(EditAnywhere, Category = "Replication")
    bool bEnablePhysicsHistoryCapture;
 
    UPROPERTY(EditAnywhere, Category = "Replication")
    float MaxSupportedLatencyPrediction;
 
    UPROPERTY(EditAnywhere, Category = "Replication", meta = (DisplayName = "Default Resimulation Replication Settings (EPhysicsReplicationMode::Resimulation)"))
    FPhysicsReplicationResimulationSettings ResimulationSettings;
 
    UPROPERTY(EditAnywhere, Category = "Replication", meta = (DisplayName = "Default settings for physics replication LOD"))
    FPhysicsReplicationLODSettings PhysicsReplicationLODSettings;
 
    FPhysicsPredictionSettings()
        : bEnablePhysicsResimulation_DEPRECATED(false)
        , ResimulationErrorThreshold_DEPRECATED(10.0f)
        , bEnablePhysicsPrediction(false)
        , bEnablePhysicsHistoryCapture(false)
        , MaxSupportedLatencyPrediction(1000)
    { }
};
 
UENUM()
namespace ESettingsLockedAxis
{
    enum Type : int
    {
        None,
        X,
        Y,
        Z,
        Invalid
    };
}
 
UCLASS(config=Engine, defaultconfig, meta=(DisplayName="Physics"), MinimalAPI)
class UPhysicsSettings : public UPhysicsSettingsCore
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY(Config, EditAnywhere, Category = Replication, meta = (DisplayName = "Physics Prediction (Experimental)"))
    FPhysicsPredictionSettings PhysicsPrediction;
 
    UPROPERTY(config, EditAnywhere, Category = Replication, meta = (DisplayName = "Default Physics Replication Settings (EPhysicsReplicationMode::Default)"))
    FRigidBodyErrorCorrection PhysicErrorCorrection;
 
    UPROPERTY(config)
    TEnumAsByte<ESettingsLockedAxis::Type> LockedAxis_DEPRECATED;
 
    UPROPERTY(config, EditAnywhere, Category = Simulation)
    TEnumAsByte<ESettingsDOF::Type> DefaultDegreesOfFreedom;
    
    UPROPERTY(config, EditAnywhere, Category = Optimization)
    bool bSuppressFaceRemapTable;
 
    UPROPERTY(config, EditAnywhere, Category = Optimization, meta = (DisplayName = "Support UV From Hit Results", ConfigRestartRequired = true))
    bool bSupportUVFromHitResults;
 
    UPROPERTY(config, EditAnywhere, Category = Optimization)
    bool bDisableActiveActors;
 
    UPROPERTY(config, EditAnywhere, Category = Optimization)
    bool bDisableKinematicStaticPairs;
 
    UPROPERTY(config, EditAnywhere, Category = Optimization)
    bool bDisableKinematicKinematicPairs;
 
    UPROPERTY(config, EditAnywhere, Category = Simulation)
    bool bDisableCCD;
 
    UPROPERTY(config, EditAnywhere, meta = (ClampMin = "0.0", UIMin = "0.0", ClampMax = "1.0", UIMax = "1.0"), Category = Framerate)
    float AnimPhysicsMinDeltaTime;
 
    UPROPERTY(config, EditAnywhere, Category = Simulation)
    bool bSimulateAnimPhysicsAfterReset;
 
    UPROPERTY(config, EditAnywhere, meta = (ClampMin = "0.0", UIMin = "0.0", ClampMax = "0.0001", UIMax = "0.0001"), Category = Framerate)
    float MinPhysicsDeltaTime;
 
    UPROPERTY(config, EditAnywhere, meta=(ClampMin="0.0013", UIMin = "0.0013", ClampMax="1.0", UIMax="1.0"), Category=Framerate)
    float MaxPhysicsDeltaTime;
 
    UPROPERTY(config, EditAnywhere, Category = Framerate)
    bool bSubstepping;
 
    UPROPERTY(config, EditAnywhere, Category = Framerate)
    bool bSubsteppingAsync;
 
    UPROPERTY(config, EditAnywhere, Category = Framerate)
    bool bTickPhysicsAsync;
 
    UPROPERTY(config, EditAnywhere, Category = Framerate, meta=(editcondition = "bTickPhysicsAsync"))
    float AsyncFixedTimeStepSize;
 
    UPROPERTY(config, EditAnywhere, meta = (ClampMin = "0.0013", UIMin = "0.0013", ClampMax = "1.0", UIMax = "1.0", editcondition = "bSubStepping"), Category=Framerate)
    float MaxSubstepDeltaTime;
 
    UPROPERTY(config, EditAnywhere, meta = (ClampMin = "1", UIMin = "1", ClampMax = "16", UIMax = "16", editcondition = "bSubstepping"), Category=Framerate)
    int32 MaxSubsteps;
 
    UPROPERTY(config, EditAnywhere, AdvancedDisplay, meta = (ClampMin = "0.0", UIMin = "0.0", ClampMax = "1.0", UIMax = "1.0"), Category = Framerate)
    float SyncSceneSmoothingFactor;
 
    UPROPERTY(config, EditAnywhere, AdvancedDisplay, meta = (ClampMin = "0.0013", UIMin = "0.0013", ClampMax = "1.0", UIMax = "1.0"), Category = Framerate)
    float InitialAverageFrameRate;
 
    UPROPERTY(config, EditAnywhere, AdvancedDisplay, meta = (ClampMin = "4", UIMin = "4"), Category = Framerate)
    int PhysXTreeRebuildRate;
 
    // PhysicalMaterial Surface Types
    UPROPERTY(config, EditAnywhere, Category=PhysicalSurfaces)
    TArray<FPhysicalSurfaceName> PhysicalSurfaces;
 
    UPROPERTY(config, EditAnywhere, Category = Broadphase)
    FBroadphaseSettings DefaultBroadphaseSettings;
 
    UPROPERTY(config, EditAnywhere, Category = ChaosPhysics)
    float MinDeltaVelocityForHitEvents;
 
    UPROPERTY(config, EditAnywhere, Category = ChaosPhysics)
    FChaosPhysicsSettings ChaosSettings;
 
public:
 
    static UPhysicsSettings* Get() { return CastChecked<UPhysicsSettings>(UPhysicsSettings::StaticClass()->GetDefaultObject()); }
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    int32 GetPhysicsHistoryCount() const
    {
        return FMath::Max<int32>(1, FMath::CeilToInt(0.001f * PhysicsPrediction.MaxSupportedLatencyPrediction / AsyncFixedTimeStepSize));
    }
 
    ENGINE_API virtual void PostInitProperties() override;
 
#if WITH_EDITOR
    ENGINE_API virtual bool CanEditChange( const FProperty* Property ) const override;
    ENGINE_API virtual void PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) override;
 
    ENGINE_API void LoadSurfaceType();
 
#endif // WITH_EDITOR
};