ChaosSolversModule.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "HAL/Event.h"
#include "HAL/IConsoleManager.h"
#include "HAL/ThreadSafeBool.h"
#include "Modules/ModuleInterface.h"
#include "Modules/ModuleManager.h"
#include "Async/AsyncWork.h"
#include "UObject/ObjectMacros.h"
#include "Framework/Threading.h"
#include "PhysicsCoreTypes.h"
#include "Chaos/Framework/MultiBufferResource.h"
#include "Chaos/Declares.h"
#include "Chaos/PhysicalMaterials.h"
#include "Chaos/Defines.h"
#include "Async/TaskGraphInterfaces.h"
 
class IChaosSolverActorClassProvider
{
public:
    virtual UClass* GetSolverActorClass() const = 0;
};
 
class IChaosSettingsProvider
{
public:
    virtual ~IChaosSettingsProvider() {}
 
    virtual float GetMinDeltaVelocityForHitEvents() const
    {
        return 0.f;
    }
 
    virtual bool GetPhysicsPredictionEnabled() const
    {
        return false;
    }
 
    UE_DEPRECATED(5.5, "GetResimulationErrorThreshold has been renamed, please use GetResimulationErrorPositionThreshold.")
    virtual float GetResimulationErrorThreshold() const
    {
        return GetResimulationErrorPositionThreshold();
    }
 
    virtual bool GetResimulationErrorPositionThresholdEnabled() const
    {
        return false;
    }
 
    virtual float GetResimulationErrorPositionThreshold() const
    {
        return 0;
    }
 
    virtual bool GetResimulationErrorRotationThresholdEnabled() const
    {
        return false;
    }
 
    virtual float GetResimulationErrorRotationThreshold() const
    {
        return 0;
    }
 
    virtual bool GetResimulationErrorLinearVelocityThresholdEnabled() const
    {
        return false;
    }
 
    virtual float GetResimulationErrorLinearVelocityThreshold() const
    {
        return 0;
    }
 
    virtual bool GetResimulationErrorAngularVelocityThresholdEnabled() const
    {
        return false;
    }
 
    virtual float GetResimulationErrorAngularVelocityThreshold() const
    {
        return 0;
    }
 
    virtual float GetPhysicsHistoryTimeLength() const
    {
        return 0;
    }
 
    virtual int32 GetPhysicsHistoryCount() const
    {
        return 0;
    }
}; 
 
namespace Chaos
{
    class FPersistentPhysicsTask;
    class FPhysicsProxy;
    class FPhysicsSolverBase;
}
 
// Default settings implementation
namespace Chaos
{
    class FInternalDefaultSettings : public IChaosSettingsProvider
    {
    public:
    };
 
    extern CHAOS_API FInternalDefaultSettings GDefaultChaosSettings;
}
 
struct FSolverStateStorage
{
    friend class FChaosSolversModule;
 
    Chaos::FPhysicsSolver* Solver;
    TArray<Chaos::FPhysicsProxy*> ActiveProxies;
    TArray<Chaos::FPhysicsProxy*> ActiveProxies_GameThread;
 
private:
 
    // Private so only the module can actually make these so they can be tracked
    FSolverStateStorage();
    FSolverStateStorage(const FSolverStateStorage& InCopy) = default;
    FSolverStateStorage(FSolverStateStorage&& InSteal) = default;
    FSolverStateStorage& operator =(const FSolverStateStorage& InCopy) = default;
    FSolverStateStorage& operator =(FSolverStateStorage&& InSteal) = default;
 
};
 
enum class ESolverFlags : uint8
{
    None = 0,
    Standalone = 1 << 0
};
ENUM_CLASS_FLAGS(ESolverFlags);
 
class FChaosSolversModule
{
public:
 
    static CHAOS_API FChaosSolversModule* GetModule();
 
    CHAOS_API FChaosSolversModule();
 
    CHAOS_API void StartupModule();
    CHAOS_API void ShutdownModule();
 
    CHAOS_API void Initialize();
    CHAOS_API void Shutdown();
 
    CHAOS_API bool IsPersistentTaskEnabled() const;
    CHAOS_API bool IsPersistentTaskRunning() const;
 
 
    CHAOS_API Chaos::FPersistentPhysicsTask* GetDedicatedTask() const;
 
    CHAOS_API void SyncTask(bool bForceBlockingSync = false);
 
    CHAOS_API Chaos::FPBDRigidsSolver* CreateSolver(UObject* InOwner, Chaos::FReal InAsyncDt, Chaos::EThreadingMode ThreadingMode = Chaos::EThreadingMode::SingleThread, const FName& DebugName = NAME_None);
 
    CHAOS_API void MigrateSolver(Chaos::FPhysicsSolverBase* InSolver, const UObject* InNewOwner);
 
    void SetSolverActorClass(UClass* InActorClass, UClass* InActorRequiredBaseClass)
    {
        SolverActorClass = InActorClass;
        SolverActorRequiredBaseClass = InActorRequiredBaseClass;
        check(IsValidSolverActorClass(SolverActorClass));
    }
 
    CHAOS_API UClass* GetSolverActorClass() const;
 
    CHAOS_API bool IsValidSolverActorClass(UClass* Class) const;
 
    CHAOS_API void DestroySolver(Chaos::FPhysicsSolverBase* InState);
 
    CHAOS_API const TArray<Chaos::FPhysicsSolverBase*>& GetAllSolvers() const;
 
    CHAOS_API TArray<const Chaos::FPhysicsSolverBase*> GetSolvers(const UObject* InOwner) const;
    CHAOS_API void GetSolvers(const UObject* InOwner, TArray<const Chaos::FPhysicsSolverBase*>& OutSolvers) const;
 
    CHAOS_API TArray<Chaos::FPhysicsSolverBase*> GetSolversMutable(const UObject* InOwner);
    CHAOS_API void GetSolversMutable(const UObject* InOwner, TArray<Chaos::FPhysicsSolverBase*>& OutSolvers);
 
    CHAOS_API void DumpHierarchyStats(int32* OutOptMaxCellElements = nullptr);
 
#if WITH_EDITOR
    CHAOS_API void PauseSolvers();
 
    CHAOS_API void ResumeSolvers();
 
    CHAOS_API void SingleStepSolvers();
 
    CHAOS_API bool ShouldStepSolver(int32& InOutSingleStepCounter) const;
#endif  // #if WITH_EDITOR
 
    void RegisterSolverActorClassProvider(IChaosSolverActorClassProvider* Provider)
    {
        SolverActorClassProvider = Provider;
    };
 
 
    CHAOS_API const IChaosSettingsProvider& GetSettingsProvider() const;
    void SetSettingsProvider(IChaosSettingsProvider* InProvider)
    {
        SettingsProvider = InProvider;
    }
 
    void LockSolvers() { SolverLock.Lock(); }
    void UnlockSolvers() { SolverLock.Unlock(); }
 
    CHAOS_API void OnUpdateMaterial(Chaos::FMaterialHandle InHandle);
    CHAOS_API void OnCreateMaterial(Chaos::FMaterialHandle InHandle);
    CHAOS_API void OnDestroyMaterial(Chaos::FMaterialHandle InHandle);
 
    CHAOS_API void OnUpdateMaterialMask(Chaos::FMaterialMaskHandle InHandle);
    CHAOS_API void OnCreateMaterialMask(Chaos::FMaterialMaskHandle InHandle);
    CHAOS_API void OnDestroyMaterialMask(Chaos::FMaterialMaskHandle InHandle);
 
    CHAOS_API void GetSolverUpdatePrerequisites(FGraphEventArray& InPrerequisiteContainer);
 
private:
 
    IChaosSolverActorClassProvider* SolverActorClassProvider;
 
    IChaosSettingsProvider* SettingsProvider;
 
    // Whether we actually spawned a physics task (distinct from whether we _should_ spawn it)
    bool bPersistentTaskSpawned;
 
    // The actually running tasks if running in a multi threaded configuration.
    FAsyncTask<Chaos::FPersistentPhysicsTask>* PhysicsAsyncTask;
    Chaos::FPersistentPhysicsTask* PhysicsInnerTask;
 
    // Core delegate signaling app shutdown, clean up and spin down threads before exit.
    FDelegateHandle PreExitHandle;
 
    // Flat list of every solver the module has created.
    TArray<Chaos::FPhysicsSolverBase*> AllSolvers;
 
    // Map of solver owners to the solvers they own. Nullptr is a valid 'owner' in that it's a map
    // key for unowned, standalone solvers
    TMap<const UObject*, TArray<Chaos::FPhysicsSolverBase*>> SolverMap;
 
    // Lock for the above list to ensure we don't delete solvers out from underneath other threads
    // or mess up the solvers array during use.
    mutable FCriticalSection SolverLock;
 
    UClass* SolverActorClass;
 
    UClass* SolverActorRequiredBaseClass;
 
    FGraphEventRef GlobalCommandTaskEventRef;
 
#if STATS
    // Stored stats from the physics thread
    float AverageUpdateTime;
    float TotalAverageUpdateTime;
    float Fps;
    float EffectiveFps;
#endif
 
#if WITH_EDITOR
    // Pause/Resume/Single-step thread safe booleans.
    FThreadSafeBool bPauseSolvers;
    FThreadSafeCounter SingleStepCounter;  // Counter that increments its value each time a single step is instructed.
#endif  // #if WITH_EDITOR
 
    // Whether we're initialized, gates work in Initialize() and Shutdown()
    bool bModuleInitialized;
 
    FDelegateHandle OnCreateMaterialHandle;
    FDelegateHandle OnDestroyMaterialHandle;
    FDelegateHandle OnUpdateMaterialHandle;
 
    FDelegateHandle OnCreateMaterialMaskHandle;
    FDelegateHandle OnDestroyMaterialMaskHandle;
    FDelegateHandle OnUpdateMaterialMaskHandle;
};
 
struct FChaosScopeSolverLock
{
    FChaosScopeSolverLock()
    {
        FChaosSolversModule::GetModule()->LockSolvers();
    }
 
    ~FChaosScopeSolverLock()
    {
        FChaosSolversModule::GetModule()->UnlockSolvers();
    }
};