InterchangeBaseNode.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/StringFwd.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "HAL/PlatformCrt.h"
#include "Math/Color.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Guid.h"
#include "Misc/TVariant.h"
#include "Nodes/InterchangeBaseNodeUtilities.h"
#include "Templates/SharedPointer.h"
#include "Types/AttributeStorage.h"
#include "UObject/AssetRegistryTagsContext.h"
#include "UObject/Class.h"
#include "UObject/Field.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/SoftObjectPath.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/UnrealType.h"
 
#include "InterchangeBaseNode.generated.h"
 
class FArchive;
class FAssetRegistryTagsContext;
class UInterchangeBaseNode;
class UInterchangeBaseNodeContainer;
struct FFrame;
 
namespace InterchangePrivateNodeBase
{
    template<typename ValueType>
    bool GetCustomAttribute(const UE::Interchange::FAttributeStorage& Attributes, const UE::Interchange::FAttributeKey& AttributeKey, const FString& OperationName, ValueType& OutAttributeValue)
    {
        if (!Attributes.ContainAttribute(AttributeKey))
        {
            return false;
        }
        UE::Interchange::FAttributeStorage::TAttributeHandle<ValueType> AttributeHandle = Attributes.GetAttributeHandle<ValueType>(AttributeKey);
        if (!AttributeHandle.IsValid())
        {
            return false;
        }
        UE::Interchange::EAttributeStorageResult Result = AttributeHandle.Get(OutAttributeValue);
        if (!UE::Interchange::IsAttributeStorageResultSuccess(Result))
        {
            UE::Interchange::LogAttributeStorageErrors(Result, OperationName, AttributeKey);
            return false;
        }
        return true;
    }
 
    template<typename ValueType>
    bool SetCustomAttribute(UE::Interchange::FAttributeStorage& Attributes, const UE::Interchange::FAttributeKey& AttributeKey, const FString& OperationName, const ValueType& AttributeValue)
    {
        UE::Interchange::EAttributeStorageResult Result = Attributes.RegisterAttribute(AttributeKey, AttributeValue);
        if (!UE::Interchange::IsAttributeStorageResultSuccess(Result))
        {
            UE::Interchange::LogAttributeStorageErrors(Result, OperationName, AttributeKey);
            return false;
        }
        return true;
    }
 
    INTERCHANGECORE_API FProperty* FindPropertyByPathChecked(TVariant<UObject*, uint8*>& Container, UStruct* Outer, FStringView PropertyPath);
}
 
#define IMPLEMENT_NODE_ATTRIBUTE_KEY(AttributeName)                                                                             \
const UE::Interchange::FAttributeKey Macro_Custom##AttributeName##Key = UE::Interchange::FAttributeKey(TEXT(#AttributeName));
 
 
#define IMPLEMENT_NODE_ATTRIBUTE_GETTER(AttributeName, AttributeType)                                                                                   \
    FString OperationName = GetTypeName() + TEXT(".Get" #AttributeName);                                                                                \
    return InterchangePrivateNodeBase::GetCustomAttribute<AttributeType>(*Attributes, Macro_Custom##AttributeName##Key, OperationName, AttributeValue);
 
#define IMPLEMENT_NODE_ATTRIBUTE_SETTER_NODELEGATE(AttributeName, AttributeType)                                                                        \
    FString OperationName = GetTypeName() + TEXT(".Set" #AttributeName);                                                                                \
    return InterchangePrivateNodeBase::SetCustomAttribute<AttributeType>(*Attributes, Macro_Custom##AttributeName##Key, OperationName, AttributeValue);
 
 
#define INTERCHANGE_BASE_NODE_ADD_ATTRIBUTE(ValueType)                                                                                                              \
    UE::Interchange::FAttributeStorage::TAttributeHandle<ValueType> Handle = RegisterAttribute<ValueType>(UE::Interchange::FAttributeKey(NodeAttributeKey), Value); \
    return Handle.IsValid();
 
#define INTERCHANGE_BASE_NODE_GET_ATTRIBUTE(ValueType)                                                                                          \
    if(HasAttribute(UE::Interchange::FAttributeKey(NodeAttributeKey)))                                                                          \
    {                                                                                                                                           \
        UE::Interchange::FAttributeStorage::TAttributeHandle<ValueType> Handle = GetAttributeHandle<ValueType>(UE::Interchange::FAttributeKey(NodeAttributeKey));   \
        if (Handle.IsValid())                                                                                                                   \
        {                                                                                                                                       \
            return (Handle.Get(OutValue) == UE::Interchange::EAttributeStorageResult::Operation_Success);                                       \
        }                                                                                                                                       \
    }                                                                                                                                           \
    return false;
 
//Interchange namespace
namespace UE::Interchange
{
    struct FBaseNodeStaticData
    {
        static INTERCHANGECORE_API const FAttributeKey& UniqueIDKey();
        static INTERCHANGECORE_API const FAttributeKey& DisplayLabelKey();
        static INTERCHANGECORE_API const FAttributeKey& NamespaceKey();
        static INTERCHANGECORE_API const FAttributeKey& ParentIDKey();
        static INTERCHANGECORE_API const FAttributeKey& DesiredChildIndexKey();
        static INTERCHANGECORE_API const FAttributeKey& IsEnabledKey();
        static INTERCHANGECORE_API const FAttributeKey& TargetAssetIDsKey();
        static INTERCHANGECORE_API const FAttributeKey& ClassTypeAttributeKey();
        static INTERCHANGECORE_API const FAttributeKey& AssetNameKey();
        static INTERCHANGECORE_API const FAttributeKey& NodeContainerTypeKey();
    };
 
} //ns UE::Interchange
 
UENUM(BlueprintType)
enum class EInterchangeNodeContainerType : uint8
{
    None,
    TranslatedScene,
    TranslatedAsset,
    FactoryData
};
 
UENUM(BlueprintType)
enum class EInterchangeNodeUserInterfaceContext : uint8
{
    None,
    Preview //When we want to preview the node data. A preview is normally read-only and should not show internal data.
};
 
UCLASS(BlueprintType, MinimalAPI)
class UInterchangeBaseNode : public UObject
{
    GENERATED_BODY()
 
public:
    static constexpr const TCHAR* HierarchySeparator = TEXT("\\");
 
    INTERCHANGECORE_API UInterchangeBaseNode();
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API void InitializeNode(const FString& UniqueID, const FString& DisplayLabel, const EInterchangeNodeContainerType NodeContainerType);
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API virtual FString GetTypeName() const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API virtual FName GetIconName() const;
 
#if WITH_EDITOR
    INTERCHANGECORE_API virtual FString GetKeyDisplayName(const UE::Interchange::FAttributeKey& NodeAttributeKey) const;
 
    INTERCHANGECORE_API virtual bool ShouldHideAttribute(const UE::Interchange::FAttributeKey& NodeAttributeKey) const;
 
    INTERCHANGECORE_API virtual FString GetAttributeCategory(const UE::Interchange::FAttributeKey& NodeAttributeKey) const;
 
#endif //WITH_EDITOR
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(Transient, DuplicateTransient)
    EInterchangeNodeUserInterfaceContext UserInterfaceContext = EInterchangeNodeUserInterfaceContext::None;
#endif
 
    template<typename T>
    UE::Interchange::FAttributeStorage::TAttributeHandle<T> RegisterAttribute(const UE::Interchange::FAttributeKey& NodeAttributeKey, const T& Value)
    {
        const UE::Interchange::EAttributeStorageResult Result = Attributes->RegisterAttribute(NodeAttributeKey, Value);
        
        if (IsAttributeStorageResultSuccess(Result))
        {
            return Attributes->GetAttributeHandle<T>(NodeAttributeKey);
        }
        LogAttributeStorageErrors(Result, TEXT("RegisterAttribute"), NodeAttributeKey);
        return UE::Interchange::FAttributeStorage::TAttributeHandle<T>();
    }
 
    INTERCHANGECORE_API virtual bool HasAttribute(const UE::Interchange::FAttributeKey& NodeAttributeKey) const;
 
    INTERCHANGECORE_API virtual UE::Interchange::EAttributeTypes GetAttributeType(const UE::Interchange::FAttributeKey& NodeAttributeKey) const;
 
    template<typename T>
    UE::Interchange::FAttributeStorage::TAttributeHandle<T> GetAttributeHandle(const UE::Interchange::FAttributeKey& NodeAttributeKey) const
    {
        return Attributes->GetAttributeHandle<T>(NodeAttributeKey);
    }
 
    INTERCHANGECORE_API void GetAttributeKeys(TArray<UE::Interchange::FAttributeKey>& AttributeKeys) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool RemoveAttribute(const FString& NodeAttributeKey);
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool AddBooleanAttribute(const FString& NodeAttributeKey, const bool& Value);
    
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool GetBooleanAttribute(const FString& NodeAttributeKey, bool& OutValue) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool AddInt32Attribute(const FString& NodeAttributeKey, const int32& Value);
    
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool GetInt32Attribute(const FString& NodeAttributeKey, int32& OutValue) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool AddFloatAttribute(const FString& NodeAttributeKey, const float& Value);
    
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool GetFloatAttribute(const FString& NodeAttributeKey, float& OutValue) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool AddDoubleAttribute(const FString& NodeAttributeKey, const double& Value);
    
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool GetDoubleAttribute(const FString& NodeAttributeKey, double& OutValue) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool AddStringAttribute(const FString& NodeAttributeKey, const FString& Value);
    
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool GetStringAttribute(const FString& NodeAttributeKey, FString& OutValue) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool AddGuidAttribute(const FString& NodeAttributeKey, const FGuid& Value);
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool GetGuidAttribute(const FString& NodeAttributeKey, FGuid& OutValue) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool AddLinearColorAttribute(const FString& NodeAttributeKey, const FLinearColor& Value);
    
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool GetLinearColorAttribute(const FString& NodeAttributeKey, FLinearColor& OutValue) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool AddVector2Attribute(const FString& NodeAttributeKey, const FVector2f& Value);
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool GetVector2Attribute(const FString& NodeAttributeKey, FVector2f& OutValue) const;
 
    template<typename AttributeType>
    AttributeType GetAttributeChecked(const FString& NodeAttributeKey) const
    {
        AttributeType Value = AttributeType();
        check(HasAttribute(UE::Interchange::FAttributeKey(NodeAttributeKey)));
        UE::Interchange::FAttributeStorage::TAttributeHandle<AttributeType> Handle = GetAttributeHandle<AttributeType>(UE::Interchange::FAttributeKey(NodeAttributeKey));
        check(Handle.IsValid());
        check(Handle.Get(Value) == UE::Interchange::EAttributeStorageResult::Operation_Success);
        return Value;
    }
 
    template<typename AttributeType>
    bool GetAttribute(const FString& NodeAttributeKey, AttributeType& OutValue) const
    {
        INTERCHANGE_BASE_NODE_GET_ATTRIBUTE(AttributeType);
    }
    template<typename AttributeType>
    bool SetAttribute(const FString& NodeAttributeKey, const AttributeType& Value)
    {
        INTERCHANGE_BASE_NODE_ADD_ATTRIBUTE(AttributeType);
    }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API FString GetUniqueID() const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API FString GetDisplayLabel() const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool SetDisplayLabel(const FString& InDisplayLabel);
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool GetNamespace(FString& Namespace) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API FString GetParentUid() const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API int32 GetDesiredChildIndex() const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API int32 GetTargetNodeCount() const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API void GetTargetNodeUids(TArray<FString>& OutTargetAssets) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool AddTargetNodeUid(const FString& AssetUid) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool RemoveTargetNodeUid(const FString& AssetUid) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool IsEnabled() const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API bool SetEnabled(const bool bIsEnabled);
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API EInterchangeNodeContainerType GetNodeContainerType() const;
 
    INTERCHANGECORE_API virtual FGuid GetHash() const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API virtual FString GetAssetName() const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
    INTERCHANGECORE_API virtual bool SetAssetName(const FString& AssetName);
 
    static INTERCHANGECORE_API FString InvalidNodeUid();
 
    INTERCHANGECORE_API virtual void Serialize(FArchive& Ar) override;
 
    static INTERCHANGECORE_API void CompareNodeStorage(const UInterchangeBaseNode* NodeA, const UInterchangeBaseNode* NodeB, TArray<UE::Interchange::FAttributeKey>& RemovedAttributes, TArray<UE::Interchange::FAttributeKey>& AddedAttributes, TArray<UE::Interchange::FAttributeKey>& ModifiedAttributes);
    
    static INTERCHANGECORE_API void CopyStorageAttributes(const UInterchangeBaseNode* SourceNode, UInterchangeBaseNode* DestinationNode, const TArray<UE::Interchange::FAttributeKey>& AttributeKeys);
    static INTERCHANGECORE_API void CopyStorageAttributes(const UInterchangeBaseNode* SourceNode, UE::Interchange::FAttributeStorage& DestinationStorage, const TArray<UE::Interchange::FAttributeKey>& AttributeKeys);
    static INTERCHANGECORE_API void CopyStorageAttributes(const UE::Interchange::FAttributeStorage& SourceStorage, UInterchangeBaseNode* DestinationNode, const TArray<UE::Interchange::FAttributeKey>& AttributeKeys); 
    static INTERCHANGECORE_API void CopyStorageAttributes(const UInterchangeBaseNode* SourceNode, UE::Interchange::FAttributeStorage& DestinationStorage, const TArray<TPair<UE::Interchange::FAttributeKey, UE::Interchange::FAttributeKey>>& SrcDestAttributeKeys);
 
    static INTERCHANGECORE_API void CopyStorage(const UInterchangeBaseNode* SourceNode, UInterchangeBaseNode* DestinationNode);
    
    virtual void AppendAssetRegistryTags(FAssetRegistryTagsContext Context) const
    {
    }
 
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    virtual void AppendAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const
    {
    }
 
protected:
 
    bool SetNamespace(const FString& InNamespace);
 
    bool SetDesiredChildIndex(const int32& ChildIndex);
 
    bool SetParentUid(const FString& ParentUid);
 
    TSharedPtr<UE::Interchange::FAttributeStorage, ESPMode::ThreadSafe> Attributes;
 
    bool bIsInitialized = false;
 
    mutable UE::Interchange::TArrayAttributeHelper<FString> TargetNodes;
 
    friend UInterchangeBaseNodeContainer;
};