InterchangeFactoryBase.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "InterchangeResultsContainer.h"
#include "InterchangeTaskSystem.h"
#include "Nodes/InterchangeFactoryBaseNode.h"
#include "UObject/Class.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/SoftObjectPath.h"
 
#include "InterchangeFactoryBase.generated.h"
 
class ULevel;
class UInterchangeBaseNodeContainer;
class UInterchangePipelineBase;
class UInterchangeSourceData;
class UInterchangeTranslatorBase;
 
UENUM(BlueprintType)
enum class EInterchangeFactoryAssetType : uint8
{
    None = 0,
    Textures,
    Materials,
    Meshes,
    Animations,
    Physics,
    Grooms,
    Sounds
};
 
class FInterchangePostImportTask
{
public:
    virtual void Execute() {};
};
 
UCLASS(BlueprintType, Blueprintable, Abstract, MinimalAPI)
class UInterchangeFactoryBase : public UObject
{
    GENERATED_BODY()
public:
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Factory")
    virtual UClass* GetFactoryClass() const
    {
        return nullptr;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Factory")
    virtual EInterchangeFactoryAssetType GetFactoryAssetType() { return EInterchangeFactoryAssetType::None; }
 
    struct FImportAssetObjectParams
    {
        UObject* Parent = nullptr;
 
        FString AssetName = FString();
 
        UInterchangeFactoryBaseNode* AssetNode = nullptr;
 
        const UInterchangeTranslatorBase* Translator = nullptr;
 
        const UInterchangeSourceData* SourceData = nullptr;
 
        const UInterchangeBaseNodeContainer* NodeContainer = nullptr;
 
        UObject* ReimportObject = nullptr;
    };
 
    struct FImportAssetResult
    {
        //If the factory sets this to true, the Interchange task import object should skip this asset.
        //An asset can be skipped if it already exists and the factory isn't doing a reimport. For example, if we import a static mesh and we find an existing material.
        //We don't want to override the material in this case because the UE material often contains content related to gameplay.
        bool bIsFactorySkipAsset = false;
        //Return the UObject imported or reimported by the factory, or leave it set to nullptr if there was an error.
        UObject* ImportedObject = nullptr;
    };
 
    UE_DEPRECATED(5.3, "This function is replaced by BeginImportAsset_GameThread.")
    virtual UObject* ImportAssetObject_GameThread(const FImportAssetObjectParams& Arguments)
    {
        return nullptr;
    }
 
    virtual void CreatePayloadTasks(const FImportAssetObjectParams& Arguments, bool bAsync, TArray<TSharedPtr<UE::Interchange::FInterchangeTaskBase>>& PayloadTasks)
    {
        return;
    }
 
    virtual FImportAssetResult BeginImportAsset_GameThread(const FImportAssetObjectParams& Arguments)
    {
        FImportAssetResult ImportAssetResult;
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        ImportAssetResult.ImportedObject = ImportAssetObject_GameThread(Arguments);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
        return ImportAssetResult;
    }
 
    UE_DEPRECATED(5.3, "This function is replaced by ImportAsset_Async.")
    virtual UObject* ImportAssetObject_Async(const FImportAssetObjectParams& Arguments)
    {
        //By default simply return the UObject created by BeginImportAsset_GameThread that was store in the asset node.
        FSoftObjectPath ReferenceObject;
        if (Arguments.AssetNode && Arguments.AssetNode->GetCustomReferenceObject(ReferenceObject))
        {
            return ReferenceObject.TryLoad();
        }
        return nullptr;
    }
 
    virtual FImportAssetResult ImportAsset_Async(const FImportAssetObjectParams& Arguments)
    {
        FImportAssetResult ImportAssetResult;
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        ImportAssetResult.ImportedObject = ImportAssetObject_Async(Arguments);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
        return ImportAssetResult;
    }
 
    virtual FImportAssetResult EndImportAsset_GameThread(const FImportAssetObjectParams& Arguments)
    {
        FImportAssetResult ImportAssetResult;
        //By default simply return the UObject created by BeginImportAssetObject_GameThread that was store in the asset node.
        FSoftObjectPath ReferenceObject;
        if (Arguments.AssetNode && Arguments.AssetNode->GetCustomReferenceObject(ReferenceObject))
        {
            ImportAssetResult.ImportedObject = ReferenceObject.TryLoad();
        }
        return ImportAssetResult;
    }
 
    struct FImportSceneObjectsParams
    {
        ULevel* Level = nullptr;
 
        FString ObjectName;
 
        UInterchangeFactoryBaseNode* FactoryNode = nullptr;
 
        const UInterchangeBaseNodeContainer* NodeContainer = nullptr;
 
        const UInterchangeSourceData* SourceData = nullptr;
 
        UObject* ReimportObject = nullptr;
 
        const UInterchangeFactoryBaseNode* ReimportFactoryNode = nullptr;
 
        TArray<TObjectPtr<UObject>> ImportAssets;
 
        bool bIsReimport = false;
 
        /*
         * This represent the async helper unique id in case a factory need to retrieve the asynchelper associate to the import task
         * 
         * TODO create a base class for FAsyncHelper in Interchange/Core so we can reference it here instead of using the unique identifier.
         * The asynchelper is currently declare in Interchange/Engine so we can't refer to it here.
         */
        int32 AsyncHelperUid = INDEX_NONE;
    };
 
    virtual UObject* ImportSceneObject_GameThread(const FImportSceneObjectsParams& Arguments)
    {
        return nullptr;
    }
 
    virtual void Cancel() {}
 
    struct FSetupObjectParams
    {
        const UInterchangeSourceData* SourceData = nullptr;
        UInterchangeFactoryBaseNode* FactoryNode = nullptr;
 
 
        UObject* ImportedObject = nullptr;
        FString NodeUniqueID;
        UInterchangeBaseNodeContainer* NodeContainer = nullptr;
        TArray<UInterchangePipelineBase*> Pipelines;
        TArray<UObject*> OriginalPipelines;
        UInterchangeTranslatorBase* Translator;
        
        bool bIsReimport  = false;
    };
 
    /*
     * Do any UObject setup required before the build and after all dependency UObjects have been imported.
     * @note - This function is called when starting the pre-completion task (before asset build is called for the asset).
     */
    virtual void SetupObject_GameThread(const FSetupObjectParams& Arguments)
    {
        check(IsInGameThread());
    }
 
    /*
     * Build the asset if it can be built.
     * 
     * @Param Arguments - The setup object data.
     * @Param OutPostEditchangeCalled - Set it to true if your implementation has called PostEditChange. Set it to false, interchange will call PostEditChange at the end of the import.
     * @note - This function is called when starting the pre-completion task.
     * @note - The default implementation for asset that do not have any build step is to call PostEditChange and set OutPostEditchangeCalled to true.
     */
    virtual void BuildObject_GameThread(const FSetupObjectParams& Arguments, bool& OutPostEditchangeCalled)
    {
        check(IsInGameThread());
#if WITH_EDITOR
        if (Arguments.ImportedObject)
        {
            Arguments.ImportedObject->PostEditChange();
            OutPostEditchangeCalled = true;
        }
#endif //WITH_EDITOR
    }
 
    /*
     * Do any final UObject setup after the asset is built
     * @note - This function is called after asset is built in FTaskWaitAssetCompilation
     */
    virtual void FinalizeObject_GameThread(const FSetupObjectParams& Arguments)
    {
        check(IsInGameThread());
    }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Factory")
    virtual bool GetSourceFilenames(const UObject* Object, TArray<FString>& OutSourceFilenames) const
    {
        return false;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Factory")
    virtual bool SetSourceFilename(const UObject* Object, const FString& SourceFilename, int32 SourceIndex) const
    {
        return false;
    }
 
    virtual void BackupSourceData(const UObject* Object) const
    {
    }
 
    virtual void ReinstateSourceData(const UObject* Object) const
    {
    }
 
    virtual void ClearBackupSourceData(const UObject* Object) const
    {
    }
 
    virtual bool SetReimportSourceIndex(const UObject* Object, int32 SourceIndex) const
    {
        return false;
    }
 
    template <typename T>
    T* AddMessage()
    {
        check(Results != nullptr);
        T* Item = Results->Add<T>();
        return Item;
    }
 
 
    void AddMessage(UInterchangeResult* Item)
    {
        check(Results != nullptr);
        Results->Add(Item);
    }
 
 
    void SetResultsContainer(UInterchangeResultsContainer* InResults)
    {
        Results = InResults;
    }
 
    void PreResetObjectProperties(const UInterchangeBaseNodeContainer* BaseNodeContainer, UInterchangeFactoryBaseNode* FactoryNode, UObject* ImportedObject)
    {
        // Restore delegates and force make the re-import strategy to apply pipeline properties.
        FactoryNode->RestoreAllCustomAttributeDelegates();
        
        ExecutePreResetObjectProperties(BaseNodeContainer, FactoryNode, ImportedObject);
    }
 
    void ResetObjectProperties(const UInterchangeBaseNodeContainer* BaseNodeContainer, UInterchangeFactoryBaseNode* FactoryNode, UObject* ImportedObject)
    {
        // Force use of ApplyPipelineProperties Reimport Strategy to apply attributes through the attribute delegates.
        EReimportStrategyFlags CachedReimportStrategyFlags = FactoryNode->GetReimportStrategyFlags();
        FactoryNode->SetReimportStrategyFlags(EReimportStrategyFlags::ApplyPipelineProperties);
        
        ExecuteResetObjectProperties(BaseNodeContainer, FactoryNode, ImportedObject);
        
        // Restore Previous State
        FactoryNode->SetReimportStrategyFlags(CachedReimportStrategyFlags);
    }
 
    void PostResetObjectProperties(const UInterchangeBaseNodeContainer* BaseNodeContainer, UInterchangeFactoryBaseNode* FactoryNode, UObject* ImportedObject)
    {
        ExecutePostResetObjectProperties(BaseNodeContainer, FactoryNode, ImportedObject);       
        FactoryNode->RemoveAllCustomAttributeDelegates();
    }
 
    virtual UObject* GetObjectToReimport(UObject* ReimportObject, const UInterchangeFactoryBaseNode& FactoryNode, const FString& PackageName, const FString& AssetName, const FString& SubPathString)
    {
        return ReimportObject;
    }
 
protected:
 
    virtual void ExecutePreResetObjectProperties(const UInterchangeBaseNodeContainer* BaseNodeContainer, UInterchangeFactoryBaseNode* FactoryNode, UObject* ImportedObject)
    {
    }
 
    virtual void ExecuteResetObjectProperties(const UInterchangeBaseNodeContainer* BaseNodeContainer, UInterchangeFactoryBaseNode* FactoryNode, UObject* ImportedObject)
    {
        FactoryNode->ApplyAllCustomAttributeToObject(ImportedObject);
    }
 
    virtual void ExecutePostResetObjectProperties(const UInterchangeBaseNodeContainer* BaseNodeContainer, UInterchangeFactoryBaseNode* FactoryNode, UObject* ImportedObject)
    {
    }
 
public:
    UPROPERTY()
    TObjectPtr<UInterchangeResultsContainer> Results;
};