InterchangeTranslatorBase.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "InterchangeResult.h"
#include "InterchangeResultsContainer.h"
#include "InterchangeSourceData.h"
#include "Misc/AssertionMacros.h"
#include "Nodes/InterchangeBaseNodeContainer.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectPtr.h"
#include "UObject/UObjectGlobals.h"
 
#include "InterchangeTranslatorBase.generated.h"
 
class UInterchangeBaseNodeContainer;
 
namespace UE::Interchange
{
    struct FAnalyticsHelper;
}
 
UCLASS(BlueprintType, Blueprintable, editinlinenew, Abstract, MinimalAPI)
class UInterchangeTranslatorSettings : public UObject
{
    GENERATED_BODY()
 
public:
    UFUNCTION(BlueprintCallable, Category = "Interchange")
    INTERCHANGECORE_API void LoadSettings();
 
    UFUNCTION(BlueprintCallable, Category = "Interchange")
    INTERCHANGECORE_API void SaveSettings();
};
 
UENUM(BlueprintType)
enum class EInterchangeTranslatorType : uint8
{
    Invalid = 0,
    Assets = 1 << 1,
    Actors = 1 << 2,
    Scenes = Assets | Actors
};
 
UENUM(BlueprintType)
enum class EInterchangeTranslatorAssetType : uint8
{
    None = 0x0,
    Textures = 0x1 << 0,
    Materials = 0x1 << 1,
    Meshes = 0x1 << 2,
    Animations = 0x1 << 3,
    Sounds = 0x1 << 4,
    Grooms = 0x1 << 5,
};
ENUM_CLASS_FLAGS(EInterchangeTranslatorAssetType);
 
UCLASS(BlueprintType, Blueprintable, Abstract, MinimalAPI)
class UInterchangeTranslatorBase : public UObject
{
    GENERATED_BODY()
public:
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Translator")
    INTERCHANGECORE_API virtual bool CanImportSourceData(const UInterchangeSourceData* InSourceData) const;
 
    virtual bool IsThreadSafe() const { return true; }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Translator")
    virtual EInterchangeTranslatorType GetTranslatorType() const { return EInterchangeTranslatorType::Assets; }
 
    bool DoesSupportAssetType(EInterchangeTranslatorAssetType AssetType) const { return EnumHasAllFlags(GetSupportedAssetTypes(), AssetType); }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Translator")
    virtual EInterchangeTranslatorAssetType GetSupportedAssetTypes() const PURE_VIRTUAL(UInterchangeTranslatorBase::GetSupportedAssetTypes, return EInterchangeTranslatorAssetType::None;);
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Translator")
    virtual TArray<FString> GetSupportedFormats() const PURE_VIRTUAL(UInterchangeTranslatorBase::GetSupportedExtensions, return TArray<FString>(););
 
    virtual bool Translate(UInterchangeBaseNodeContainer& BaseNodeContainer) const
    {
        return false;
    }
 
    virtual void ReleaseSource()
    {
        return;
    }
 
    virtual void ImportFinish()
    {
        return;
    }
 
    template <typename T>
    T* AddMessage() const
    {
        if (ensure(Results) && ensure(SourceData))
        {
            T* Item = Results->Add<T>();
            Item->SourceAssetName = SourceData->GetFilename();
            return Item;
        }
        return nullptr;
    }
 
    void AddMessage(UInterchangeResult* Item) const
    {
        if (ensure(Results) && ensure(SourceData))
        {
            Results->Add(Item);
            Item->SourceAssetName = SourceData->GetFilename();
        }
    }
    
    void SetResultsContainer(UInterchangeResultsContainer* InResults)
    {
        Results = InResults;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Translator")
    const UInterchangeSourceData* GetSourceData() const
    {
        return SourceData;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Translator")
    virtual UInterchangeTranslatorSettings* GetSettings() const { return nullptr; }
 
    UFUNCTION(BlueprintCallable, Category = "Interchange | Translator")
    virtual void SetSettings(const UInterchangeTranslatorSettings* InterchangeTranslatorSettings) { }
 
    UPROPERTY()
    TObjectPtr<UInterchangeResultsContainer> Results;
 
    UPROPERTY()
    TObjectPtr<const UInterchangeSourceData> SourceData;
 
    TSharedPtr<UE::Interchange::FAnalyticsHelper> AnalyticsHelper = nullptr;
};