UE Namespace Reference

Namespaces
namespace	AccessDetection
namespace	AdvancedWidgets
namespace	AI
namespace	AISense_Sight
namespace	Analytics
namespace	Anim
namespace	Animation
namespace	AnimationCore
namespace	AnimBank
namespace	ArchiveStackTrace
namespace	Assert
namespace	AssetAccessRestrictions
namespace	AssetBundleEntry
namespace	AssetData
namespace	AssetDataGather
namespace	AssetManager
namespace	AssetRegistry
namespace	AsyncPackage2
namespace	BehaviorTree
namespace	BlackboardKeySelector
namespace	Blueprint
namespace	BlueprintPropertyHelpers
namespace	BulkData
namespace	BulkDataRegistry
namespace	CADKernel
namespace	ClothingSimulation
namespace	CodeGen
namespace	Color
namespace	ColorGrading
namespace	CompactBinary
namespace	ComparisonUtility
namespace	CompressedBuffer
namespace	ConfigAccessTracking
namespace	ConfigCacheIni
namespace	ConfigUtilities
namespace	ConsoleManager
namespace	Constraints
namespace	Conversion
namespace	Cook
namespace	CookAssetRegistryAccessTracker
namespace	Core
namespace	CoreObject
namespace	CoreRedirects
namespace	CoreUObject
namespace	CubicBezier
namespace	Cursor
namespace	Curves
namespace	D3D12Descriptors
namespace	D3D12RHI
namespace	Dataflow
namespace	DataflowContextHelpers
namespace	DataTableJSON
namespace	DataValidation
namespace	DDS
namespace	DebugDrawHelper
namespace	Delegates
namespace	Deque
namespace	DerivedData
namespace	detail
namespace	Detour
namespace	DirectoryTree
namespace	DynamicConfig
namespace	DynamicMesh
namespace	DynamicMeshEditorInternals
namespace	Editor
namespace	Engine
namespace	EnumFlags
namespace	EventLoop
namespace	FActorInstanceHandle
namespace	FAndroidPlatformDynamicRHI
namespace	FieldNotification
namespace	FileHelper
namespace	FilePackageStorePrivate
namespace	FIOSPlatformDynamicRHI
namespace	FIOSPlatformMisc
namespace	FMacPlatformDynamicRHI
namespace	FXRenderingUtils
namespace	GameModeBase
namespace	Gameplay
namespace	GameplayTags
namespace	GC
namespace	GenericHash
namespace	Geometry
namespace	GeometryCollectionConvexUtility
namespace	GeometryCollectionInternal
namespace	GizmoRenderingUtil
namespace	GizmoUtil
namespace	Graph
namespace	HAL
namespace	Handler
namespace	HLSL
namespace	HttpRequestCommon
namespace	ImageWrapper
namespace	Impl
namespace	Input
namespace	InputDeviceScope
namespace	InstanceAttributeTracker
namespace	InteractiveToolsFramework
namespace	Interchange
namespace	InterchangeTaskParsing
namespace	InternalUVPacking
namespace	IoStore
	NO_LOGGING.
namespace	Json
namespace	JsonArray
namespace	JsonObjectGraph
namespace	JsonSerializable
namespace	JsonUtilities
namespace	Kismet
namespace	KismetArray
namespace	Landscape
namespace	LinearBlockAllocator
namespace	LiveLink
namespace	LLMPrivate
namespace	Local
namespace	Logging
namespace	LWC
namespace	Mac
namespace	Mass
namespace	MaterialInterface
namespace	Math
namespace	MathCore
namespace	MediaTexture
namespace	MediaUtils
namespace	MemStack
namespace	MeshNormalsLocals
namespace	MeshPassUtils
namespace	MessageLog
namespace	MorphTargetVertexCodec
namespace	MovieScene
namespace	MovieSceneTracks
namespace	MultiBoxUtils
namespace	Name
namespace	Navigation
namespace	NavigationElement
namespace	NavigationHelper
namespace	NavigationOctree
namespace	NavMesh
namespace	Net
namespace	NetworkPhysicsUtils
namespace	NNE
namespace	Object
namespace	Online
namespace	OpenGL
namespace	OrientedBoxTypeLocals
namespace	OS
namespace	Package
namespace	PackagePathPrivate
namespace	PackageWriter
namespace	PakFile
namespace	ParkingLot
namespace	Paths
namespace	PipelineCacheUtilities
namespace	PixelFormat
namespace	PlatformFileJournal
namespace	PluginDescriptor
namespace	PluginManager
namespace	Private
namespace	Profiling
namespace	Projects
namespace	ProjectUtilities
namespace	PropertyAccessUtil
namespace	PropertyViewer
namespace	RDG
namespace	Recast
namespace	ReferenceChainSearch
namespace	Reflection
namespace	RemoteExecutor
namespace	RemoteObject
namespace	RenderCommandPipe
namespace	RenderCore
namespace	Renderer
namespace	RendererPrivateUtils
namespace	RenderViewportFeedback
namespace	ReplaySubsystem
namespace	RHI
namespace	RHICore
namespace	RHIResourceUtils
namespace	RHITextureUtils
namespace	Runtime
namespace	SavePackageUtilities
namespace	Sequencer
namespace	Serialization
namespace	Shader
namespace	ShaderBinaryUtilities
namespace	ShaderCompiler
namespace	ShaderLibrary
namespace	ShaderPermutationUtils
namespace	ShaderPipeline
namespace	ShaderUtils
namespace	SharedBuffer
namespace	SkeletalRender
namespace	Slate
namespace	SoftObjectPath
namespace	Solvers
namespace	SourceLocation
namespace	Spline
namespace	SplineComponent
namespace	SplineMesh
namespace	StageProviderUtils
namespace	StaticMesh
namespace	Stats
namespace	StereoRenderUtils
namespace	StreamableManager
namespace	String
namespace	StringTable
namespace	StructuredArchive
namespace	StructUtils
namespace	SVT
namespace	SweepGeneratorLocals
namespace	Tasks
namespace	Telemetry
namespace	Text
namespace	TextureDefines
namespace	TextureUtilitiesCommon
namespace	Tick
namespace	TimeManagement
namespace	ToolMenuCustomization
namespace	TopLevelAssetPath
namespace	Trace
namespace	Transaction
namespace	TransformConstraintUtil
namespace	TransformGizmoUtil
namespace	TypedElementFramework
namespace	UAF
namespace	UMG
namespace	UnifiedError
namespace	UniversalObjectLocator
namespace	UObjectArrayPrivate
namespace	Verse
namespace	VersePath
namespace	Virtualization
namespace	VirtualProduction
namespace	VisualLogger
namespace	Vulkan
namespace	VulkanTexture
namespace	WindowsApplication
namespace	WindowsInput
namespace	WindowsPlatformFile
namespace	WindowsPlatformFileJournal
namespace	XRStereoLayerCVars
namespace	ZenCookOnTheFly

Classes
struct	CSerializableForLog
struct	FAcquireLock
class	FAssetLog
class	FConditionVariable
struct	FDeferLock
class	FDerivedData
class	FDerivedDataIoBatch
class	FDerivedDataIoOptions
struct	FDerivedDataIoPriority
class	FDerivedDataIoRequest
class	FDerivedDataIoResponse
struct	FDynamicallyTypedValue
struct	FDynamicallyTypedValueType
class	FEncryptionKeyManager
class	FForkPageProtector
class	FGenericPlatformIoDispatcher
class	FGenericPlatformIoDispatcherFactory
class	FHttpIoDispatcher
class	FInheritedContextBase
class	FInheritedContextScope
struct	FIoBlockKey
struct	FIoBufferHandle
class	FIoChunkBlockMemoryPool
struct	FIoDirectReadRequestParams
class	FIoDispatcherChunkBlockDecoder
class	FIoDispatcherFilesystemStats
struct	FIoEncodedBlockRequest
class	FIoFileBlockCache
struct	FIoFileBlockLink
class	FIoFileBlockMemoryPool
struct	FIoFileBlockRequest
struct	FIoFileHandle
struct	FIoFileProperties
struct	FIoFileReadRequest
struct	FIoFileReadResult
struct	FIoFileStat
class	FIoHttpBatch
class	FIoHttpHeaders
struct	FIoHttpOptions
struct	FIoHttpRange
class	FIoHttpRequest
class	FIoHttpResponse
struct	FIoPlatformFileInfo
struct	FIoPlatformReadRequest
class	FIoQueue
class	FIoRelativeUrl
class	FIoScatterGatherRequestParams
class	FIoServiceThread
struct	FItem
class	FLinearBlockAllocator
class	FLinearBlockAllocatorThreadAccessor
class	FLogRecord
class	FLogTime
class	FMacSystemWideMutex
class	FManualResetEvent
struct	FMonotonicTimePoint
struct	FMonotonicTimeSpan
struct	FMountPaksExArgs
struct	FMultiprocessCreatedContext
struct	FMultiprocessDetachedContext
class	FMutex
class	FPackageResourceIoBackend
class	FPackageTrailer
class	FPackageTrailerBuilder
struct	FPayloadInfo
class	FPlatformIoDispatcher
class	FPlatformIoDispatcherBase
struct	FPlatformIoDispatcherCreateParams
class	FPlatformIoDispatcherRequestMgr
class	FPlatformIoDispatcherStats
class	FPlatformRWLock
class	FPlatformSystemWideMutexNotImplemented
class	FPropertyPathName
struct	FPropertyPathNameSegment
class	FPropertyPathNameTree
class	FPropertyTypeName
class	FPropertyTypeNameBuilder
struct	FPropertyTypeNameNode
struct	FPropertyTypeNameNodeProxy
class	FPropertyTypeNameTable
struct	FPropertyValueInContainer
class	FRecursiveMutex
class	FRecursiveWordMutex
struct	FScopedObjectSerializeContext
class	FScriptTimeLimiter
class	FSerializedPropertyPathScope
class	FSharedMutex
class	FSharedRecursiveMutex
class	FSourceLocation
class	FSpinLock
struct	FSubItem
class	FTexture2DStreamIn_DerivedData
class	FTexture2DStreamIn_DerivedData_AsyncCreate
class	FTexture2DStreamIn_DerivedData_AsyncReallocate
class	FTexture2DStreamIn_DerivedData_Virtual
class	FTimeout
class	FUnixSystemWideMutex
class	FWindowsRecursiveMutex
class	FWindowsSharedMutex
class	FWindowsSystemWideMutex
class	FWordMutex
struct	FWordMutexQueueNode
class	IHttpIoDispatcher
class	IPlatformIoDispatcher
class	ProxyChangeEvent
class	TAtomicFlags
class	TConditionalScopeLock
class	TConsumeAllMpmcQueue
class	TDynamicSharedLock
class	TDynamicSharedLock< FSharedRecursiveMutex >
class	TDynamicUniqueLock
class	TEventCount
class	TEventCountToken
class	TExternalMutex
struct	TFindRedirectForPropertyTraits
struct	TFindRedirectForPropertyTraits< FByteProperty >
struct	TFindRedirectForPropertyTraits< FEnumProperty >
struct	TFindRedirectForPropertyTraits< FStructProperty >
class	TFunctionWithContext
class	TFunctionWithContext< ReturnType(ArgTypes...)>
class	TGenericPlatformSharedMutex
struct	THash
class	TIntrusiveMutex
class	TIntrusiveUniqueLock
class	TMultiUniqueLock
class	TReadScopeLock
class	TRWScopeLock
class	TRWSpinLock
class	TScopeLock
class	TScopeTryLock
class	TScopeUnlock
class	TSharedLock
class	TSharedLock< FSharedRecursiveMutex >
class	TSharedString
class	TUniqueLock
class	TWriteScopeLock

Concepts
concept	CIntrusiveMutexParams
concept	CArithmetic
concept	CCharType
concept	CCompatibleCharType
concept	CCompatibleStringViewable
concept	CContiguousRange
concept	CConvertibleTo
concept	CDecaysTo
concept	CDerivedFrom
concept	CFloatingPoint
concept	CIntegral
concept	CNotCVRefTo
concept	CPointer
concept	CSameAs
concept	CStringViewable
concept	same_as
concept	convertible_to
concept	derived_from

Typedefs
using	FPlatformIoDispatcherFactory = FGenericPlatformIoDispatcherFactory
using	FIoFileReadRequestCompleted = TUniqueFunction< void(FIoFileReadResult &&)>
template<typename T , SIZE_T Size = 8>
using	FTempArray = TArray< T, TInlineAllocator< Size > >
using	FIoEncodedBlockRequestAllocator = TSingleThreadedSlabAllocator< FIoEncodedBlockRequest, 1024 >
using	FIoEncodedBlockRequestList = TIntrusiveList< FIoEncodedBlockRequest >
using	FIoFileBlockLinkAllocator = TSingleThreadedSlabAllocator< FIoFileBlockLink, 128 >
using	FIoPlatformReadRequestAllocator = TSingleThreadedSlabAllocator< FIoPlatformReadRequest, 1024 >
using	FIoPlatformReadRequestList = TIntrusiveList< FIoPlatformReadRequest >
using	FIoFileBlockRequestAllocator = TSingleThreadedSlabAllocator< FIoFileBlockRequest, 1024 >
using	FIoFileBlockRequestList = TIntrusiveList< FIoFileBlockRequest >
using	FPlatformRecursiveMutex = FPThreadsRecursiveMutex
using	FPlatformSharedMutex = FPThreadsSharedMutex
using	FPlatformSystemWideMutex = FPlatformSystemWideMutexNotImplemented
using	FEventCount = TEventCount< uint32 >
using	FEventCountToken = TEventCountToken< uint32 >
using	TIntrusiveMutex = TExternalMutex< Core::Private::FExternalMutexParams >
template<typename ParamsType >
using	TIntrusiveMutexStateType_T = std::decay_t< decltype(ParamsType::IsLockedFlag)>
using	FTransactionallySafeMutex = FMutex
using	FTransactionallySafeRecursiveMutex = ::UE::FRecursiveMutex
using	FTransactionallySafeSharedMutex = ::UE::FSharedMutex
using	TConsumeAllMpmcQueue = TDepletableMpmcQueue< T, AllocatorType >
using	FSharedString = TSharedString< TCHAR >
using	FAnsiSharedString = TSharedString< ANSICHAR >
using	FWideSharedString = TSharedString< WIDECHAR >
using	FUtf8SharedString = TSharedString< UTF8CHAR >
using	FRWSpinLock = TRWSpinLock< uint32 >
using	FDerivedDataIoComplete = TUniqueFunction< void()>
using	FHash32 = THash< 32 >
using	FHash64 = THash< 64 >
using	FHash96 = THash< 96 >
using	FHash128 = THash< 128 >
using	FHash160 = THash< 160 >
using	FHash256 = THash< 256 >
using	FIoHttpRequestHandle = UPTRINT
using	FIoHttpRequestCompleted = TUniqueFunction< void(FIoHttpResponse &&)>

Enumerations
enum class	EIoFilePropertyFlags : uint8 { None = 0 , Encrypted = (1 << 0) , Signed = (1 << 1) }
enum class	EConsumeAllMpmcQueueResult { HadItems , WasEmpty }
enum class	EPackageTrailerVersion : uint32 {   INITIAL = 0 , ACCESS_PER_PAYLOAD = 1 , PAYLOAD_FLAGS = 2 , AUTOMATIC_VERSION_PLUS_ONE ,   AUTOMATIC_VERSION = AUTOMATIC_VERSION_PLUS_ONE - 1 }
enum class	EDerivedDataFlags : uint32 { None = 0 , Required = 1 << 0 , Optional = 1 << 1 , MemoryMapped = 1 << 2 }
enum class	EDerivedDataIoStatus : uint8 { Ok , Error , Canceled , Unknown }
enum class	EPayloadStorageType : uint8 { Any , Local , Referenced , Virtualized }
enum class	EPayloadFilter { CanVirtualize }
enum class	EPayloadStatus { NotFound = 0 , StoredLocally , StoredAsReference , StoredVirtualized }
enum class	EPayloadAccessMode : uint8 { Local = 0 , Referenced , Virtualized }
enum class	EPayloadFlags : uint16 { None = 0 }
enum class	EPrintObjectFlag : uint32 { None = 0 , Verbose = (1 << 0) , PropertyInitializationState = (1 << 1) , FullArchetypeChain = (1 << 2) }
enum class	EIoHttpFlags { None = 0 , ReadCache = (1 << 0) , ResponseHeaders = (1 << 1) , Default = ReadCache }
enum class	EIoHttpResponseFlags : uint8 { None = 0 , Cached = (1 << 0) }

Functions
TUniquePtr< IPlatformIoDispatcher >	MakeGenericPlatformIoDispatcher (FPlatformIoDispatcherCreateParams &&Params)
	ENUM_CLASS_FLAGS (EIoFilePropertyFlags)
template<typename... Args>
bool	IsIoErrorAnyOf (EIoErrorCode ErrorCode, Args... Expected)
	TRACE_DECLARE_INT_COUNTER (ChunkDecoderQueueCount, TEXT("IoDispatcher/ChunkDecoderQueueCount"))
	TRACE_DECLARE_INT_COUNTER (AvailableChunkDecoderWorkerCount, TEXT("IoDispatcher/AvailableChunkDecoderWorkerCount"))
int32	GetPlayInEditorID ()
void	SetPlayInEditorID (int32 InPlayInEditorID)
bool	GetIsEditorLoadingPackage ()
void	SetIsEditorLoadingPackage (bool InValue)
int32	GetMultiprocessId ()
bool	IsUsingZenPakFileStreaming ()
bool	IsGCLocked ()
template<typename T , typename AllocatorType = FMemory>
class	UE_DEPRECATED (5.3, "This concurrent queue was deprecated because it uses spin-waiting that can cause priority inversion and subsequently deadlocks on some platforms. Please use TConsumeAllMpmcQueue.") TDepletableMpmcQueue final
template<typename HashType , typename CharType >
constexpr HashType	HashStringFNV1a (TStringView< CharType > String)
template<typename HashType , typename CharType , int32 Len>
UE_CONSTEVAL HashType	HashStringFNV1a (const CharType(&StringLiteral)[Len])
template<typename CharType >
constexpr uint32	HashStringFNV1a32 (TStringView< CharType > String)
template<typename CharType , int32 Len>
UE_CONSTEVAL uint32	HashStringFNV1a32 (const CharType(&StringLiteral)[Len])
template<typename CharType >
constexpr uint64	HashStringFNV1a64 (TStringView< CharType > String)
template<typename CharType , int32 Len>
UE_CONSTEVAL uint64	HashStringFNV1a64 (const CharType(&StringLiteral)[Len])
template<typename ValueType UE_REQUIRES>
void	SerializeForLog (FCbWriter &Writer, ValueType &&Value)
template<typename ValueType UE_REQUIRES>
void	CallSerializeForLog (FCbWriter &Writer, ValueType &&Value)
template<typename... InvocableTypes>
UE_REWRITE constexpr auto	Overload (InvocableTypes &&... Invocables)
COREPRECISEFP_API bool	PreciseFPEqual (float Lhs, float Rhs)
COREPRECISEFP_API bool	PreciseFPEqual (double Lhs, double Rhs)
COREPRECISEFP_API uint32	PreciseFPHash (float)
COREPRECISEFP_API uint32	PreciseFPHash (double)
FStringBuilderBase &	operator<< (FStringBuilderBase &Builder, const FDerivedData &Data)
template<typename NamesCollection >
int64	GetMaxEnumValue (const NamesCollection &InNamesAndValues, EEnumFlags InFlags)
EInternalObjectFlags	GetAsyncLoadingInternalFlagsExclusion ()
void	SendOverrideAllObjectPropertiesEvent (TNotNull< UObject * > Object)
void	SendClearOverridesEvent (TNotNull< UObject * > Object)
void	SendOverridePropertyEvent (TNotNull< UObject * > Object, const FPropertyVisitorPath &PropertyPath, EPropertyChangeType::Type ChangeType)
void	SendOverridePropertyEvent (TNotNull< UObject * > Object, const FPropertyChangedEvent &PropertyEvent, const FEditPropertyChain &PropertyChain)
void	SendClearOverriddenPropertyEvent (TNotNull< UObject * > Object, const FPropertyVisitorPath &PropertyPath)
void	SendClearOverriddenPropertyEvent (TNotNull< UObject * > Object, const FPropertyChangedEvent &PropertyEvent, const FEditPropertyChain &PropertyChain)
void	SendPreOverridePropertyEvent (TNotNull< UObject * > Object, const FPropertyVisitorPath &PropertyPath)
void	SendPreOverridePropertyEvent (TNotNull< UObject * > Object, const FEditPropertyChain &PropertyChain)
void	SendPostOverridePropertyEvent (TNotNull< UObject * > Object, const FPropertyVisitorPath &PropertyPath, const EPropertyChangeType::Type ChangeType)
void	SendPostOverridePropertyEvent (TNotNull< UObject * > Object, const FPropertyChangedEvent &PropertyEvent, const FEditPropertyChain &PropertyChain)
FIoChunkId	CreatePackageResourceChunkId (const FName &PackageName, EPackageSegment Segment, const FBulkDataCookedIndex &CookedIndex, bool bExternalResource)
bool	TryGetPackageNameFromChunkId (const FIoChunkId &ChunkId, FName &OutPackageName, EPackageSegment &OutSegment, bool &bOutExternal)
bool	TryGetPackagePathFromChunkId (const FIoChunkId &ChunkId, FPackagePath &OutPath, EPackageSegment &OutSegment, bool &bExternal)
bool	TryGetPackagePathFromChunkId (const FIoChunkId &ChunkId, FPackagePath &OutPath, EPackageSegment &OutSegment, bool &bExternal, FBulkDataCookedIndex &OutCookedIndex)
EAsyncIOPriorityAndFlags	ConvertToAsyncIoPriority (const int32 IoDispatcherProperty)
TSharedRef< IIoDispatcherBackend >	MakePackageResourceIoDispatcherBackend (IPackageResourceManager &Mgr)
FArchive &	operator<< (FArchive &Ar, FPackageTrailer::FHeader &Header)
FArchive &	operator<< (FArchive &Ar, FPackageTrailer::FFooter &Footer)
bool	FindPayloadsInPackageFile (const FPackagePath &PackagePath, EPayloadStorageType Filter, TArray< FIoHash > &OutPayloadIds)
UObject *	FindObjectByTypePath (UClass *Class, FPropertyTypeName TypePath)
FPropertyTypeName	ApplyRedirectsToPropertyType (FPropertyTypeName OldTypeName, const FProperty *Property)
template<typename T >
T *	FindObjectByTypePath (FPropertyTypeName TypePath)
FProperty *	FindPropertyByNameAndTypeName (const UStruct *Struct, FName Name, FPropertyTypeName TypeName)
FPropertyValueInContainer	TryResolvePropertyPath (const FPropertyPathName &Path, UObject *Object)
FPropertyValueInContainer	TryResolvePropertyPathForChangeEvent (const FPropertyPathName &Path, UObject *Object, uint32 ChangeType, TSharedPtr< FPropertyChangedChainEvent > &OutEvent, FEditPropertyChain &OutChain)
uint32	GetTypeHash (const FPropertyPathName &Path)
void	AppendHash (FBlake3 &Builder, const FPropertyPathNameTree &Tree)
	LLM_DEFINE_TAG (FPropertyTypeName)
uint32	GetTypeHash (const FPropertyTypeNameNode &Node)
FArchive &	operator<< (FArchive &Ar, FPropertyTypeNameNode &Node)
void	operator<< (FStructuredArchiveSlot Slot, FPropertyTypeNameNode &Node)
const FPropertyTypeNameNode *	AppendNode (FStringBuilderBase &Builder, const FPropertyTypeNameNode *Node)
uint32	GetTypeHash (const FPropertyTypeName &TypeName)
void	AppendHash (FBlake3 &Builder, const FPropertyTypeName &TypeName)
bool	operator== (const FPropertyTypeName &Lhs, const FPropertyTypeName &Rhs)
bool	operator< (const FPropertyTypeName &Lhs, const FPropertyTypeName &Rhs)
FArchive &	operator<< (FArchive &Ar, FPropertyTypeName &TypeName)
void	operator<< (FStructuredArchiveSlot Slot, FPropertyTypeName &TypeName)
FStringBuilderBase &	operator<< (FStringBuilderBase &Builder, const FPropertyTypeName &TypeName)
bool	IsSavingPackage (UObject *InOuter)
	ENUM_CLASS_FLAGS (EDerivedDataFlags)
	ENUM_CLASS_FLAGS (EPayloadFlags)
template<typename CharType >
TStringBuilderBase< CharType > &	operator<< (TStringBuilderBase< CharType > &Builder, EPayloadAccessMode Mode)
void	PrintObjectsInOuter (UObject *Object, EPrintObjectFlag Flags, FOutputDevice *InOutputDevice)
void	PrintObjectsWithName (const TCHAR *ObjectName, EPrintObjectFlag Flags, FOutputDevice *InOutputDevice)
void	PrintStructProperties (UStruct *Struct, void *StructData, EPrintObjectFlag Flags, FOutputDevice *InOutputDevice)
void	PrintObjectProperties (UObject *Object, EPrintObjectFlag Flags, FOutputDevice *InOutputDevice)
void	PrintObjectArchetype (UObject *Object, EPrintObjectFlag Flags, FOutputDevice *InOutputDevice)
void	PrintObjectIDO (UObject *Object, EPrintObjectFlag Flags, FOutputDevice *InOutputDevice)
void	PrintClassDefaultObject (const UClass *Class, EPrintObjectFlag Flags, FOutputDevice *InOutputDevice)
void	PrintStructHierarchy (const UStruct *Struct, EPrintObjectFlag Flags, FOutputDevice *InOutputDevice)
	ENUM_CLASS_FLAGS (EPrintObjectFlag)
	ENUM_CLASS_FLAGS (EIoHttpFlags)
	ENUM_CLASS_FLAGS (EIoHttpResponseFlags)

Variables
TUniquePtr< IPlatformIoDispatcher >	GPlatformIoDispatcher
int	GIsUsingZenPakFileStreaming = -1
constexpr struct UE::FAcquireLock	AcquireLock
constexpr struct UE::FDeferLock	DeferLock
constexpr uint8	CookedIndexByteIdx = 8
const FName	NAME_Key (ANSITEXTVIEW("Key"))
const FName	NAME_Value (ANSITEXTVIEW("Value"))
FPropertyTypeNameTable	GPropertyTypeNameTable
FAutoConsoleCommandWithArgsAndOutputDevice	CVarCommandPrintObjectsInOuter (TEXT("Obj.DumpObjectsInOuter"), TEXT("Lists all objects under a specified parent (the parent object must be specified as a name or path, e.g., /MyLevel/MyLevel.MyLevel:PersistentLevel)."), FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ObjectPath;EPrintObjectFlag Flags;ParseObjectIdAndFlags(Args, ObjectPath, Flags);UObject *Object=FindFirstObjectSafe< UObject >(*ObjectPath);if(Object) { PrintObjectsInOuter(Object, Flags, &OutputDevice);} else { OutputDevice.Logf(TEXT("PrintObjectsInOuter: failed to find any objects for path: '%s'"), *ObjectPath);} } else { OutputDevice.Logf(TEXT("PrintObjectsInOuter: no object path specified (example usage: Obj.DumpObjectsInOuter /MyLevel/MyLevel.MyLevel:PersistentLevel)"));LogHelp(OutputDevice);} }))
FAutoConsoleCommandWithArgsAndOutputDevice	CVarCommandPrintObjectsWithName (TEXT("Obj.DumpObjectsWithName"), TEXT("Lists all objects with a given name."), FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ObjectName;EPrintObjectFlag Flags;ParseObjectIdAndFlags(Args, ObjectName, Flags);PrintObjectsWithName(*ObjectName, Flags, &OutputDevice);} else { OutputDevice.Logf(TEXT("PrintObjectsWithName: no object name specified (example usage: Obj.DumpObjectsWithName PersistentLevel)"));LogHelp(OutputDevice);} }))
FAutoConsoleCommandWithArgsAndOutputDevice	CVarCommandPrintObjectProperties (TEXT("Obj.DumpProperties"), TEXT("Lists the properties of an object (the object must be specified as a name or path, e.g., /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor). Pass InitState=true to iclude the properties' initialization state."), FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ObjectPath;EPrintObjectFlag Flags;ParseObjectIdAndFlags(Args, ObjectPath, Flags);UObject *Object=FindFirstObjectSafe< UObject >(*ObjectPath);if(Object) { PrintObjectProperties(Object, Flags, &OutputDevice);} else { OutputDevice.Logf(TEXT("PrintObjectProperties: failed to find any objects for path: '%s'"), *ObjectPath);} } else { OutputDevice.Logf(TEXT("PrintObjectProperties: no object path specified (example usage: Obj.DumpProperties /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor)"));LogHelp(OutputDevice);} }))
FAutoConsoleCommandWithArgsAndOutputDevice	CVarCommandPrintObjectArchetype (TEXT("Obj.DumpArchetype"), TEXT("Outputs an object's archetype (the object must be specified as a name or path, e.g., /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor)."), FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ObjectPath;EPrintObjectFlag Flags;ParseObjectIdAndFlags(Args, ObjectPath, Flags);UObject *Object=FindFirstObjectSafe< UObject >(*ObjectPath);if(Object) { PrintObjectArchetype(Object, Flags, &OutputDevice);} else { OutputDevice.Logf(TEXT("PrintObjectArchetype: failed to find any objects for path: '%s'"), *ObjectPath);} } else { OutputDevice.Logf(TEXT("PrintObjectArchetype: no object path specified (example usage: Obj.DumpArchetype /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor)"));LogHelp(OutputDevice);} }))
FAutoConsoleCommandWithArgsAndOutputDevice	CVarCommandPrintObjectIDO (TEXT("Obj.DumpIDO"), TEXT("Outputs an object's IDO (Instance Data Object) (the object must be specified as a name or path, e.g., /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor)."), FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ObjectPath;EPrintObjectFlag Flags;ParseObjectIdAndFlags(Args, ObjectPath, Flags);UObject *Object=FindFirstObjectSafe< UObject >(*ObjectPath);if(Object) { PrintObjectIDO(Object, Flags, &OutputDevice);} else { OutputDevice.Logf(TEXT("PrintObjectIDO: failed to find any objects for path: '%s'"), *ObjectPath);} } else { OutputDevice.Logf(TEXT("PrintObjectIDO: no object path specified (example usage: Obj.DumpArchetype /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor)"));LogHelp(OutputDevice);} }))
FAutoConsoleCommandWithArgsAndOutputDevice	CVarCommandPrintCDO (TEXT("Obj.DumpCDO"), TEXT("Outputs a class' Class Default Object."), FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ClassPath;EPrintObjectFlag Flags;ParseObjectIdAndFlags(Args, ClassPath, Flags);UClass *Class=FindFirstObjectSafe< UClass >(*ClassPath);if(Class) { PrintClassDefaultObject(Class, Flags, &OutputDevice);} else { OutputDevice.Logf(TEXT("PrintClassDefaultObject: failed to find any classes for path: '%s'"), *ClassPath);} } else { OutputDevice.Logf(TEXT("PrintClassDefaultObject: no class name or path specified (example usage: Obj.DumpCDO MyActor)"));LogHelp(OutputDevice);} }))
FAutoConsoleCommandWithArgsAndOutputDevice	CVarCommandPrintStructHierarchy (TEXT("Obj.DumpStructHierarchy"), TEXT("Outputs a struct (or class) type hierarchy."), FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString StructPath;EPrintObjectFlag Flags;ParseObjectIdAndFlags(Args, StructPath, Flags);UStruct *Struct=FindFirstObjectSafe< UStruct >(*StructPath);if(Struct) { PrintStructHierarchy(Struct, Flags, &OutputDevice);} else { OutputDevice.Logf(TEXT("PrintStructHierarchy: failed to find any types for path: '%s'"), *StructPath);} } else { OutputDevice.Logf(TEXT("PrintStructHierarchy: no struct name or path specified (example usage: Obj.DumpStructHierarchy MyActor)"));LogHelp(OutputDevice);} }))
TSharedPtr< IHttpIoDispatcher >	GHttpIoDispatcher

Detailed Description

Implements a rectangular 2D Box.

Structure for a combined axis aligned bounding box and bounding sphere with the same origin. (28 bytes).

Structure for capsules.

A capsule consists of two sphere connected by a cylinder.

Dual quaternion class

4x4 matrix of floating point values.

Note that, like with FTransform, Matrix-Matrix multiplication is applied such that C = A * B will yield a transform C that logically first applies A then B, so (A*B).TransformPosition(Pt) == B.TransformPosition(A.TransformPosition(Pt))

Matrix elements are accessed with M[RowIndex][ColumnIndex].

Structure for three dimensional planes.

Stores the coeffecients as Xx+Yy+Zz=W. Note that this is different from many other Plane classes that use Xx+Yy+Zz+W=0.

3D Ray represented by Origin and (normalized) Direction

Implements a basic sphere.

A vector in 2-D space composed of components (X, Y) with floating point precision.

Utility functions and console commands that print UObject state information. Can be used in a debugger as well.

Utility functions for constructing various PointSetAdapter and MeshAdapter instances from dynamic meshes

Utility functions for manipulating DynamicMesh attribute sets

This is an internal singleton used to support UDynamicMesh::ExportCustomProperties() and UDynamicMesh::ImportCustomProperties() below.

Landscape GPU culling implementation Each landscape section is split to a smaller tiles (4x4 quads) Tiles are frustum culled in compute Culling is done for each view, including shadow views Only active for LOD0 atm

Implementation of custom blend logic should be as follows (using doubles as an example). Specializing TBlendableTokenTraits for a particular input data type causes WorkingDataType to be used during the blending operation. Where WorkingDataType belongs to a namespace, ADL will be employed to discover any relevant overloads for BlendValue that match the necessary types. This allows blending of any arbitrary type into the WorkingDataType.

namespace MovieScene { Define a custom namespaced type that will be used to calculate blends between doubles struct FBlendableDouble { FBlendableDouble() : AbsoluteTotal(0.0), AdditiveTotal(0.0) {}

double AbsoluteTotal; double AdditiveTotal;

TOptional<float> TotalWeight;

double Resolve(TMovieSceneInitialValueStore<int32>& InitialValueStore) { if (TotalWeight.IsSet()) { if (TotalWeight.GetValue() == 0.f) { AbsoluteTotal = InitialValueStore.GetInitialValue(); } else { AbsoluteTotal /= TotalWeight.GetValue(); } }

return AbsoluteTotal + AdditiveTotal; } };

void BlendValue(FBlendableDouble& OutBlend, double InValue, float Weight, EMovieSceneBlendType BlendType, TMovieSceneInitialValueStore<double>& InitialValueStore) { if (BlendType == EMovieSceneBlendType::Absolute || BlendType == EMovieSceneBlendType::Relative) { if (BlendType == EMovieSceneBlendType::Relative) { OutBlend.AbsoluteTotal += (InitialValueStore.GetInitialValue() + InValue) * Weight; } else { OutBlend.AbsoluteTotal += InValue * Weight; }

OutBlend.TotalWeight = OutBlend.TotalWeight.Get(0.f) + Weight; } else if (BlendType == EMovieSceneBlendType::Additive) { OutBlend.AdditiveTotal += InValue * Weight; } } } template<> struct TBlendableTokenTraits<double> { typedef UE::MovieScene::FBlendableDouble WorkingDataType; };

~ Generic multi-channel blending support for sequencer. Works in conjunction with TMovieSceneBlendingActuator<Type> where Type has been set up with the correct traits to allow multi-channel blending: Example:

// My struct contains 3 floats, so is represented as a TMultiChannelValue<float, 3> struct FMyStruct { float X, Y, Z; ... };

namespace MovieScene { // Marshall my struct into a multi-channel value inline void MultiChannelFromData(FMyStruct In, TMultiChannelValue<float, 3>& Out) { Out = { In.X, In.Y, In.Z }; } // Marshall my struct out of a static float array inline void ResolveChannelsToData(float (&Channels)[3], FMyStruct& Out) { Out = FMyStruct(Channels[0], Channels[1], Channels[2]); } }

// Access a unique runtime type identifier for FMyStruct. Implemented in cpp to ensure there is only ever 1. This is required to support actuators operating on FMyStructs. template<> MYMODULE_API FMovieSceneAnimTypeID GetBlendingDataType<FMyStruct>();

// Inform the blending code to use a maksed blendable of 3 floats for my struct template<> struct TBlendableTokenTraits<FMyStruct> { typedef UE::MovieScene::TMaskedBlendable<float, 3> WorkingDataType; };

// To inject a blendable token into the accumulator for an FMyStruct: UE::MovieScene::TMultiChannelValue<float, 3> AnimatedData;

// Set the X and Z channels AnimatedData.Set(0, 100.f); AnimatedData.Set(2, 250.f);

// Ensure the accumulator knows how to apply an FMyStruct (usually this will be on a property, and happen through EnsureActuator<>) FMovieSceneBlendingActuatorID ActuatorTypeID = FMyActuatorType::GetActuatorTypeID(); if (!ExecutionTokens.GetAccumulator().FindActuator<FMyStruct>(ActuatorTypeID)) { ExecutionTokens.GetAccumulator().DefineActuator(ActuatorTypeID, MakeShared<FMyActuatorType>()); }

// Add the blendable to the accumulator float Weight = EvaluateEasing(Context.GetTime()); // Constructing a TBlendableToken from any type other than TMultiChannelValue<float, 3> requires a supporting BlendValue function ExecutionTokens.BlendToken(ActuatorTypeID, TBlendableToken<FMyStruct>(AnimatedData, EMovieSceneBlendType::Absolute, Weight));

Enums related to the PacketHandler

Code for reading .shk files and using that information to map shader hashes back to human-readable identifies.

Typedef Documentation

FAnsiSharedString

using UE::FAnsiSharedString = typedef TSharedString<ANSICHAR>

FDerivedDataIoComplete

using UE::FDerivedDataIoComplete = typedef TUniqueFunction<void ()>

FEventCount

using UE::FEventCount = typedef TEventCount<uint32>

FEventCountToken

using UE::FEventCountToken = typedef TEventCountToken<uint32>

FHash128

using UE::FHash128 = typedef THash<128>

FHash160

using UE::FHash160 = typedef THash<160>

FHash256

using UE::FHash256 = typedef THash<256>

FHash32

using UE::FHash32 = typedef THash<32>

FHash64

using UE::FHash64 = typedef THash<64>

FHash96

using UE::FHash96 = typedef THash<96>

FIoEncodedBlockRequestAllocator

using UE::FIoEncodedBlockRequestAllocator = typedef TSingleThreadedSlabAllocator<FIoEncodedBlockRequest, 1024>

FIoEncodedBlockRequestList

using UE::FIoEncodedBlockRequestList = typedef TIntrusiveList<FIoEncodedBlockRequest>

FIoFileBlockLinkAllocator

using UE::FIoFileBlockLinkAllocator = typedef TSingleThreadedSlabAllocator<FIoFileBlockLink, 128>

FIoFileBlockRequestAllocator

using UE::FIoFileBlockRequestAllocator = typedef TSingleThreadedSlabAllocator<FIoFileBlockRequest, 1024>

FIoFileBlockRequestList

using UE::FIoFileBlockRequestList = typedef TIntrusiveList<FIoFileBlockRequest>

FIoFileReadRequestCompleted

using UE::FIoFileReadRequestCompleted = typedef TUniqueFunction<void(FIoFileReadResult&&)>

FIoHttpRequestCompleted

using UE::FIoHttpRequestCompleted = typedef TUniqueFunction<void(FIoHttpResponse&&)>

HTTP completion callback.

FIoHttpRequestHandle

using UE::FIoHttpRequestHandle = typedef UPTRINT

Internal request handle type.

FIoPlatformReadRequestAllocator

using UE::FIoPlatformReadRequestAllocator = typedef TSingleThreadedSlabAllocator<FIoPlatformReadRequest, 1024>

FIoPlatformReadRequestList

using UE::FIoPlatformReadRequestList = typedef TIntrusiveList<FIoPlatformReadRequest>

FPlatformIoDispatcherFactory

using UE::FPlatformIoDispatcherFactory = typedef FGenericPlatformIoDispatcherFactory

FPlatformRecursiveMutex

typedef FWindowsRecursiveMutex UE::FPlatformRecursiveMutex

FPlatformSharedMutex

typedef FWindowsSharedMutex UE::FPlatformSharedMutex

FPlatformSystemWideMutex

typedef FWindowsSystemWideMutex UE::FPlatformSystemWideMutex

FRWSpinLock

using UE::FRWSpinLock = typedef TRWSpinLock<uint32>

FSharedString

using UE::FSharedString = typedef TSharedString<TCHAR>

FTempArray

template<typename T , SIZE_T Size = 8>

using UE::FTempArray = typedef TArray<T, TInlineAllocator<Size> >

FTransactionallySafeMutex

using UE::FTransactionallySafeMutex = typedef FMutex

FTransactionallySafeRecursiveMutex

using UE::FTransactionallySafeRecursiveMutex = typedef ::UE::FRecursiveMutex

FTransactionallySafeSharedMutex

using UE::FTransactionallySafeSharedMutex = typedef ::UE::FSharedMutex

FUtf8SharedString

using UE::FUtf8SharedString = typedef TSharedString<UTF8CHAR>

FWideSharedString

using UE::FWideSharedString = typedef TSharedString<WIDECHAR>

TConsumeAllMpmcQueue

using UE::TConsumeAllMpmcQueue = typedef TDepletableMpmcQueue<T, AllocatorType>

TIntrusiveMutex

using UE::TIntrusiveMutex = typedef TExternalMutex<Core::Private::FExternalMutexParams>

TIntrusiveMutexStateType_T

template<typename ParamsType >

using UE::TIntrusiveMutexStateType_T = typedef std::decay_t<decltype(ParamsType::IsLockedFlag)>

Enumeration Type Documentation

EConsumeAllMpmcQueueResult

enum class UE::EConsumeAllMpmcQueueResult

strong

Enumerator
HadItems
WasEmpty

EDerivedDataFlags

enum class UE::EDerivedDataFlags : uint32

strong

Flags that modify how this derived data is saved and how it may be loaded.

Enumerator
None
Required	Stage the referenced data with required content. May combine with Optional to stage into both locations.
Optional	Stage the referenced data with optional content.
MemoryMapped	Stage the referenced data with alignment padding to allow memory-mapped access on supported platforms.

EDerivedDataIoStatus

enum class UE::EDerivedDataIoStatus : uint8

strong

Status of an operation on a Derived Data Reference.

Enumerator
Ok	The operation completed successfully.
Error	The operation completed unsuccessfully.
Canceled	The operation was canceled before it completed.
Unknown	The operation has not completed or is otherwise in an unknown state.

EIoFilePropertyFlags

enum class UE::EIoFilePropertyFlags : uint8

strong

Specifies whether a file contains encrypted or signed I/O store chunks.

Enumerator
None
Encrypted
Signed

EIoHttpFlags

enum class UE::EIoHttpFlags

strong

Flags for controlling the behavior of an HTTP request.

Enumerator
None	No additional flags.
ReadCache	Whether to read from the HTTP cache.
ResponseHeaders	Whether to include response headers.
Default	Default flags.

EIoHttpResponseFlags

enum class UE::EIoHttpResponseFlags : uint8

strong

Flags describing a HTTP response.

Enumerator
None	No additional flags.
Cached	The response was retrieved from the cache.

EPackageTrailerVersion

enum class UE::EPackageTrailerVersion : uint32

strong

The version number for the FPackageTrailer format

Enumerator
INITIAL
ACCESS_PER_PAYLOAD
PAYLOAD_FLAGS
AUTOMATIC_VERSION_PLUS_ONE
AUTOMATIC_VERSION

EPayloadAccessMode

enum class UE::EPayloadAccessMode : uint8

strong

Lists the various methods of payload access that the trailer supports

Enumerator
Local	The payload is stored in the Payload Data segment of the trailer and the offsets in FLookupTableEntry will be relative to the start of this segment
Referenced	The payload is stored in another package trailer (most likely the workspace domain package file) and the offsets in FLookupTableEntry are absolute offsets in that external file
Virtualized	The payload is virtualized and needs to be accessed via IVirtualizationSystem

EPayloadFilter

enum class UE::EPayloadFilter

strong

Used to filter requests based on how a payload can function

Enumerator
CanVirtualize	All payloads that are stored locally and do not have virtualization disabled

EPayloadFlags

enum class UE::EPayloadFlags : uint16

strong

Flags that can be set on payloads in a payload trailer

Enumerator
None	No flags are set

EPayloadStatus

enum class UE::EPayloadStatus

strong

Used to show the status of a payload

Enumerator
NotFound	The payload is not registered in the package trailer
StoredLocally	The payload is stored locally inside the current package trailer where ever that is written to disk
StoredAsReference	The payload is stored in the workspace domain trailer
StoredVirtualized	The payload is virtualized and needs to be accessed via the IVirtualizationSystem

EPayloadStorageType

enum class UE::EPayloadStorageType : uint8

strong

Trailer Format The FPackageTrailer is a container that will commonly be appended to the end of a package file. The main purpose of the trailer is to store the bulkdata payloads contained by the package until they are virtualized or moved to an additional storage location.

By storing the payloads in a data format adjacent to the rest of the package we can perform the virtualization process without needing to re-save the package itself which in turn should allow for external tools to be able to perform the virtualization process themselves rather than needing to force it through engine code.

The package trailer is intended to an easy format for external code/script to be able to manipulate. To make things clearer we do not serialize containers directly but write out each data structure one at a time so that it should be easy to see how to manipulate the file.

The file is split into three parts:

[Header] The header contains the useful info about the trailer and the payloads in general. @See UE::FLookupTableEntry for details about the look up table's data.

[Payload Data] If the trailer is in the workspace domain package then we will store all non-virtualized payloads here. If the trailer is in the editor domain then there will be no payload data section and the header will be referencing the trailer in the workspace domain instead.

[Footer] The footer allows for us to load the trailer in reverse and replicates the end of package file tag (PACKAGE_FILE_TAG), it should only be used for finding the start of the trailer or validation.

CurrentVersion UE::EPackageTrailerVersion::INITIAL

---

| [Header] | | Tag | uint64 | Should match FHeader::HeaderTag, used to identify that the data being read is an FPackageTrailer | | Version | uint32 | Version number of the format

See also

UE::EPackageTrailerVersion | | HeaderLength | uint32 | The total size of the header on disk in bytes. | | PayloadsDataLength | uint64 | The total size of the payload data on disk in bytes | | NumPayloads | int32 | The number of payloads in LookupTableArray | | LookupTableArray | FLookupTableEntry | An array of FLookupTableEntry

UE::Private::FLookupTableEntry | |____________________________________________________________________________________________________________________________________________| | [Payload Data] | | Array | FCompressedBuffer | A binary blob containing all of the payloads. Individual payloads can be found via | | the LookupTableArray found in the header. | |____________________________________________________________________________________________________________________________________________| | [Footer] | | Tag | uint64 | Should match FFooter::FooterTag, used to identify that the data being read is an FPackageTrailer | | TrailerLength | uint64 | The total size of the trailer on disk in bytes. Can be used to find the start of the trailer when | | reading backwards. | | PackageTag | uint32 | The end of package tag, PACKAGE_FILE_TAG. This is used to validate that a package file on disk is | | not corrupt. By ending the trailer with this tag we allow that validation code to work. | |____________________________________________________________________________________________________________________________________________| Used to filter requests based on how a payload is stored

Enumerator
Any	All payload regardless of type.
Local	All payloads stored locally in the package trailer.
Referenced	All payloads that are a reference to payloads stored in the workspace domain trailer
Virtualized	All payloads stored in a virtualized backend.

EPrintObjectFlag

enum class UE::EPrintObjectFlag : uint32

strong

Flags for specifying optional behaviors.

Enumerator
None	No optional behaviors.
Verbose	Include verbose information.
PropertyInitializationState	Include the initialization state for properties (only relevant for functions that print properties).
FullArchetypeChain	Show the full archetype hierarchy (only relevant for functions that print archetypes).

Function Documentation

AppendHash() [1/2]

void UE::AppendHash	(	FBlake3 &	Builder,
		const FPropertyPathNameTree &	Tree
	)

AppendHash() [2/2]

void UE::AppendHash	(	FBlake3 &	Builder,
		const FPropertyTypeName &	TypeName
	)

AppendNode()

const FPropertyTypeNameNode * UE::AppendNode ( FStringBuilderBase &  Builder, const FPropertyTypeNameNode *  Node  )

inline

ApplyRedirectsToPropertyType()

FPropertyTypeName UE::ApplyRedirectsToPropertyType	(	FPropertyTypeName	OldTypeName,
		const FProperty *	Property = nullptr
	)

Applies core redirects to type names and paths within the property type.

Allows partial matches only when a property is given and matches the layout of the type name. Example: StructProperty(OldName) will not have an OldName redirect applied if Property is an FIntProperty.

Parameters

OldTypeName	The type name to apply core redirects to.
Property	Optional. The property that the type name might correspond to.

Returns

The new type name, if redirects were applied, otherwise an empty type name.

CallSerializeForLog()

template<typename ValueType UE_REQUIRES>

void UE::CallSerializeForLog ( FCbWriter &  Writer, ValueType &&  Value  )

inline

Wrapper to support calling SerializeForLog with ADL from within an overload of SerializeForLog.

ConvertToAsyncIoPriority()

EAsyncIOPriorityAndFlags UE::ConvertToAsyncIoPriority ( const int32  IoDispatcherProperty )

inline

CreatePackageResourceChunkId()

COREUOBJECT_API FIoChunkId UE::CreatePackageResourceChunkId	(	const FName &	PackageName,
		EPackageSegment	Segment,
		const FBulkDataCookedIndex &	CookedIndex,
		bool	bExternalResource
	)

ENUM_CLASS_FLAGS() [1/6]

UE::ENUM_CLASS_FLAGS

(

EDerivedDataFlags

)

ENUM_CLASS_FLAGS() [2/6]

UE::ENUM_CLASS_FLAGS

(

EIoFilePropertyFlags

)

ENUM_CLASS_FLAGS() [3/6]

UE::ENUM_CLASS_FLAGS

(

EIoHttpFlags

)

ENUM_CLASS_FLAGS() [4/6]

UE::ENUM_CLASS_FLAGS

(

EIoHttpResponseFlags

)

ENUM_CLASS_FLAGS() [5/6]

UE::ENUM_CLASS_FLAGS

(

EPayloadFlags

)

ENUM_CLASS_FLAGS() [6/6]

UE::ENUM_CLASS_FLAGS

(

EPrintObjectFlag

)

FindObjectByTypePath() [1/2]

template<typename T >

T * UE::FindObjectByTypePath

(

FPropertyTypeName

TypePath

)

FindObjectByTypePath() [2/2]

UObject * UE::FindObjectByTypePath	(	UClass *	Class,
		FPropertyTypeName	TypePath
	)

FindPayloadsInPackageFile()

COREUOBJECT_API bool UE::FindPayloadsInPackageFile	(	const FPackagePath &	PackagePath,
		EPayloadStorageType	Filter,
		TArray< FIoHash > &	OutPayloadIds
	)

Used to find the identifiers of the payload in a given package. Note that this will return the payloads included in the package on disk and will not take into account any edits to the package if they are in memory and unsaved.

Parameters

PackagePath	The package to look in.
Filter	What sort of payloads should be returned.

See also

EPayloadType

Parameters

OutPayloadIds

This array will be filled with the FPayloadId values found in the package that passed the filter. Note that existing content in the array will be preserved. It is up to the caller to empty it.

Returns

True if the package was parsed successfully (although it might not have contained any payloads) and false if opening or parsing the package file failed.

FindPropertyByNameAndTypeName()

UE_API FProperty * UE::FindPropertyByNameAndTypeName	(	const UStruct *	Struct,
		FName	Name,
		FPropertyTypeName	TypeName
	)

Find a property in Struct that matches both the name and the type.

Type matching uses FProperty::CanSerializeFromTypeName.

Returns

A matching property if found, otherwise null.

GetAsyncLoadingInternalFlagsExclusion()

COREUOBJECT_API EInternalObjectFlags UE::GetAsyncLoadingInternalFlagsExclusion

(

)

GetIsEditorLoadingPackage()

CORE_API bool UE::GetIsEditorLoadingPackage

(

)

GetMaxEnumValue()

template<typename NamesCollection >

int64 UE::GetMaxEnumValue	(	const NamesCollection &	InNamesAndValues,
		EEnumFlags	InFlags
	)

GetMultiprocessId()

CORE_API int32 UE::GetMultiprocessId

(

)

If multiple copies of the process are running and communicating together, the director process has MultiprocessId 0 and the worker processes have MultiprocessId > 0. When only a single process is running, GetMultiprocessId returns 0. Based on commandline. Primary example is cookworkers in multiprocess cook. Systems that need to write a separate file per running process should use this id as part of their file descriptor.

GetPlayInEditorID()

CORE_API int32 UE::GetPlayInEditorID

(

)

GetTypeHash() [1/3]

uint32 UE::GetTypeHash

(

const FPropertyPathName &

Path

)

GetTypeHash() [2/3]

uint32 UE::GetTypeHash

(

const FPropertyTypeName &

TypeName

)

GetTypeHash() [3/3]

uint32 UE::GetTypeHash ( const FPropertyTypeNameNode &  Node )

inline

HashStringFNV1a() [1/2]

template<typename HashType , typename CharType , int32 Len>

UE_CONSTEVAL HashType UE::HashStringFNV1a

(

const CharType(&)

StringLiteral[Len]

)

HashStringFNV1a() [2/2]

template<typename HashType , typename CharType >

constexpr HashType UE::HashStringFNV1a ( TStringView< CharType >  String )

constexpr

Implements a constexpr usable version of FNV1a for strings.

Note: This implementation is 'stable' such that the same string of different character widths will hash to the same value (eg. HashStringFNV1a("Hello") == HashStringFNV1a(L"Hello")). This behavior is appropriate here as we're operating on strings specifically rather than raw buffers and we want consistent hashes between different platforms.

HashStringFNV1a32() [1/2]

template<typename CharType , int32 Len>

UE_CONSTEVAL uint32 UE::HashStringFNV1a32

(

const CharType(&)

StringLiteral[Len]

)

HashStringFNV1a32() [2/2]

template<typename CharType >

constexpr uint32 UE::HashStringFNV1a32 ( TStringView< CharType >  String )

constexpr

HashStringFNV1a64() [1/2]

template<typename CharType , int32 Len>

UE_CONSTEVAL uint64 UE::HashStringFNV1a64

(

const CharType(&)

StringLiteral[Len]

)

HashStringFNV1a64() [2/2]

template<typename CharType >

constexpr uint64 UE::HashStringFNV1a64 ( TStringView< CharType >  String )

constexpr

IsGCLocked()

CORE_API bool UE::IsGCLocked

(

)

IsIoErrorAnyOf()

template<typename... Args>

bool UE::IsIoErrorAnyOf	(	EIoErrorCode	ErrorCode,
		Args...	Expected
	)

IsSavingPackage()

COREUOBJECT_API bool UE::IsSavingPackage

(

UObject *

InOuter = nullptr

)

Return if the passed in package is currently saving, or if any packages are saving if no parameter is passed.

Parameters

InOuter

The object which we want to check if its package is saving

Returns

true if the package is saving, or if any packages are saving if no parameter is passed in.

IsUsingZenPakFileStreaming()

bool CORE_API UE::IsUsingZenPakFileStreaming

(

)

LLM_DEFINE_TAG()

UE::LLM_DEFINE_TAG

(

FPropertyTypeName

)

MakeGenericPlatformIoDispatcher()

TUniquePtr< IPlatformIoDispatcher > UE::MakeGenericPlatformIoDispatcher

(

FPlatformIoDispatcherCreateParams &&

Params

)

MakePackageResourceIoDispatcherBackend()

COREUOBJECT_API TSharedRef< IIoDispatcherBackend > UE::MakePackageResourceIoDispatcherBackend

(

IPackageResourceManager &

Mgr

)

operator<()

bool UE::operator<	(	const FPropertyTypeName &	Lhs,
		const FPropertyTypeName &	Rhs
	)

operator<<() [1/9]

FArchive & UE::operator<<	(	FArchive &	Ar,
		FPackageTrailer::FFooter &	Footer
	)

Serialization operator

operator<<() [2/9]

FArchive & UE::operator<<	(	FArchive &	Ar,
		FPackageTrailer::FHeader &	Header
	)

Serialization operator

operator<<() [3/9]

FArchive & UE::operator<<	(	FArchive &	Ar,
		FPropertyTypeName &	TypeName
	)

operator<<() [4/9]

FArchive & UE::operator<< ( FArchive &  Ar, FPropertyTypeNameNode &  Node  )

inline

operator<<() [5/9]

FStringBuilderBase & UE::operator<<	(	FStringBuilderBase &	Builder,
		const FDerivedData &	Data
	)

Appends the name and description of this reference to the builder.

operator<<() [6/9]

FStringBuilderBase & UE::operator<<	(	FStringBuilderBase &	Builder,
		const FPropertyTypeName &	TypeName
	)

operator<<() [7/9]

void UE::operator<<	(	FStructuredArchiveSlot	Slot,
		FPropertyTypeName &	TypeName
	)

operator<<() [8/9]

void UE::operator<< ( FStructuredArchiveSlot  Slot, FPropertyTypeNameNode &  Node  )

inline

operator<<() [9/9]

template<typename CharType >

TStringBuilderBase< CharType > & UE::operator<< ( TStringBuilderBase< CharType > &  Builder, EPayloadAccessMode  Mode  )

inline

Allow EPayloadAccessMode to work with string builder

operator==()

bool UE::operator==	(	const FPropertyTypeName &	Lhs,
		const FPropertyTypeName &	Rhs
	)

Overload()

template<typename... InvocableTypes>

UE_REWRITE constexpr auto UE::Overload ( InvocableTypes &&...  Invocables )

constexpr

PreciseFPEqual() [1/2]

bool UE::PreciseFPEqual	(	double	Lhs,
		double	Rhs
	)

PreciseFPEqual() [2/2]

bool UE::PreciseFPEqual	(	float	Lhs,
		float	Rhs
	)

PreciseFPHash() [1/2]

uint32 UE::PreciseFPHash

(

double

D

)

PreciseFPHash() [2/2]

uint32 UE::PreciseFPHash

(

float

F

)

PrintClassDefaultObject()

UE_INTERNAL void UE::PrintClassDefaultObject	(	const UClass *	Class,
		EPrintObjectFlag	Flags = EPrintObjectFlag::None,
		FOutputDevice *	OutputDevice = nullptr
	)

Outputs a class' Class Default Object.

Parameters

Class	The class to use.
Flags	For specifying optional behaviors.
OutputDevice	The output device to print to (can be NULL).

PrintObjectArchetype()

UE_INTERNAL void UE::PrintObjectArchetype	(	UObject *	Object,
		EPrintObjectFlag	Flags = EPrintObjectFlag::None,
		FOutputDevice *	OutputDevice = nullptr
	)

Outputs an object's archetype.

Parameters

Object	The object to use.
Flags	For specifying optional behaviors.
OutputDevice	The output device to print to (can be NULL).

PrintObjectIDO()

UE_INTERNAL void UE::PrintObjectIDO	(	UObject *	Object,
		EPrintObjectFlag	Flags = EPrintObjectFlag::None,
		FOutputDevice *	OutputDevice = nullptr
	)

Outputs an object's IDO (Instance Data Object).

Parameters

Object	The object to use.
Flags	For specifying optional behaviors.
OutputDevice	The output device to print to (can be NULL).

PrintObjectProperties()

UE_INTERNAL void UE::PrintObjectProperties	(	UObject *	Object,
		EPrintObjectFlag	Flags = EPrintObjectFlag::None,
		FOutputDevice *	OutputDevice = nullptr
	)

Lists the property values of an object.

Parameters

Object	The object to use.
Flags	For specifying optional behaviors.
OutputDevice	The output device to print to (can be NULL).

PrintObjectsInOuter()

UE_INTERNAL void UE::PrintObjectsInOuter	(	UObject *	Object,
		EPrintObjectFlag	Flags = EPrintObjectFlag::None,
		FOutputDevice *	OutputDevice = nullptr
	)

Lists all objects under a specified parent.

Parameters

Object	The outer object to use.
OutputDevice	The output device to print to (can be NULL).

PrintObjectsWithName()

UE_INTERNAL void UE::PrintObjectsWithName	(	const TCHAR *	ObjectName,
		EPrintObjectFlag	Flags = EPrintObjectFlag::None,
		FOutputDevice *	OutputDevice = nullptr
	)

Lists all objects with a given name.

Parameters

ObjectName	The name to search for.
Flags	For specifying optional behaviors.
OutputDevice	The output device to print to (can be NULL).

PrintStructHierarchy()

UE_INTERNAL void UE::PrintStructHierarchy	(	const UStruct *	Struct,
		EPrintObjectFlag	Flags = EPrintObjectFlag::None,
		FOutputDevice *	OutputDevice = nullptr
	)

Outputs a struct's type hierarchy.

Parameters

Struct	The struct to use.
Flags	For specifying optional behaviors.
OutputDevice	The output device to print to (can be NULL).

PrintStructProperties()

UE_INTERNAL void UE::PrintStructProperties	(	UStruct *	Struct,
		void *	StructData,
		EPrintObjectFlag	Flags = EPrintObjectFlag::None,
		FOutputDevice *	OutputDevice = nullptr
	)

Lists the properties of a UStruct instance.

Parameters

Struct	The type of the UStruct instance.
StructData	The data of the UStruct instance.
Flags	For specifying optional behaviors.
OutputDevice	The output device to print to (can be NULL).

SendClearOverriddenPropertyEvent() [1/2]

COREUOBJECT_API void UE::SendClearOverriddenPropertyEvent	(	TNotNull< UObject * >	Object,
		const FPropertyChangedEvent &	PropertyEvent,
		const FEditPropertyChain &	PropertyChain
	)

SendClearOverriddenPropertyEvent() [2/2]

COREUOBJECT_API void UE::SendClearOverriddenPropertyEvent	(	TNotNull< UObject * >	Object,
		const FPropertyVisitorPath &	PropertyPath
	)

Helper method that calls the pre and post change notification responsible for clearing a property override. This is the preferred way to clear property overrides because it will notify listeners

Parameters

Object	owning the property to clear
PropertyPath	to the property to clear from the root of the specified object

Returns

true if the property was successfully cleared.

SendClearOverridesEvent()

COREUOBJECT_API void UE::SendClearOverridesEvent

(

TNotNull< UObject * >

Object

)

Helper method that calls the pre and post change notification responsible for clearing the overrides of an object. This is the preferred way to clear overrides because it will notify listeners

Parameters

Object

to clear overrides on

SendOverrideAllObjectPropertiesEvent()

COREUOBJECT_API void UE::SendOverrideAllObjectPropertiesEvent

(

TNotNull< UObject * >

Object

)

Helper method that calls the pre and post change notification responsible for overriding an object. This is the preferred way to override because it will notify listeners

Parameters

Object

to override all it's properties

SendOverridePropertyEvent() [1/2]

COREUOBJECT_API void UE::SendOverridePropertyEvent	(	TNotNull< UObject * >	Object,
		const FPropertyChangedEvent &	PropertyEvent,
		const FEditPropertyChain &	PropertyChain
	)

SendOverridePropertyEvent() [2/2]

COREUOBJECT_API void UE::SendOverridePropertyEvent	(	TNotNull< UObject * >	Object,
		const FPropertyVisitorPath &	PropertyPath,
		EPropertyChangeType::Type	ChangeType = EPropertyChangeType::Unspecified
	)

Helper method that calls the pre and post change notification responsible for overriding an object property. This is the preferred way to override properties because it will notify listeners Note: If you're also changing property values (especially if it's in a container) use SendPreOverridePropertyEvent and SendPostOverridePropertyEvent instead!

Parameters

Object	owning the property
PropertyPath	leading to the property that is about to be overridden
ChangeType	of the current operation

SendPostOverridePropertyEvent() [1/2]

COREUOBJECT_API void UE::SendPostOverridePropertyEvent	(	TNotNull< UObject * >	Object,
		const FPropertyChangedEvent &	PropertyEvent,
		const FEditPropertyChain &	PropertyChain
	)

SendPostOverridePropertyEvent() [2/2]

COREUOBJECT_API void UE::SendPostOverridePropertyEvent	(	TNotNull< UObject * >	Object,
		const FPropertyVisitorPath &	PropertyPath,
		EPropertyChangeType::Type	ChangeType = EPropertyChangeType::Unspecified
	)

Helper method that calls the post-change notification responsible for overriding an object property. This is the preferred way to override properties because it will notify listeners

Parameters

Object	owning the property
PropertyPath	leading to the property that was overridden
ChangeType	of the current operation

SendPreOverridePropertyEvent() [1/2]

COREUOBJECT_API void UE::SendPreOverridePropertyEvent	(	TNotNull< UObject * >	Object,
		const FEditPropertyChain &	PropertyChain
	)

SendPreOverridePropertyEvent() [2/2]

COREUOBJECT_API void UE::SendPreOverridePropertyEvent	(	TNotNull< UObject * >	Object,
		const FPropertyVisitorPath &	PropertyPath
	)

Helper method that calls the pre-change notification responsible for overriding an object property. This is the preferred way to override properties because it will notify listeners

Parameters

Object	owning the property
PropertyPath	leading to the property about to be overridden

SerializeForLog()

template<typename ValueType UE_REQUIRES>

void UE::SerializeForLog ( FCbWriter &  Writer, ValueType &&  Value  )

inline

Serializes the value to be used in a log message.

Overload this when the log behavior needs to differ from general serialization to compact binary.

There are three ways to perform custom formatting for values that are serialized as an object:

1. Add a $text field that is a string with the exact text to display.
2. Add a $format field that is a format string that may reference fields of the object and their sub-objects.
3. Add a $locformat field that is a localized format string that may reference fields of the object and their sub-objects. The namespace and key must be included in $locns and $lockey string fields. Serialize FText to the writer using SerializeLogFormat().

Arrays and objects without custom formatting are converted to JSON.

SetIsEditorLoadingPackage()

CORE_API void UE::SetIsEditorLoadingPackage

(

bool

InValue

)

SetPlayInEditorID()

CORE_API void UE::SetPlayInEditorID

(

int32

InPlayInEditorID

)

TRACE_DECLARE_INT_COUNTER() [1/2]

UE::TRACE_DECLARE_INT_COUNTER	(	AvailableChunkDecoderWorkerCount	,
		TEXT("IoDispatcher/AvailableChunkDecoderWorkerCount")
	)

TRACE_DECLARE_INT_COUNTER() [2/2]

UE::TRACE_DECLARE_INT_COUNTER	(	ChunkDecoderQueueCount	,
		TEXT("IoDispatcher/ChunkDecoderQueueCount")
	)

TryGetPackageNameFromChunkId()

COREUOBJECT_API bool UE::TryGetPackageNameFromChunkId	(	const FIoChunkId &	ChunkId,
		FName &	OutPackageName,
		EPackageSegment &	OutSegment,
		bool &	bOutExternal
	)

TryGetPackagePathFromChunkId() [1/2]

bool UE::TryGetPackagePathFromChunkId	(	const FIoChunkId &	ChunkId,
		FPackagePath &	OutPath,
		EPackageSegment &	OutSegment,
		bool &	bExternal
	)

TryGetPackagePathFromChunkId() [2/2]

bool UE::TryGetPackagePathFromChunkId	(	const FIoChunkId &	ChunkId,
		FPackagePath &	OutPath,
		EPackageSegment &	OutSegment,
		bool &	bExternal,
		FBulkDataCookedIndex &	OutCookedIndex
	)

TryResolvePropertyPath()

UE_API FPropertyValueInContainer UE::TryResolvePropertyPath	(	const FPropertyPathName &	Path,
		UObject *	Object
	)

Try to resolve the property path to a property value within the object.

Parameters

Path	The non-empty property path to resolve.
Object	The object representing the root of the property path to resolve.

Returns

A valid property value reference if resolved, otherwise an invalid reference.

TryResolvePropertyPathForChangeEvent()

UE_API FPropertyValueInContainer UE::TryResolvePropertyPathForChangeEvent	(	const FPropertyPathName &	Path,
		UObject *	Object,
		uint32	ChangeType,
		TSharedPtr< FPropertyChangedChainEvent > &	OutEvent,
		FEditPropertyChain &	OutChain
	)

Try to resolve the property path to a property value within the object and construct an FPropertyChangeChainEvent that can be used to notify changes to the resolved data

Parameters

Path	The non-empty property path to resolve.
Object	The object representing the root of the property path to resolve.
ChangeType	The change type to assign to the FPropertyChangeChainEvent
OutEvent	The resulting change event
OutChain	The property chain associated with the event

Returns

A valid property value reference if resolved, otherwise an invalid reference.

UE_DEPRECATED()

template<typename T , typename AllocatorType = FMemory>

class UE::UE_DEPRECATED ( 5.  3, "This concurrent queue was deprecated because it uses spin-waiting that can cause priority inversion and subsequently deadlocks on some platforms. Please use TConsumeAllMpmcQueue."    )

final

WARNING: this queue can cause priority inversion or a livelock due to spinlocking in Deplete() method, though we haven't seen this happened in practice. Prefer TConsumeAllMpmcQueue which is equally fast in LIFO mode, and only slightly slower in FIFO mode.

Multi-producer/multi-consumer unbounded concurrent queue that is atomically consumed and is reset to its default empty state. A typical use case is when the consumer doesn't stop until the queue is depleted. Is faster than traditional MPSC and MPMC queues, especially for consumer. Consumes elements in FIFO order.

Takes all items from the queue atomically and then consumes them.

Parameters

Consumer

a functor with signature AnyReturnType (T Value)

Variable Documentation

AcquireLock

constexpr struct UE::FAcquireLock UE::AcquireLock

CookedIndexByteIdx

constexpr uint8 UE::CookedIndexByteIdx = 8

constexpr

CVarCommandPrintCDO

FAutoConsoleCommandWithArgsAndOutputDevice UE::CVarCommandPrintCDO(TEXT("Obj.DumpCDO"), TEXT("Outputs a class' Class Default Object."), FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ClassPath; EPrintObjectFlag Flags; ParseObjectIdAndFlags(Args, ClassPath, Flags); UClass *Class=FindFirstObjectSafe< UClass >(*ClassPath); if(Class) { PrintClassDefaultObject(Class, Flags, &OutputDevice); } else { OutputDevice.Logf(TEXT("PrintClassDefaultObject: failed to find any classes for path: '%s'"), *ClassPath); } } else { OutputDevice.Logf(TEXT("PrintClassDefaultObject: no class name or path specified (example usage: Obj.DumpCDO MyActor)")); LogHelp(OutputDevice); } }))	(	TEXT("Obj.DumpCDO")	,
		TEXT("Outputs a class' Class Default Object.")	,
		FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ClassPath; EPrintObjectFlag Flags; ParseObjectIdAndFlags(Args, ClassPath, Flags); UClass *Class=FindFirstObjectSafe< UClass >(*ClassPath); if(Class) { PrintClassDefaultObject(Class, Flags, &OutputDevice); } else { OutputDevice.Logf(TEXT("PrintClassDefaultObject: failed to find any classes for path: '%s'"), *ClassPath); } } else { OutputDevice.Logf(TEXT("PrintClassDefaultObject: no class name or path specified (example usage: Obj.DumpCDO MyActor)")); LogHelp(OutputDevice); } })
	)

CVarCommandPrintObjectArchetype

FAutoConsoleCommandWithArgsAndOutputDevice UE::CVarCommandPrintObjectArchetype(TEXT("Obj.DumpArchetype"), TEXT("Outputs an object's archetype (the object must be specified as a name or path, e.g., /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor)."), FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ObjectPath; EPrintObjectFlag Flags; ParseObjectIdAndFlags(Args, ObjectPath, Flags); UObject *Object=FindFirstObjectSafe< UObject >(*ObjectPath); if(Object) { PrintObjectArchetype(Object, Flags, &OutputDevice); } else { OutputDevice.Logf(TEXT("PrintObjectArchetype: failed to find any objects for path: '%s'"), *ObjectPath); } } else { OutputDevice.Logf(TEXT("PrintObjectArchetype: no object path specified (example usage: Obj.DumpArchetype /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor)")); LogHelp(OutputDevice); } }))	(	TEXT("Obj.DumpArchetype")	,
		TEXT("Outputs an object's archetype (the object must be specified as a name or path, e.g., /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor).")	,
		FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ObjectPath; EPrintObjectFlag Flags; ParseObjectIdAndFlags(Args, ObjectPath, Flags); UObject *Object=FindFirstObjectSafe< UObject >(*ObjectPath); if(Object) { PrintObjectArchetype(Object, Flags, &OutputDevice); } else { OutputDevice.Logf(TEXT("PrintObjectArchetype: failed to find any objects for path: '%s'"), *ObjectPath); } } else { OutputDevice.Logf(TEXT("PrintObjectArchetype: no object path specified (example usage: Obj.DumpArchetype /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor)")); LogHelp(OutputDevice); } })
	)

CVarCommandPrintObjectIDO

FAutoConsoleCommandWithArgsAndOutputDevice UE::CVarCommandPrintObjectIDO(TEXT("Obj.DumpIDO"), TEXT("Outputs an object's IDO (Instance Data Object) (the object must be specified as a name or path, e.g., /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor)."), FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ObjectPath; EPrintObjectFlag Flags; ParseObjectIdAndFlags(Args, ObjectPath, Flags); UObject *Object=FindFirstObjectSafe< UObject >(*ObjectPath); if(Object) { PrintObjectIDO(Object, Flags, &OutputDevice); } else { OutputDevice.Logf(TEXT("PrintObjectIDO: failed to find any objects for path: '%s'"), *ObjectPath); } } else { OutputDevice.Logf(TEXT("PrintObjectIDO: no object path specified (example usage: Obj.DumpArchetype /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor)")); LogHelp(OutputDevice); } }))	(	TEXT("Obj.DumpIDO")	,
		TEXT("Outputs an object's IDO (Instance Data Object) (the object must be specified as a name or path, e.g., /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor).")	,
		FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ObjectPath; EPrintObjectFlag Flags; ParseObjectIdAndFlags(Args, ObjectPath, Flags); UObject *Object=FindFirstObjectSafe< UObject >(*ObjectPath); if(Object) { PrintObjectIDO(Object, Flags, &OutputDevice); } else { OutputDevice.Logf(TEXT("PrintObjectIDO: failed to find any objects for path: '%s'"), *ObjectPath); } } else { OutputDevice.Logf(TEXT("PrintObjectIDO: no object path specified (example usage: Obj.DumpArchetype /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor)")); LogHelp(OutputDevice); } })
	)

CVarCommandPrintObjectProperties

FAutoConsoleCommandWithArgsAndOutputDevice UE::CVarCommandPrintObjectProperties(TEXT("Obj.DumpProperties"), TEXT("Lists the properties of an object (the object must be specified as a name or path, e.g., /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor). Pass InitState=true to iclude the properties' initialization state."), FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ObjectPath; EPrintObjectFlag Flags; ParseObjectIdAndFlags(Args, ObjectPath, Flags); UObject *Object=FindFirstObjectSafe< UObject >(*ObjectPath); if(Object) { PrintObjectProperties(Object, Flags, &OutputDevice); } else { OutputDevice.Logf(TEXT("PrintObjectProperties: failed to find any objects for path: '%s'"), *ObjectPath); } } else { OutputDevice.Logf(TEXT("PrintObjectProperties: no object path specified (example usage: Obj.DumpProperties /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor)")); LogHelp(OutputDevice); } }))	(	TEXT("Obj.DumpProperties")	,
		TEXT("Lists the properties of an object (the object must be specified as a name or path, e.g., /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor). Pass InitState=true to iclude the properties' initialization state.")	,
		FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ObjectPath; EPrintObjectFlag Flags; ParseObjectIdAndFlags(Args, ObjectPath, Flags); UObject *Object=FindFirstObjectSafe< UObject >(*ObjectPath); if(Object) { PrintObjectProperties(Object, Flags, &OutputDevice); } else { OutputDevice.Logf(TEXT("PrintObjectProperties: failed to find any objects for path: '%s'"), *ObjectPath); } } else { OutputDevice.Logf(TEXT("PrintObjectProperties: no object path specified (example usage: Obj.DumpProperties /MyLevel/MyLevel.MyLevel:PersistentLevel.MyActor)")); LogHelp(OutputDevice); } })
	)

CVarCommandPrintObjectsInOuter

FAutoConsoleCommandWithArgsAndOutputDevice UE::CVarCommandPrintObjectsInOuter(TEXT("Obj.DumpObjectsInOuter"), TEXT("Lists all objects under a specified parent (the parent object must be specified as a name or path, e.g., /MyLevel/MyLevel.MyLevel:PersistentLevel)."), FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ObjectPath; EPrintObjectFlag Flags; ParseObjectIdAndFlags(Args, ObjectPath, Flags); UObject *Object=FindFirstObjectSafe< UObject >(*ObjectPath); if(Object) { PrintObjectsInOuter(Object, Flags, &OutputDevice); } else { OutputDevice.Logf(TEXT("PrintObjectsInOuter: failed to find any objects for path: '%s'"), *ObjectPath); } } else { OutputDevice.Logf(TEXT("PrintObjectsInOuter: no object path specified (example usage: Obj.DumpObjectsInOuter /MyLevel/MyLevel.MyLevel:PersistentLevel)")); LogHelp(OutputDevice); } }))	(	TEXT("Obj.DumpObjectsInOuter")	,
		TEXT("Lists all objects under a specified parent (the parent object must be specified as a name or path, e.g., /MyLevel/MyLevel.MyLevel:PersistentLevel).")	,
		FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ObjectPath; EPrintObjectFlag Flags; ParseObjectIdAndFlags(Args, ObjectPath, Flags); UObject *Object=FindFirstObjectSafe< UObject >(*ObjectPath); if(Object) { PrintObjectsInOuter(Object, Flags, &OutputDevice); } else { OutputDevice.Logf(TEXT("PrintObjectsInOuter: failed to find any objects for path: '%s'"), *ObjectPath); } } else { OutputDevice.Logf(TEXT("PrintObjectsInOuter: no object path specified (example usage: Obj.DumpObjectsInOuter /MyLevel/MyLevel.MyLevel:PersistentLevel)")); LogHelp(OutputDevice); } })
	)

CVarCommandPrintObjectsWithName

FAutoConsoleCommandWithArgsAndOutputDevice UE::CVarCommandPrintObjectsWithName(TEXT("Obj.DumpObjectsWithName"), TEXT("Lists all objects with a given name."), FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ObjectName; EPrintObjectFlag Flags; ParseObjectIdAndFlags(Args, ObjectName, Flags); PrintObjectsWithName(*ObjectName, Flags, &OutputDevice); } else { OutputDevice.Logf(TEXT("PrintObjectsWithName: no object name specified (example usage: Obj.DumpObjectsWithName PersistentLevel)")); LogHelp(OutputDevice); } }))	(	TEXT("Obj.DumpObjectsWithName")	,
		TEXT("Lists all objects with a given name.")	,
		FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString ObjectName; EPrintObjectFlag Flags; ParseObjectIdAndFlags(Args, ObjectName, Flags); PrintObjectsWithName(*ObjectName, Flags, &OutputDevice); } else { OutputDevice.Logf(TEXT("PrintObjectsWithName: no object name specified (example usage: Obj.DumpObjectsWithName PersistentLevel)")); LogHelp(OutputDevice); } })
	)

CVarCommandPrintStructHierarchy

FAutoConsoleCommandWithArgsAndOutputDevice UE::CVarCommandPrintStructHierarchy(TEXT("Obj.DumpStructHierarchy"), TEXT("Outputs a struct (or class) type hierarchy."), FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString StructPath; EPrintObjectFlag Flags; ParseObjectIdAndFlags(Args, StructPath, Flags); UStruct *Struct=FindFirstObjectSafe< UStruct >(*StructPath); if(Struct) { PrintStructHierarchy(Struct, Flags, &OutputDevice); } else { OutputDevice.Logf(TEXT("PrintStructHierarchy: failed to find any types for path: '%s'"), *StructPath); } } else { OutputDevice.Logf(TEXT("PrintStructHierarchy: no struct name or path specified (example usage: Obj.DumpStructHierarchy MyActor)")); LogHelp(OutputDevice); } }))	(	TEXT("Obj.DumpStructHierarchy")	,
		TEXT("Outputs a struct (or class) type hierarchy.")	,
		FConsoleCommandWithArgsAndOutputDeviceDelegate::CreateLambda([](const TArray< FString > &Args, FOutputDevice &OutputDevice) { if(Args.Num() > 0) { FString StructPath; EPrintObjectFlag Flags; ParseObjectIdAndFlags(Args, StructPath, Flags); UStruct *Struct=FindFirstObjectSafe< UStruct >(*StructPath); if(Struct) { PrintStructHierarchy(Struct, Flags, &OutputDevice); } else { OutputDevice.Logf(TEXT("PrintStructHierarchy: failed to find any types for path: '%s'"), *StructPath); } } else { OutputDevice.Logf(TEXT("PrintStructHierarchy: no struct name or path specified (example usage: Obj.DumpStructHierarchy MyActor)")); LogHelp(OutputDevice); } })
	)

DeferLock

constexpr struct UE::FDeferLock UE::DeferLock

GHttpIoDispatcher

TSharedPtr<IHttpIoDispatcher> UE::GHttpIoDispatcher

GIsUsingZenPakFileStreaming

int UE::GIsUsingZenPakFileStreaming = -1

GPlatformIoDispatcher

TUniquePtr<IPlatformIoDispatcher> UE::GPlatformIoDispatcher

GPropertyTypeNameTable

FPropertyTypeNameTable UE::GPropertyTypeNameTable

NAME_Key

UE_API const FName UE::NAME_Key

(

ANSITEXTVIEW("Key")

)

NAME_Value

UE_API const FName UE::NAME_Value

(

ANSITEXTVIEW("Value")

)