DataflowSimulationManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Interface.h"
#include "Subsystems/WorldSubsystem.h"
#include "Templates/SharedPointer.h"
#include "Dataflow/DataflowSimulationContext.h"
 
#include "DataflowSimulationManager.generated.h"
 
#define UE_API DATAFLOWSIMULATION_API
 
struct FDataflowSimulationProxy;
class IDataflowSimulationInterface;
 
namespace UE::Dataflow
{
    namespace Private
    {
        struct  FDataflowSimulationData
        {
            TMap<FString, TSet<IDataflowSimulationInterface*>> SimulationInterfaces;
 
            TSharedPtr<UE::Dataflow::FDataflowSimulationContext> SimulationContext;
 
            bool IsEmpty() const
            {
                for(const TPair<FString, TSet<IDataflowSimulationInterface*>>& InterfacesPair : SimulationInterfaces)
                {
                    if(!InterfacesPair.Value.IsEmpty())
                    {
                        return false;
                    }
                }
                return true;
            }
        };
    }
    DATAFLOWSIMULATION_API void RegisterSimulationInterface(const TObjectPtr<UObject>& SimulationObject);
    DATAFLOWSIMULATION_API void UnregisterSimulationInterface(const TObjectPtr<UObject>& SimulationObject);
}
 
UCLASS(MinimalAPI)
class UDataflowSimulationManager : public UTickableWorldSubsystem
{
    GENERATED_BODY()
 
public:
    UE_API UDataflowSimulationManager();
    virtual ~UDataflowSimulationManager() override  = default;
 
    static UE_API void OnStartup();
    
    static UE_API void OnShutdown();
 
    // Begin FTickableGameObject overrides
    UE_API virtual void Tick(float DeltaTime) override;
    virtual bool IsTickableInEditor() const override { return true; }
    UE_API virtual ETickableTickType GetTickableTickType() const override;
    UE_API virtual bool DoesSupportWorldType(const EWorldType::Type WorldType) const override;
    UE_API virtual TStatId GetStatId() const override;
    // End FTickableGameObject overrides
    
    // Begin USubsystem overrides
    UE_API virtual void Initialize(FSubsystemCollectionBase& Collection) override;
    UE_API virtual void Deinitialize() override;
    // End USubsystem overrides
 
    UE_API void AdvanceSimulationProxies(const float DeltaTime, const float SimulationTime);
 
    UE_API bool HasSimulationInterface(const IDataflowSimulationInterface* SimulationInterface) const;
 
    UE_API void AddSimulationInterface(IDataflowSimulationInterface* SimulationInterface);
 
    UE_API void RemoveSimulationInterface(const IDataflowSimulationInterface* SimulationInterface);
 
    UE_API void ReadSimulationInterfaces(const float DeltaTime, const bool bAsyncTask);
 
    UE_API void WriteSimulationInterfaces(const float DeltaTime, const bool bAsyncTask);
 
    UE_API void ReadRestartData();
 
    UE_API void InitSimulationInterfaces();
 
    UE_API void ResetSimulationInterfaces();
 
    UE_API void CompleteSimulationTasks();
 
    UE_API void StartSimulationTasks(const float DeltaTime, const float SimulationTime);
 
    bool GetSimulationEnabled() const { return bIsSimulationEnabled; }
 
    void SetSimulationEnabled(const bool bSimulationEnabled) {bIsSimulationEnabled = bSimulationEnabled;}
 
    void SetSimulationStepping(const bool bSimulationStepping) {bStepSimulationScene = bSimulationStepping;}
 
    UE_API TSharedPtr<UE::Dataflow::FDataflowSimulationContext> GetSimulationContext(const TObjectPtr<UDataflow>& DataflowAsset) const;
    
private :
 
    UE_API void PreProcessSimulation(const float DeltaTime);
 
    UE_API void PostProcessSimulation(const float DeltaTime);
 
    static UE_API FDelegateHandle OnObjectPropertyChangedHandle;
 
    static UE_API FDelegateHandle OnWorldPostActorTick;
 
    static UE_API FDelegateHandle OnCreatePhysicsStateHandle;
 
    static UE_API FDelegateHandle OnDestroyPhysicsStateHandle;
 
    TMap<TObjectPtr<UDataflow>, UE::Dataflow::Private::FDataflowSimulationData> SimulationData;
    
    TArray<FGraphEventRef> SimulationTasks;
 
    bool bIsSimulationEnabled = true;
    
    bool bStepSimulationScene = false;
};
 
UINTERFACE(MinimalAPI, Blueprintable)
class UDataflowSimulationActor : public UInterface
{
    GENERATED_BODY()
};
 
class IDataflowSimulationActor
{
    GENERATED_BODY()
 
public:
    UFUNCTION(BlueprintCallable, BlueprintNativeEvent, Category="Dataflow")
    void PreDataflowSimulationTick(const float SimulationTime, const float DeltaTime);
 
    UFUNCTION(BlueprintCallable, BlueprintNativeEvent, Category="Dataflow")
    void PostDataflowSimulationTick(const float SimulationTime, const float DeltaTime);
};
 
#undef UE_API