DataflowSimulationNodes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Dataflow/DataflowObject.h"
#include "Dataflow/DataflowSimulationProxy.h"
#include "Dataflow/DataflowSimulationContext.h"
 
#include "DataflowSimulationNodes.generated.h"
 
#define UE_API DATAFLOWSIMULATION_API
 
USTRUCT(BlueprintType)
struct FDataflowSimulationProperty
{
    GENERATED_BODY()
 
    /* Simulation proxy used to pass information in between nodes */
    FDataflowSimulationProxy* SimulationProxy;
};
 
USTRUCT()
struct FDataflowSimulationNode : public FDataflowNode
{
    GENERATED_BODY()
 
    FDataflowSimulationNode()
        : Super() { }
 
    FDataflowSimulationNode(const UE::Dataflow::FNodeParameters& Param, FGuid InGuid = FGuid::NewGuid())
        : Super(Param,InGuid) {
    }
 
    virtual ~FDataflowSimulationNode() {}
    
    static FName StaticType() { return FName("FDataflowSimulationNode"); }
 
    virtual bool IsA(FName InType) const override 
    { 
        return InType.ToString().Equals(StaticType().ToString()) 
            || Super::IsA(InType); 
    }
 
    virtual void Evaluate(UE::Dataflow::FContext& Context, const FDataflowOutput* Output) const override
    {
        if(Context.IsA(UE::Dataflow::FDataflowSimulationContext::StaticType()))
        {
            UE::Dataflow::FDataflowSimulationContext& SimulationContext = StaticCast<UE::Dataflow::FDataflowSimulationContext&>(Context);
            EvaluateSimulation(SimulationContext, Output);
            
        }
    }
 
protected :
 
    virtual void EvaluateSimulation(UE::Dataflow::FDataflowSimulationContext& SimulationContext, const FDataflowOutput* Output) const {};
};
 
USTRUCT()
struct FDataflowInvalidNode : public FDataflowSimulationNode
{
    GENERATED_BODY()
 
    FDataflowInvalidNode()
        : Super() { }
 
    FDataflowInvalidNode(const UE::Dataflow::FNodeParameters& Param, FGuid InGuid = FGuid::NewGuid())
        : Super(Param,InGuid) {
    }
 
    virtual ~FDataflowInvalidNode() {}
    
    static FName StaticType() { return FName("FDataflowInvalidNode"); }
 
    virtual bool IsA(FName InType) const override 
    { 
        return InType.ToString().Equals(StaticType().ToString()) 
            || Super::IsA(InType); 
    }
};
 
USTRUCT()
struct FDataflowExecutionNode : public FDataflowSimulationNode
{
    GENERATED_BODY()
 
    FDataflowExecutionNode()
        : Super() { }
 
    FDataflowExecutionNode(const UE::Dataflow::FNodeParameters& Param, FGuid InGuid = FGuid::NewGuid())
        : Super(Param,InGuid) {
    }
 
    virtual ~FDataflowExecutionNode() {}
    
    static FName StaticType() { return FName("FDataflowExecutionNode"); }
 
    virtual bool IsA(FName InType) const override 
    { 
        return InType.ToString().Equals(StaticType().ToString()) 
            || Super::IsA(InType); 
    }
};
 
USTRUCT()
struct FDataflowSimulationTime 
{
    GENERATED_BODY()
 
public:
    FDataflowSimulationTime(): DeltaTime(0.0f), CurrentTime(0.0f)
    {}
    
    FDataflowSimulationTime(const float InDeltaTime, const float InCurrentTime) : DeltaTime(InDeltaTime), CurrentTime(InCurrentTime)
    {}
    
    UPROPERTY(Transient, SkipSerialization)
    float DeltaTime = 0.0f;
 
    UPROPERTY(Transient, SkipSerialization)
    float CurrentTime = 0.0f;
 
    UPROPERTY(Transient, SkipSerialization)
    float TimeOffset = 0.0f;
};
 
USTRUCT(meta = (DataflowSimulation))
struct FGetSimulationTimeDataflowNode : public FDataflowInvalidNode
{
    GENERATED_BODY()
    DATAFLOW_NODE_DEFINE_INTERNAL(FGetSimulationTimeDataflowNode, "GetSimulationTime", "Physics|Common", UDataflow::SimulationTag)
 
public:
    
    FGetSimulationTimeDataflowNode(const UE::Dataflow::FNodeParameters& InParam, FGuid InGuid = FGuid::NewGuid())
    : FDataflowInvalidNode(InParam, InGuid)
    {
        RegisterOutputConnection(&SimulationTime);
    }
    
    UPROPERTY(Transient, SkipSerialization, Meta = (DataflowOutput))
    FDataflowSimulationTime SimulationTime = FDataflowSimulationTime(0.0f, 0.0f);
 
    UE_API virtual void EvaluateSimulation(UE::Dataflow::FDataflowSimulationContext& SimulationContext, const FDataflowOutput* Output) const override;
};
 
USTRUCT(meta = (DataflowSimulation))
struct FGetPhysicsSolversDataflowNode : public FDataflowInvalidNode
{
    GENERATED_BODY()
    DATAFLOW_NODE_DEFINE_INTERNAL(FGetPhysicsSolversDataflowNode, "GetPhysicsSolvers", "Physics|Solver", UDataflow::SimulationTag)
 
public:
    
    FGetPhysicsSolversDataflowNode(const UE::Dataflow::FNodeParameters& InParam, FGuid InGuid = FGuid::NewGuid())
    : FDataflowInvalidNode(InParam, InGuid)
    {
        RegisterOutputConnection(&PhysicsSolvers);
    }
 
    UPROPERTY(Transient, SkipSerialization, Meta = (DataflowOutput))
    TArray<FDataflowSimulationProperty> PhysicsSolvers;
 
    UPROPERTY(EditAnywhere, Category="Simulation")
    TArray<FString> SimulationGroups;
 
    virtual void EvaluateSimulation(UE::Dataflow::FDataflowSimulationContext& SimulationContext, const FDataflowOutput* Output) const override;
};
 
USTRUCT(meta = (DataflowSimulation))
struct FAdvancePhysicsSolversDataflowNode : public FDataflowSimulationNode
{
    GENERATED_BODY()
    DATAFLOW_NODE_DEFINE_INTERNAL(FAdvancePhysicsSolversDataflowNode, "AdvancePhysicsSolvers", "Physics|Solver", UDataflow::SimulationTag)
 
public:
    
    FAdvancePhysicsSolversDataflowNode(const UE::Dataflow::FNodeParameters& InParam, FGuid InGuid = FGuid::NewGuid())
    : FDataflowSimulationNode(InParam, InGuid)
    {
        RegisterInputConnection(&SimulationTime);
        RegisterInputConnection(&PhysicsSolvers);
        RegisterOutputConnection(&PhysicsSolvers, &PhysicsSolvers);
    }
 
    UPROPERTY(Transient, SkipSerialization, Meta = (DataflowInput))
    FDataflowSimulationTime SimulationTime = FDataflowSimulationTime(0.0f,0.0f);
 
    UPROPERTY(Transient, SkipSerialization, Meta = (DataflowInput, DataflowOutput, DataflowPassthrough = "PhysicsSolvers"))
    TArray<FDataflowSimulationProperty> PhysicsSolvers;
 
    virtual void EvaluateSimulation(UE::Dataflow::FDataflowSimulationContext& SimulationContext, const FDataflowOutput* Output) const override;
};
 
USTRUCT(meta = (DataflowSimulation))
struct FFilterSimulationProxiesDataflowNode : public FDataflowSimulationNode
{
    GENERATED_BODY()
    DATAFLOW_NODE_DEFINE_INTERNAL(FFilterSimulationProxiesDataflowNode, "FilterSimulationProxies", "Physics|Proxy", UDataflow::SimulationTag)
 
public:
    
    FFilterSimulationProxiesDataflowNode(const UE::Dataflow::FNodeParameters& InParam, FGuid InGuid = FGuid::NewGuid())
    : FDataflowSimulationNode(InParam, InGuid)
    {
        RegisterInputConnection(&SimulationProxies);
        RegisterOutputConnection(&FilteredProxies);
    }
 
    UPROPERTY(Transient, SkipSerialization, Meta = (DataflowInput))
    TArray<FDataflowSimulationProperty> SimulationProxies;
 
    UPROPERTY(Transient, SkipSerialization, Meta = (DataflowOutput))
    TArray<FDataflowSimulationProperty> FilteredProxies;
 
    UPROPERTY(EditAnywhere, Category="Simulation")
    TArray<FString> SimulationGroups;
 
    virtual void EvaluateSimulation(UE::Dataflow::FDataflowSimulationContext& SimulationContext, const FDataflowOutput* Output) const override;
};
 
USTRUCT(meta = (DataflowSimulation))
struct FSimulationProxiesTerminalDataflowNode : public FDataflowExecutionNode
{
    GENERATED_BODY()
    DATAFLOW_NODE_DEFINE_INTERNAL(FSimulationProxiesTerminalDataflowNode, "SimulationProxiesTerminal", "Terminal|Proxy", UDataflow::SimulationTag)
 
public:
    
    FSimulationProxiesTerminalDataflowNode(const UE::Dataflow::FNodeParameters& InParam, FGuid InGuid = FGuid::NewGuid())
    : FDataflowExecutionNode(InParam, InGuid)
    {
        RegisterInputConnection(&SimulationProxies);
    }
 
    UPROPERTY(Transient, SkipSerialization, Meta = (DataflowInput))
    TArray<FDataflowSimulationProperty> SimulationProxies;
    
    virtual void EvaluateSimulation(UE::Dataflow::FDataflowSimulationContext& SimulationContext, const FDataflowOutput* Output) const override;
};
 
namespace UE::Dataflow
{
    void RegisterDataflowSimulationNodes();
}
 
 
#undef UE_API