648 lines
24 KiB
C++
648 lines
24 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#pragma once
|
|
|
|
#include "CoreMinimal.h"
|
|
#include "UObject/ObjectMacros.h"
|
|
#include "UObject/UObjectGlobals.h"
|
|
#include "UObject/Object.h"
|
|
#include "UObject/PackageId.h"
|
|
#include "UObject/LinkerSave.h"
|
|
#include "Misc/Guid.h"
|
|
#include "Misc/WorldCompositionUtility.h"
|
|
#include "Misc/OutputDeviceError.h"
|
|
#include "Misc/ObjectThumbnail.h"
|
|
#include "Serialization/CustomVersion.h"
|
|
#include "Templates/UniquePtr.h"
|
|
#include "Misc/SecureHash.h"
|
|
#include "Async/Future.h"
|
|
|
|
class Error;
|
|
|
|
// This is a dummy type which is not implemented anywhere. It's only
|
|
// used to flag a deprecated Conform argument to package save functions.
|
|
class FLinkerNull;
|
|
struct FPackageSaveInfo;
|
|
class FSavePackageContext;
|
|
struct FSavePackageArgs;
|
|
|
|
/**
|
|
* Represents the result of saving a package
|
|
*/
|
|
enum class ESavePackageResult
|
|
{
|
|
/** Package was saved successfully */
|
|
Success,
|
|
/** Unknown error occured when saving package */
|
|
Error,
|
|
/** Canceled by user */
|
|
Canceled,
|
|
/** [When cooking] Package was not saved because it contained editor-only data */
|
|
ContainsEditorOnlyData,
|
|
/** [When cooking] Package was not saved because it was referenced by editor-only properties */
|
|
ReferencedOnlyByEditorOnlyData,
|
|
/** [When cooking] Package was not saved because it contains assets that were converted into native code */
|
|
ReplaceCompletely,
|
|
/** [When cooking] Package was saved, but we should generate a stub so that other converted packages can interface with it*/
|
|
GenerateStub,
|
|
/** [When cooking] When performing package diff, the package generated in memory was different to the one that existed on disk */
|
|
DifferentContent,
|
|
/** [When cooking] The file requested (when cooking on the fly) did not exist on disk */
|
|
MissingFile
|
|
};
|
|
|
|
/**
|
|
* Struct returned from save package, contains the enum as well as extra data about what was written
|
|
*/
|
|
struct FSavePackageResultStruct
|
|
{
|
|
/** Success/failure of the save operation */
|
|
ESavePackageResult Result;
|
|
|
|
/** Total size of all files written out, including bulk data */
|
|
int64 TotalFileSize;
|
|
|
|
/** MD5 hash of the cooked data */
|
|
TFuture<FMD5Hash> CookedHash;
|
|
|
|
/** Linker for linker comparison after save. */
|
|
TUniquePtr<FLinkerSave> LinkerSave;
|
|
|
|
/** Constructors, it will implicitly construct from the result enum */
|
|
FSavePackageResultStruct(): Result(ESavePackageResult::Error), TotalFileSize(0) {}
|
|
FSavePackageResultStruct(ESavePackageResult InResult): Result(InResult), TotalFileSize(0) {}
|
|
FSavePackageResultStruct(ESavePackageResult InResult, int64 InTotalFileSize): Result(InResult), TotalFileSize(InTotalFileSize) {}
|
|
FSavePackageResultStruct(ESavePackageResult InResult, int64 InTotalFileSize, TFuture<FMD5Hash>&& InHash, TUniquePtr<FLinkerSave> Linker = nullptr): Result(InResult), TotalFileSize(InTotalFileSize), CookedHash(MoveTemp(InHash)), LinkerSave(MoveTemp(Linker)) {}
|
|
|
|
bool operator==(const FSavePackageResultStruct& Other) const
|
|
{
|
|
return Result == Other.Result;
|
|
}
|
|
|
|
bool operator!=(const FSavePackageResultStruct& Other) const
|
|
{
|
|
return Result != Other.Result;
|
|
}
|
|
};
|
|
|
|
COREUOBJECT_API void StartSavingEDLCookInfoForVerification();
|
|
COREUOBJECT_API void VerifyEDLCookInfo(bool bFullReferencesExpected = true);
|
|
|
|
/**
|
|
* A package.
|
|
*/
|
|
PRAGMA_DISABLE_DEPRECATION_WARNINGS // Required for auto-generated functions referencing PackageFlags
|
|
class COREUOBJECT_API UPackage: public UObject
|
|
{
|
|
DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR_NO_VTABLE_CTOR(UPackage, UObject, 0, TEXT("/Script/CoreUObject"), CASTCLASS_UPackage, NO_API)
|
|
/** DO NOT USE. This constructor is for internal usage only for hot-reload purposes. */
|
|
UPackage(FVTableHelper& Helper)
|
|
: Super(Helper){};
|
|
|
|
public:
|
|
UPackage(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get())
|
|
: Super(ObjectInitializer)
|
|
{
|
|
}
|
|
|
|
/** delegate type for package dirty state events. ( Params: UPackage* ModifiedPackage ) */
|
|
DECLARE_MULTICAST_DELEGATE_OneParam(FOnPackageDirtyStateChanged, class UPackage*);
|
|
/** delegate type for package saved events ( Params: const FString& PackageFileName, UObject* Outer ) */
|
|
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnPackageSaved, const FString&, UObject*);
|
|
/** delegate type for when a package is marked as dirty via UObjectBaseUtilty::MarkPackageDirty ( Params: UPackage* ModifiedPackage, bool bWasDirty ) */
|
|
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnPackageMarkedDirty, class UPackage*, bool);
|
|
/** delegate type for when a package is about to be saved */
|
|
DECLARE_MULTICAST_DELEGATE_OneParam(FPreSavePackage, class UPackage*);
|
|
|
|
/** Delegate to notify subscribers when a package is about to be saved. */
|
|
static FPreSavePackage PreSavePackageEvent;
|
|
/** Delegate to notify subscribers when a package has been saved. This is triggered when the package saving
|
|
* has completed and was successful. */
|
|
static FOnPackageSaved PackageSavedEvent;
|
|
/** Delegate to notify subscribers when the dirty state of a package is changed.
|
|
* Allows the editor to register the modified package as one that should be prompted for source control checkout.
|
|
* Use Package->IsDirty() to get the updated dirty state of the package */
|
|
static FOnPackageDirtyStateChanged PackageDirtyStateChangedEvent;
|
|
/**
|
|
* Delegate to notify subscribers when a package is marked as dirty via UObjectBaseUtilty::MarkPackageDirty
|
|
* Note: Unlike FOnPackageDirtyStateChanged, this is always called, even when the package is already dirty
|
|
* Use bWasDirty to check the previous dirty state of the package
|
|
* Use Package->IsDirty() to get the updated dirty state of the package
|
|
*/
|
|
static FOnPackageMarkedDirty PackageMarkedDirtyEvent;
|
|
|
|
private:
|
|
/** Used by the editor to determine if a package has been changed. */
|
|
uint8 bDirty : 1;
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
/** True if this package is only referenced by editor-only properties */
|
|
uint8 bLoadedByEditorPropertiesOnly : 1;
|
|
#endif
|
|
|
|
public:
|
|
#if WITH_EDITORONLY_DATA
|
|
/** True if this packages has been cooked for the editor / opened cooked by the editor */
|
|
uint8 bIsCookedForEditor : 1;
|
|
#endif
|
|
|
|
/** Whether this package has been fully loaded (aka had all it's exports created) at some point. */
|
|
mutable uint8 bHasBeenFullyLoaded : 1;
|
|
|
|
/**
|
|
* Whether this package can be imported, i.e. its package name is a package that exists on disk.
|
|
* Note: This includes all normal packages where the Name matches the FileName
|
|
* and localized packages shadowing an existing source package,
|
|
* but excludes level streaming packages with /Temp/ names.
|
|
*/
|
|
uint8 bCanBeImported : 1;
|
|
|
|
private:
|
|
/** Time in seconds it took to fully load this package. 0 if package is either in process of being loaded or has never been fully loaded. */
|
|
float LoadTime; // TODO: strip from runtime?
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
/** Indicates which folder to display this package under in the Generic Browser's list of packages. If not specified, package is added to the root level. */
|
|
FName FolderName;
|
|
#endif
|
|
|
|
/** GUID of package if it was loaded from disk. Changes at every save. */
|
|
UE_DEPRECATED(4.27, "UPackage::Guid has not been used by the engine for a long time and it will be removed.")
|
|
FGuid Guid;
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
/** Persistent GUID of package if it was loaded from disk. Persistent across saves. */
|
|
FGuid PersistentGuid;
|
|
#endif
|
|
/** Chunk IDs for the streaming install chunks this package will be placed in. Empty for no chunk */
|
|
TArray<int32> ChunkIDs;
|
|
|
|
public:
|
|
virtual bool IsNameStableForNetworking() const override { return true; } // For now, assume all packages have stable net names
|
|
virtual bool NeedsLoadForClient() const override { return true; } // To avoid calling the expensive generic version, which only makes sure that the UPackage static class isn't excluded
|
|
virtual bool NeedsLoadForServer() const override { return true; }
|
|
virtual bool IsPostLoadThreadSafe() const override;
|
|
virtual bool IsDestructionThreadSafe() const override { return true; }
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
/** Sets the bLoadedByEditorPropertiesOnly flag */
|
|
void SetLoadedByEditorPropertiesOnly(bool bIsEditorOnly, bool bRecursive = false);
|
|
/** returns true when the package is only referenced by editor-only flag */
|
|
bool IsLoadedByEditorPropertiesOnly() const { return bLoadedByEditorPropertiesOnly; }
|
|
#endif
|
|
|
|
private:
|
|
/** Package Flags */
|
|
uint32 PackageFlagsPrivate;
|
|
|
|
/** Globally unique id used to address I/O chunks within the package */
|
|
FPackageId PackageId;
|
|
|
|
public:
|
|
/** Editor only: PIE instance ID this package belongs to, INDEX_NONE otherwise */
|
|
int32 PIEInstanceID; // TODO: strip from runtime?
|
|
|
|
/** The name of the file that this package was loaded from */
|
|
FName FileName;
|
|
|
|
/** Linker load associated with this package */
|
|
class FLinkerLoad* LinkerLoad;
|
|
|
|
/** Linker package version this package has been serialized with. This is mostly used by PostLoad **/
|
|
int32 LinkerPackageVersion;
|
|
|
|
/** Linker licensee version this package has been serialized with. This is mostly used by PostLoad **/
|
|
int32 LinkerLicenseeVersion;
|
|
|
|
/** Linker custom version container this package has been serialized with. This is mostly used by PostLoad **/
|
|
FCustomVersionContainer LinkerCustomVersion;
|
|
|
|
/** size of the file for this package; if the package was not loaded from a file or was a forced export in another package, this will be zero */
|
|
uint64 FileSize; // TODO: strip from runtime?
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
/** Editor only: Thumbnails stored in this package */
|
|
TUniquePtr<FThumbnailMap> ThumbnailMap;
|
|
|
|
// MetaData for the editor, or NULL in the game
|
|
class UMetaData* MetaData;
|
|
#endif
|
|
|
|
// World browser information
|
|
TUniquePtr<FWorldTileInfo> WorldTileInfo;
|
|
|
|
/**
|
|
* Called after the C++ constructor and after the properties have been initialized, but before the config has been loaded, etc.
|
|
* mainly this is to emulate some behavior of when the constructor was called after the properties were initialized.
|
|
*/
|
|
virtual void PostInitProperties() override;
|
|
|
|
virtual void BeginDestroy() override;
|
|
|
|
/** Serializer */
|
|
virtual void Serialize(FArchive& Ar) override;
|
|
|
|
/** Packages are never assets */
|
|
virtual bool IsAsset() const override { return false; }
|
|
|
|
// UPackage interface.
|
|
|
|
/**
|
|
* Sets the time it took to load this package.
|
|
*/
|
|
void SetLoadTime(float InLoadTime)
|
|
{
|
|
LoadTime = InLoadTime;
|
|
}
|
|
|
|
/**
|
|
* Returns the time it took the last time this package was fully loaded, 0 otherwise.
|
|
*
|
|
* @return Time it took to load.
|
|
*/
|
|
float GetLoadTime()
|
|
{
|
|
return LoadTime;
|
|
}
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
/**
|
|
* Get the package's folder name
|
|
* @return Folder name
|
|
*/
|
|
FName GetFolderName() const
|
|
{
|
|
return FolderName;
|
|
}
|
|
|
|
/**
|
|
* Set the package's folder name
|
|
*/
|
|
void SetFolderName(FName name)
|
|
{
|
|
FolderName = name;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* Clear the package dirty flag without any transaction tracking
|
|
*/
|
|
void ClearDirtyFlag()
|
|
{
|
|
bDirty = false;
|
|
}
|
|
|
|
/**
|
|
* Marks/Unmarks the package's bDirty flag, save the package to the transaction buffer if a transaction is ongoing
|
|
*/
|
|
void SetDirtyFlag(bool bIsDirty);
|
|
|
|
/**
|
|
* Returns whether the package needs to be saved.
|
|
*
|
|
* @return true if the package is dirty and needs to be saved, false otherwise.
|
|
*/
|
|
bool IsDirty() const
|
|
{
|
|
return bDirty;
|
|
}
|
|
|
|
/**
|
|
* Marks this package as being fully loaded.
|
|
*/
|
|
void MarkAsFullyLoaded()
|
|
{
|
|
bHasBeenFullyLoaded = true;
|
|
}
|
|
|
|
/**
|
|
* Returns whether the package is fully loaded.
|
|
*
|
|
* @return true if fully loaded or no file associated on disk, false otherwise
|
|
*/
|
|
bool IsFullyLoaded() const;
|
|
|
|
/**
|
|
* Fully loads this package. Safe to call multiple times and won't clobber already loaded assets.
|
|
*/
|
|
void FullyLoad();
|
|
|
|
/**
|
|
* Marks/Unmarks the package's bCanBeImported flag.
|
|
*/
|
|
void SetCanBeImportedFlag(bool bInCanBeImported)
|
|
{
|
|
bCanBeImported = bInCanBeImported;
|
|
}
|
|
|
|
/**
|
|
* Returns whether the package can be imported.
|
|
*
|
|
* @return true if the package can be imported.
|
|
*/
|
|
bool CanBeImported() const
|
|
{
|
|
return bCanBeImported;
|
|
}
|
|
/**
|
|
* Tags the Package's metadata
|
|
*/
|
|
virtual void TagSubobjects(EObjectFlags NewFlags) override;
|
|
|
|
/**
|
|
* Called to indicate that this package contains a ULevel or UWorld object.
|
|
*/
|
|
void ThisContainsMap()
|
|
{
|
|
SetPackageFlags(PKG_ContainsMap);
|
|
}
|
|
|
|
/**
|
|
* Returns whether this package contains a ULevel or UWorld object.
|
|
*
|
|
* @return true if package contains ULevel/ UWorld object, false otherwise.
|
|
*/
|
|
bool ContainsMap() const
|
|
{
|
|
return HasAnyPackageFlags(PKG_ContainsMap);
|
|
}
|
|
|
|
/**
|
|
* Called to indicate that this package contains data required to be gathered for localization.
|
|
*/
|
|
void ThisRequiresLocalizationGather(bool Value)
|
|
{
|
|
if (Value)
|
|
{
|
|
SetPackageFlags(PKG_RequiresLocalizationGather);
|
|
}
|
|
else
|
|
{
|
|
ClearPackageFlags(PKG_RequiresLocalizationGather);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns whether this package contains data required to be gathered for localization.
|
|
*
|
|
* @return true if package contains contains data required to be gathered for localization, false otherwise.
|
|
*/
|
|
bool RequiresLocalizationGather() const
|
|
{
|
|
return HasAnyPackageFlags(PKG_RequiresLocalizationGather);
|
|
}
|
|
|
|
// UE-21181 - trying to track when a flag gets set on a package due to PIE
|
|
#if WITH_EDITOR
|
|
static UPackage* EditorPackage;
|
|
void SetPackageFlagsTo(uint32 NewFlags);
|
|
#else
|
|
/**
|
|
* Sets all package flags to the specified values.
|
|
*
|
|
* @param NewFlags New value for package flags
|
|
*/
|
|
FORCEINLINE void SetPackageFlagsTo(uint32 NewFlags)
|
|
{
|
|
PackageFlagsPrivate = NewFlags;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* Set the specified flags to true. Does not affect any other flags.
|
|
*
|
|
* @param NewFlags Package flags to enable
|
|
*/
|
|
FORCEINLINE void SetPackageFlags(uint32 NewFlags)
|
|
{
|
|
SetPackageFlagsTo(PackageFlagsPrivate | NewFlags);
|
|
}
|
|
|
|
/**
|
|
* Set the specified flags to false. Does not affect any other flags.
|
|
*
|
|
* @param NewFlags Package flags to disable
|
|
*/
|
|
FORCEINLINE void ClearPackageFlags(uint32 NewFlags)
|
|
{
|
|
SetPackageFlagsTo(PackageFlagsPrivate & ~NewFlags);
|
|
}
|
|
|
|
/**
|
|
* Used to safely check whether the passed in flag is set.
|
|
*
|
|
* @param FlagsToCheck Package flags to check for
|
|
*
|
|
* @return true if the passed in flag is set, false otherwise
|
|
* (including no flag passed in, unless the FlagsToCheck is CLASS_AllFlags)
|
|
*/
|
|
FORCEINLINE bool HasAnyPackageFlags(uint32 FlagsToCheck) const
|
|
{
|
|
return (PackageFlagsPrivate & FlagsToCheck) != 0;
|
|
}
|
|
|
|
/**
|
|
* Used to safely check whether all of the passed in flags are set.
|
|
*
|
|
* @param FlagsToCheck Package flags to check for
|
|
* @return true if all of the passed in flags are set (including no flags passed in), false otherwise
|
|
*/
|
|
FORCEINLINE bool HasAllPackagesFlags(uint32 FlagsToCheck) const
|
|
{
|
|
return ((PackageFlagsPrivate & FlagsToCheck) == FlagsToCheck);
|
|
}
|
|
|
|
/**
|
|
* Gets the package flags.
|
|
*
|
|
* @return The package flags.
|
|
*/
|
|
FORCEINLINE uint32 GetPackageFlags() const
|
|
{
|
|
return PackageFlagsPrivate;
|
|
}
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
/** Returns true if this package has a thumbnail map */
|
|
bool HasThumbnailMap() const
|
|
{
|
|
return ThumbnailMap.IsValid();
|
|
}
|
|
|
|
/** Returns the thumbnail map for this package (const). Only call this if HasThumbnailMap returns true! */
|
|
const FThumbnailMap& GetThumbnailMap() const
|
|
{
|
|
check(HasThumbnailMap());
|
|
return *ThumbnailMap;
|
|
}
|
|
|
|
/** Access the thumbnail map for this package. Only call this if HasThumbnailMap returns true! */
|
|
FThumbnailMap& AccessThumbnailMap()
|
|
{
|
|
check(HasThumbnailMap());
|
|
return *ThumbnailMap;
|
|
}
|
|
#endif
|
|
|
|
/** returns our Guid */
|
|
UE_DEPRECATED(4.27, "UPackage::Guid has not been used by the engine for a long time and GetGuid will be removed.")
|
|
FORCEINLINE FGuid GetGuid() const
|
|
{
|
|
return Guid;
|
|
}
|
|
/** makes our a new fresh Guid */
|
|
UE_DEPRECATED(4.27, "UPackage::Guid has not been used by the engine for a long time and MakeNewGuid will be removed.")
|
|
FORCEINLINE FGuid MakeNewGuid()
|
|
{
|
|
Guid = FGuid::NewGuid();
|
|
return Guid;
|
|
}
|
|
/** sets a specific Guid */
|
|
UE_DEPRECATED(4.27, "UPackage::Guid has not been used by the engine for a long time and SetGuid will be removed.")
|
|
FORCEINLINE void SetGuid(FGuid NewGuid)
|
|
{
|
|
Guid = NewGuid;
|
|
}
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
/** returns our persistent Guid */
|
|
FORCEINLINE FGuid GetPersistentGuid() const
|
|
{
|
|
return PersistentGuid;
|
|
}
|
|
/** sets a specific persistent Guid */
|
|
FORCEINLINE void SetPersistentGuid(FGuid NewPersistentGuid)
|
|
{
|
|
PersistentGuid = NewPersistentGuid;
|
|
}
|
|
#endif
|
|
|
|
/** returns our FileSize */
|
|
FORCEINLINE int64 GetFileSize()
|
|
{
|
|
return FileSize;
|
|
}
|
|
|
|
/** returns our ChunkIDs */
|
|
FORCEINLINE const TArray<int32>& GetChunkIDs() const
|
|
{
|
|
return ChunkIDs;
|
|
}
|
|
/** sets our ChunkIDs */
|
|
FORCEINLINE void SetChunkIDs(const TArray<int32>& InChunkIDs)
|
|
{
|
|
ChunkIDs = InChunkIDs;
|
|
}
|
|
|
|
/** returns the unique package id */
|
|
FORCEINLINE FPackageId GetPackageId() const
|
|
{
|
|
return PackageId;
|
|
}
|
|
|
|
/** sets the unique package id */
|
|
FORCEINLINE void SetPackageId(FPackageId InPackageId)
|
|
{
|
|
PackageId = InPackageId;
|
|
}
|
|
|
|
/**
|
|
* Utility function to find Asset in this package, if any
|
|
* @return the asset in the package, if any
|
|
*/
|
|
UObject* FindAssetInPackage() const;
|
|
|
|
/**
|
|
* Return the list of packages found assigned to object outer-ed to the top level objects of this package
|
|
* @return the array of external packages
|
|
*/
|
|
TArray<UPackage*> GetExternalPackages() const;
|
|
|
|
////////////////////////////////////////////////////////
|
|
// MetaData
|
|
|
|
/**
|
|
* Gets (after possibly creating) a metadata object for this package
|
|
*
|
|
* @param bAllowLoadObject Can load an object to find it's UMetaData if not currently loaded.
|
|
*
|
|
* @return A valid UMetaData pointer for all objects in this package
|
|
*/
|
|
class UMetaData* GetMetaData();
|
|
|
|
/**
|
|
* Save one specific object (along with any objects it references contained within the same Outer) into an Unreal package.
|
|
*
|
|
* @param InOuter the outer to use for the new package
|
|
* @param Base the object that should be saved into the package
|
|
* @param TopLevelFlags For all objects which are not referenced [either directly, or indirectly] through Base, only objects
|
|
* that contain any of these flags will be saved. If 0 is specified, only objects which are referenced
|
|
* by Base will be saved into the package.
|
|
* @param Filename the name to use for the new package file
|
|
* @param Error error output
|
|
* @param Conform if non-NULL, all index tables for this will be sorted to match the order of the corresponding index table
|
|
* in the conform package
|
|
* @param bForceByteSwapping whether we should forcefully byte swap before writing to disk
|
|
* @param bWarnOfLongFilename [opt] If true (the default), warn when saving to a long filename.
|
|
* @param SaveFlags Flags to control saving
|
|
* @param TargetPlatform The platform being saved for
|
|
* @param FinalTimeStamp If not FDateTime::MinValue(), the timestamp the saved file should be set to. (Intended for cooking only...)
|
|
*
|
|
* @return FSavePackageResultStruct enum value with the result of saving a package as well as extra data
|
|
*/
|
|
static FSavePackageResultStruct Save(UPackage* InOuter, UObject* Base, EObjectFlags TopLevelFlags, const TCHAR* Filename,
|
|
FOutputDevice* Error = GError, FLinkerNull* Conform = NULL, bool bForceByteSwapping = false, bool bWarnOfLongFilename = true,
|
|
uint32 SaveFlags = SAVE_None, const class ITargetPlatform* TargetPlatform = NULL, const FDateTime& FinalTimeStamp = FDateTime::MinValue(),
|
|
bool bSlowTask = true, class FArchiveDiffMap* InOutDiffMap = nullptr,
|
|
FSavePackageContext* SavePackageContext = nullptr);
|
|
|
|
/**
|
|
* Save an asset into an Unreal Package
|
|
* Save2 is currently experimental and shouldn't be used until it can safely replace Save.
|
|
*/
|
|
static FSavePackageResultStruct Save2(UPackage* InPackage, UObject* InAsset, const TCHAR* InFilename, FSavePackageArgs& SaveArgs);
|
|
|
|
/**
|
|
* Save a list of packages concurrently using Save2 mechanism
|
|
* SaveConcurrent is currently experimental and shouldn't be used until it can safely replace Save.
|
|
*/
|
|
static ESavePackageResult SaveConcurrent(TArrayView<FPackageSaveInfo> InPackages, FSavePackageArgs& SaveArgs, TArray<FSavePackageResultStruct>& OutResults);
|
|
|
|
/**
|
|
* Save one specific object (along with any objects it references contained within the same Outer) into an Unreal package.
|
|
*
|
|
* @param InOuter the outer to use for the new package
|
|
* @param Base the object that should be saved into the package
|
|
* @param TopLevelFlags For all objects which are not referenced [either directly, or indirectly] through Base, only objects
|
|
* that contain any of these flags will be saved. If 0 is specified, only objects which are referenced
|
|
* by Base will be saved into the package.
|
|
* @param Filename the name to use for the new package file
|
|
* @param Error error output
|
|
* @param Conform if non-NULL, all index tables for this will be sorted to match the order of the corresponding index table
|
|
* in the conform package
|
|
* @param bForceByteSwapping whether we should forcefully byte swap before writing to disk
|
|
* @param bWarnOfLongFilename [opt] If true (the default), warn when saving to a long filename.
|
|
* @param SaveFlags Flags to control saving
|
|
* @param TargetPlatform The platform being saved for
|
|
* @param FinalTimeStamp If not FDateTime::MinValue(), the timestamp the saved file should be set to. (Intended for cooking only...)
|
|
*
|
|
* @return true if the package was saved successfully.
|
|
*/
|
|
static bool SavePackage(UPackage* InOuter, UObject* Base, EObjectFlags TopLevelFlags, const TCHAR* Filename,
|
|
FOutputDevice* Error = GError, FLinkerNull* Conform = NULL, bool bForceByteSwapping = false, bool bWarnOfLongFilename = true,
|
|
uint32 SaveFlags = SAVE_None, const class ITargetPlatform* TargetPlatform = NULL, const FDateTime& FinalTimeStamp = FDateTime::MinValue(), bool bSlowTask = true);
|
|
|
|
/** Wait for any SAVE_Async file writes to complete **/
|
|
static void WaitForAsyncFileWrites();
|
|
|
|
/**
|
|
* Determines if a package contains no more assets.
|
|
*
|
|
* @param Package the package to test
|
|
* @param LastReferencer the optional last UObject referencer to this package. This object will be excluded when determining if the package is empty
|
|
* @return true if Package contains no more assets.
|
|
*/
|
|
static bool IsEmptyPackage(UPackage* Package, const UObject* LastReferencer = NULL);
|
|
};
|
|
PRAGMA_ENABLE_DEPRECATION_WARNINGS
|