PackageFileSummary.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 "IO/IoHash.h"
#include "Misc/EngineVersion.h"
#include "Misc/Guid.h"
#include "Serialization/CustomVersion.h"
#include "Serialization/StructuredArchive.h"
#include "UObject/ObjectVersion.h"
 
#if WITH_EDITORONLY_DATA
#include "IO/IoHash.h"
#endif
 
class FArchive;
struct FCompressedChunk;
 
/*----------------------------------------------------------------------------
    Items stored in Unrealfiles.
----------------------------------------------------------------------------*/
 
//@todo: shouldn't need ExportCount/NameCount with the linker free package map; if so, clean this stuff up
struct FGenerationInfo
{
    int32 ExportCount;
 
    int32 NameCount;
 
    FGenerationInfo( int32 InExportCount, int32 InNameCount );
 
    void Serialize(FArchive& Ar, const struct FPackageFileSummary& Summary);
    void Serialize(FStructuredArchive::FSlot Slot, const struct FPackageFileSummary& Summary);
};
 
struct FPackageFileSummary
{
    int32       Tag;
 
private:
    /* UE file version */
    FPackageFileVersion FileVersionUE;
    /* Licensee file version */
    int32       FileVersionLicenseeUE;
    /* Custom version numbers. Keyed off a unique tag for each custom component. */
    FCustomVersionContainer CustomVersionContainer;
 
    uint32  PackageFlags;
 
public:
    int32       TotalHeaderSize;
 
    FString PackageName;
 
    int32       NameCount;
 
    int32   NameOffset;
 
    int32       SoftObjectPathsCount;
 
    int32       SoftObjectPathsOffset;
 
    FString     LocalizationId;
 
    int32       GatherableTextDataCount;
 
    int32       GatherableTextDataOffset;
 
    int32       MetaDataOffset;
 
    int32       ExportCount;
 
    int32       ExportOffset;
 
    int32       ImportCount;
 
    int32       ImportOffset;
 
    int32       CellExportCount;
 
    int32       CellExportOffset;
 
    int32       CellImportCount;
 
    int32       CellImportOffset;
 
    int32       DependsOffset;
 
    int32       SoftPackageReferencesCount;
 
    int32       SoftPackageReferencesOffset;
 
    int32       SearchableNamesOffset;
 
    int32       ThumbnailTableOffset;
 
    int32       ImportTypeHierarchiesCount;
 
    int32       ImportTypeHierarchiesOffset;
 
private:
    FIoHash     SavedHash;
 
public:
#if WITH_EDITORONLY_DATA
    FGuid   PersistentGuid;
#endif
 
    TArray<FGenerationInfo> Generations;
 
    FEngineVersion SavedByEngineVersion;
 
    FEngineVersion CompatibleWithEngineVersion;
 
    uint32  CompressionFlags;
 
    uint32  PackageSource;
 
    bool bUnversioned;
 
    int32   AssetRegistryDataOffset;
 
    int64   BulkDataStartOffset;
    int32   WorldTileInfoDataOffset;
 
    TArray<int32>   ChunkIDs;
 
    int32       PreloadDependencyCount;
 
    int32       PreloadDependencyOffset;
 
    int32       NamesReferencedFromExportDataCount;
    
    int64       PayloadTocOffset;
    
    int32       DataResourceOffset;
 
    COREUOBJECT_API FPackageFileSummary();
 
    // Workaround for clang deprecation warnings for deprecated members in implicit constructors
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    FPackageFileSummary(FPackageFileSummary&&) = default;
    FPackageFileSummary(const FPackageFileSummary&) = default;
    FPackageFileSummary& operator=(FPackageFileSummary&&) = default;
    FPackageFileSummary& operator=(const FPackageFileSummary&) = default;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
    
    FPackageFileVersion GetFileVersionUE() const
    {
        return FileVersionUE;
    }
 
    UE_DEPRECATED(5.0, "Use UEVer instead which returns the version as a FPackageFileVersion. See the @FPackageFileVersion documentation for further details")
    int32 GetFileVersionUE4() const
    {
        return FileVersionUE.FileVersionUE4;
    }
 
    int32 GetFileVersionLicenseeUE() const
    {
        return FileVersionLicenseeUE;
    }
 
    UE_DEPRECATED(5.0, "Use GetFileVersionLicenseeUE instead")
    int32 GetFileVersionLicenseeUE4() const
    {
        return GetFileVersionLicenseeUE();
    }
 
    const FCustomVersionContainer& GetCustomVersionContainer() const
    {
        return CustomVersionContainer;
    }
 
    void SetCustomVersionContainer(const FCustomVersionContainer& InContainer);
 
    COREUOBJECT_API void SetFileVersions(const int32 EpicUE4, const int32 EpicUE5, const int32 LicenseeUE, const bool bInSaveUnversioned = false);
    
    UE_DEPRECATED(5.0, "Use the other overload of SetFileVersions that takes an UE5 version as well")
    inline void SetFileVersions(const int32 EpicUE, const int32 LicenseeUE, const bool bInSaveUnversioned = false)
    {
        SetFileVersions(EpicUE, GPackageFileUEVersion.FileVersionUE5, LicenseeUE, bInSaveUnversioned);
    }
 
    void SetToLatestFileVersions(const bool bInSaveUnversioned)
    {
        FileVersionUE = GPackageFileUEVersion;
        FileVersionLicenseeUE = GPackageFileLicenseeUEVersion;
 
        bUnversioned = bInSaveUnversioned;
    }
 
    bool IsFileVersionTooOld() const
    {
        return FileVersionUE < VER_UE4_OLDEST_LOADABLE_PACKAGE;
    }
 
    bool IsFileVersionTooNew() const
    {
        return FileVersionUE.FileVersionUE4 > GPackageFileUEVersion.FileVersionUE4 || FileVersionUE.FileVersionUE5 > GPackageFileUEVersion.FileVersionUE5;
    }
 
    COREUOBJECT_API bool IsFileVersionValid() const;
 
    uint32 GetPackageFlags() const
    {
        return PackageFlags;
    }
 
    void SetPackageFlags(uint32 InPackageFlags);
 
#if WITH_EDITORONLY_DATA
    COREUOBJECT_API FIoHash GetSavedHash() const;
    COREUOBJECT_API void SetSavedHash(const FIoHash& InSavedHash);
    COREUOBJECT_API int64 GetSavedHashRelativeOffset() const;
#endif
 
    friend COREUOBJECT_API FArchive& operator<<(FArchive& Ar, FPackageFileSummary& Sum);
    friend COREUOBJECT_API void operator<<(FStructuredArchive::FSlot Slot, FPackageFileSummary& Sum);
 
private:
 
    void InvalidateFileVersion()
    {
        FileVersionUE = FPackageFileVersion::CreateUE4Version((EUnrealEngineObjectUE4Version)(VER_UE4_OLDEST_LOADABLE_PACKAGE - 1));
    }
};