DataflowContent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "DataflowContextObject.h"
#include "UObject/Interface.h"
#include "Templates/SharedPointer.h"
#include "GameFramework/Actor.h"
#include "DataflowContent.generated.h"
 
#define UE_API DATAFLOWENGINE_API
 
 
class FDataflowEditorToolkit;
class USkeletalMesh;
class USkeleton;
class USkeletalMeshComponent;
class UAnimationAsset;
class UDataflowBaseContent;
class FPreviewScene;
class UAnimSingleNodeInstance;
 
namespace UE::DataflowContextHelpers
{
    // Return a new(or saved) content that can store the execution state of the graph. 
    template<class T>
    DATAFLOWENGINE_API TObjectPtr<T> CreateNewDataflowContent(const TObjectPtr<UObject>& ContentOwner);
}
 
UINTERFACE(MinimalAPI)
class UDataflowContentOwner : public UInterface
{
    GENERATED_BODY()
};
 
class IDataflowContentOwner
{
public:
 
    GENERATED_BODY()
 
    
    UE_API TObjectPtr<UDataflowBaseContent> BuildDataflowContent();
 
    DECLARE_MULTICAST_DELEGATE(FOnContentOwnerChanged);
 
    FOnContentOwnerChanged OnContentOwnerChanged;
 
    void InvalidateDataflowContents() const
    {
        OnContentOwnerChanged.Broadcast();
    }
    
    virtual void WriteDataflowContent(const TObjectPtr<UDataflowBaseContent>& DataflowContent) const = 0;
 
    virtual void ReadDataflowContent(const TObjectPtr<UDataflowBaseContent>& DataflowContent) = 0;
    
protected :
 
    virtual TObjectPtr<UDataflowBaseContent> CreateDataflowContent() = 0;
};
 
UCLASS(MinimalAPI)
class UDataflowBaseContent : public UDataflowContextObject
{
    GENERATED_BODY()
 
public:
    UE_API UDataflowBaseContent();
    UE_API ~UDataflowBaseContent();
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnContentDataChanged, TObjectPtr<AActor>& SimulationActor);
 
    FOnContentDataChanged OnContentDataChanged;
 
    bool IsConstructionDirty() const { return bIsConstructionDirty; }
    UE_API void SetConstructionDirty(bool InDirty);
    
    bool IsSimulationDirty() const { return bIsSimulationDirty; }
    UE_API void SetSimulationDirty(bool InDirty);
 
    UE_API void SetLastModifiedTimestamp(UE::Dataflow::FTimestamp InTimestamp, bool bMakeDirty =true);
    const UE::Dataflow::FTimestamp& GetLastModifiedTimestamp() const { return LastModifiedTimestamp; }
 
    UE_API virtual void SetDataflowContext(const TSharedPtr<UE::Dataflow::FEngineContext>& InContext) override;
 
    UE_API void UpdateContentDatas();
 
    virtual void AddContentObjects(FReferenceCollector& Collector) {}
 
    UE_API virtual void SetActorProperties(TObjectPtr<AActor>& PreviewActor) const;
    
    UE_API void SetDataflowOwner(const TObjectPtr<UObject>& InOwner);
    UE_API TObjectPtr<UObject> GetDataflowOwner() const;
    
    UE_API virtual void SetDataflowAsset(const TObjectPtr<UDataflow>& InAsset) override;
 
    void SetDataflowTerminal(const FString& InPath) { DataflowTerminal = InPath;  SetConstructionDirty(true); SetSimulationDirty(true);}
    const FString& GetDataflowTerminal() const { return DataflowTerminal; }
 
    void SetTerminalAsset(const TObjectPtr<UObject>& InAsset) { TerminalAsset = InAsset;  SetConstructionDirty(true); SetSimulationDirty(true);}
    const TObjectPtr<UObject>& GetTerminalAsset() const { return TerminalAsset;}
 
    void SetPreviewClass(const TSubclassOf<AActor>& InPreviewClass) { PreviewClass = InPreviewClass;  SetConstructionDirty(true); SetSimulationDirty(true);}
    const TSubclassOf<AActor>& GetPreviewClass() const { return PreviewClass;}
 
    UE_API virtual void Serialize(FArchive& Ar);
 
    /* Context cache saving */
    bool IsSaved() const { return bIsSaved; }
    void SetIsSaved(bool bInSaved) { bIsSaved = bInSaved; }
 
    //~ UObject interface
    static UE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
 
#if WITH_EDITOR
    UE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif //if WITH_EDITOR
 
protected:
    
    UPROPERTY(Transient, SkipSerialization)
    FString DataflowTerminal = "";
    
    UPROPERTY(Transient, SkipSerialization)
    TObjectPtr<UObject> TerminalAsset = nullptr;
 
    UE::Dataflow::FTimestamp LastModifiedTimestamp = UE::Dataflow::FTimestamp::Invalid;
 
    UPROPERTY()
    bool bIsConstructionDirty = true;
 
    UPROPERTY()
    bool bIsSimulationDirty = true;
 
    bool bIsSaved = false;
 
    TSubclassOf<AActor> PreviewClass;
 
    static UE_API void OverrideActorProperty(const TObjectPtr<AActor>& PreviewActor, TObjectPtr<UObject> PropertyValue, const FName& PropertyName);
 
    template<typename StructType>
    static void OverrideStructProperty(const TObjectPtr<AActor>& PreviewActor, const StructType& PropertyValue, const FName& PropertyName);
};
 
template<typename StructType>
void UDataflowBaseContent::OverrideStructProperty(const TObjectPtr<AActor>& PreviewActor, const StructType& PropertyValue, const FName& PropertyName)
{
    if(PreviewActor)
    {
        if(const FProperty* DataflowProperty = PreviewActor->GetClass()->FindPropertyByName(PropertyName))
        {
            if (const FStructProperty* StructProperty = CastField<FStructProperty>(DataflowProperty))
            {
                if(StructProperty->Struct == StructType::StaticStruct())
                {
                    if(StructType* PropertyStruct = DataflowProperty->ContainerPtrToValuePtr<StructType>(PreviewActor))
                    {
                        (*PropertyStruct) = PropertyValue;
                    }
                }
            }
        }
    }
}
 
UCLASS(MinimalAPI)
class  UDataflowSkeletalContent : public UDataflowBaseContent
{
    GENERATED_BODY()
 
public:
    UE_API UDataflowSkeletalContent();
    virtual ~UDataflowSkeletalContent() override{}
    
#if WITH_EDITOR
    UE_API virtual bool CanEditChange(const FProperty* InProperty) const override;
    UE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif //if WITH_EDITOR
 
    UE_API virtual void AddContentObjects(FReferenceCollector& Collector) override;
 
    UE_API void SetSkeletalMesh(const TObjectPtr<USkeletalMesh>& InMesh, const bool bHideAsset = false);
    const TObjectPtr<USkeletalMesh>& GetSkeletalMesh() const { return SkeletalMesh; }
 
    UE_API void SetAnimationAsset(const TObjectPtr<UAnimationAsset>& InAnimation, const bool bHideAsset = false);
    const TObjectPtr<UAnimationAsset>& GetAnimationAsset() const { return AnimationAsset; }
 
    //~ UObject interface
    static UE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
 
    UE_API virtual void SetActorProperties(TObjectPtr<AActor>& PreviewActor) const override;
 
protected:
 
    UPROPERTY(EditAnywhere, Category = "Preview", Transient, SkipSerialization)
    TObjectPtr<USkeletalMesh> SkeletalMesh = nullptr;
 
    UPROPERTY(EditAnywhere, Category = "Preview", Transient, SkipSerialization)
    TObjectPtr<UAnimationAsset> AnimationAsset = nullptr;
 
    bool bHideSkeletalMesh = false;
 
    bool bHideAnimationAsset = false;
};
 
#undef UE_API