ouczbs/EM_Task
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
EM_Task/CoreUObject/Public/UObject/Package.h

648 lines
24 KiB
C
Raw Permalink Normal View History

add
2026-02-13 16:18:33 +08:00
// 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
Reference in New Issue Copy Permalink