InterchangeAssetImportData.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "EditorFramework/AssetImportData.h"
#include "InterchangeTranslatorBase.h"
#include "Nodes/InterchangeBaseNode.h"
#include "Nodes/InterchangeBaseNodeContainer.h"
#include "UObject/AssetRegistryTagsContext.h"
#include "UObject/Class.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
 
#include "InterchangeAssetImportData.generated.h"
 
class UInterchangePipelineBase;
 
UCLASS(BlueprintType, MinimalAPI)
class UInterchangeAssetImportData : public UAssetImportData
{
    GENERATED_BODY()
public:
    // Begin UObject interface
    virtual void PostLoad() override;
    virtual void Serialize(FArchive& Ar) override;
    // End UObject interface
 
#if WITH_EDITOR
    INTERCHANGEENGINE_API  virtual bool ConvertAssetImportDataToNewOwner(UObject* Owner) override;
#endif
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | AssetImportData")
    FString ScriptGetFirstFilename() const
    {
        //TODO make sure this work at runtime
#if WITH_EDITORONLY_DATA
        return GetFirstFilename();
#else
        return FString();
#endif
    }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | AssetImportData")
    TArray<FString> ScriptExtractFilenames() const
    {
        //TODO make sure this work at runtime
#if WITH_EDITORONLY_DATA
        return ExtractFilenames();
#else
        return TArray<FString>();
#endif
    }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | AssetImportData")
    TArray<FString> ScriptExtractDisplayLabels() const
    {
        TArray<FString> TempDisplayLabels;
        //TODO make sure this work at runtime
#if WITH_EDITORONLY_DATA
        ExtractDisplayLabels(TempDisplayLabels);
#endif
        return TempDisplayLabels;
    }
 
#if WITH_EDITORONLY_DATA
#if WITH_EDITOR
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    virtual void AppendAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) override
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS;
        Super::AppendAssetRegistryTags(OutTags);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS;
    }
 
    virtual void AppendAssetRegistryTags(FAssetRegistryTagsContext Context) override
    {
        if(const UInterchangeBaseNodeContainer* NodeContainerTmp = GetNodeContainer())
        {
            if (NodeContainerTmp->IsNodeUidValid(NodeUniqueID))
            {
                if (const UInterchangeBaseNode* Node = GetStoredNode(NodeUniqueID))
                {
                    PRAGMA_DISABLE_DEPRECATION_WARNINGS;
                    TArray<UObject::FAssetRegistryTag> DeprecatedFunctionTags;
                    Node->AppendAssetRegistryTags(DeprecatedFunctionTags);
                    for (UObject::FAssetRegistryTag& Tag : DeprecatedFunctionTags)
                    {
                        Context.AddTag(MoveTemp(Tag));
                    }
                    PRAGMA_ENABLE_DEPRECATION_WARNINGS;
                    Node->AppendAssetRegistryTags(Context);
                }
            }
        }
        Super::AppendAssetRegistryTags(Context);
    }
#endif
#endif
 
    UPROPERTY(EditAnywhere, Category = "Interchange | AssetImportData")
    FSoftObjectPath SceneImportAsset;
 
    static UInterchangeAssetImportData* GetFromObject(UObject* Object)
    {
        if (Object)
        {
            TArray<UObject*> SubObjects;
            GetObjectsWithOuter(Object, SubObjects);
            for (UObject* SubObject : SubObjects)
            {
                if (UInterchangeAssetImportData* AssetImportData = Cast<UInterchangeAssetImportData>(SubObject))
                {
                    return AssetImportData;
                }
            }
        }
 
        return nullptr;
    }
 
    UPROPERTY(VisibleAnywhere, Category = "Interchange | AssetImportData")
    FString NodeUniqueID;
 
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | AssetImportData")
    INTERCHANGEENGINE_API UInterchangeBaseNodeContainer* GetNodeContainer() const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | AssetImportData")
    INTERCHANGEENGINE_API void SetNodeContainer(UInterchangeBaseNodeContainer* InNodeContainer) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | AssetImportData")
    INTERCHANGEENGINE_API TArray<UObject*> GetPipelines() const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | AssetImportData")
    INTERCHANGEENGINE_API int32 GetNumberOfPipelines() const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | AssetImportData")
    INTERCHANGEENGINE_API void SetPipelines(const TArray<UObject*>& InPipelines);
 
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | AssetImportData")
    INTERCHANGEENGINE_API const UInterchangeBaseNode* GetStoredNode(const FString& InNodeUniqueId) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | AssetImportData")
    INTERCHANGEENGINE_API UInterchangeFactoryBaseNode* GetStoredFactoryNode(const FString& InNodeUniqueId) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | AssetImportData")
    INTERCHANGEENGINE_API const UInterchangeTranslatorSettings* GetTranslatorSettings() const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | AssetImportData")
    INTERCHANGEENGINE_API void SetTranslatorSettings(UInterchangeTranslatorSettings* TranslatorSettings) const;
 
    INTERCHANGEENGINE_API void BackupSourceData() const;
    INTERCHANGEENGINE_API void ClearBackupSourceData() const;
    INTERCHANGEENGINE_API void ReinstateBackupSourceData();
 
private:
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Use GetNodeContainer/SetNodeContainer instead."))
    TObjectPtr<UInterchangeBaseNodeContainer> NodeContainer_DEPRECATED;
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Use GetPipelines/SetPipelines instead."))
    TArray<TObjectPtr<UObject>> Pipelines_DEPRECATED;
 
    UPROPERTY(Transient)
    mutable TObjectPtr<UInterchangeBaseNodeContainer> TransientNodeContainer;
 
    UPROPERTY(Transient)
    mutable TArray<TObjectPtr<UObject>> TransientPipelines;
 
    UPROPERTY(Transient)
    mutable TObjectPtr<UInterchangeTranslatorSettings> TransientTranslatorSettings;
 
    void ProcessContainerCache() const;
    void ProcessPipelinesCache() const;
    void ProcessDeprecatedData() const;
    void ProcessTranslatorCache() const;
    mutable TArray64<uint8> CachedNodeContainer;
    mutable TArray<TPair<FString, FString>> CachedPipelines; //Class, Data(serialized JSON) pair
    mutable FCustomVersionContainer CachedCustomVersions; // Custom versions of the archive we deserialized from, to help us deserialize our cached data
    mutable TPair<FString, FString> CachedTranslatorSettings;
 
#if WITH_EDITORONLY_DATA
    mutable FAssetImportInfo SourceDataBackup;
#endif
    // #todo_interchange: TODO: Move to as a IntercnageManager utility method
    static TMap<FString, UClass*> GetPipelineClassPerName();
};
 
UCLASS(Abstract, MinimalAPI)
class UInterchangeAssetImportDataConverterBase : public UObject
{
    GENERATED_BODY()
public:
 
    /* Converter must return which class they can convert to and from UInterchangeAssetImportData. */
    virtual bool CanConvertClass(const UClass* SourceClass, const UClass* DestinationClass) const { return false; }
 
    virtual bool ConvertImportData(UObject* Asset, const FString& TargetExtension) const
    {
        return false;
    }
 
    virtual bool ConvertImportData(const UObject* SourceImportData, const UClass* DestinationClass, UObject** DestinationImportData) const
    {
        return false;
    }
};