ObjectResource.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "Misc/AssertionMacros.h"
#include "Misc/CString.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/Guid.h"
#include "Serialization/BulkDataCookedIndex.h"
#include "Serialization/StructuredArchive.h"
#include "Serialization/StructuredArchiveAdapters.h"
#include "Serialization/StructuredArchiveSlots.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectMacros.h"
#if !WITH_VERSE_VM
#include "Containers/Utf8String.h"
#endif
 
class FArchive;
class FLinkerLoad;
class FPackageIndex;
class UClass;
class UObject;
 
namespace Verse
{
    struct VCppClassInfo;
    struct VCell;
    struct VUniqueString;
}
 
class FPackageIndex
{
    int32 Index;
 
    UE_FORCEINLINE_HINT explicit FPackageIndex(int32 InIndex)
        : Index(InIndex)
    {
 
    }
public:
    UE_FORCEINLINE_HINT FPackageIndex()
        : Index(0)
    {
 
    }
    UE_FORCEINLINE_HINT bool IsImport() const
    {
        return Index < 0;
    }
    UE_FORCEINLINE_HINT bool IsExport() const
    {
        return Index > 0;
    }
    UE_FORCEINLINE_HINT bool IsNull() const
    {
        return Index == 0;
    }
    inline int32 ToImport() const
    {
        check(IsImport());
        return -Index - 1;
    }
    inline int32 ToExport() const
    {
        check(IsExport());
        return Index - 1;
    }
    UE_FORCEINLINE_HINT int32 ForDebugging() const
    {
        return Index;
    }
 
    inline static FPackageIndex FromImport(int32 ImportIndex)
    {
        check(ImportIndex >= 0);
        return FPackageIndex(-ImportIndex - 1);
    }
    inline static FPackageIndex FromExport(int32 ExportIndex)
    {
        check(ExportIndex >= 0);
        return FPackageIndex(ExportIndex + 1);
    }
 
    UE_FORCEINLINE_HINT bool operator==(const FPackageIndex& Other) const
    {
        return Index == Other.Index;
    }
    UE_FORCEINLINE_HINT bool operator!=(const FPackageIndex& Other) const
    {
        return Index != Other.Index;
    }
 
    UE_FORCEINLINE_HINT bool operator<(const FPackageIndex& Other) const
    {
        return Index < Other.Index;
    }
    UE_FORCEINLINE_HINT bool operator>(const FPackageIndex& Other) const
    {
        return Index > Other.Index;
    }
    UE_FORCEINLINE_HINT bool operator<=(const FPackageIndex& Other) const
    {
        return Index <= Other.Index;
    }
    UE_FORCEINLINE_HINT bool operator>=(const FPackageIndex& Other) const
    {
        return Index >= Other.Index;
    }
    inline friend FArchive& operator<<(FArchive& Ar, FPackageIndex& Value)
    {
        FStructuredArchiveFromArchive(Ar).GetSlot() << Value;
        return Ar;
    }
 
    UE_FORCEINLINE_HINT friend void operator<<(FStructuredArchive::FSlot Slot, FPackageIndex& Value)
    {
        Slot << Value.Index;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT friend uint32 GetTypeHash(const FPackageIndex& In)
    {
        return uint32(In.Index);
    }
 
    friend FString LexToString(const FPackageIndex& Value)
    {
        return FString::FromInt(Value.Index);
    }
 
    friend void LexFromString(FPackageIndex& Value, const TCHAR* String)
    {
        Value.Index = FCString::Atoi(String);
    }
};
 
struct FObjectResource
{
    FName           ObjectName;
 
    FPackageIndex   OuterIndex;
 
#if WITH_EDITORONLY_DATA
    FName           OldClassName;
#endif
 
    FObjectResource();
    FObjectResource( UObject* InObject );
};
 
/*-----------------------------------------------------------------------------
    FObjectExport.
-----------------------------------------------------------------------------*/
 
struct FObjectExport : public FObjectResource
{
    FPackageIndex   ClassIndex;
 
    FPackageIndex ThisIndex;
 
    FPackageIndex   SuperIndex;
 
    FPackageIndex   TemplateIndex;
 
    EObjectFlags    ObjectFlags;
 
    int64           SerialSize;
 
    int64           SerialOffset;
 
    int64               ScriptSerializationStartOffset;
 
    int64               ScriptSerializationEndOffset;
 
    UObject*        Object;
 
    int32           HashNext;
 
    bool            bForcedExport:1;   
 
    bool            bNotForClient:1;   
 
    bool            bNotForServer:1;
 
    bool            bNotAlwaysLoadedForEditorGame:1;
 
    bool            bIsAsset:1;
 
    bool            bIsInheritedInstance:1;
 
    bool            bGeneratePublicHash:1;
 
    bool            bExportLoadFailed:1;
 
    bool            bWasFiltered:1;
 
    uint32          PackageFlags;
 
    int32 FirstExportDependency;
    int32 SerializationBeforeSerializationDependencies;
    int32 CreateBeforeSerializationDependencies;
    int32 SerializationBeforeCreateDependencies;
    int32 CreateBeforeCreateDependencies;
 
    COREUOBJECT_API FObjectExport();
    FObjectExport(UObject* InObject, bool bInNotAlwaysLoadedForEditorGame = true);
 
    // Workaround for clang deprecation warnings for deprecated PackageGuid member in implicit constructors
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    FObjectExport(FObjectExport&&) = default;
    FObjectExport(const FObjectExport&) = default;
    FObjectExport& operator=(FObjectExport&&) = default;
    FObjectExport& operator=(const FObjectExport&) = default;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    COREUOBJECT_API void ResetObject();
    
    friend COREUOBJECT_API FArchive& operator<<(FArchive& Ar, FObjectExport& E);
    friend COREUOBJECT_API void operator<<(FStructuredArchive::FSlot Slot, FObjectExport& E);
};
 
/*-----------------------------------------------------------------------------
    FObjectTextExport
-----------------------------------------------------------------------------*/
 
// TODO SavePackageDeprecation: remove once SavePackage2 replaces SavePackage
struct FObjectTextExport
{
    FObjectTextExport(FObjectExport& InExport, UObject* InOuter)
        : Export(InExport)
        , Outer(InOuter)
    {
    }
 
    FObjectExport& Export;
 
    UObject* Outer;
 
    FString ClassName;
 
    FString SuperStructName;
 
    FString OuterName;
 
    friend COREUOBJECT_API void operator<<(FStructuredArchive::FSlot Slot, FObjectTextExport& E);
};
 
/*-----------------------------------------------------------------------------
    FObjectImport.
-----------------------------------------------------------------------------*/
 
struct FObjectImport : public FObjectResource
{
    FName           ClassPackage;
 
    FName           ClassName;
 
#if WITH_EDITORONLY_DATA
    FName           PackageName;
#endif
 
    int32             SourceIndex;
 
    bool            bImportOptional;
 
    bool            bImportPackageHandled;
    bool            bImportSearchedFor;
    bool            bImportFailed;
 
    UObject* XObject;
 
    FLinkerLoad* SourceLinker;
 
    COREUOBJECT_API FObjectImport();
    FObjectImport( UObject* InObject );
    FObjectImport( UObject* InObject, UClass* InClass );
 
    bool HasPackageName() const
    {
#if WITH_EDITORONLY_DATA
        return !PackageName.IsNone();
#else
        return false;
#endif
    }
 
    FName GetPackageName() const
    {
#if WITH_EDITORONLY_DATA
        return PackageName;
#else
        return NAME_None;
#endif
    }
 
    void SetPackageName(FName InPackageName)
    {
#if WITH_EDITORONLY_DATA
        PackageName = InPackageName;
#endif
    }
    
    friend COREUOBJECT_API FArchive& operator<<(FArchive& Ar, FObjectImport& I);
    friend COREUOBJECT_API void operator<<( FStructuredArchive::FSlot Slot, FObjectImport& I );
};
 
enum class EObjectDataResourceFlags : uint32
{
    None                    = 0,
    Inline                  = (1 << 0),
    Streaming               = (1 << 1),
    Optional                = (1 << 2),
    Duplicate               = (1 << 3),
    MemoryMapped            = (1 << 4),
    DerivedDataReference    = (1 << 5),
};
ENUM_CLASS_FLAGS(EObjectDataResourceFlags);
 
struct FObjectDataResource
{
    enum class EVersion : uint32
    {
        Invalid,
        Initial,
        AddedCookedIndex,
        LatestPlusOne,
        Latest = LatestPlusOne - 1
    };
 
    EObjectDataResourceFlags Flags = EObjectDataResourceFlags::None;
    FBulkDataCookedIndex CookedIndex;
    int64 SerialOffset = -1;
    int64 DuplicateSerialOffset = -1;
    int64 SerialSize = -1;
    int64 RawSize = -1;
    FPackageIndex OuterIndex;
    uint32 LegacyBulkDataFlags = 0;
    COREUOBJECT_API static FArchive& Serialize(FArchive& Ar, TArray<FObjectDataResource>& DataResources);
    COREUOBJECT_API static void Serialize(FStructuredArchive::FSlot Slot, TArray<FObjectDataResource>& DataResources);
};
 
struct FCellResource
{
#if WITH_VERSE_VM || defined(__INTELLISENSE__)
    Verse::VUniqueString* VersePath;
#else
    FUtf8String VersePath;
#endif
};
 
struct FCellExport : FCellResource
{
#if WITH_VERSE_VM || defined(__INTELLISENSE__)
    const Verse::VCppClassInfo* CppClassInfo;
#else
    FName CppClassInfo;
#endif
 
    int64 SerialOffset;
    int64 SerialLayoutSize;
    int64 SerialSize;
 
    Verse::VCell* Cell;
 
    int32 FirstExportDependency;
    int32 SerializationBeforeSerializationDependencies;
    int32 CreateBeforeSerializationDependencies;
 
    COREUOBJECT_API FCellExport();
#if WITH_VERSE_VM || defined(__INTELLISENSE__)
    FCellExport(Verse::VCell* InCell);
#endif
 
    friend COREUOBJECT_API FArchive& operator<<(FArchive& Ar, FCellExport& E);
    friend COREUOBJECT_API void operator<<(FStructuredArchive::FSlot Slot, FCellExport& E);
};
 
struct FCellImport : FCellResource
{
    FPackageIndex PackageIndex;
 
    Verse::VCell* Cell;
 
    COREUOBJECT_API FCellImport();
    FCellImport(Verse::VCell* InCell);
 
    friend COREUOBJECT_API FArchive& operator<<(FArchive& Ar, FCellImport& I);
    friend COREUOBJECT_API void operator<<(FStructuredArchive::FSlot Slot, FCellImport& I);
};