DataflowInstance.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Dataflow/DataflowContent.h"
#include "StructUtils/PropertyBag.h"
#include "UObject/ObjectPtr.h"
 
#include "DataflowInstance.generated.h"
 
namespace UE::Dataflow::Private
{
    class FVariablesOverridesDetails;
}
 
namespace UE::Dataflow::InstanceUtils::Private
{
    // need to be in the header to be used by the templated structure override methods
    template<typename T, typename TWriteElementFunction>
    bool OverrideVariableArray(FInstancedPropertyBag& Variables, FName VariableName, const TArray<T>& Values, const TWriteElementFunction& WriteElementFunction, FGuid& OutGuid)
    {
        if (const FPropertyBagPropertyDesc* Desc = Variables.FindPropertyDescByName(VariableName))
        {
            TValueOrError<FPropertyBagArrayRef, EPropertyBagResult> MutableArrayRef = Variables.GetMutableArrayRef(*Desc);
            if (FPropertyBagArrayRef* ArrayRef = MutableArrayRef.TryGetValue())
            {
                bool bSuccess = true;
                ArrayRef->EmptyValues();
                ArrayRef->AddValues(Values.Num());
                for (int32 Idx = 0; Idx < Values.Num(); ++Idx)
                {
                    bSuccess &= (WriteElementFunction(*ArrayRef, Idx, Values[Idx]) == EPropertyBagResult::Success);
                }
                if (bSuccess)
                {
                    OutGuid = Desc->ID;
                }
                return bSuccess;
            }
        }
        OutGuid.Invalidate();
        return false;
    }
}
 
class UDataflow;
struct FDataflowInstance;
 
USTRUCT()
struct FDataflowVariableOverrides
{
    GENERATED_USTRUCT_BODY();
 
    DATAFLOWENGINE_API FDataflowVariableOverrides(FDataflowInstance* InOwner = nullptr);
 
    // prevent the copy constructor to avoid having a copy with the same owner
    // use the assignment operator instead on a newly created FDataflowVariableOverrides with the right owner to copy its content over 
    FDataflowVariableOverrides(const FDataflowVariableOverrides& Other) = delete;
 
    DATAFLOWENGINE_API FDataflowVariableOverrides& operator=(const FDataflowVariableOverrides& Other);
 
    DATAFLOWENGINE_API void RemoveAllVariables();
 
    DATAFLOWENGINE_API void SyncVariables();
 
    DATAFLOWENGINE_API bool HasVariable(FName VariableName) const;
 
    DATAFLOWENGINE_API bool IsVariableOverridden(FName VariableName) const;
 
    DATAFLOWENGINE_API const FInstancedPropertyBag& GetVariables() const;
 
    DATAFLOWENGINE_API FInstancedPropertyBag& GetVariables();
 
    DATAFLOWENGINE_API static FName GetVariablePropertyName();
 
    DATAFLOWENGINE_API bool OverrideVariableBool(FName VariableName, bool bValue);
 
    DATAFLOWENGINE_API bool OverrideVariableBoolArray(FName VariableName, const TArray<bool>& Values);
 
    DATAFLOWENGINE_API bool OverrideVariableInt(FName VariableName, int64 Value);
 
    DATAFLOWENGINE_API bool OverrideVariableInt32Array(FName VariableName, const TArray<int32>& Values);
 
    DATAFLOWENGINE_API bool OverrideVariableInt64Array(FName VariableName, const TArray<int64>& Values);
 
    DATAFLOWENGINE_API bool OverrideVariableFloat(FName VariableName, float Value);
 
    DATAFLOWENGINE_API bool OverrideVariableFloatArray(FName VariableName, const TArray<float>& Values);
 
    DATAFLOWENGINE_API bool OverrideVariableObject(FName VariableName, const UObject* Value);
 
    DATAFLOWENGINE_API bool OverrideVariableObjectArray(FName VariableName, const TArray<TObjectPtr<UObject>>& Values);
 
    DATAFLOWENGINE_API bool OverrideVariableObjectArray(FName VariableName, const TArray<UObject*>& Values);
 
    DATAFLOWENGINE_API bool OverrideVariableName(FName VariableName, FName Value);
 
    DATAFLOWENGINE_API bool OverrideVariableName(FName VariableName, const TArray<FName>& Values);
 
    DATAFLOWENGINE_API bool OverrideVariableString(FName VariableName, FString Value);
 
    DATAFLOWENGINE_API bool OverrideVariableString(FName VariableName, const TArray<FString>& Values);
 
    template <typename T>
    bool OverrideVariableStruct(FName VariableName, const T& Value)
    {
        if (const FPropertyBagPropertyDesc* Desc = Variables.FindPropertyDescByName(VariableName))
        {
            if (Variables.SetValueStruct(VariableName, Value) == EPropertyBagResult::Success)
            {
                OverriddenVariableGuids.AddUnique(Desc->ID);
                return true;
            }
        }
        return false;
    }
 
    template <typename T>
    bool OverrideVariableStructArray(FName VariableName, const TArray<T>& Values)
    {
        using namespace UE::Dataflow::InstanceUtils::Private;
 
        auto WriteStructValue = [](FPropertyBagArrayRef& ArrayRef, int32 Idx, const T& Value)
            {
                return ArrayRef.SetValueStruct(Idx, Value);
            };
 
        return OverrideVariableArrayAndNotify(Variables, VariableName, Values, WriteStructValue);
    }
 
#if WITH_EDITOR
 
    void OnOwnerPostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent);
    void OnDataflowVariablesChanged(const UDataflow* DataflowAsset, FName VariableName);
#endif
 
private:
    friend class UE::Dataflow::Private::FVariablesOverridesDetails;
 
    DATAFLOWENGINE_API const FInstancedPropertyBag* GetDefaultVariablesFromAsset() const;
 
    DATAFLOWENGINE_API FInstancedPropertyBag& GetOverridenVariables();
 
    DATAFLOWENGINE_API bool IsVariableOverridden(const FGuid PropertyID) const;
 
    DATAFLOWENGINE_API void SetVariableOverridden(const FGuid PropertyID, const bool bIsOverridden);
 
    void RemoveOverridenVariablesNotInDataflowAsset();
 
private:
    void SetVariableOverrideAndNotify(const FGuid& PropertyID, bool bOverrideState);
 
    template<typename T, typename TWriteElementFunction>
    bool OverrideVariableArrayAndNotify(FInstancedPropertyBag& InVariables, FName InVariableName, const TArray<T>& InValues, const TWriteElementFunction& InWriteElementFunction)
    {
        FGuid PropertyGuid;
        const bool bSuccess = UE::Dataflow::InstanceUtils::Private::OverrideVariableArray(InVariables, InVariableName, InValues, InWriteElementFunction, PropertyGuid);
        if (bSuccess)
        {
            SetVariableOverrideAndNotify(PropertyGuid, true);
        }
        return bSuccess;
    }
 
private:
 
    UPROPERTY(EditAnywhere, Category = "Dataflow", meta = (FixedLayout, ShowOnlyInnerProperties))
    FInstancedPropertyBag Variables;
 
    UPROPERTY()
    TArray<FGuid> OverriddenVariableGuids;
 
    FDataflowInstance* Owner = nullptr;
};
 
USTRUCT()
struct FDataflowInstance
{
    GENERATED_USTRUCT_BODY();
 
    DATAFLOWENGINE_API explicit FDataflowInstance(UObject* InOwner = nullptr, UDataflow* InDataflowAsset = nullptr, FName InTerminalNodeName = NAME_None);
    DATAFLOWENGINE_API ~FDataflowInstance();
 
public:
    DATAFLOWENGINE_API void SetDataflowAsset(UDataflow* DataflowAsset);
 
    DATAFLOWENGINE_API UDataflow* GetDataflowAsset() const;
 
    DATAFLOWENGINE_API void SetDataflowTerminal(FName TerminalNodeName);
 
    DATAFLOWENGINE_API FName GetDataflowTerminal() const;
 
    DATAFLOWENGINE_API const FInstancedPropertyBag& GetVariables() const;
 
    DATAFLOWENGINE_API FInstancedPropertyBag& GetVariables();
 
    DATAFLOWENGINE_API static FName GetDataflowTerminalPropertyName();
 
    DATAFLOWENGINE_API static FName GetDataflowAssetPropertyName();
 
    DATAFLOWENGINE_API static FName GetVariableOverridesPropertyName();
 
    DATAFLOWENGINE_API const FDataflowVariableOverrides& GetVariableOverrides() const;
 
    DATAFLOWENGINE_API FDataflowVariableOverrides& GetVariableOverrides();
 
    DATAFLOWENGINE_API void SyncVariables();
 
    DATAFLOWENGINE_API bool UpdateOwnerAsset(bool bUpdateDependentAssets = false) const;
 
#if WITH_EDITOR
    DATAFLOWENGINE_API TSharedPtr<FStructOnScope> MakeStructOnScope() const;
#endif 
 
private:
    UPROPERTY(EditAnywhere, Category = "Dataflow")
    TObjectPtr<UDataflow> DataflowAsset;
 
    UPROPERTY(EditAnywhere, Category = "Dataflow")
    FName DataflowTerminal;
 
    UPROPERTY(EditAnywhere, Category = "Dataflow", meta=(ShowOnlyInnerProperties))
    FDataflowVariableOverrides VariableOverrides;
 
private:
    friend class UE::Dataflow::Private::FVariablesOverridesDetails;
 
#if WITH_EDITOR
    void OnOwnerPostEditChangeProperty(UObject* InObject, struct FPropertyChangedEvent& InPropertyChangedEvent);
 
    FDelegateHandle OnOwnerPropertyChangedHandle;
#endif
 
    // Owning Object
    UPROPERTY()
    TObjectPtr<UObject> Owner = nullptr;
};
 
UINTERFACE(MinimalAPI)
class UDataflowInstanceInterface : public UInterface
{
    GENERATED_BODY()
};
 
class IDataflowInstanceInterface
{
    GENERATED_BODY()
 
public:
    virtual const FDataflowInstance& GetDataflowInstance() const = 0;
    virtual FDataflowInstance& GetDataflowInstance() = 0;
};
 
namespace UE::Dataflow::InstanceUtils
{
    DATAFLOWENGINE_API bool HasValidDataflowAsset(UObject* Obj);
 
    DATAFLOWENGINE_API UDataflow* GetDataflowAssetFromObject(UObject* Obj);
 
    DATAFLOWENGINE_API const UDataflow* GetDataflowAssetFromObject(const UObject* Obj);
 
    DATAFLOWENGINE_API FName GetTerminalNodeNameFromObject(UObject* Obj);
 
    DATAFLOWENGINE_API TArray<FName> GetTerminalNodeNames(const UDataflow* DataflowAsset);
}