Exporter.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Templates/SubclassOf.h"
#include "Exporter.generated.h"
 
class FExportObjectInnerContext;
class UActorComponent;
class UAssetExportTask;
 
UCLASS(abstract, transient, MinimalAPI)
class UExporter : public UObject
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY(BlueprintReadWrite, Category=Misc)
    TSubclassOf<class UObject>  SupportedClass;
 
    UPROPERTY(transient)
    TObjectPtr<class UObject> ExportRootScope;    // transient
 
    UPROPERTY(BlueprintReadWrite, Category=Misc)
    TArray<FString> FormatExtension;
 
    UPROPERTY(BlueprintReadWrite, Category=Misc)
    TArray<FString> FormatDescription;
 
    UPROPERTY()
    int32 PreferredFormatIndex;
 
    UPROPERTY()
    int32 TextIndent;
 
    UPROPERTY(BlueprintReadWrite, Category=Misc)
    uint32 bText:1;
 
    UPROPERTY()
    uint32 bSelectedOnly:1;
 
    UPROPERTY()
    uint32 bForceFileOperations:1;
 
    UPROPERTY(BlueprintReadWrite, Category=Misc)
    TObjectPtr<class UAssetExportTask> ExportTask;
 
    ENGINE_API static       FString CurrentFilename;
    static  const       bool    bEnableDebugBrackets;
 
    //~ Begin UObject Interface.
    ENGINE_API virtual void Serialize( FArchive& Ar ) override;
    //~ End UObject Interface.
 
    // Returns whether this exporter supports the specific object
    ENGINE_API virtual bool SupportsObject(UObject* Object) const;
 
     virtual bool ExportText( const class FExportObjectInnerContext* Context, UObject* Object, const TCHAR* Type, FOutputDevice& Ar, FFeedbackContext* Warn, uint32 PortFlags=0 ) { return( false );}
 
     struct FExportPackageParams
    {
        FString RootMapPackageName;
        const class FExportObjectInnerContext* Context;
        UPackage* InPackage;
        UObject* InObject;
        const TCHAR* Type;
        FOutputDevice* Ar;
        FFeedbackContext* Warn;
        uint32 PortFlags;
    };
 
    virtual void ExportPackageObject(FExportPackageParams& ExpPackageParams) {};
 
    virtual void ExportPackageInners(FExportPackageParams& ExpPackageParams) {};
 
    virtual bool ExportBinary( UObject* Object, const TCHAR* Type, FArchive& Ar, FFeedbackContext* Warn, int32 FileIndex = 0, uint32 PortFlags=0 ) { return( false );}
 
    virtual int32 GetFileCount( UObject* Object ) const { return( 1 ); }
 
    virtual FString GetUniqueFilename( UObject* Object, const TCHAR* Filename, int32 FileIndex, int32 FileCount ) const
    {
        check( FileIndex == 0 && FileCount == 1 );
        return FString( Filename );
    }
 
    ENGINE_API virtual bool GetBatchMode() const;
 
    ENGINE_API virtual void SetBatchMode(bool InBatchExportMode);
 
    ENGINE_API virtual bool GetCancelBatch() const;
 
    ENGINE_API virtual void SetCancelBatch(bool InCancelBatch);
 
    ENGINE_API virtual bool GetShowExportOption() const;
 
    ENGINE_API virtual void SetShowExportOption(bool InShowExportOption);
 
    ENGINE_API static UExporter* FindExporter( UObject* Object, const TCHAR* Filetype );
 
    ENGINE_API static int32 ExportToFile( UObject* Object, UExporter* Exporter, const TCHAR* Filename, bool InSelectedOnly, bool NoReplaceIdentical=false, bool Prompt=false );
 
    ENGINE_API static bool ExportToArchive(UObject* Object, UExporter* Exporter, FArchive& Ar, const TCHAR* FileType, int32 FileIndex);
 
 
    ENGINE_API static bool ExportToOutputDevice( const class FExportObjectInnerContext* Context, UObject* Object, UExporter* InExporter, FOutputDevice& Out, const TCHAR* FileType, int32 Indent, uint32 PortFlags=0, bool bInSelectedOnly=false, UObject* ExportRootScope = NULL);
 
    struct FExportToFileParams
    {
        UObject* Object;
        UExporter* Exporter;
        const TCHAR* Filename;
        bool InSelectedOnly;
        bool NoReplaceIdentical;
        bool Prompt;
        bool bUseFileArchive;
        TArray<UObject*> IgnoreObjectList;
        bool WriteEmptyFiles;
    };
 
    UFUNCTION(BlueprintCallable, Category = "Miscellaneous")
    static ENGINE_API bool RunAssetExportTask( class UAssetExportTask* Task );
 
    UFUNCTION(BlueprintImplementableEvent, Category = "Miscellaneous")
    bool ScriptRunAssetExportTask( class UAssetExportTask* Task );
 
    UFUNCTION(BlueprintCallable, Category = "Miscellaneous")
    static ENGINE_API bool RunAssetExportTasks( const TArray<UAssetExportTask*>& ExportTasks );
    
    ENGINE_API void ExportObjectInner(const class FExportObjectInnerContext* Context, UObject* Object, FOutputDevice& Ar, uint32 PortFlags);
 
    static ENGINE_API bool IsObjectSelectedForExport(const FExportObjectInnerContext* Context, const UObject* Object);
 
protected:
    virtual void ExportComponentExtra(const FExportObjectInnerContext* Context, const TArray<UActorComponent*>& Components, FOutputDevice& Ar, uint32 PortFlags) {}
 
    ENGINE_API void EmitBeginObject( FOutputDevice& Ar, UObject* Obj, uint32 PortFlags );
 
    ENGINE_API void EmitEndObject( FOutputDevice& Ar );
 
protected:
    static TSet< TWeakObjectPtr<UExporter> > RegisteredExporters;
 
    bool BatchExportMode;
 
    bool ShowExportOption;
 
    bool CancelBatch;
};