InterchangePipelineBase.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/UnrealString.h"
#include "CoreMinimal.h"
#include "HAL/Platform.h"
#include "InterchangeResultsContainer.h"
#include "InterchangeSourceData.h"
#include "Misc/AssertionMacros.h"
#include "Misc/OptionalFwd.h"
#include "Nodes/InterchangeBaseNodeContainer.h"
#include "Nodes/InterchangeFactoryBaseNode.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectPtr.h"
#include "UObject/UObjectGlobals.h"
#include "Widgets/SCompoundWidget.h"
#include "Widgets/SWindow.h"
 
#include "InterchangePipelineBase.generated.h"
 
class FText;
class UClass;
class UInterchangeBaseNodeContainer;
class UInterchangeResult;
class UInterchangeSourceData;
struct FFrame;
 
UENUM(BlueprintType)
enum class EInterchangePipelineTask : uint8
{
    PostTranslator,
    PostFactory,
    PostImport,
    Export
};
 
UENUM()
enum class EInterchangePipelineContext : uint8
{
    None, //Default pipeline instance we refer in the project settings pipeline stack. This context should allow editing of the properties states
    AssetImport,
    AssetReimport,
    SceneImport,
    SceneReimport,
    AssetCustomLODImport,
    AssetCustomLODReimport,
    AssetAlternateSkinningImport,
    AssetAlternateSkinningReimport,
    AssetCustomMorphTargetImport, //Import the content has a combine static mesh so we can add a custom morph target to a skeletal mesh
    AssetCustomMorphTargetReImport,
};
 
USTRUCT()
struct FInterchangePipelineContextParams
{
    GENERATED_BODY()
 
    UPROPERTY()
    EInterchangePipelineContext ContextType = EInterchangePipelineContext::None;
 
    UPROPERTY()
    TObjectPtr<UClass> ImportObjectType = nullptr;
 
    UPROPERTY()
    TObjectPtr<UObject> ReimportAsset = nullptr;
 
    UPROPERTY()
    TObjectPtr<const UInterchangeBaseNodeContainer> BaseNodeContainer = nullptr;
 
    friend FArchive& operator<<(FArchive& Ar, FInterchangePipelineContextParams& Params);
};
 
USTRUCT(BlueprintType)
struct FInterchangePipelinePropertyStatePerContext
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Property States")
    bool bVisible = true;
 
    friend FArchive& operator<<(FArchive& Ar, FInterchangePipelinePropertyStatePerContext& Params);
};
 
USTRUCT(BlueprintType)
struct FInterchangePipelinePropertyStates
{
    GENERATED_BODY()
 
    
    bool IsPropertyLocked() const
    {
        return bLocked;
    }
    
    void SetPropertyLocked(const bool bLockValue)
    {
        bLocked = bLockValue;
    }
 
    bool IsPropertyPreDialogReset() const
    {
        return bPreDialogReset;
    }
 
    void SetPropertyPreDialogReset(const bool bPreDialogResetValue)
    {
        bPreDialogReset = bPreDialogResetValue;
    }
 
 
    bool IsPropertyVisibleInShowEssentials() const
    {
        return BasicLayoutStates.bVisible;
    }
 
    bool IsPropertyVisible(const bool bIsReimportContext, const bool bIsShowEssentials) const
    {
        bool bVisible = bIsReimportContext ? ReimportStates.bVisible : ImportStates.bVisible;
        if (bVisible)
        {
            bVisible = bIsShowEssentials ? BasicLayoutStates.bVisible : true;
        }
        return bVisible;
    }
 
    void SetPropertyImportVisibility(const bool bVisibleValue)
    {
        ImportStates.bVisible = bVisibleValue;
    }
 
    void SetPropertyReimportVisibility(const bool bVisibleValue)
    {
        ReimportStates.bVisible = bVisibleValue;
    }
 
    void SetPropertyShowEssentialsVisibility(const bool bVisibleValue)
    {
        BasicLayoutStates.bVisible = bVisibleValue;
    }
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Property States")
    bool bLocked = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Property States")
    bool bPreDialogReset = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Context Properties States")
    FInterchangePipelinePropertyStatePerContext BasicLayoutStates;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Context Properties States")
    FInterchangePipelinePropertyStatePerContext ImportStates;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Context Properties States")
    FInterchangePipelinePropertyStatePerContext ReimportStates;
 
    friend FArchive& operator<<(FArchive& Ar, FInterchangePipelinePropertyStates& Params);
};
 
struct FInterchangeConflictInfo
{
    FString DisplayName;
    FString Description;
    FGuid UniqueId;
    TObjectPtr<UInterchangePipelineBase> Pipeline = nullptr;
    TSet<UClass*> AffectedAssetClasses;
};
 
class SInterchangeBaseConflictWidget : public SCompoundWidget
{
public:
    SLATE_BEGIN_ARGS(SInterchangeBaseConflictWidget)
        : _WidgetWindow(nullptr)
        {}
 
        SLATE_ARGUMENT(TSharedPtr<SWindow>, WidgetWindow)
 
    SLATE_END_ARGS()
 
    virtual void SetWidgetWindow(TSharedPtr<SWindow> InWidgetWindow)
    {
        WidgetWindow = InWidgetWindow;
    }
 
    FVector2D GetMinimumSize(float ApplicationScale) const
    {
        return ComputeDesiredSize(ApplicationScale);
    }
protected:
    TSharedPtr<SWindow> WidgetWindow = nullptr;
};
 
UCLASS(BlueprintType, Blueprintable, editinlinenew, Abstract, MinimalAPI)
class UInterchangePipelineBase : public UObject
{
    GENERATED_BODY()
 
public:
 
    UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Interchange | Pipeline")
    INTERCHANGECORE_API FString ScriptedGetPipelineDisplayName() const;
    FString ScriptedGetPipelineDisplayName_Implementation() const
    {
        //By default we call the virtual GetPipelineDisplayName
        return GetPipelineDisplayName();
    }
 
    UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Interchange | Pipeline")
    INTERCHANGECORE_API void ScriptedExecutePipeline(UInterchangeBaseNodeContainer* BaseNodeContainer, const TArray<UInterchangeSourceData*>& SourceDatas, const FString& ContentBasePath);
    void ScriptedExecutePipeline_Implementation(UInterchangeBaseNodeContainer* BaseNodeContainer, const TArray<UInterchangeSourceData*>& SourceDatas, const FString& ContentBasePath)
    {
        //By default we call the virtual import pipeline execution
        ExecutePipeline(BaseNodeContainer, SourceDatas, ContentBasePath);
    }
 
    UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Interchange | Pipeline")
    INTERCHANGECORE_API void ScriptedExecutePostFactoryPipeline(const UInterchangeBaseNodeContainer* BaseNodeContainer, const FString& FactoryNodeKey, UObject* CreatedAsset, bool bIsAReimport);
    void ScriptedExecutePostFactoryPipeline_Implementation(const UInterchangeBaseNodeContainer* BaseNodeContainer, const FString& FactoryNodeKey, UObject* CreatedAsset, bool bIsAReimport)
    {
        //By default we call the virtual import pipeline execution
        ExecutePostFactoryPipeline(BaseNodeContainer, FactoryNodeKey, CreatedAsset, bIsAReimport);
    }
    UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Interchange | Pipeline")
    INTERCHANGECORE_API void ScriptedExecutePostImportPipeline(const UInterchangeBaseNodeContainer* BaseNodeContainer, const FString& FactoryNodeKey, UObject* CreatedAsset, bool bIsAReimport);
    void ScriptedExecutePostImportPipeline_Implementation(const UInterchangeBaseNodeContainer* BaseNodeContainer, const FString& FactoryNodeKey, UObject* CreatedAsset, bool bIsAReimport)
    {
        //By default we call the virtual import pipeline execution
        ExecutePostImportPipeline(BaseNodeContainer, FactoryNodeKey, CreatedAsset, bIsAReimport);
    }
 
    UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Interchange | Pipeline")
    INTERCHANGECORE_API void ScriptedExecutePostBroadcastPipeline(const UInterchangeBaseNodeContainer* BaseNodeContainer, const FString& FactoryNodeKey, UObject* CreatedAsset, bool bIsAReimport);
    void ScriptedExecutePostBroadcastPipeline_Implementation(const UInterchangeBaseNodeContainer* BaseNodeContainer, const FString& FactoryNodeKey, UObject* CreatedAsset, bool bIsAReimport)
    {
        //By default we call the virtual import pipeline execution
        ExecutePostBroadcastPipeline(BaseNodeContainer, FactoryNodeKey, CreatedAsset, bIsAReimport);
    }
 
    UFUNCTION(BlueprintCallable, BlueprintNativeEvent, Category = "Interchange | Pipeline")
    INTERCHANGECORE_API void ScriptedExecuteExportPipeline(UInterchangeBaseNodeContainer* BaseNodeContainer);
 
    void ScriptedExecuteExportPipeline_Implementation(UInterchangeBaseNodeContainer* BaseNodeContainer)
    {
        ExecuteExportPipeline(BaseNodeContainer);
    }
 
    UE_DEPRECATED(5.4, "This function will be remove, call CanExecuteOnAnyThread function")
    bool ScriptedCanExecuteOnAnyThread(EInterchangePipelineTask PipelineTask)
    {
        return CanExecuteOnAnyThread(PipelineTask);
    }
 
    virtual bool CanExecuteOnAnyThread(EInterchangePipelineTask PipelineTask)
    {
        return true;
    }
 
    UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Interchange | Pipeline")
    INTERCHANGECORE_API void ScriptedSetReimportSourceIndex(UClass* ReimportObjectClass, const int32 SourceFileIndex);
 
    void ScriptedSetReimportSourceIndex_Implementation(UClass* ReimportObjectClass, const int32 SourceFileIndex)
    {
        SetReimportSourceIndex(ReimportObjectClass, SourceFileIndex);
    }
 
    virtual bool IsScripted()
    {
        return true;
    }
 
    INTERCHANGECORE_API static FString GetDefaultConfigFileName();
    
    INTERCHANGECORE_API void LoadSettings(const FName PipelineStackName, bool bResetPreDialog = false);
 
    INTERCHANGECORE_API void SaveSettings(const FName PipelineStackName);
 
    INTERCHANGECORE_API virtual void AdjustSettingsForContext(const FInterchangePipelineContextParams& ContextParams);
    INTERCHANGECORE_API virtual void AdjustSettingsFromCache();
 
    INTERCHANGECORE_API void TransferAdjustSettings(const UInterchangePipelineBase* SourcePipeline);
 
    void SetShowEssentialsMode(bool bShowEssentialsModeValue)
    {
        bIsShowEssentials = bShowEssentialsModeValue;
    }
 
    /*
     * Set to true if this pipeline is from a re-import or an override pipelines stack
     */
    void SetFromReimportOrOverride(bool bInFromReimportOrOverride)
    {
        bFromReimportOrOverride = bInFromReimportOrOverride;
    }
 
    /*
     * Return true if the pipeline was created for a re-import or an override pipelines stack
     */
    bool IsFromReimportOrOverride() const
    {
        return bFromReimportOrOverride;
    }
    
    virtual void PreDialogCleanup(const FName PipelineStackName) {}
 
    virtual bool IsSettingsAreValid(TOptional<FText>& OutInvalidReason) const
    {
        return true;
    }
 
#if WITH_EDITOR
    virtual void FilterPropertiesFromTranslatedData(UInterchangeBaseNodeContainer* InBaseNodeContainer)
    {
        //The base class function do not have anything to filter
    }
 
    virtual bool IsPropertyChangeNeedRefresh(const FPropertyChangedEvent& PropertyChangedEvent) const
    {
        return false;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Pipeline")
    virtual void GetSupportAssetClasses(TArray<UClass*>& PipelineSupportAssetClasses) const
    {
        return;
    }
 
#endif //WITH_EDITOR
 
    virtual TArray<FInterchangeConflictInfo> GetConflictInfos(UObject* ReimportObject, UInterchangeBaseNodeContainer* InBaseNodeContainer, UInterchangeSourceData* SourceData)
    {
        //The base class function do not have any conflict
        ConflictInfos.Empty();
        return ConflictInfos;
    }
 
    virtual void ShowConflictDialog(const FGuid& ConflictUniqueId)
    {
        return;
    }
 
    template <typename T>
    T* AddMessage() const
    {
        check(Results != nullptr);
        T* Item = Results->Add<T>();
        return Item;
    }
 
    void AddMessage(UInterchangeResult* Item) const
    {
        check(Results != nullptr);
        Results->Add(Item);
    }
    
    void SetResultsContainer(UInterchangeResultsContainer* InResults)
    {
        Results = InResults;
    }
 
    INTERCHANGECORE_API const FInterchangePipelinePropertyStates* GetPropertyStates(const FName PropertyPath) const;
 
    INTERCHANGECORE_API FInterchangePipelinePropertyStates* GetMutablePropertyStates(const FName PropertyPath);
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Pipeline")
    INTERCHANGECORE_API bool DoesPropertyStatesExist(const FName PropertyPath) const;
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Pipeline")
    INTERCHANGECORE_API FInterchangePipelinePropertyStates& FindOrAddPropertyStates(const FName PropertyPath);
 
    static INTERCHANGECORE_API FName GetPropertiesStatesPropertyName();
 
    static INTERCHANGECORE_API FName GetResultsPropertyName();
 
    bool CanEditPropertiesStates() { return bAllowPropertyStatesEdition; }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Pipeline")
    bool IsReimportContext() { return bIsReimportContext; }
 
    bool IsShowEssentials() { return bIsShowEssentials; }
 
#if WITH_EDITOR
    /*
     * FName or FString properties can have a dynamic set of possible values. When displaying 
     * a pipeline property in the property editor, this function will be call for all FString and FName
     * properties and will generate a combo box with the PossibleValues if the function return true.
     */
    virtual bool GetPropertyPossibleValues(const FName PropertyPath, TArray<FString>& PossibleValues)
    {
        return false;
    }
#endif //WITH_EDITOR
 
    /*
     * Return true if the pipeline is not a sub-pipeline. Standalone pipelines can have some extra properties.
     * The customize detail of the pipeline will call this function to show or hide those properties.
     * The pipeline itself can call the function to know whether a property must be used.
     * Example: the override asset name property.
     */
    bool IsStandAlonePipeline() const
    {
        return this == GetMostPipelineOuter();
    };
 
    /*
    * Update/reset the TWeakObjectPtrs to point to their original TObjectPtr.
    * Works based on Variable naming.
    */
    INTERCHANGECORE_API void UpdateWeakObjectPtrs();
 
    INTERCHANGECORE_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
    INTERCHANGECORE_API virtual void Serialize(FArchive& Ar) override;
    /*
     * If this returns true, this pipeline will be saved in the asset import data.
     * We will reuse this pipeline when reimporting the asset.
     * If false, it's probably a debug helper pipeline that we do not want to save into assets.
     */
    UFUNCTION(BlueprintCallable, Category = "Interchange | Pipeline")
    virtual bool SupportReimport() const { return true; }
 
    /*
     * The Unreal import system has an option to force a name if we import only one main asset (one texture, one mesh or one animation).
     * The generic asset pipeline uses this information to behave as expected.
     */
    UPROPERTY()
    FString DestinationName;
 
    /*
     * The content path where asset should be created.
     */
    UPROPERTY()
    FString ContentImportPath;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FSoftObjectPath OriginalPipelinePath;
#endif
 
    INTERCHANGECORE_API UInterchangePipelineBase* GetMostPipelineOuter() const;
 
protected:
 
    INTERCHANGECORE_API virtual FString GetPipelineDisplayName() const;
 
    virtual void ExecutePipeline(UInterchangeBaseNodeContainer* BaseNodeContainer, const TArray<UInterchangeSourceData*>& SourceDatas, const FString& ContentBasePath)
    {
    }
 
    virtual void ExecutePostFactoryPipeline(const UInterchangeBaseNodeContainer* BaseNodeContainer, const FString& NodeKey, UObject* CreatedAsset, bool bIsAReimport)
    {
    }
 
    virtual void ExecutePostImportPipeline(const UInterchangeBaseNodeContainer* BaseNodeContainer, const FString& NodeKey, UObject* CreatedAsset, bool bIsAReimport)
    {
    }
 
    virtual void ExecutePostBroadcastPipeline(const UInterchangeBaseNodeContainer* BaseNodeContainer, const FString& NodeKey, UObject* CreatedAsset, bool bIsAReimport)
    {
    }
 
    virtual void SetReimportSourceIndex(UClass* ReimportObjectClass, const int32 SourceFileIndex)
    {
    }
 
    virtual void ExecuteExportPipeline(UInterchangeBaseNodeContainer* BaseNodeContainer)
    {
    }
 
    INTERCHANGECORE_API void LoadSettingsInternal(const FName PipelineStackName, const FString& ConfigFilename, TMap<FName, FInterchangePipelinePropertyStates>& ParentPropertiesStates, bool bResetPreDialog, bool& bOutRequiresSaving);
 
    INTERCHANGECORE_API void SaveSettingsInternal(const FName PipelineStackName, const FString& ConfigFilename);
 
#if WITH_EDITOR
    static INTERCHANGECORE_API void InternalToggleVisibilityPropertiesOfMetaDataValue(UInterchangePipelineBase* OuterMostPipeline, UInterchangePipelineBase* Pipeline, bool bDoTransientSubPipeline, const FString& MetaDataKey, const FString& MetaDataValue, const bool bVisibilityState);
    static INTERCHANGECORE_API void HidePropertiesOfCategory(UInterchangePipelineBase* OuterMostPipeline, UInterchangePipelineBase* Pipeline, const FString& HideCategoryName, bool bDoTransientSubPipeline = false);
    static INTERCHANGECORE_API void HidePropertiesOfSubCategory(UInterchangePipelineBase* OuterMostPipeline, UInterchangePipelineBase* Pipeline, const FString& HideSubCategoryName, bool bDoTransientSubPipeline = false);
    static INTERCHANGECORE_API void HideProperty(UInterchangePipelineBase* OuterMostPipeline, UInterchangePipelineBase* Pipeline, const FName& HidePropertyName);
#endif //WITH_EDITOR
    
    UPROPERTY(Transient)
    bool bAllowPropertyStatesEdition = true;
 
    UPROPERTY(Transient)
    bool bIsReimportContext = false;
 
    UPROPERTY(Transient)
    bool bIsShowEssentials = false;
 
    /*
     * If true, this pipeline was create to re-import an asset or override the project settings pipelines.
     * That kind of pipeline will not be treat like project settings pipeline in the UI. PredialogCleanup will not be called.
     */
    UPROPERTY()
    bool bFromReimportOrOverride = false;
 
    UPROPERTY()
    TObjectPtr<UInterchangeResultsContainer> Results;
 
    UPROPERTY()
    TMap<FName, FInterchangePipelinePropertyStates> PropertiesStates;
 
    UPROPERTY(Transient)
    mutable TMap<FName, FInterchangePipelinePropertyStates> CachePropertiesStates;
 
    UPROPERTY(Transient)
    mutable FInterchangePipelineContextParams CacheContextParam;
 
    TArray<FInterchangeConflictInfo> ConflictInfos; 
};