#include "Misc/EnumClassFlags.h"
#include "UObject/Script.h"

Classes
class	FVTableHelper

struct	FReferencerInformation

struct	FReferencerInformationList

struct	FUObjectCppClassStaticFunctions

class	FRestoreForUObjectOverwrite

Namespaces
namespace	UC

namespace	UI

namespace	UF

namespace	UP

namespace	US

namespace	UM

namespace	GameplayTagsManager

namespace	UE

namespace	UE4

Macros
#define	USE_COMPILED_IN_NATIVES 1

#define	THREADSAFE_UOBJECTS 1

#define	USTRUCT_ISCHILDOF_OUTERWALK 1

#define	USTRUCT_ISCHILDOF_STRUCTARRAY 2

#define	USTRUCT_FAST_ISCHILDOF_IMPL USTRUCT_ISCHILDOF_STRUCTARRAY

#define	USTRUCT_FAST_ISCHILDOF_COMPARE_WITH_OUTERWALK 0

#define	UE_WITH_CONSTINIT_UOBJECT 0

#define	UE_CONSTINIT_UOBJECT_DECL constinit

#define	PKG_TransientFlags (PKG_NewlyCreated \| PKG_IsSaving \| PKG_ReloadingForCooker)

#define	PKG_InMemoryOnly (EPackageFlags)(PKG_CompiledIn \| PKG_NewlyCreated)

#define	NO_API

#define	CLASS_Inherit

#define	CLASS_RecompilerClear ((EClassFlags)(CLASS_Inherit \| CLASS_Abstract \| CLASS_Native \| CLASS_Intrinsic \| CLASS_TokenStreamAssembled))

#define	CLASS_ShouldNeverBeLoaded ((EClassFlags)(CLASS_Native \| CLASS_Optional \| CLASS_Intrinsic \| CLASS_TokenStreamAssembled))

#define	CLASS_ScriptInherit ((EClassFlags)(CLASS_Inherit \| CLASS_EditInlineNew \| CLASS_CollapseCategories))

#define	CLASS_SaveInCompiledInClasses

#define	CLASS_AllFlags ((EClassFlags)0xFFFFFFFFu)

#define	CASTCLASS_AllFlags ((EClassCastFlags)0xFFFFFFFFFFFFFFFF)

#define	CPF_NativeAccessSpecifiers (CPF_NativeAccessSpecifierPublic \| CPF_NativeAccessSpecifierProtected \| CPF_NativeAccessSpecifierPrivate)

#define	CPF_ParmFlags (CPF_Parm \| CPF_OutParm \| CPF_ReturnParm \| CPF_RequiredParm \| CPF_ReferenceParm \| CPF_ConstParm )

#define	CPF_PropagateToArrayInner (CPF_ExportObject \| CPF_PersistentInstance \| CPF_InstancedReference \| CPF_ContainsInstancedReference \| CPF_Config \| CPF_EditConst \| CPF_Deprecated \| CPF_EditorOnly \| CPF_AutoWeak \| CPF_UObjectWrapper )

#define	CPF_PropagateToOptionalInner (CPF_ExportObject \| CPF_PersistentInstance \| CPF_InstancedReference \| CPF_ContainsInstancedReference \| CPF_Config \| CPF_EditConst \| CPF_Deprecated \| CPF_EditorOnly \| CPF_AutoWeak \| CPF_UObjectWrapper \| CPF_Edit )

#define	CPF_PropagateToMapValue (CPF_ExportObject \| CPF_PersistentInstance \| CPF_InstancedReference \| CPF_ContainsInstancedReference \| CPF_Config \| CPF_EditConst \| CPF_Deprecated \| CPF_EditorOnly \| CPF_AutoWeak \| CPF_UObjectWrapper \| CPF_Edit )

#define	CPF_PropagateToMapKey (CPF_ExportObject \| CPF_PersistentInstance \| CPF_InstancedReference \| CPF_ContainsInstancedReference \| CPF_Config \| CPF_EditConst \| CPF_Deprecated \| CPF_EditorOnly \| CPF_AutoWeak \| CPF_UObjectWrapper \| CPF_Edit )

#define	CPF_PropagateToSetElement (CPF_ExportObject \| CPF_PersistentInstance \| CPF_InstancedReference \| CPF_ContainsInstancedReference \| CPF_Config \| CPF_EditConst \| CPF_Deprecated \| CPF_EditorOnly \| CPF_AutoWeak \| CPF_UObjectWrapper \| CPF_Edit )

#define	CPF_InterfaceClearMask (CPF_ExportObject\|CPF_InstancedReference\|CPF_ContainsInstancedReference)

#define	CPF_DevelopmentAssets (CPF_EditorOnly)

#define	CPF_ComputedFlags (CPF_IsPlainOldData \| CPF_NoDestructor \| CPF_ZeroConstructor \| CPF_HasGetValueTypeHash)

#define	CPF_TObjectPtrWrapper (CPF_UObjectWrapper \| CPF_TObjectPtr)

#define	CPF_AllFlags ((EPropertyFlags)0xFFFFFFFFFFFFFFFF)

#define	RF_AllFlags (EObjectFlags)0xffffffff
	All flags, used mainly for error checking.

#define	RF_Load ((EObjectFlags)(RF_Public \| RF_Standalone \| RF_Transactional \| RF_ClassDefaultObject \| RF_ArchetypeObject \| RF_DefaultSubObject \| RF_TextExportTransient \| RF_InheritableComponentTemplate \| RF_DuplicateTransient \| RF_NonPIEDuplicateTransient \| RF_MigratingAsset))

#define	RF_PropagateToSubObjects ((EObjectFlags)(RF_Public \| RF_ArchetypeObject \| RF_Transactional \| RF_Transient))

#define	EInternalObjectFlags_MinFlagBitIndex 14

#define	EInternalObjectFlags_RefCountMask 0xFFFFFFFF

#define	EInternalObjectFlags_GarbageCollectionKeepFlags (EInternalObjectFlags::Borrowed \| EInternalObjectFlags::Native \| EInternalObjectFlags::Async \| EInternalObjectFlags::AsyncLoadingPhase1 \| EInternalObjectFlags::AsyncLoadingPhase2 \| EInternalObjectFlags::LoaderImport)

#define	EInternalObjectFlags_AllFlags (EInternalObjectFlags::Remote \| EInternalObjectFlags::RemoteReference \| EInternalObjectFlags::Borrowed \| EInternalObjectFlags::ReachabilityFlag0 \| EInternalObjectFlags::ReachabilityFlag1 \| EInternalObjectFlags::ReachabilityFlag2 \| EInternalObjectFlags::AutoRTFMConstructionAborted \| EInternalObjectFlags::LoaderImport \| EInternalObjectFlags::Garbage \| EInternalObjectFlags::ReachableInCluster \| EInternalObjectFlags::ClusterRoot \| EInternalObjectFlags::Native \| EInternalObjectFlags::Async \| EInternalObjectFlags::AsyncLoadingPhase1 \| EInternalObjectFlags::AsyncLoadingPhase2 \| EInternalObjectFlags::RootSet \| EInternalObjectFlags::PendingConstruction \| EInternalObjectFlags::Unreachable)

#define	EInternalObjectFlags_RootFlags (EInternalObjectFlags::RootSet \| EInternalObjectFlags_GarbageCollectionKeepFlags)

#define	EInternalObjectFlags_ReachabilityFlags (EInternalObjectFlags::ReachabilityFlag0 \| EInternalObjectFlags::ReachabilityFlag1 \| EInternalObjectFlags::ReachabilityFlag2 \| EInternalObjectFlags::Unreachable)

#define	EInternalObjectFlags_AsyncLoading (EInternalObjectFlags::AsyncLoadingPhase1 \| EInternalObjectFlags::AsyncLoadingPhase2)

#define	DEFAULT_OBJECT_PREFIX TEXT("Default__")

#define	UPROPERTY(...)
	UObject definition macros.

#define	UFUNCTION(...)

#define	USTRUCT(...)

#define	UMETA(...)

#define	UPARAM(...)

#define	UENUM(...)

#define	UDELEGATE(...)

#define	RIGVM_METHOD(...)

#define	VMODULE(...)

#define	UE_INLINE_STRINGIFY(name) #name

#define	UE_INLINE_GENERATED_CPP_BY_NAME(name) UE_INLINE_STRINGIFY(name.gen.cpp)

#define	BODY_MACRO_COMBINE_INNER(A, B, C, D) A##B##C##D

#define	BODY_MACRO_COMBINE(A, B, C, D) BODY_MACRO_COMBINE_INNER(A,B,C,D)

#define	GENERATED_BODY_LEGACY(...) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_GENERATED_BODY_LEGACY);

#define	GENERATED_BODY(...) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_GENERATED_BODY);

#define	GENERATED_USTRUCT_BODY(...) GENERATED_BODY()

#define	GENERATED_UCLASS_BODY(...) GENERATED_BODY_LEGACY()

#define	GENERATED_UINTERFACE_BODY(...) GENERATED_BODY_LEGACY()

#define	GENERATED_IINTERFACE_BODY(...) GENERATED_BODY_LEGACY()

#define	UCLASS(...) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_PROLOG)

#define	VINTERFACES(...) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_VINTERFACES)

#define	UINTERFACE(...) UCLASS()

#define	DECLARE_FUNCTION(func) static void func( UObject* Context, FFrame& Stack, RESULT_DECL )

#define	DEFINE_FUNCTION(func) void func( UObject* Context, FFrame& Stack, RESULT_DECL )

#define	RELAY_CONSTRUCTOR(TClass, TSuperClass) TClass(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get()) : TSuperClass(ObjectInitializer) {}

#define	UE_DELETE_COPY_MOVE_CONSTRUCTORS(TClass) TClass(const TClass&) = delete; TClass(TClass&&) = delete;

#define	COMPILED_IN_FLAGS(TStaticFlags) (TStaticFlags \| CLASS_Intrinsic)

#define	DECLARE_SERIALIZER(TClass)

#define	IMPLEMENT_FARCHIVE_SERIALIZER(TClass) void TClass::Serialize(FArchive& Ar) { TClass::Serialize(FStructuredArchiveFromArchive(Ar).GetSlot().EnterRecord()); }

#define	IMPLEMENT_FSTRUCTUREDARCHIVE_SERIALIZER(TClass) void TClass::Serialize(FStructuredArchive::FRecord Record) { FArchiveUObjectFromStructuredArchive Ar(Record.EnterField(TEXT("BaseClassAutoGen"))); TClass::Serialize(Ar.GetArchive()); Ar.Close(); }

#define	DECLARE_FARCHIVE_SERIALIZER(TClass, API) virtual API void Serialize(FArchive& Ar) override;

#define	DECLARE_FSTRUCTUREDARCHIVE_SERIALIZER(TClass, API) virtual API void Serialize(FStructuredArchive::FRecord Record) override;

#define	CONSTRUCT_RELOAD_VERSION_INFO(VersionInfo, ...) VersionInfo()

#define	DECLARE_CLASS(TClass, TSuperClass, TStaticFlags, TStaticCastFlags, TPackage, TRequiredAPI)

#define	DECLARE_CLASS2(TClass, TSuperClass, TStaticFlags, TStaticCastFlags, TPackage, TPrivateAccessor)

#define	DEFINE_FORBIDDEN_DEFAULT_CONSTRUCTOR_CALL(TClass) static_assert(false, "You have to define " #TClass "::" #TClass "() or " #TClass "::" #TClass "(const FObjectInitializer&). This is required by UObject system to work correctly.");

#define	DEFINE_DEFAULT_CONSTRUCTOR_CALL(TClass) static void __DefaultConstructor(const FObjectInitializer& X) { new((EInternal*)X.GetObj())TClass; }

#define	DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) static void __DefaultConstructor(const FObjectInitializer& X) { new((EInternal*)X.GetObj())TClass(X); }

#define	DEFINE_ABSTRACT_DEFAULT_CONSTRUCTOR_CALL(TClass) DEFINE_DEFAULT_CONSTRUCTOR_CALL(TClass)

#define	DEFINE_ABSTRACT_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass)

#define	DECLARE_VTABLE_PTR_HELPER_CTOR(API, TClass)

#define	DEFINE_VTABLE_PTR_HELPER_CTOR_NS(Namespace, TClass) Namespace TClass::TClass(FVTableHelper& Helper) : Super(Helper) {};

#define	DEFINE_VTABLE_PTR_HELPER_CTOR(TClass) DEFINE_VTABLE_PTR_HELPER_CTOR_NS(, TClass)

#define	DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER_DUMMY()

#define	DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(TClass) DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER_DUMMY()

#define	DECLARE_CLASS_INTRINSIC_NO_CTOR(TClass, TSuperClass, TStaticFlags, TPackage)

#define	DECLARE_CLASS_INTRINSIC(TClass, TSuperClass, TStaticFlags, TPackage) DECLARE_CLASS_INTRINSIC_API(TClass,TSuperClass,TStaticFlags,TPackage, NO_API)

#define	DECLARE_CLASS_INTRINSIC_API(TClass, TSuperClass, TStaticFlags, TPackage, TRequiredAPI)

#define	DECLARE_CASTED_CLASS_INTRINSIC_WITH_API_NO_CTOR(TClass, TSuperClass, TStaticFlags, TPackage, TStaticCastFlags, TRequiredAPI)

#define	DECLARE_CASTED_CLASS_INTRINSIC_WITH_API(TClass, TSuperClass, TStaticFlags, TPackage, TStaticCastFlags, TRequiredAPI)

#define	DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR_NO_VTABLE_CTOR(TClass, TSuperClass, TStaticFlags, TPackage, TStaticCastFlags, TRequiredAPI)

#define	DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR(TClass, TSuperClass, TStaticFlags, TPackage, TStaticCastFlags, TRequiredAPI)

#define	DECLARE_CASTED_CLASS_INTRINSIC(TClass, TSuperClass, TStaticFlags, TPackage, TStaticCastFlags) DECLARE_CASTED_CLASS_INTRINSIC_WITH_API( TClass, TSuperClass, TStaticFlags, TPackage, TStaticCastFlags, NO_API) \

#define	DECLARE_WITHIN_INTERNAL(TWithinClass, bCanUseOnCDO)

#define	DECLARE_WITHIN(TWithinClass) DECLARE_WITHIN_INTERNAL( TWithinClass, false )

#define	DECLARE_WITHIN_UPACKAGE() DECLARE_WITHIN_INTERNAL( UPackage, true )

#define	UOBJECT_CPPCLASS_STATICFUNCTIONS_ALLCONFIGS(TClass) FUObjectCppClassStaticFunctions::AddReferencedObjectsType(&TClass::AddReferencedObjects)

#define	UOBJECT_CPPCLASS_STATICFUNCTIONS_WITHEDITORONLYDATA(TClass)

#define	UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS(TClass)

#define	IMPLEMENT_CLASS_NO_AUTO_REGISTRATION(TClass)

#define	IMPLEMENT_CLASS(TClass, TClassCrc)

#define	IMPLEMENT_INTRINSIC_CLASS(TClass, TRequiredAPI, TSuperClass, TSuperRequiredAPI, TPackage, InitCode)

#define	IMPLEMENT_CORE_INTRINSIC_CLASS(TClass, TSuperClass, InitCode) IMPLEMENT_INTRINSIC_CLASS(TClass, COREUOBJECT_API, TSuperClass, COREUOBJECT_API, CoreUObject, InitCode)

#define	REN_None (0x0000)

#define	REN_ForceNoResetLoaders (0x0001)

#define	REN_Test (0x0002)

#define	REN_DoNotDirty (0x0004)

#define	REN_DontCreateRedirectors (0x0010)

#define	REN_NonTransactional (0x0020)

#define	REN_ForceGlobalUnique (0x0040)

#define	REN_SkipGeneratedClasses (0x0080)

#define	REN_SkipComponentRegWork (0x0100)

#define	REN_AllowPackageLinkerMismatch (0x0200)

#define	VALIDATE_CLASS_REPS DO_CHECK

#define	DECLARE_VALIDATE_GENERATED_REP_ENUMS(API)

Typedefs
typedef uint64	ScriptPointerType

typedef uint32	ERenameFlags

typedef void(*	FAsyncCompletionCallback) (UObject LinkerRoot, void CallbackUserData)

Enumerations
enum	ELoadFlags { LOAD_None = 0x00000000 , LOAD_Async = 0x00000001 , LOAD_NoWarn = 0x00000002 , LOAD_EditorOnly = 0x00000004 , LOAD_ResolvingDeferredExports = 0x00000008 , LOAD_Verify = 0x00000010 , LOAD_NoVerify = 0x00000080 , LOAD_IsVerifying = 0x00000100 , LOAD_SkipLoadImportedPackages = 0x00000200 , UE_DEPRECATED =(5.5, "This flag is now obsolete as the functionality is unnecessary.") = 0x00000400 , LOAD_DisableDependencyPreloading = 0x00001000 , LOAD_Quiet = 0x00002000 , LOAD_FindIfFail = 0x00004000 , LOAD_MemoryReader = 0x00008000 , LOAD_NoRedirects = 0x00010000 , LOAD_ForDiff = 0x00020000 , LOAD_PackageForPIE = 0x00080000 , LOAD_DeferDependencyLoads = 0x00100000 , LOAD_ForFileDiff = 0x00200000 , LOAD_DisableCompileOnLoad = 0x00400000 , LOAD_DisableEngineVersionChecks = 0x00800000 }

enum	ESaveFlags { SAVE_None = 0x00000000 , SAVE_NoError = 0x00000001 , SAVE_FromAutosave = 0x00000002 , SAVE_KeepDirty = 0x00000004 , UE_DEPRECATED =(5.5, "This flag is now obsolete as the functionality is unnecessary.") = 0x00000400 , SAVE_Async = 0x00000010 , SAVE_Unversioned_Native = 0x00000020 , SAVE_CutdownPackage = 0x00000040 , SAVE_KeepEditorOnlyCookedPackages = 0x00000080 , SAVE_Concurrent = 0x00000100 , UE_DEPRECATED =(5.5, "This flag is now obsolete as the functionality is unnecessary.") = 0x00000400 , SAVE_BulkDataByReference = 0x00002000 , SAVE_Unversioned_Properties = 0x00004000 , SAVE_Optional = 0x00008000 , SAVE_AllowTimeout = 0x00010000 , SAVE_RehydratePayloads = 0x00020000 , SAVE_CookSoftPackageReferences = 0x00040000 , SAVE_Unversioned = SAVE_Unversioned_Native \| SAVE_Unversioned_Properties }

enum	EPackageFlags { PKG_None = 0x00000000 , PKG_NewlyCreated = 0x00000001 , PKG_ClientOptional = 0x00000002 , PKG_ServerSideOnly = 0x00000004 , PKG_CompiledIn = 0x00000010 , PKG_ForDiffing = 0x00000020 , PKG_EditorOnly = 0x00000040 , PKG_Developer = 0x00000080 , PKG_UncookedOnly = 0x00000100 , PKG_Cooked = 0x00000200 , PKG_ContainsNoAsset = 0x00000400 , PKG_NotExternallyReferenceable = 0x00000800 , PKG_AccessSpecifierEpicInternal = 0x00001000 , PKG_UnversionedProperties = 0x00002000 , PKG_ContainsMapData = 0x00004000 , PKG_IsSaving = 0x00008000 , PKG_Compiling = 0x00010000 , PKG_ContainsMap = 0x00020000 , PKG_RequiresLocalizationGather = 0x00040000 , PKG_LoadUncooked = 0x00080000 , PKG_PlayInEditor = 0x00100000 , PKG_ContainsScript = 0x00200000 , PKG_DisallowExport = 0x00400000 , PKG_CookGenerated = 0x08000000 , PKG_DynamicImports = 0x10000000 , PKG_RuntimeGenerated = 0x20000000 , PKG_ReloadingForCooker = 0x40000000 , PKG_FilterEditorOnly = 0x80000000 }

enum	EStaticConstructor { EC_StaticConstructor }

enum	EInternal { EC_InternalUseOnlyConstructor }

enum	ECppProperty { EC_CppProperty }

enum	EClassFlags { CLASS_None = 0x00000000u , CLASS_Abstract = 0x00000001u , CLASS_DefaultConfig = 0x00000002u , CLASS_Config = 0x00000004u , CLASS_Transient = 0x00000008u , CLASS_Optional = 0x00000010u , CLASS_MatchedSerializers = 0x00000020u , CLASS_ProjectUserConfig = 0x00000040u , CLASS_Native = 0x00000080u , CLASS_NotPlaceable = 0x00000200u , CLASS_PerObjectConfig = 0x00000400u , CLASS_ReplicationDataIsSetUp = 0x00000800u , CLASS_EditInlineNew = 0x00001000u , CLASS_CollapseCategories = 0x00002000u , CLASS_Interface = 0x00004000u , CLASS_PerPlatformConfig = 0x00008000u , CLASS_Const = 0x00010000u , CLASS_NeedsDeferredDependencyLoading = 0x00020000u , CLASS_CompiledFromBlueprint = 0x00040000u , CLASS_MinimalAPI = 0x00080000u , CLASS_RequiredAPI = 0x00100000u , CLASS_DefaultToInstanced = 0x00200000u , CLASS_TokenStreamAssembled = 0x00400000u , CLASS_HasInstancedReference = 0x00800000u , CLASS_Hidden = 0x01000000u , CLASS_Deprecated = 0x02000000u , CLASS_HideDropDown = 0x04000000u , CLASS_GlobalUserConfig = 0x08000000u , CLASS_Intrinsic = 0x10000000u , CLASS_Constructed = 0x20000000u , CLASS_ConfigDoNotCheckDefaults = 0x40000000u , CLASS_NewerVersionExists = 0x80000000u }

enum	EClassCastFlags : uint64 { CASTCLASS_None = 0x0000000000000000 , CASTCLASS_UField = 0x0000000000000001 , CASTCLASS_FInt8Property = 0x0000000000000002 , CASTCLASS_UEnum = 0x0000000000000004 , CASTCLASS_UStruct = 0x0000000000000008 , CASTCLASS_UScriptStruct = 0x0000000000000010 , CASTCLASS_UClass = 0x0000000000000020 , CASTCLASS_FByteProperty = 0x0000000000000040 , CASTCLASS_FIntProperty = 0x0000000000000080 , CASTCLASS_FFloatProperty = 0x0000000000000100 , CASTCLASS_FUInt64Property = 0x0000000000000200 , CASTCLASS_FClassProperty = 0x0000000000000400 , CASTCLASS_FUInt32Property = 0x0000000000000800 , CASTCLASS_FInterfaceProperty = 0x0000000000001000 , CASTCLASS_FNameProperty = 0x0000000000002000 , CASTCLASS_FStrProperty = 0x0000000000004000 , CASTCLASS_FProperty = 0x0000000000008000 , CASTCLASS_FObjectProperty = 0x0000000000010000 , CASTCLASS_FBoolProperty = 0x0000000000020000 , CASTCLASS_FUInt16Property = 0x0000000000040000 , CASTCLASS_UFunction = 0x0000000000080000 , CASTCLASS_FStructProperty = 0x0000000000100000 , CASTCLASS_FArrayProperty = 0x0000000000200000 , CASTCLASS_FInt64Property = 0x0000000000400000 , CASTCLASS_FDelegateProperty = 0x0000000000800000 , CASTCLASS_FNumericProperty = 0x0000000001000000 , CASTCLASS_FMulticastDelegateProperty = 0x0000000002000000 , CASTCLASS_FObjectPropertyBase = 0x0000000004000000 , CASTCLASS_FWeakObjectProperty = 0x0000000008000000 , CASTCLASS_FLazyObjectProperty = 0x0000000010000000 , CASTCLASS_FSoftObjectProperty = 0x0000000020000000 , CASTCLASS_FTextProperty = 0x0000000040000000 , CASTCLASS_FInt16Property = 0x0000000080000000 , CASTCLASS_FDoubleProperty = 0x0000000100000000 , CASTCLASS_FSoftClassProperty = 0x0000000200000000 , CASTCLASS_UPackage = 0x0000000400000000 , CASTCLASS_ULevel = 0x0000000800000000 , CASTCLASS_AActor = 0x0000001000000000 , CASTCLASS_APlayerController = 0x0000002000000000 , CASTCLASS_APawn = 0x0000004000000000 , CASTCLASS_USceneComponent = 0x0000008000000000 , CASTCLASS_UPrimitiveComponent = 0x0000010000000000 , CASTCLASS_USkinnedMeshComponent = 0x0000020000000000 , CASTCLASS_USkeletalMeshComponent = 0x0000040000000000 , CASTCLASS_UBlueprint = 0x0000080000000000 , CASTCLASS_UDelegateFunction = 0x0000100000000000 , CASTCLASS_UStaticMeshComponent = 0x0000200000000000 , CASTCLASS_FMapProperty = 0x0000400000000000 , CASTCLASS_FSetProperty = 0x0000800000000000 , CASTCLASS_FEnumProperty = 0x0001000000000000 , CASTCLASS_USparseDelegateFunction = 0x0002000000000000 , CASTCLASS_FMulticastInlineDelegateProperty = 0x0004000000000000 , CASTCLASS_FMulticastSparseDelegateProperty = 0x0008000000000000 , CASTCLASS_FFieldPathProperty = 0x0010000000000000 , CASTCLASS_FLargeWorldCoordinatesRealProperty = 0x0080000000000000 , CASTCLASS_FOptionalProperty = 0x0100000000000000 , CASTCLASS_FVValueProperty = 0x0200000000000000 , CASTCLASS_FVRestValueProperty = 0x0400000000000000 , CASTCLASS_FVerseStringProperty = 0x0800000000000000 , CASTCLASS_FUtf8StrProperty = 0x1000000000000000 , CASTCLASS_FAnsiStrProperty = 0x2000000000000000 , CASTCLASS_FVCellProperty = 0x4000000000000000 }

enum	EPropertyFlags : uint64 { CPF_None = 0 , CPF_Edit = 0x0000000000000001 , CPF_ConstParm = 0x0000000000000002 , CPF_BlueprintVisible = 0x0000000000000004 , CPF_ExportObject = 0x0000000000000008 , CPF_BlueprintReadOnly = 0x0000000000000010 , CPF_Net = 0x0000000000000020 , CPF_EditFixedSize = 0x0000000000000040 , CPF_Parm = 0x0000000000000080 , CPF_OutParm = 0x0000000000000100 , CPF_ZeroConstructor = 0x0000000000000200 , CPF_ReturnParm = 0x0000000000000400 , CPF_DisableEditOnTemplate = 0x0000000000000800 , CPF_NonNullable = 0x0000000000001000 , CPF_Transient = 0x0000000000002000 , CPF_Config = 0x0000000000004000 , CPF_RequiredParm = 0x0000000000008000 , CPF_DisableEditOnInstance = 0x0000000000010000 , CPF_EditConst = 0x0000000000020000 , CPF_GlobalConfig = 0x0000000000040000 , CPF_InstancedReference = 0x0000000000080000 , CPF_ExperimentalExternalObjects = 0x0000000000100000 , CPF_DuplicateTransient = 0x0000000000200000 , CPF_SaveGame = 0x0000000001000000 , CPF_NoClear = 0x0000000002000000 , CPF_Virtual = 0x0000000004000000 , CPF_ReferenceParm = 0x0000000008000000 , CPF_BlueprintAssignable = 0x0000000010000000 , CPF_Deprecated = 0x0000000020000000 , CPF_IsPlainOldData = 0x0000000040000000 , CPF_RepSkip = 0x0000000080000000 , CPF_RepNotify = 0x0000000100000000 , CPF_Interp = 0x0000000200000000 , CPF_NonTransactional = 0x0000000400000000 , CPF_EditorOnly = 0x0000000800000000 , CPF_NoDestructor = 0x0000001000000000 , CPF_AutoWeak = 0x0000004000000000 , CPF_ContainsInstancedReference = 0x0000008000000000 , CPF_AssetRegistrySearchable = 0x0000010000000000 , CPF_SimpleDisplay = 0x0000020000000000 , CPF_AdvancedDisplay = 0x0000040000000000 , CPF_Protected = 0x0000080000000000 , CPF_BlueprintCallable = 0x0000100000000000 , CPF_BlueprintAuthorityOnly = 0x0000200000000000 , CPF_TextExportTransient = 0x0000400000000000 , CPF_NonPIEDuplicateTransient = 0x0000800000000000 , CPF_ExposeOnSpawn = 0x0001000000000000 , CPF_PersistentInstance = 0x0002000000000000 , CPF_UObjectWrapper = 0x0004000000000000 , CPF_HasGetValueTypeHash = 0x0008000000000000 , CPF_NativeAccessSpecifierPublic = 0x0010000000000000 , CPF_NativeAccessSpecifierProtected = 0x0020000000000000 , CPF_NativeAccessSpecifierPrivate = 0x0040000000000000 , CPF_SkipSerialization = 0x0080000000000000 , CPF_TObjectPtr = 0x0100000000000000 , CPF_ExperimentalOverridableLogic = 0x0200000000000000 , CPF_ExperimentalAlwaysOverriden = 0x0400000000000000 , CPF_ExperimentalNeverOverriden = 0x0800000000000000 , CPF_AllowSelfReference = 0x1000000000000000 }

enum class	EArrayPropertyFlags : uint8 { None , UsesMemoryImageAllocator }

enum class	EMapPropertyFlags : uint8 { None , UsesMemoryImageAllocator }

enum class	EPropertyObjectReferenceType : uint32 { None = 0 , Strong = 1 << 0 , Weak = 1 << 1 , Soft = 1 << 2 , Conservative = 1 << 3 , MAX = Conservative << 1 , Any = Strong \| Weak \| Soft \| Conservative }

enum	EObjectFlags { RF_NoFlags = 0x00000000 , RF_Public =0x00000001 , RF_Standalone =0x00000002 , RF_MarkAsNative =0x00000004 , RF_Transactional =0x00000008 , RF_ClassDefaultObject =0x00000010 , RF_ArchetypeObject =0x00000020 , RF_Transient =0x00000040 , RF_MarkAsRootSet =0x00000080 , RF_TagGarbageTemp =0x00000100 , RF_NeedInitialization =0x00000200 , RF_NeedLoad =0x00000400 , UE_DEPRECATED =(5.5, "This flag is now obsolete as the functionality is unnecessary.") = 0x00000400 , RF_NeedPostLoad =0x00001000 , RF_NeedPostLoadSubobjects =0x00002000 , RF_NewerVersionExists =0x00004000 , RF_BeginDestroyed =0x00008000 , RF_FinishDestroyed =0x00010000 , RF_BeingRegenerated =0x00020000 , RF_DefaultSubObject =0x00040000 , RF_WasLoaded =0x00080000 , RF_TextExportTransient =0x00100000 , RF_LoadCompleted =0x00200000 , RF_InheritableComponentTemplate = 0x00400000 , RF_DuplicateTransient =0x00800000 , RF_StrongRefOnFrame =0x01000000 , RF_NonPIEDuplicateTransient =0x02000000 , RF_ImmutableDefaultObject =0x04000000 , RF_WillBeLoaded =0x08000000 , RF_HasExternalPackage =0x10000000 , RF_MigratingAsset =0x20000000 , RF_MirroredGarbage =0x40000000 , RF_AllocatedInSharedPage =0x80000000 }

enum class	EInternalObjectFlags : int32 { None = 0 , Remote = 0 , RemoteReference = 0 , Borrowed = 0 , ReachabilityFlag0 = 1 << 14 , ReachabilityFlag1 = 1 << 15 , ReachabilityFlag2 = 1 << 16 , AutoRTFMConstructionAborted = 1 << 17 , LoaderImport = 1 << 20 , Garbage = 1 << 21 , AsyncLoadingPhase1 = 1 << 22 , ReachableInCluster = 1 << 23 , ClusterRoot = 1 << 24 , Native = 1 << 25 , Async = 1 << 26 , AsyncLoadingPhase2 = 1 << 27 , Unreachable = 1 << 28 , UE_DEPRECATED =(5.7, "Use GetRefCount() to determine if a refcount exists instead.") = 1 << 29 , RootSet = 1 << 30 , PendingConstruction = 1 << 31 }

enum class	EEnumFlags : uint8 { None , Flags = 0x00000001 , NewerVersionExists = 0x00000002 }

enum	{ UC::classGroup , UC::Within , UC::BlueprintType , UC::NotBlueprintType , UC::Blueprintable , UC::NotBlueprintable , UC::MinimalAPI , UC::customConstructor , UC::CustomFieldNotify , UC::Intrinsic , UC::noexport , UC::placeable , UC::notplaceable , UC::DefaultToInstanced , UC::Const , UC::Abstract , UC::deprecated , UC::Transient , UC::nonTransient , UC::Optional , UC::config , UC::perObjectConfig , UC::configdonotcheckdefaults , UC::defaultconfig , UC::EditorConfig , UC::editinlinenew , UC::noteditinlinenew , UC::hidedropdown , UC::showCategories , UC::hideCategories , UC::ComponentWrapperClass , UC::showFunctions , UC::hideFunctions , UC::autoExpandCategories , UC::autoCollapseCategories , UC::dontAutoCollapseCategories , UC::collapseCategories , UC::dontCollapseCategories , UC::prioritizeCategories , UC::AdvancedClassDisplay , UC::ConversionRoot , UC::Experimental , UC::EarlyAccessPreview , UC::SparseClassDataType , UC::CustomThunkTemplates }

enum	{ UI::MinimalAPI , UI::Blueprintable , UI::NotBlueprintable , UI::ConversionRoot }

enum	{ UF::BlueprintImplementableEvent , UF::BlueprintNativeEvent , UF::SealedEvent , UF::Exec , UF::Server , UF::Client , UF::NetMulticast , UF::Reliable , UF::Unreliable , UF::BlueprintPure , UF::BlueprintCallable , UF::BlueprintGetter , UF::BlueprintSetter , UF::BlueprintAuthorityOnly , UF::BlueprintCosmetic , UF::BlueprintInternalUseOnly , UF::CallInEditor , UF::CustomThunk , UF::Category , UF::FieldNotify , UF::WithValidation , UF::ServiceRequest , UF::ServiceResponse , UF::Variadic , UF::ReturnDisplayName , UF::InternalUseParam , UF::ForceAsFunction , UF::IgnoreTypePromotion }

enum	{ UP::Const , UP::Config , UP::GlobalConfig , UP::Localized , UP::Transient , UP::DuplicateTransient , UP::NonPIETransient , UP::NonPIEDuplicateTransient , UP::Ref , UP::Export , UP::NoClear , UP::EditFixedSize , UP::Replicated , UP::ReplicatedUsing , UP::NotReplicated , UP::Interp , UP::NonTransactional , UP::Instanced , UP::BlueprintAssignable , UP::Category , UP::SimpleDisplay , UP::AdvancedDisplay , UP::EditAnywhere , UP::EditInstanceOnly , UP::EditDefaultsOnly , UP::VisibleAnywhere , UP::VisibleInstanceOnly , UP::VisibleDefaultsOnly , UP::BlueprintReadOnly , UP::BlueprintGetter , UP::BlueprintReadWrite , UP::BlueprintSetter , UP::AssetRegistrySearchable , UP::SaveGame , UP::BlueprintCallable , UP::BlueprintAuthorityOnly , UP::TextExportTransient , UP::SkipSerialization , UP::HideSelfPin , UP::FieldNotify }

enum	{ US::NoExport , US::Atomic , US::Immutable , US::BlueprintType , US::BlueprintInternalUseOnly , US::BlueprintInternalUseOnlyHierarchical }

enum	{ UM::ToolTip , UM::ShortTooltip , UM::DocumentationPolicy }

enum	{ UM::BlueprintSpawnableComponent , UM::ChildCanTick , UM::ChildCannotTick , UM::DebugTreeLeaf , UM::IgnoreCategoryKeywordsInSubclasses , UM::DeprecatedNode , UM::DeprecationMessage , UM::DisplayName , UM::ScriptName , UM::IsBlueprintBase , UM::KismetHideOverrides , UM::LoadBehavior , UM::ProhibitedInterfaces , UM::RestrictedToClasses , UM::ShowWorldContextPin , UM::DontUseGenericSpawnObject , UM::ExposedAsyncProxy , UM::BlueprintThreadSafe , UM::UsesHierarchy }

enum	{ UM::HasNativeBreak , UM::HasNativeMake , UM::HiddenByDefault , UM::DisableSplitPin }

enum	{ UM::AllowAbstract , UM::AllowAnyActor , UM::AllowedClasses , UM::AllowPreserveRatio , UM::AllowPrivateAccess , UM::ArrayClamp , UM::AssetBundles , UM::BlueprintBaseOnly , UM::BlueprintCompilerGeneratedDefaults , UM::ClampMin , UM::ClampMax , UM::ConfigHierarchyEditable , UM::ContentDir , UM::Delta , UM::DeprecatedProperty , UM::DisallowedAssetDataTags , UM::DisallowedClasses , UM::DisplayAfter , UM::DisplayPriority , UM::DisplayThumbnail , UM::EditCondition , UM::EditConditionHides , UM::EditFixedOrder , UM::ExactClass , UM::ExposeFunctionCategories , UM::ExposeOnSpawn , UM::FilePathFilter , UM::RelativeToGameDir , UM::FixedIncrement , UM::ForceRebuildProperty , UM::ForceShowEngineContent , UM::ForceShowPluginContent , UM::HideAlphaChannel , UM::HideInDetailPanel , UM::HideViewOptions , UM::IgnoreForMemberInitializationTest , UM::InlineEditConditionToggle , UM::LinearDeltaSensitivity , UM::LongPackageName , UM::MakeEditWidget , UM::MakeStructureDefaultValue , UM::MetaClass , UM::MustImplement , UM::ObjectMustImplement , UM::Multiple , UM::MaxLength , UM::MultiLine , UM::PasswordField , UM::NoElementDuplicate , UM::NoResetToDefault , UM::NoEditInline , UM::NoSpinbox , UM::OnlyPlaceable , UM::RelativePath , UM::RelativeToGameContentDir , UM::RequiredAssetDataTags , UM::ScriptNoExport , UM::ShowOnlyInnerProperties , UM::ShowTreeView , UM::SliderExponent , UM::TitleProperty , UM::UIMin , UM::UIMax , UM::Units , UM::ForceUnits , UM::Untracked , UM::DevelopmentOnly , UM::NeedsLatentFixup , UM::LatentCallbackTarget , UM::GetOptions , UM::PinHiddenByDefault , UM::ValidEnumValues , UM::InvalidEnumValues , UM::GetRestrictedEnumValues , UM::GetAssetFilter , UM::GetClassFilter , UM::GetAllowedClasses , UM::GetDisallowedClasses , UM::AllowEditInlineCustomization }

enum	{ UM::NeverAsPin , UM::PinShownByDefault , UM::AlwaysAsPin , UM::CustomizeProperty }

enum	{ UM::OverridingInputProperty , UM::RequiredInput }

enum	{ UM::AdvancedDisplay , UM::ArrayParm , UM::ArrayTypeDependentParams , UM::AutoCreateRefTerm , UM::UE_DEPRECATED =(5.6, "Use HidePinAssetPicker instead.") , UM::HidePinAssetPicker , UM::BlueprintInternalUseOnly , UM::BlueprintProtected , UM::CallableWithoutWorldContext , UM::CommutativeAssociativeBinaryOperator , UM::CompactNodeTitle , UM::CustomStructureParam , UM::DefaultToSelf , UM::DeprecatedFunction , UM::ExpandEnumAsExecs , UM::ExpandBoolAsExecs , UM::ScriptMethod , UM::ScriptMethodSelfReturn , UM::ScriptMethodMutable , UM::ScriptOperator , UM::ScriptConstant , UM::ScriptConstantHost , UM::HidePin , UM::HideSpawnParms , UM::Keywords , UM::Latent , UM::LatentInfo , UM::MaterialParameterCollectionFunction , UM::NativeBreakFunc , UM::NativeMakeFunc , UM::UnsafeDuringActorConstruction , UM::WorldContext , UM::BlueprintAutocast , UM::NotBlueprintThreadSafe , UM::DeterminesOutputType , UM::DynamicOutputParam , UM::DataTablePin , UM::SetParam , UM::MapParam , UM::MapKeyParam , UM::MapValueParam , UM::Bitmask , UM::BitmaskEnum , UM::Bitflags , UM::UseEnumValuesAsMaskValuesInEditor , UM::AnimBlueprintFunction , UM::ArrayParam }

enum	{ UM::CannotImplementInterfaceInBlueprint , UM::CannotGenerateMessageNodes }

Functions
	ENUM_CLASS_FLAGS (EPackageFlags)

	ENUM_CLASS_FLAGS (EClassFlags)

	ENUM_CLASS_FLAGS (EPropertyObjectReferenceType)

COREUOBJECT_API const TCHAR *	LexToString (EPropertyObjectReferenceType Type)

	ENUM_CLASS_FLAGS (EObjectFlags)

COREUOBJECT_API FString	LexToString (EObjectFlags Flags)

	ENUM_CLASS_FLAGS (EInternalObjectFlags)

Variables
constexpr EObjectFlags	RF_InternalPendingKill = RF_MirroredGarbage

constexpr EObjectFlags	RF_InternalGarbage = RF_MirroredGarbage

constexpr EObjectFlags	RF_InternalMirroredFlags = RF_MirroredGarbage

constexpr EObjectFlags	RF_HasPlaceholderType = EObjectFlags(0x20000000)

Macro Definition Documentation

◆ BODY_MACRO_COMBINE

#define BODY_MACRO_COMBINE	(	A,
		B,
		C,
		D
	)	BODY_MACRO_COMBINE_INNER(A,B,C,D)

◆ BODY_MACRO_COMBINE_INNER

#define BODY_MACRO_COMBINE_INNER	(	A,
		B,
		C,
		D
	)	A##B##C##D

◆ CASTCLASS_AllFlags

#define CASTCLASS_AllFlags ((EClassCastFlags)0xFFFFFFFFFFFFFFFF)

◆ CLASS_AllFlags

#define CLASS_AllFlags ((EClassFlags)0xFFFFFFFFu)

◆ CLASS_Inherit

#define CLASS_Inherit

Value:

EClassFlags

Definition ObjectMacros.h:199

CLASS_NeedsDeferredDependencyLoading

@ CLASS_NeedsDeferredDependencyLoading

Definition ObjectMacros.h:241

CLASS_Transient

@ CLASS_Transient

Definition ObjectMacros.h:209

CLASS_Deprecated

@ CLASS_Deprecated

Definition ObjectMacros.h:262

CLASS_DefaultToInstanced

@ CLASS_DefaultToInstanced

Definition ObjectMacros.h:253

CLASS_DefaultConfig

@ CLASS_DefaultConfig

Definition ObjectMacros.h:205

CLASS_GlobalUserConfig

@ CLASS_GlobalUserConfig

Definition ObjectMacros.h:266

CLASS_ProjectUserConfig

@ CLASS_ProjectUserConfig

Definition ObjectMacros.h:215

CLASS_PerPlatformConfig

@ CLASS_PerPlatformConfig

Definition ObjectMacros.h:236

CLASS_ConfigDoNotCheckDefaults

@ CLASS_ConfigDoNotCheckDefaults

Definition ObjectMacros.h:272

CLASS_HasInstancedReference

@ CLASS_HasInstancedReference

Definition ObjectMacros.h:258

CLASS_Const

@ CLASS_Const

Definition ObjectMacros.h:238

CLASS_NotPlaceable

@ CLASS_NotPlaceable

Definition ObjectMacros.h:222

CLASS_PerObjectConfig

@ CLASS_PerObjectConfig

Definition ObjectMacros.h:224

CLASS_Config

@ CLASS_Config

Definition ObjectMacros.h:207

CLASS_Optional

@ CLASS_Optional

Definition ObjectMacros.h:211

Flags to inherit from base class

◆ CLASS_RecompilerClear

#define CLASS_RecompilerClear ((EClassFlags)(CLASS_Inherit | CLASS_Abstract | CLASS_Native | CLASS_Intrinsic | CLASS_TokenStreamAssembled))

These flags will be cleared by the compiler when the class is parsed during script compilation

◆ CLASS_SaveInCompiledInClasses

#define CLASS_SaveInCompiledInClasses

Value:

    ((EClassFlags)(\
    CLASS_Abstract | \
    CLASS_DefaultConfig | \
    CLASS_GlobalUserConfig | \
    CLASS_ProjectUserConfig | \
    CLASS_PerPlatformConfig | \
    CLASS_Config | \
    CLASS_Transient | \
    CLASS_Optional | \
    CLASS_Native | \
    CLASS_NotPlaceable | \
    CLASS_PerObjectConfig | \
    CLASS_PerPlatformConfig | \
    CLASS_ConfigDoNotCheckDefaults | \
    CLASS_EditInlineNew | \
    CLASS_CollapseCategories | \
    CLASS_Interface | \
    CLASS_DefaultToInstanced | \
    CLASS_HasInstancedReference | \
    CLASS_Hidden | \
    CLASS_Deprecated | \
    CLASS_HideDropDown | \
    CLASS_Intrinsic | \
    CLASS_Const | \
    CLASS_MinimalAPI | \
    CLASS_RequiredAPI | \
    CLASS_MatchedSerializers | \
    CLASS_NeedsDeferredDependencyLoading))

This is used as a mask for the flags put into generated code for "compiled in" classes.

◆ CLASS_ScriptInherit

#define CLASS_ScriptInherit ((EClassFlags)(CLASS_Inherit | CLASS_EditInlineNew | CLASS_CollapseCategories))

These flags will be inherited from the base class only for non-intrinsic classes

◆ CLASS_ShouldNeverBeLoaded

#define CLASS_ShouldNeverBeLoaded ((EClassFlags)(CLASS_Native | CLASS_Optional | CLASS_Intrinsic | CLASS_TokenStreamAssembled))

These flags will be cleared by the compiler when the class is parsed during script compilation

◆ COMPILED_IN_FLAGS

#define COMPILED_IN_FLAGS ( TStaticFlags ) (TStaticFlags | CLASS_Intrinsic)

◆ CONSTRUCT_RELOAD_VERSION_INFO

#define CONSTRUCT_RELOAD_VERSION_INFO	(	VersionInfo,
		...
	)	VersionInfo()

◆ CPF_AllFlags

#define CPF_AllFlags ((EPropertyFlags)0xFFFFFFFFFFFFFFFF)

Mask of all property flags

◆ CPF_ComputedFlags

#define CPF_ComputedFlags (CPF_IsPlainOldData | CPF_NoDestructor | CPF_ZeroConstructor | CPF_HasGetValueTypeHash)

All the properties that should never be loaded or saved

◆ CPF_DevelopmentAssets

#define CPF_DevelopmentAssets (CPF_EditorOnly)

All the properties that can be stripped for final release console builds

◆ CPF_InterfaceClearMask

#define CPF_InterfaceClearMask (CPF_ExportObject|CPF_InstancedReference|CPF_ContainsInstancedReference)

The flags that should never be set on interface properties

◆ CPF_NativeAccessSpecifiers

#define CPF_NativeAccessSpecifiers (CPF_NativeAccessSpecifierPublic | CPF_NativeAccessSpecifierProtected | CPF_NativeAccessSpecifierPrivate)

All Native Access Specifier flags

◆ CPF_ParmFlags

All parameter flags

◆ CPF_PropagateToArrayInner

Flags that are propagated to properties inside containers

◆ CPF_PropagateToMapKey

◆ CPF_PropagateToMapValue

◆ CPF_PropagateToOptionalInner

◆ CPF_PropagateToSetElement

◆ CPF_TObjectPtrWrapper

#define CPF_TObjectPtrWrapper (CPF_UObjectWrapper | CPF_TObjectPtr)

◆ DECLARE_CASTED_CLASS_INTRINSIC

#define DECLARE_CASTED_CLASS_INTRINSIC	(	TClass,
		TSuperClass,
		TStaticFlags,
		TPackage,
		TStaticCastFlags
	)	DECLARE_CASTED_CLASS_INTRINSIC_WITH_API( TClass, TSuperClass, TStaticFlags, TPackage, TStaticCastFlags, NO_API) \

◆ DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR

#define DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR	(	TClass,
		TSuperClass,
		TStaticFlags,
		TPackage,
		TStaticCastFlags,
		TRequiredAPI
	)

Value:

DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR_NO_VTABLE_CTOR( TClass, TSuperClass, TStaticFlags, TPackage, TStaticCastFlags, TRequiredAPI ) \

\

TClass(FVTableHelper& Helper) : Super(Helper) {}; \

StaticCastSharedRef

UE_FORCEINLINE_HINT TSharedRef< CastToType, Mode > StaticCastSharedRef(TSharedRef< CastFromType, Mode > const &InSharedRef)

Definition SharedPointer.h:127

DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR_NO_VTABLE_CTOR

#define DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR_NO_VTABLE_CTOR(TClass, TSuperClass, TStaticFlags, TPackage, TStaticCastFlags, TRequiredAPI)

Definition ObjectMacros.h:1991

FVTableHelper

Definition ObjectMacros.h:180

◆ DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR_NO_VTABLE_CTOR

#define DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR_NO_VTABLE_CTOR	(	TClass,
		TSuperClass,
		TStaticFlags,
		TPackage,
		TStaticCastFlags,
		TRequiredAPI
	)

Value:

    DECLARE_CLASS(TClass,TSuperClass,TStaticFlags|CLASS_Intrinsic,TStaticCastFlags,TPackage, TRequiredAPI ) \
	UE_DELETE_COPY_MOVE_CONSTRUCTORS(TClass) \
    static void StaticRegisterNatives##TClass() {} \
	DECLARE_SERIALIZER(TClass) \
	DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) \
    static void IntrinsicClassInit(UClass* Class); \
    static UObject* __VTableCtorCaller(FVTableHelper& Helper) \
    { \
        return new (EC_InternalUseOnlyConstructor, GetTransientPackageAsObject(), NAME_None, RF_NeedLoad | RF_ClassDefaultObject | RF_TagGarbageTemp) TClass(Helper); \
    }

◆ DECLARE_CASTED_CLASS_INTRINSIC_WITH_API

#define DECLARE_CASTED_CLASS_INTRINSIC_WITH_API	(	TClass,
		TSuperClass,
		TStaticFlags,
		TPackage,
		TStaticCastFlags,
		TRequiredAPI
	)

Value:

    DECLARE_CLASS(TClass,TSuperClass,TStaticFlags|CLASS_Intrinsic,TStaticCastFlags,TPackage,TRequiredAPI ) \
	RELAY_CONSTRUCTOR(TClass, TSuperClass) \
	UE_DELETE_COPY_MOVE_CONSTRUCTORS(TClass) \
\	TClass(FVTableHelper& Helper) : Super(Helper) {}; \
    static void StaticRegisterNatives##TClass() {} \
	DECLARE_SERIALIZER(TClass) \
	DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) \
    static void IntrinsicClassInit(UClass* Class); \
    static UObject* __VTableCtorCaller(FVTableHelper& Helper) \
    { \
        return new (EC_InternalUseOnlyConstructor, GetTransientPackageAsObject(), NAME_None, RF_NeedLoad | RF_ClassDefaultObject | RF_TagGarbageTemp) TClass(Helper); \
    }

◆ DECLARE_CASTED_CLASS_INTRINSIC_WITH_API_NO_CTOR

#define DECLARE_CASTED_CLASS_INTRINSIC_WITH_API_NO_CTOR	(	TClass,
		TSuperClass,
		TStaticFlags,
		TPackage,
		TStaticCastFlags,
		TRequiredAPI
	)

Value:

    DECLARE_CLASS(TClass, TSuperClass, TStaticFlags | CLASS_Intrinsic, TStaticCastFlags, TPackage, TRequiredAPI) \
	UE_DELETE_COPY_MOVE_CONSTRUCTORS(TClass) \
    static void StaticRegisterNatives##TClass() {} \
	DECLARE_SERIALIZER(TClass) \
	DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) \
    static void IntrinsicClassInit(UClass* Class); \
    static UObject* __VTableCtorCaller(FVTableHelper& Helper) \
    { \
        return new (EC_InternalUseOnlyConstructor, GetTransientPackageAsObject(), NAME_None, RF_NeedLoad | RF_ClassDefaultObject | RF_TagGarbageTemp) TClass(Helper); \
    }

◆ DECLARE_CLASS

#define DECLARE_CLASS	(	TClass,
		TSuperClass,
		TStaticFlags,
		TStaticCastFlags,
		TPackage,
		TRequiredAPI
	)

Value:

TRequiredAPI static UClass* GetPrivateStaticClass(); \

DECLARE_CLASS2(TClass, TSuperClass, TStaticFlags, TStaticCastFlags, TPackage, GetPrivateStaticClass )

◆ DECLARE_CLASS2

#define DECLARE_CLASS2	(	TClass,
		TSuperClass,
		TStaticFlags,
		TStaticCastFlags,
		TPackage,
		TPrivateAccessor
	)

◆ DECLARE_CLASS_INTRINSIC

#define DECLARE_CLASS_INTRINSIC	(	TClass,
		TSuperClass,
		TStaticFlags,
		TPackage
	)	DECLARE_CLASS_INTRINSIC_API(TClass,TSuperClass,TStaticFlags,TPackage, NO_API)

◆ DECLARE_CLASS_INTRINSIC_API

#define DECLARE_CLASS_INTRINSIC_API	(	TClass,
		TSuperClass,
		TStaticFlags,
		TPackage,
		TRequiredAPI
	)

Value:

    DECLARE_CLASS(TClass,TSuperClass,TStaticFlags|CLASS_Intrinsic,CASTCLASS_None,TPackage,TRequiredAPI) \
	RELAY_CONSTRUCTOR(TClass, TSuperClass) \
	UE_DELETE_COPY_MOVE_CONSTRUCTORS(TClass) \
\	TClass(FVTableHelper& Helper) : Super(Helper) {}; \
    static void StaticRegisterNatives##TClass() {} \
	DECLARE_SERIALIZER(TClass) \
	DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) \
    static void IntrinsicClassInit(UClass* Class); \
    static UObject* __VTableCtorCaller(FVTableHelper& Helper) \
    { \
        return new (EC_InternalUseOnlyConstructor, GetTransientPackageAsObject(), NAME_None, RF_NeedLoad | RF_ClassDefaultObject | RF_TagGarbageTemp) TClass(Helper); \
    }

◆ DECLARE_CLASS_INTRINSIC_NO_CTOR

#define DECLARE_CLASS_INTRINSIC_NO_CTOR	(	TClass,
		TSuperClass,
		TStaticFlags,
		TPackage
	)

Value:

    DECLARE_CLASS(TClass, TSuperClass, TStaticFlags | CLASS_Intrinsic, CASTCLASS_None, TPackage, NO_API) \
    static void StaticRegisterNatives##TClass() {} \
	DECLARE_SERIALIZER(TClass) \
	UE_DELETE_COPY_MOVE_CONSTRUCTORS(TClass) \
	DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) \
    static void IntrinsicClassInit(UClass* Class); \
    static UObject* __VTableCtorCaller(FVTableHelper& Helper) \
    { \
        return new (EC_InternalUseOnlyConstructor, GetTransientPackageAsObject(), NAME_None, RF_NeedLoad | RF_ClassDefaultObject | RF_TagGarbageTemp) TClass(Helper); \
    }

◆ DECLARE_FARCHIVE_SERIALIZER

#define DECLARE_FARCHIVE_SERIALIZER	(	TClass,
		API
	)	virtual API void Serialize(FArchive& Ar) override;

◆ DECLARE_FSTRUCTUREDARCHIVE_SERIALIZER

#define DECLARE_FSTRUCTUREDARCHIVE_SERIALIZER	(	TClass,
		API
	)	virtual API void Serialize(FStructuredArchive::FRecord Record) override;

◆ DECLARE_FUNCTION

#define DECLARE_FUNCTION ( func ) static void func( UObject* Context, FFrame& Stack, RESULT_DECL )

◆ DECLARE_SERIALIZER

#define DECLARE_SERIALIZER ( TClass )

Value:

    friend FArchive &operator<<( FArchive& Ar, TClass*& Res ) \
    { \
        return Ar << (UObject*&)Res; \
    } \
    friend void operator<<(FStructuredArchive::FSlot InSlot, TClass*& Res) \
    { \
        InSlot << (UObject*&)Res; \
    }

◆ DECLARE_VALIDATE_GENERATED_REP_ENUMS

#define DECLARE_VALIDATE_GENERATED_REP_ENUMS ( API )

◆ DECLARE_VTABLE_PTR_HELPER_CTOR

#define DECLARE_VTABLE_PTR_HELPER_CTOR	(	API,
		TClass
	)

Value:

\

API TClass(FVTableHelper& Helper);

◆ DECLARE_WITHIN

#define DECLARE_WITHIN ( TWithinClass ) DECLARE_WITHIN_INTERNAL( TWithinClass, false )

◆ DECLARE_WITHIN_INTERNAL

#define DECLARE_WITHIN_INTERNAL	(	TWithinClass,
		bCanUseOnCDO
	)

Value:

 \
    typedef class TWithinClass WithinClass;  \
    TWithinClass* GetOuter##TWithinClass() const { return (ensure(bCanUseOnCDO || !HasAnyFlags(RF_ClassDefaultObject)) ? (TWithinClass*)GetOuter() : nullptr); }

◆ DECLARE_WITHIN_UPACKAGE

#define DECLARE_WITHIN_UPACKAGE ( ) DECLARE_WITHIN_INTERNAL( UPackage, true )

◆ DEFAULT_OBJECT_PREFIX

#define DEFAULT_OBJECT_PREFIX TEXT("Default__")

◆ DEFINE_ABSTRACT_DEFAULT_CONSTRUCTOR_CALL

#define DEFINE_ABSTRACT_DEFAULT_CONSTRUCTOR_CALL ( TClass ) DEFINE_DEFAULT_CONSTRUCTOR_CALL(TClass)

◆ DEFINE_ABSTRACT_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL

#define DEFINE_ABSTRACT_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL ( TClass ) DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass)

◆ DEFINE_DEFAULT_CONSTRUCTOR_CALL

#define DEFINE_DEFAULT_CONSTRUCTOR_CALL ( TClass ) static void __DefaultConstructor(const FObjectInitializer& X) { new((EInternal*)X.GetObj())TClass; }

◆ DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL

#define DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL ( TClass ) static void __DefaultConstructor(const FObjectInitializer& X) { new((EInternal*)X.GetObj())TClass(X); }

◆ DEFINE_FORBIDDEN_DEFAULT_CONSTRUCTOR_CALL

#define DEFINE_FORBIDDEN_DEFAULT_CONSTRUCTOR_CALL ( TClass ) static_assert(false, "You have to define " #TClass "::" #TClass "() or " #TClass "::" #TClass "(const FObjectInitializer&). This is required by UObject system to work correctly.");

◆ DEFINE_FUNCTION

#define DEFINE_FUNCTION ( func ) void func( UObject* Context, FFrame& Stack, RESULT_DECL )

◆ DEFINE_VTABLE_PTR_HELPER_CTOR

#define DEFINE_VTABLE_PTR_HELPER_CTOR ( TClass ) DEFINE_VTABLE_PTR_HELPER_CTOR_NS(, TClass)

◆ DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER

#define DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER ( TClass ) DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER_DUMMY()

◆ DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER_DUMMY

#define DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER_DUMMY ( )

Value:

    static UObject* __VTableCtorCaller(FVTableHelper& Helper) \
    { \
        return nullptr; \
    }

◆ DEFINE_VTABLE_PTR_HELPER_CTOR_NS

#define DEFINE_VTABLE_PTR_HELPER_CTOR_NS	(	Namespace,
		TClass
	)	Namespace TClass::TClass(FVTableHelper& Helper) : Super(Helper) {};

◆ EInternalObjectFlags_AllFlags

◆ EInternalObjectFlags_AsyncLoading

#define EInternalObjectFlags_AsyncLoading (EInternalObjectFlags::AsyncLoadingPhase1 | EInternalObjectFlags::AsyncLoadingPhase2)

◆ EInternalObjectFlags_GarbageCollectionKeepFlags

#define EInternalObjectFlags_GarbageCollectionKeepFlags (EInternalObjectFlags::Borrowed | EInternalObjectFlags::Native | EInternalObjectFlags::Async | EInternalObjectFlags::AsyncLoadingPhase1 | EInternalObjectFlags::AsyncLoadingPhase2 | EInternalObjectFlags::LoaderImport)

◆ EInternalObjectFlags_MinFlagBitIndex

#define EInternalObjectFlags_MinFlagBitIndex 14

◆ EInternalObjectFlags_ReachabilityFlags

#define EInternalObjectFlags_ReachabilityFlags (EInternalObjectFlags::ReachabilityFlag0 | EInternalObjectFlags::ReachabilityFlag1 | EInternalObjectFlags::ReachabilityFlag2 | EInternalObjectFlags::Unreachable)

◆ EInternalObjectFlags_RefCountMask

#define EInternalObjectFlags_RefCountMask 0xFFFFFFFF

◆ EInternalObjectFlags_RootFlags

#define EInternalObjectFlags_RootFlags (EInternalObjectFlags::RootSet | EInternalObjectFlags_GarbageCollectionKeepFlags)

◆ GENERATED_BODY

#define GENERATED_BODY ( ... ) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_GENERATED_BODY);

◆ GENERATED_BODY_LEGACY

#define GENERATED_BODY_LEGACY ( ... ) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_GENERATED_BODY_LEGACY);

◆ GENERATED_IINTERFACE_BODY

#define GENERATED_IINTERFACE_BODY ( ... ) GENERATED_BODY_LEGACY()

◆ GENERATED_UCLASS_BODY

#define GENERATED_UCLASS_BODY ( ... ) GENERATED_BODY_LEGACY()

Examples: /work/Engine/Source/Runtime/UMG/Public/Components/Widget.h.

◆ GENERATED_UINTERFACE_BODY

#define GENERATED_UINTERFACE_BODY ( ... ) GENERATED_BODY_LEGACY()

◆ GENERATED_USTRUCT_BODY

#define GENERATED_USTRUCT_BODY ( ... ) GENERATED_BODY()

◆ IMPLEMENT_CLASS

#define IMPLEMENT_CLASS	(	TClass,
		TClassCrc
	)

Value:

    IMPLEMENT_CLASS_NO_AUTO_REGISTRATION(TClass) \
    /* Do not change the AutoInitialize_ without changing LC_SymbolPatterns */ \
    static FRegisterCompiledInInfo AutoInitialize_##TClass(&Z_Construct_UClass_##TClass, TClass::StaticClass, TClass::StaticPackage(), TEXT(#TClass), Z_Registration_Info_UClass_##TClass, CONSTRUCT_RELOAD_VERSION_INFO(FClassReloadVersionInfo, sizeof(TClass), TClassCrc));

◆ IMPLEMENT_CLASS_NO_AUTO_REGISTRATION

#define IMPLEMENT_CLASS_NO_AUTO_REGISTRATION ( TClass )

Value:

    FClassRegistrationInfo Z_Registration_Info_UClass_##TClass; \
    UClass* TClass::GetPrivateStaticClass() \
    { \
		if (!Z_Registration_Info_UClass_##TClass.InnerSingleton) \
        { \
            /* this could be handled with templates, but we want it external to avoid code bloat */ \
			GetPrivateStaticClassBody( \
                StaticPackage(), \
                (TCHAR*)TEXT(#TClass) + 1 + ((StaticClassFlags & CLASS_Deprecated) ? 11 : 0), \
                Z_Registration_Info_UClass_##TClass.InnerSingleton, \
                StaticRegisterNatives##TClass, \
                sizeof(TClass), \
                alignof(TClass), \
                TClass::StaticClassFlags, \
                TClass::StaticClassCastFlags(), \
                TClass::StaticConfigName(), \
                (UClass::ClassConstructorType)InternalConstructor<TClass>, \
                (UClass::ClassVTableHelperCtorCallerType)InternalVTableHelperCtorCaller<TClass>, \
                UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS(TClass), \
                &TClass::Super::StaticClass, \
                &TClass::WithinClass::StaticClass \
            ); \
        } \
        return Z_Registration_Info_UClass_##TClass.InnerSingleton; \
    }

◆ IMPLEMENT_CORE_INTRINSIC_CLASS

#define IMPLEMENT_CORE_INTRINSIC_CLASS	(	TClass,
		TSuperClass,
		InitCode
	)	IMPLEMENT_INTRINSIC_CLASS(TClass, COREUOBJECT_API, TSuperClass, COREUOBJECT_API, CoreUObject, InitCode)

◆ IMPLEMENT_FARCHIVE_SERIALIZER

#define IMPLEMENT_FARCHIVE_SERIALIZER ( TClass ) void TClass::Serialize(FArchive& Ar) { TClass::Serialize(FStructuredArchiveFromArchive(Ar).GetSlot().EnterRecord()); }

◆ IMPLEMENT_FSTRUCTUREDARCHIVE_SERIALIZER

#define IMPLEMENT_FSTRUCTUREDARCHIVE_SERIALIZER ( TClass ) void TClass::Serialize(FStructuredArchive::FRecord Record) { FArchiveUObjectFromStructuredArchive Ar(Record.EnterField(TEXT("BaseClassAutoGen"))); TClass::Serialize(Ar.GetArchive()); Ar.Close(); }

◆ IMPLEMENT_INTRINSIC_CLASS

#define IMPLEMENT_INTRINSIC_CLASS	(	TClass,
		TRequiredAPI,
		TSuperClass,
		TSuperRequiredAPI,
		TPackage,
		InitCode
	)

Value:

    TRequiredAPI UClass* Z_Construct_UClass_##TClass(); \
    extern FClassRegistrationInfo Z_Registration_Info_UClass_##TClass; \
    struct Z_Construct_UClass_##TClass##_Statics \
    { \
        static UClass* Construct() \
        { \
            extern TSuperRequiredAPI UClass* Z_Construct_UClass_##TSuperClass(); \
            UClass* SuperClass = Z_Construct_UClass_##TSuperClass(); \
            UClass* Class = TClass::StaticClass(); \
			UObjectForceRegistration(Class); \
			check(Class->GetSuperClass() == SuperClass); \
            TClass::IntrinsicClassInit(Class); \
            Class->StaticLink(); \
            return Class; \
        } \
    }; \
    void TClass::IntrinsicClassInit(UClass* Class) \
    { \
        InitCode \
    } \
    UClass* Z_Construct_UClass_##TClass() \
    { \
		if (!Z_Registration_Info_UClass_##TClass.OuterSingleton) \
        { \
            Z_Registration_Info_UClass_##TClass.OuterSingleton = Z_Construct_UClass_##TClass##_Statics::Construct();\
        } \
		check(Z_Registration_Info_UClass_##TClass.OuterSingleton->GetClass()); \
        return Z_Registration_Info_UClass_##TClass.OuterSingleton; \
    } \
	IMPLEMENT_CLASS(TClass, 0)

◆ NO_API

#define NO_API

Empty API definition. Used as a placeholder parameter when no DLL export/import API is needed for a UObject class

◆ PKG_InMemoryOnly

#define PKG_InMemoryOnly (EPackageFlags)(PKG_CompiledIn | PKG_NewlyCreated)

Flag mask that indicates if this package is a package that exists in memory only.

◆ PKG_TransientFlags

#define PKG_TransientFlags (PKG_NewlyCreated | PKG_IsSaving | PKG_ReloadingForCooker)

◆ RELAY_CONSTRUCTOR

#define RELAY_CONSTRUCTOR	(	TClass,
		TSuperClass
	)	TClass(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get()) : TSuperClass(ObjectInitializer) {}

◆ REN_AllowPackageLinkerMismatch

#define REN_AllowPackageLinkerMismatch (0x0200)

Prevents rename from clearing an object's linker when being renamed to a new package

◆ REN_DoNotDirty

#define REN_DoNotDirty (0x0004)

Indicates that the object (and new outer) should not be dirtied

◆ REN_DontCreateRedirectors

#define REN_DontCreateRedirectors (0x0010)

Don't create an object redirector, even if the class is marked RF_Public

◆ REN_ForceGlobalUnique

#define REN_ForceGlobalUnique (0x0040)

Force unique names across all packages not just within the scope of the new outer

◆ REN_ForceNoResetLoaders

#define REN_ForceNoResetLoaders (0x0001)

UE_DEPRECATED(5.5, "Rename will no longer call ResetLoaders making this flag no longer needed.") - Rename won't call ResetLoaders or flush async loading. You should pass this if you are renaming a deep subobject and do not need to reset loading for the outer package

◆ REN_None

#define REN_None (0x0000)

Default rename behavior

◆ REN_NonTransactional

#define REN_NonTransactional (0x0020)

Don't call Modify() on the objects, so they won't be stored in the transaction buffer

◆ REN_SkipComponentRegWork

#define REN_SkipComponentRegWork (0x0100)

Prevents renaming from unregistering/registering all components

◆ REN_SkipGeneratedClasses

#define REN_SkipGeneratedClasses (0x0080)

Prevent renaming of any child generated classes and CDO's in blueprints

◆ REN_Test

#define REN_Test (0x0002)

Just test to make sure that the rename is guaranteed to succeed if an non test rename immediately follows

◆ RF_AllFlags

#define RF_AllFlags (EObjectFlags)0xffffffff

All flags, used mainly for error checking.

Mask for all object flags

◆ RF_Load

Flags to load from unreal asset files

◆ RF_PropagateToSubObjects

#define RF_PropagateToSubObjects ((EObjectFlags)(RF_Public | RF_ArchetypeObject | RF_Transactional | RF_Transient))

Sub-objects will inherit these flags from their SuperObject

◆ RIGVM_METHOD

#define RIGVM_METHOD ( ... )

◆ THREADSAFE_UOBJECTS

#define THREADSAFE_UOBJECTS 1

Set this to 0 to disable UObject thread safety features

◆ UCLASS

#define UCLASS ( ... ) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_PROLOG)

Examples: /work/Engine/Source/Runtime/UMG/Public/Components/Widget.h.

◆ UDELEGATE

#define UDELEGATE ( ... )

◆ UE_CONSTINIT_UOBJECT_DECL

#define UE_CONSTINIT_UOBJECT_DECL constinit

◆ UE_DELETE_COPY_MOVE_CONSTRUCTORS

#define UE_DELETE_COPY_MOVE_CONSTRUCTORS ( TClass ) TClass(const TClass&) = delete; TClass(TClass&&) = delete;

◆ UE_INLINE_GENERATED_CPP_BY_NAME

#define UE_INLINE_GENERATED_CPP_BY_NAME ( name ) UE_INLINE_STRINGIFY(name.gen.cpp)

◆ UE_INLINE_STRINGIFY

#define UE_INLINE_STRINGIFY ( name ) #name

◆ UE_WITH_CONSTINIT_UOBJECT

#define UE_WITH_CONSTINIT_UOBJECT 0

◆ UENUM

#define UENUM ( ... )

Examples: /work/Engine/Source/Runtime/UMG/Public/Components/Widget.h.

◆ UFUNCTION

#define UFUNCTION ( ... )

Examples: /work/Engine/Source/Runtime/UMG/Public/Components/Widget.h.

◆ UINTERFACE

#define UINTERFACE ( ... ) UCLASS()

◆ UMETA

#define UMETA ( ... )

◆ UOBJECT_CPPCLASS_STATICFUNCTIONS_ALLCONFIGS

#define UOBJECT_CPPCLASS_STATICFUNCTIONS_ALLCONFIGS ( TClass ) FUObjectCppClassStaticFunctions::AddReferencedObjectsType(&TClass::AddReferencedObjects)

◆ UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS

#define UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS ( TClass )

Value:

    FUObjectCppClassStaticFunctions \
    ( \
		UOBJECT_CPPCLASS_STATICFUNCTIONS_ALLCONFIGS(TClass) \
		UOBJECT_CPPCLASS_STATICFUNCTIONS_WITHEDITORONLYDATA(TClass) \
    )

A macro called from the IMPLEMENT_CLASS macro that allows the compiler to report to the UClass constructor the class-specific overrides of UnrealEngine's list of reflected UObject static functions.

◆ UOBJECT_CPPCLASS_STATICFUNCTIONS_WITHEDITORONLYDATA

#define UOBJECT_CPPCLASS_STATICFUNCTIONS_WITHEDITORONLYDATA ( TClass )

◆ UPARAM

#define UPARAM ( ... )

◆ UPROPERTY

#define UPROPERTY ( ... )

UObject definition macros.

Examples: /work/Engine/Source/Runtime/UMG/Public/Components/Widget.h.

◆ USE_COMPILED_IN_NATIVES

#define USE_COMPILED_IN_NATIVES 1

◆ USTRUCT

#define USTRUCT ( ... )

◆ USTRUCT_FAST_ISCHILDOF_COMPARE_WITH_OUTERWALK

#define USTRUCT_FAST_ISCHILDOF_COMPARE_WITH_OUTERWALK 0

◆ USTRUCT_FAST_ISCHILDOF_IMPL

#define USTRUCT_FAST_ISCHILDOF_IMPL USTRUCT_ISCHILDOF_STRUCTARRAY

◆ USTRUCT_ISCHILDOF_OUTERWALK

#define USTRUCT_ISCHILDOF_OUTERWALK 1

◆ USTRUCT_ISCHILDOF_STRUCTARRAY

#define USTRUCT_ISCHILDOF_STRUCTARRAY 2

◆ VALIDATE_CLASS_REPS

#define VALIDATE_CLASS_REPS DO_CHECK

◆ VINTERFACES

#define VINTERFACES ( ... ) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_VINTERFACES)

◆ VMODULE

#define VMODULE ( ... )

Typedef Documentation

◆ ERenameFlags

typedef uint32 ERenameFlags

Options to the UObject::Rename() function, bit flag

◆ FAsyncCompletionCallback

typedef void(* FAsyncCompletionCallback) (UObject *LinkerRoot, void *CallbackUserData)

◆ ScriptPointerType

typedef uint64 ScriptPointerType

Represents a serializable object pointer in blueprint bytecode. This is always 64-bits, even on 32-bit platforms.

Enumeration Type Documentation

◆ EArrayPropertyFlags

enum class EArrayPropertyFlags : uint8

strong

Extra flags for array properties.

Enumerator
None
UsesMemoryImageAllocator

◆ EClassCastFlags

enum EClassCastFlags : uint64

Flags used for quickly casting classes of certain types; all class cast flags are inherited

This MUST be kept in sync with EClassCastFlags defined in Engine\Source\Programs\Shared\EpicGames.Core\UnrealEngineTypes.cs

Enumerator
CASTCLASS_None
CASTCLASS_UField
CASTCLASS_FInt8Property
CASTCLASS_UEnum
CASTCLASS_UStruct
CASTCLASS_UScriptStruct
CASTCLASS_UClass
CASTCLASS_FByteProperty
CASTCLASS_FIntProperty
CASTCLASS_FFloatProperty
CASTCLASS_FUInt64Property
CASTCLASS_FClassProperty
CASTCLASS_FUInt32Property
CASTCLASS_FInterfaceProperty
CASTCLASS_FNameProperty
CASTCLASS_FStrProperty
CASTCLASS_FProperty
CASTCLASS_FObjectProperty
CASTCLASS_FBoolProperty
CASTCLASS_FUInt16Property
CASTCLASS_UFunction
CASTCLASS_FStructProperty
CASTCLASS_FArrayProperty
CASTCLASS_FInt64Property
CASTCLASS_FDelegateProperty
CASTCLASS_FNumericProperty
CASTCLASS_FMulticastDelegateProperty
CASTCLASS_FObjectPropertyBase
CASTCLASS_FWeakObjectProperty
CASTCLASS_FLazyObjectProperty
CASTCLASS_FSoftObjectProperty
CASTCLASS_FTextProperty
CASTCLASS_FInt16Property
CASTCLASS_FDoubleProperty
CASTCLASS_FSoftClassProperty
CASTCLASS_UPackage
CASTCLASS_ULevel
CASTCLASS_AActor
CASTCLASS_APlayerController
CASTCLASS_APawn
CASTCLASS_USceneComponent
CASTCLASS_UPrimitiveComponent
CASTCLASS_USkinnedMeshComponent
CASTCLASS_USkeletalMeshComponent
CASTCLASS_UBlueprint
CASTCLASS_UDelegateFunction
CASTCLASS_UStaticMeshComponent
CASTCLASS_FMapProperty
CASTCLASS_FSetProperty
CASTCLASS_FEnumProperty
CASTCLASS_USparseDelegateFunction
CASTCLASS_FMulticastInlineDelegateProperty
CASTCLASS_FMulticastSparseDelegateProperty
CASTCLASS_FFieldPathProperty
CASTCLASS_FLargeWorldCoordinatesRealProperty
CASTCLASS_FOptionalProperty
CASTCLASS_FVValueProperty
CASTCLASS_FVRestValueProperty
CASTCLASS_FVerseStringProperty
CASTCLASS_FUtf8StrProperty
CASTCLASS_FAnsiStrProperty
CASTCLASS_FVCellProperty

◆ EClassFlags

enum EClassFlags

Flags describing a class.

This MUST be kept in sync with EClassFlags defined in Engine\Source\Programs\Shared\EpicGames.Core\UnrealEngineTypes.cs

Enumerator
CLASS_None	No Flags
CLASS_Abstract	Class is abstract and can't be instantiated directly.
CLASS_DefaultConfig	Save object configuration only to Default INIs, never to local INIs. Must be combined with CLASS_Config
CLASS_Config	Load object configuration at construction time.
CLASS_Transient	This object type can't be saved; null it out at save time.
CLASS_Optional	This object type may not be available in certain context. (i.e. game runtime or in certain configuration). Optional class data is saved separately to other object types. (i.e. might use sidecar files)
CLASS_MatchedSerializers
CLASS_ProjectUserConfig	Indicates that the config settings for this class will be saved to Project/User*.ini (similar to CLASS_GlobalUserConfig)
CLASS_Native	Class is a native class - native interfaces will have CLASS_Native set, but not RF_MarkAsNative
CLASS_NotPlaceable	Do not allow users to create in the editor.
CLASS_PerObjectConfig	Handle object configuration on a per-object basis, rather than per-class.
CLASS_ReplicationDataIsSetUp	Whether SetUpRuntimeReplicationData still needs to be called for this class
CLASS_EditInlineNew	Class can be constructed from editinline New button.
CLASS_CollapseCategories	Display properties in the editor without using categories.
CLASS_Interface	Class is an interface
CLASS_PerPlatformConfig	Config for this class is overridden in platform inis, reload when previewing platforms
CLASS_Const	all properties and functions in this class are const and should be exported as const
CLASS_NeedsDeferredDependencyLoading	Class flag indicating objects of this class need deferred dependency loading
CLASS_CompiledFromBlueprint	Indicates that the class was created from blueprint source material
CLASS_MinimalAPI	Indicates that only the bare minimum bits of this class should be DLL exported/imported
CLASS_RequiredAPI	Indicates this class must be DLL exported/imported (along with all of it's members)
CLASS_DefaultToInstanced	Indicates that references to this class default to instanced. Used to be subclasses of UComponent, but now can be any UObject
CLASS_TokenStreamAssembled	Indicates that the parent token stream has been merged with ours.
CLASS_HasInstancedReference	Class has component properties.
CLASS_Hidden	Don't show this class in the editor class browser or edit inline new menus.
CLASS_Deprecated	Don't save objects of this class when serializing
CLASS_HideDropDown	Class not shown in editor drop down for class selection
CLASS_GlobalUserConfig	Class settings are saved to <AppData>/..../Blah.ini (as opposed to CLASS_DefaultConfig)
CLASS_Intrinsic	Class was declared directly in C++ and has no boilerplate generated by UnrealHeaderTool
CLASS_Constructed	Class has already been constructed (maybe in a previous DLL version before hot-reload).
CLASS_ConfigDoNotCheckDefaults	Indicates that object configuration will not check against ini base/defaults when serialized
CLASS_NewerVersionExists	Class has been consigned to oblivion as part of a blueprint recompile, and a newer version currently exists.

◆ ECppProperty

enum ECppProperty

Enumerator
EC_CppProperty

◆ EEnumFlags

enum class EEnumFlags : uint8

strong

Flags describing a UEnum

This MUST be kept in sync with EEnumFlags defined in Engine\Source\Programs\Shared\EpicGames.Core\UnrealEngineTypes.cs

Enumerator
None
Flags
NewerVersionExists

◆ EInternal

enum EInternal

Enumerator
EC_InternalUseOnlyConstructor

◆ EInternalObjectFlags

enum class EInternalObjectFlags : int32

strong

Objects flags for internal use (GC, low level UObject code)

This MUST be kept in sync with EInternalObjectFlags defined in Engine\Source\Programs\Shared\EpicGames.Core\UnrealEngineTypes.cs

Enumerator
None
Remote
RemoteReference
Borrowed
ReachabilityFlag0	One of the flags used by Garbage Collector to determine UObject's reachability state.
ReachabilityFlag1	One of the flags used by Garbage Collector to determine UObject's reachability state.
ReachabilityFlag2	One of the flags used by Garbage Collector to determine UObject's reachability state.
AutoRTFMConstructionAborted
LoaderImport	Object is ready to be imported by another package during loading.
Garbage	Garbage from logical point of view and should not be referenced. This flag is mirrored in EObjectFlags as RF_Garbage for performance.
AsyncLoadingPhase1	Object is being asynchronously loaded.
ReachableInCluster	External reference to object in cluster exists.
ClusterRoot	Root of a cluster.
Native	Native (UClass only).
Async	Object exists only on a different thread than the game thread.
AsyncLoadingPhase2	Object is being asynchronously loaded.
Unreachable	Object is not reachable on the object graph.
UE_DEPRECATED	Object currently has ref-counts associated with it.
RootSet	Object will not be garbage collected, even if unreferenced.
PendingConstruction	Object didn't have its class constructor called yet (only the UObjectBase one to initialize its most basic members)

◆ ELoadFlags

enum ELoadFlags

Flags for loading objects, used by LoadObject() and related functions and passed as a uint32

Enumerator
LOAD_None	No flags.
LOAD_Async	Loads the package using async loading path/ reader.
LOAD_NoWarn	Don't display warning if load fails.
LOAD_EditorOnly	Load for editor-only purposes and by editor-only code.
LOAD_ResolvingDeferredExports	Denotes that we should not defer export loading (as we're resolving them)
LOAD_Verify	Only verify existance; don't actually load.
LOAD_NoVerify	Don't verify imports yet.
LOAD_IsVerifying	Is verifying imports.
LOAD_SkipLoadImportedPackages	Assume that all import packages are already loaded and don't call LoadPackage when creating imports.
UE_DEPRECATED	BulkData identifiers should be regenerated as they are loaded. Keep this object during garbage collection because it's still being used by the cooker.
LOAD_DisableDependencyPreloading	Bypass dependency preloading system.
LOAD_Quiet	No log warnings.
LOAD_FindIfFail	Tries FindObject if a linker cannot be obtained (e.g. package is currently being compiled)
LOAD_MemoryReader	Loads the file into memory and serializes from there.
LOAD_NoRedirects	Never follow redirects when loading objects; redirected loads will fail.
LOAD_ForDiff	Loading for diffing in the editor.
LOAD_PackageForPIE	This package is being loaded for PIE, it must be flagged as such immediately.
LOAD_DeferDependencyLoads	Do not load external (blueprint) dependencies (instead, track them for deferred loading)
LOAD_ForFileDiff	Load the package (not for diffing in the editor), instead verify at the two packages serialized output are the same, if they are not then debug break so that you can get the callstack and object information.
LOAD_DisableCompileOnLoad	Prevent this load call from running compile on load for the loaded blueprint (intentionally not recursive, dependencies will still compile on load)
LOAD_DisableEngineVersionChecks	Prevent this load call from running engine version checks.

◆ EMapPropertyFlags

enum class EMapPropertyFlags : uint8

strong

Extra flags for map properties.

Enumerator
None
UsesMemoryImageAllocator

◆ EObjectFlags

enum EObjectFlags

Flags describing an object instance When modifying this enum, update the LexToString implementation!

Enumerator
RF_NoFlags	No flags, used to avoid a cast.
RF_Public	Object is visible outside its package.
RF_Standalone	Keep object around for editing even if unreferenced.
RF_MarkAsNative	Object (UField) will be marked as native on construction (DO NOT USE THIS FLAG in HasAnyFlags() etc)
RF_Transactional	Object is transactional.
RF_ClassDefaultObject	This object is used as the default template for all instances of a class. One object is created for each class.
RF_ArchetypeObject	This object can be used as a template for instancing objects. This is set on all types of object templates.
RF_Transient	Don't save object.
RF_MarkAsRootSet	Object will be marked as root set on construction and not be garbage collected, even if unreferenced (DO NOT USE THIS FLAG in HasAnyFlags() etc)
RF_TagGarbageTemp	This is a temp user flag for various utilities that need to use the garbage collector. The garbage collector itself does not interpret it.
RF_NeedInitialization	This object has not completed its initialization process. Cleared when ~FObjectInitializer completes.
RF_NeedLoad	During load, indicates object needs loading.
UE_DEPRECATED	BulkData identifiers should be regenerated as they are loaded. Keep this object during garbage collection because it's still being used by the cooker.
RF_NeedPostLoad	Object needs to be postloaded.
RF_NeedPostLoadSubobjects	During load, indicates that the object still needs to instance subobjects and fixup serialized component references.
RF_NewerVersionExists	Object has been consigned to oblivion due to its owner package being reloaded, and a newer version currently exists.
RF_BeginDestroyed	BeginDestroy has been called on the object.
RF_FinishDestroyed	FinishDestroy has been called on the object.
RF_BeingRegenerated	Flagged on UObjects that are used to create UClasses (e.g. Blueprints) while they are regenerating their UClass on load (See FLinkerLoad::CreateExport()), as well as UClass objects in the midst of being created.
RF_DefaultSubObject	Flagged on subobject templates that were created in a class constructor, and all instances created from those templates.
RF_WasLoaded	Flagged on UObjects that were loaded.
RF_TextExportTransient	Do not export object to text form (e.g. copy/paste). Generally used for sub-objects that can be regenerated from data in their parent object.
RF_LoadCompleted	Object has been completely serialized by linkerload at least once. DO NOT USE THIS FLAG, It should be replaced with RF_WasLoaded.
RF_InheritableComponentTemplate	Flagged on subobject templates stored inside a class instead of the class default object, they are instanced after default subobjects.
RF_DuplicateTransient	Object should not be included in any type of duplication (copy/paste, binary duplication, etc.)
RF_StrongRefOnFrame	References to this object from persistent function frame are handled as strong ones.
RF_NonPIEDuplicateTransient	Object should not be included for duplication unless it's being duplicated for a PIE session.
RF_ImmutableDefaultObject	Hidden version of the class default object that cannot and will never be mutated.
RF_WillBeLoaded	This object was constructed during load and will be loaded shortly.
RF_HasExternalPackage	This object has an external package assigned and should look it up when getting the outermost package.
RF_MigratingAsset	Objects marked as MigratingAsset can be migrated to another server even if they've been loaded from disk.
RF_MirroredGarbage	Garbage from logical point of view and should not be referenced. This flag is mirrored in EInternalObjectFlags as Garbage for performance.
RF_AllocatedInSharedPage	Allocated from a ref-counted page shared with other UObjects.

◆ EPackageFlags

enum EPackageFlags

Package flags, passed into UPackage::SetPackageFlags and related functions

This MUST be kept in sync with EPackageFlags defined in Engine\Source\Programs\Shared\EpicGames.Core\UnrealEngineTypes.cs

Enumerator
PKG_None	No flags.
PKG_NewlyCreated	Newly created package, not saved yet. In editor only.
PKG_ClientOptional	Purely optional for clients.
PKG_ServerSideOnly	Only needed on the server side.
PKG_CompiledIn	This package is from "compiled in" classes.
PKG_ForDiffing	This package was loaded just for the purposes of diffing.
PKG_EditorOnly	This is editor-only package (for example: editor module script package)
PKG_Developer	Developer module.
PKG_UncookedOnly	Loaded only in uncooked builds (i.e. runtime in editor)
PKG_Cooked	Package is cooked.
PKG_ContainsNoAsset	Package doesn't contain any asset object (although asset tags can be present)
PKG_NotExternallyReferenceable	Objects in this package cannot be referenced in a different plugin or mount point (i.e /Game -> /Engine)
PKG_AccessSpecifierEpicInternal	Objects in this package can only be referenced in a different plugin or mount point by Epic.
PKG_UnversionedProperties	Uses unversioned property serialization instead of versioned tagged property serialization.
PKG_ContainsMapData	Contains map data (UObjects only referenced by a single ULevel) but is stored in a different package.
PKG_IsSaving	Temporarily set on a package while it is being saved.
PKG_Compiling	package is currently being compiled
PKG_ContainsMap	Set if the package contains a ULevel/ UWorld object.
PKG_RequiresLocalizationGather	Set if the package contains any data to be gathered by localization.
PKG_LoadUncooked	This package must be loaded uncooked from IoStore/ZenStore (set only when cooking, to communicate to zenstore via the PackageStoreOptimizer)
PKG_PlayInEditor	Set if the package was created for the purpose of PIE.
PKG_ContainsScript	Package is allowed to contain UClass objects.
PKG_DisallowExport	Editor should not export asset in this package.
PKG_CookGenerated	This package was generated by the cooker and does not exist in the WorkspaceDomain.
PKG_DynamicImports	This package should resolve dynamic imports from its export at runtime.
PKG_RuntimeGenerated	This package contains elements that are runtime generated, and may not follow standard loading order rules.
PKG_ReloadingForCooker	This package is reloading in the cooker, try to avoid getting data we will never need. We won't save this package.
PKG_FilterEditorOnly	Package has editor-only data filtered out.

◆ EPropertyFlags

enum EPropertyFlags : uint64

Flags associated with each property in a class, overriding the property's default behavior.

Warning: When adding one here, please update ParsePropertyFlags()

This MUST be kept in sync with EPackageFlags defined in Engine\Source\Programs\Shared\EpicGames.Core\UnrealEngineTypes.cs

Enumerator
CPF_None
CPF_Edit	Property is user-settable in the editor.
CPF_ConstParm	This is a constant function parameter.
CPF_BlueprintVisible	This property can be read by blueprint code.
CPF_ExportObject	Object can be exported with actor.
CPF_BlueprintReadOnly	This property cannot be modified by blueprint code.
CPF_Net	Property is relevant to network replication.
CPF_EditFixedSize	Indicates that elements of an array can be modified, but its size cannot be changed.
CPF_Parm	Function/When call parameter.
CPF_OutParm	Value is copied out after function call.
CPF_ZeroConstructor	memset is fine for construction
CPF_ReturnParm	Return value.
CPF_DisableEditOnTemplate	Disable editing of this property on an archetype/sub-blueprint.
CPF_NonNullable	Object property can never be null.
CPF_Transient	Property is transient: shouldn't be saved or loaded, except for Blueprint CDOs.
CPF_Config	Property should be loaded/saved as permanent profile.
CPF_RequiredParm	Parameter must be linked explicitly in blueprint. Leaving the parameter out results in a compile error.
CPF_DisableEditOnInstance	Disable editing on an instance of this class.
CPF_EditConst	Property is uneditable in the editor.
CPF_GlobalConfig	Load config from base class, not subclass.
CPF_InstancedReference	Property is a component references.
CPF_ExperimentalExternalObjects	Property saves objects in separate files, breaks hard links and reload them based on discovery.
CPF_DuplicateTransient	Property should always be reset to the default value during any type of duplication (copy/paste, binary duplication, etc.)
CPF_SaveGame	Property should be serialized for save games, this is only checked for game-specific archives with ArIsSaveGame.
CPF_NoClear	Hide clear button.
CPF_Virtual	Property is defined on an interface and does not include a useful Offset_Internal.
CPF_ReferenceParm	Value is passed by reference; CPF_OutParam and CPF_Param should also be set.
CPF_BlueprintAssignable	MC Delegates only. Property should be exposed for assigning in blueprint code.
CPF_Deprecated	Property is deprecated. Read it from an archive, but don't save it.
CPF_IsPlainOldData	If this is set, then the property can be memcopied instead of CopyCompleteValue / CopySingleValue.
CPF_RepSkip	Not replicated. For non replicated properties in replicated structs.
CPF_RepNotify	Notify actors when a property is replicated.
CPF_Interp	interpolatable property for use with cinematics
CPF_NonTransactional	Property isn't transacted.
CPF_EditorOnly	Property should only be loaded in the editor.
CPF_NoDestructor	No destructor.
CPF_AutoWeak	Only used for weak pointers, means the export type is autoweak.
CPF_ContainsInstancedReference	Property contains component references.
CPF_AssetRegistrySearchable	asset instances will add properties with this flag to the asset registry automatically
CPF_SimpleDisplay	The property is visible by default in the editor details view.
CPF_AdvancedDisplay	The property is advanced and not visible by default in the editor details view.
CPF_Protected	property is protected from the perspective of script
CPF_BlueprintCallable	MC Delegates only. Property should be exposed for calling in blueprint code.
CPF_BlueprintAuthorityOnly	MC Delegates only. This delegate accepts (only in blueprint) only events with BlueprintAuthorityOnly.
CPF_TextExportTransient	Property shouldn't be exported to text format (e.g. copy/paste)
CPF_NonPIEDuplicateTransient	Property should only be copied in PIE.
CPF_ExposeOnSpawn	Property is exposed on spawn.
CPF_PersistentInstance	A object referenced by the property is duplicated like a component. (Each actor should have an own instance.)
CPF_UObjectWrapper	Property was parsed as a wrapper class like TSubclassOf<T>, FScriptInterface etc., rather than a USomething*.
CPF_HasGetValueTypeHash	This property can generate a meaningful hash value.
CPF_NativeAccessSpecifierPublic	Public native access specifier.
CPF_NativeAccessSpecifierProtected	Protected native access specifier.
CPF_NativeAccessSpecifierPrivate	Private native access specifier.
CPF_SkipSerialization	Property shouldn't be serialized, can still be exported to text.
CPF_TObjectPtr	Property is a TObjectPtr<T> instead of a USomething*. Need to differentiate between TObjectclassOf and TObjectPtr.
CPF_ExperimentalOverridableLogic	**Experimental* Property will use different logic to serialize knowing what changes are done against its default use the overridable information provided by the overridable manager on the object
CPF_ExperimentalAlwaysOverriden	**Experimental* Property should never inherit from the parent when using overridable serialization
CPF_ExperimentalNeverOverriden	**Experimental* Property should never be overridden when using overridable serialization
CPF_AllowSelfReference	Enables the instancing graph self referencing logic, delegates and verse function are already using this.

◆ EPropertyObjectReferenceType

enum class EPropertyObjectReferenceType : uint32

strong

Enumerator
None
Strong
Weak
Soft
Conservative
MAX
Any

◆ ESaveFlags

enum ESaveFlags

Flags for saving objects/packages, passed into UPackage::SavePackage() as a uint32

Enumerator
SAVE_None	No flags.
SAVE_NoError	Don't generate errors on save.
SAVE_FromAutosave	Used to indicate this save was initiated automatically.
SAVE_KeepDirty	Do not clear the dirty flag when saving.
UE_DEPRECATED	BulkData identifiers should be regenerated as they are loaded. Keep this object during garbage collection because it's still being used by the cooker.
SAVE_Async	Save to a memory writer, then actually write to disk async.
SAVE_Unversioned_Native	Save all versions as zero. Upon load this is changed to the current version. This is only reasonable to use with full cooked builds for distribution.
SAVE_CutdownPackage	Saving cutdown packages in a temp location WITHOUT renaming the package.
SAVE_KeepEditorOnlyCookedPackages	Keep packages which are marked as editor only even though we are cooking.
SAVE_Concurrent	We are save packages in multiple threads at once and should not call non-threadsafe functions or rely on globals. GIsSavingPackage should be set and PreSave/Postsave functions should be called before/after the entire concurrent save.
UE_DEPRECATED	BulkData identifiers should be regenerated as they are loaded. Keep this object during garbage collection because it's still being used by the cooker.
SAVE_BulkDataByReference	When saving to a different file than the package's LoadedPath, point bulkdata in the new file to be loaded from the original file.
SAVE_Unversioned_Properties	Properties are saved without property name information, and are saved/loaded in the order of the current binary. This is only reasonable to use with full cooked builds for distribution, or with a domain that selects the payload matching a given version externally.
SAVE_Optional	Indicate that we to save optional exports. This flag is only valid while cooking. Optional exports are filtered if not specified during cooking.
SAVE_AllowTimeout	If present, if SavePackage is blocked by an asynchronous operation, it will quickly fail with ESavePackageResult::Timeout, otherwise it will wait for a while and then fail with ESavePackageResult::Error.
SAVE_RehydratePayloads	Any virtualized payloads in the package should be pulled and stored locally in the package file during the save.
SAVE_CookSoftPackageReferences	Indicate that we want to save soft package references for cooked packages.
SAVE_Unversioned

◆ EStaticConstructor

enum EStaticConstructor

Enumerator
EC_StaticConstructor

Function Documentation

◆ ENUM_CLASS_FLAGS() [1/5]

ENUM_CLASS_FLAGS ( EClassFlags )

◆ ENUM_CLASS_FLAGS() [2/5]

ENUM_CLASS_FLAGS ( EInternalObjectFlags )

◆ ENUM_CLASS_FLAGS() [3/5]

ENUM_CLASS_FLAGS ( EObjectFlags )

◆ ENUM_CLASS_FLAGS() [4/5]

ENUM_CLASS_FLAGS ( EPackageFlags )

◆ ENUM_CLASS_FLAGS() [5/5]

ENUM_CLASS_FLAGS ( EPropertyObjectReferenceType )

◆ LexToString() [1/2]

COREUOBJECT_API FString LexToString ( EObjectFlags Flags )

◆ LexToString() [2/2]

COREUOBJECT_API const TCHAR * LexToString ( EPropertyObjectReferenceType Type )

Variable Documentation

◆ RF_HasPlaceholderType

constexpr EObjectFlags RF_HasPlaceholderType = EObjectFlags(0x20000000)

inlineconstexpr

◆ RF_InternalGarbage

constexpr EObjectFlags RF_InternalGarbage = RF_MirroredGarbage

inlineconstexpr

◆ RF_InternalMirroredFlags

constexpr EObjectFlags RF_InternalMirroredFlags = RF_MirroredGarbage

inlineconstexpr

◆ RF_InternalPendingKill

constexpr EObjectFlags RF_InternalPendingKill = RF_MirroredGarbage

inlineconstexpr

Classes

Namespaces

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ BODY_MACRO_COMBINE

◆ BODY_MACRO_COMBINE_INNER

◆ CASTCLASS_AllFlags

◆ CLASS_AllFlags

◆ CLASS_Inherit

◆ CLASS_RecompilerClear

◆ CLASS_SaveInCompiledInClasses

◆ CLASS_ScriptInherit

◆ CLASS_ShouldNeverBeLoaded

◆ COMPILED_IN_FLAGS

◆ CONSTRUCT_RELOAD_VERSION_INFO

◆ CPF_AllFlags

◆ CPF_ComputedFlags

◆ CPF_DevelopmentAssets

◆ CPF_InterfaceClearMask

◆ CPF_NativeAccessSpecifiers

◆ CPF_ParmFlags

◆ CPF_PropagateToArrayInner

◆ CPF_PropagateToMapKey

◆ CPF_PropagateToMapValue

◆ CPF_PropagateToOptionalInner

◆ CPF_PropagateToSetElement

◆ CPF_TObjectPtrWrapper

◆ DECLARE_CASTED_CLASS_INTRINSIC

◆ DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR

◆ DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR_NO_VTABLE_CTOR

◆ DECLARE_CASTED_CLASS_INTRINSIC_WITH_API

◆ DECLARE_CASTED_CLASS_INTRINSIC_WITH_API_NO_CTOR

◆ DECLARE_CLASS

◆ DECLARE_CLASS2

◆ DECLARE_CLASS_INTRINSIC

◆ DECLARE_CLASS_INTRINSIC_API

◆ DECLARE_CLASS_INTRINSIC_NO_CTOR

◆ DECLARE_FARCHIVE_SERIALIZER

◆ DECLARE_FSTRUCTUREDARCHIVE_SERIALIZER

◆ DECLARE_FUNCTION

◆ DECLARE_SERIALIZER

◆ DECLARE_VALIDATE_GENERATED_REP_ENUMS

◆ DECLARE_VTABLE_PTR_HELPER_CTOR

◆ DECLARE_WITHIN

◆ DECLARE_WITHIN_INTERNAL

◆ DECLARE_WITHIN_UPACKAGE

◆ DEFAULT_OBJECT_PREFIX

◆ DEFINE_ABSTRACT_DEFAULT_CONSTRUCTOR_CALL

◆ DEFINE_ABSTRACT_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL

◆ DEFINE_DEFAULT_CONSTRUCTOR_CALL

◆ DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL

◆ DEFINE_FORBIDDEN_DEFAULT_CONSTRUCTOR_CALL

◆ DEFINE_FUNCTION

◆ DEFINE_VTABLE_PTR_HELPER_CTOR

◆ DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER

◆ DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER_DUMMY

◆ DEFINE_VTABLE_PTR_HELPER_CTOR_NS

◆ EInternalObjectFlags_AllFlags

◆ EInternalObjectFlags_AsyncLoading

◆ EInternalObjectFlags_GarbageCollectionKeepFlags

◆ EInternalObjectFlags_MinFlagBitIndex

◆ EInternalObjectFlags_ReachabilityFlags

◆ EInternalObjectFlags_RefCountMask

◆ EInternalObjectFlags_RootFlags

◆ GENERATED_BODY

◆ GENERATED_BODY_LEGACY

◆ GENERATED_IINTERFACE_BODY

◆ GENERATED_UCLASS_BODY

◆ GENERATED_UINTERFACE_BODY

◆ GENERATED_USTRUCT_BODY

◆ IMPLEMENT_CLASS

◆ IMPLEMENT_CLASS_NO_AUTO_REGISTRATION

◆ IMPLEMENT_CORE_INTRINSIC_CLASS

◆ IMPLEMENT_FARCHIVE_SERIALIZER

◆ IMPLEMENT_FSTRUCTUREDARCHIVE_SERIALIZER

◆ IMPLEMENT_INTRINSIC_CLASS