1398 lines
51 KiB
C++
1398 lines
51 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
/*=============================================================================
|
|
UObjectBase.cpp: Unreal UObject base class
|
|
=============================================================================*/
|
|
|
|
#include "UObject/UObjectBase.h"
|
|
#include "Misc/MessageDialog.h"
|
|
#include "Misc/ConfigCacheIni.h"
|
|
#include "HAL/IConsoleManager.h"
|
|
#include "HAL/LowLevelMemTracker.h"
|
|
#include "Misc/FeedbackContext.h"
|
|
#include "Modules/ModuleManager.h"
|
|
#include "UObject/UObjectAllocator.h"
|
|
#include "UObject/UObjectHash.h"
|
|
#include "UObject/Class.h"
|
|
#include "UObject/UObjectIterator.h"
|
|
#include "UObject/Package.h"
|
|
#include "Templates/Casts.h"
|
|
#include "UObject/GCObject.h"
|
|
#include "UObject/LinkerLoad.h"
|
|
#include "Misc/CommandLine.h"
|
|
#include "Interfaces/IPluginManager.h"
|
|
#include "Serialization/LoadTimeTrace.h"
|
|
|
|
DEFINE_LOG_CATEGORY_STATIC(LogUObjectBase, Log, All);
|
|
DEFINE_STAT(STAT_UObjectsStatGroupTester);
|
|
|
|
DECLARE_CYCLE_STAT(TEXT("CreateStatID"), STAT_CreateStatID, STATGROUP_StatSystem);
|
|
|
|
DEFINE_LOG_CATEGORY_STATIC(LogUObjectBootstrap, Display, Display);
|
|
|
|
/** Whether uobject system is initialized. */
|
|
namespace Internal
|
|
{
|
|
static bool& GetUObjectSubsystemInitialised()
|
|
{
|
|
static bool ObjInitialized = false;
|
|
return ObjInitialized;
|
|
}
|
|
}; // namespace Internal
|
|
bool UObjectInitialized()
|
|
{
|
|
return Internal::GetUObjectSubsystemInitialised();
|
|
}
|
|
|
|
/** Objects to automatically register once the object system is ready. */
|
|
struct FPendingRegistrantInfo
|
|
{
|
|
const TCHAR* Name;
|
|
const TCHAR* PackageName;
|
|
FPendingRegistrantInfo(const TCHAR* InName, const TCHAR* InPackageName)
|
|
: Name(InName), PackageName(InPackageName)
|
|
{}
|
|
static TMap<UObjectBase*, FPendingRegistrantInfo>& GetMap()
|
|
{
|
|
static TMap<UObjectBase*, FPendingRegistrantInfo> PendingRegistrantInfo;
|
|
return PendingRegistrantInfo;
|
|
}
|
|
};
|
|
|
|
/** Objects to automatically register once the object system is ready. */
|
|
struct FPendingRegistrant
|
|
{
|
|
UObjectBase* Object;
|
|
FPendingRegistrant* NextAutoRegister;
|
|
FPendingRegistrant(UObjectBase* InObject)
|
|
: Object(InObject), NextAutoRegister(NULL)
|
|
{}
|
|
};
|
|
static FPendingRegistrant* GFirstPendingRegistrant = NULL;
|
|
static FPendingRegistrant* GLastPendingRegistrant = NULL;
|
|
|
|
#if USE_PER_MODULE_UOBJECT_BOOTSTRAP
|
|
static TMap<FName, TArray<FPendingRegistrant*>>& GetPerModuleBootstrapMap()
|
|
{
|
|
static TMap<FName, TArray<FPendingRegistrant*>> PendingRegistrantInfo;
|
|
return PendingRegistrantInfo;
|
|
}
|
|
|
|
#endif
|
|
|
|
/**
|
|
* Constructor used for bootstrapping
|
|
* @param InClass possibly NULL, this gives the class of the new object, if known at this time
|
|
* @param InFlags RF_Flags to assign
|
|
*/
|
|
UObjectBase::UObjectBase(EObjectFlags InFlags)
|
|
: ObjectFlags(InFlags), InternalIndex(INDEX_NONE), ClassPrivate(nullptr), OuterPrivate(nullptr)
|
|
{}
|
|
|
|
/**
|
|
* Constructor used by StaticAllocateObject
|
|
* @param InClass non NULL, this gives the class of the new object, if known at this time
|
|
* @param InFlags RF_Flags to assign
|
|
* @param InOuter outer for this object
|
|
* @param InName name of the new object
|
|
* @param InObjectArchetype archetype to assign
|
|
*/
|
|
UObjectBase::UObjectBase(UClass* InClass, EObjectFlags InFlags, EInternalObjectFlags InInternalFlags, UObject* InOuter, FName InName)
|
|
: ObjectFlags(InFlags), InternalIndex(INDEX_NONE), ClassPrivate(InClass), OuterPrivate(InOuter)
|
|
{
|
|
check(ClassPrivate);
|
|
// Add to global table.
|
|
AddObject(InName, InInternalFlags);
|
|
}
|
|
|
|
/**
|
|
* Final destructor, removes the object from the object array, and indirectly, from any annotations
|
|
**/
|
|
UObjectBase::~UObjectBase()
|
|
{
|
|
// If not initialized, skip out.
|
|
if (UObjectInitialized() && ClassPrivate && !GIsCriticalError)
|
|
{
|
|
// Validate it.
|
|
check(IsValidLowLevel());
|
|
check(GetFName() == NAME_None);
|
|
GUObjectArray.FreeUObjectIndex(this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Convert a boot-strap registered class into a real one, add to uobject array, etc
|
|
*
|
|
* @param UClassStaticClass Now that it is known, fill in UClass::StaticClass() as the class
|
|
*/
|
|
void UObjectBase::DeferredRegister(UClass* UClassStaticClass, const TCHAR* PackageName, const TCHAR* InName)
|
|
{
|
|
check(UObjectInitialized());
|
|
// Set object properties.
|
|
UPackage* Package = CreatePackage(PackageName);
|
|
check(Package);
|
|
Package->SetPackageFlags(PKG_CompiledIn);
|
|
OuterPrivate = Package;
|
|
|
|
check(UClassStaticClass);
|
|
check(!ClassPrivate);
|
|
ClassPrivate = UClassStaticClass;
|
|
|
|
// Add to the global object table.
|
|
AddObject(FName(InName), EInternalObjectFlags::None);
|
|
// At this point all compiled-in objects should have already been fully constructed so it's safe to remove the NotFullyConstructed flag
|
|
// which was set in FUObjectArray::AllocateUObjectIndex (called from AddObject)
|
|
GUObjectArray.IndexToObject(InternalIndex)->ClearFlags(EInternalObjectFlags::PendingConstruction);
|
|
|
|
// Make sure that objects disregarded for GC are part of root set.
|
|
check(!GUObjectArray.IsDisregardForGC(this) || GUObjectArray.IndexToObject(InternalIndex)->IsRootSet());
|
|
|
|
UE_LOG(LogUObjectBootstrap, Verbose, TEXT("UObjectBase::DeferredRegister %s %s"), PackageName, InName);
|
|
}
|
|
|
|
/**
|
|
* Add a newly created object to the name hash tables and the object array
|
|
*
|
|
* @param Name name to assign to this uobject
|
|
*/
|
|
void UObjectBase::AddObject(FName InName, EInternalObjectFlags InSetInternalFlags)
|
|
{
|
|
NamePrivate = InName;
|
|
EInternalObjectFlags InternalFlagsToSet = InSetInternalFlags;
|
|
if (!IsInGameThread())
|
|
{
|
|
InternalFlagsToSet |= EInternalObjectFlags::Async;
|
|
}
|
|
if (ObjectFlags & RF_MarkAsRootSet)
|
|
{
|
|
InternalFlagsToSet |= EInternalObjectFlags::RootSet;
|
|
ObjectFlags &= ~RF_MarkAsRootSet;
|
|
}
|
|
if (ObjectFlags & RF_MarkAsNative)
|
|
{
|
|
InternalFlagsToSet |= EInternalObjectFlags::Native;
|
|
ObjectFlags &= ~RF_MarkAsNative;
|
|
}
|
|
GUObjectArray.AllocateUObjectIndex(this);
|
|
check(InName != NAME_None && InternalIndex >= 0);
|
|
if (InternalFlagsToSet != EInternalObjectFlags::None)
|
|
{
|
|
GUObjectArray.IndexToObject(InternalIndex)->SetFlags(InternalFlagsToSet);
|
|
}
|
|
HashObject(this);
|
|
check(IsValidLowLevel());
|
|
}
|
|
|
|
/**
|
|
* Just change the FName and Outer and rehash into name hash tables. For use by higher level rename functions.
|
|
*
|
|
* @param NewName new name for this object
|
|
* @param NewOuter new outer for this object, if NULL, outer will be unchanged
|
|
*/
|
|
void UObjectBase::LowLevelRename(FName NewName, UObject* NewOuter)
|
|
{
|
|
#if STATS || ENABLE_STATNAMEDEVENTS_UOBJECT
|
|
((UObject*)this)->ResetStatID(); // reset the stat id since this thing now has a different name
|
|
#endif
|
|
UnhashObject(this);
|
|
check(InternalIndex >= 0);
|
|
NamePrivate = NewName;
|
|
if (NewOuter)
|
|
{
|
|
OuterPrivate = NewOuter;
|
|
}
|
|
HashObject(this);
|
|
}
|
|
|
|
UPackage* UObjectBase::GetExternalPackage() const
|
|
{
|
|
// if we have no outer, consider this a package, packages returns themselves as their external package
|
|
if (OuterPrivate == nullptr)
|
|
{
|
|
return CastChecked<UPackage>((UObject*)(this));
|
|
}
|
|
UPackage* ExternalPackage = nullptr;
|
|
if ((GetFlags() & RF_HasExternalPackage) != 0)
|
|
{
|
|
ExternalPackage = GetObjectExternalPackageThreadSafe(this);
|
|
// if the flag is set there should be an override set.
|
|
ensure(ExternalPackage);
|
|
}
|
|
return ExternalPackage;
|
|
}
|
|
|
|
UPackage* UObjectBase::GetExternalPackageInternal() const
|
|
{
|
|
// if we have no outer, consider this a package, packages returns themselves as their external package
|
|
if (OuterPrivate == nullptr)
|
|
{
|
|
return CastChecked<UPackage>((UObject*)(this));
|
|
}
|
|
return (GetFlags() & RF_HasExternalPackage) != 0 ? GetObjectExternalPackageInternal(this) : nullptr;
|
|
}
|
|
|
|
void UObjectBase::SetExternalPackage(UPackage* InPackage)
|
|
{
|
|
HashObjectExternalPackage(this, InPackage);
|
|
if (InPackage)
|
|
{
|
|
SetFlagsTo(GetFlags() | RF_HasExternalPackage);
|
|
}
|
|
else
|
|
{
|
|
SetFlagsTo(GetFlags() & ~RF_HasExternalPackage);
|
|
}
|
|
}
|
|
|
|
void UObjectBase::SetClass(UClass* NewClass)
|
|
{
|
|
#if STATS || ENABLE_STATNAMEDEVENTS_UOBJECT
|
|
((UObject*)this)->ResetStatID(); // reset the stat id since this thing now has a different name
|
|
#endif
|
|
|
|
UnhashObject(this);
|
|
#if USE_UBER_GRAPH_PERSISTENT_FRAME
|
|
UClass* OldClass = ClassPrivate;
|
|
ClassPrivate->DestroyPersistentUberGraphFrame((UObject*)this);
|
|
#endif
|
|
ClassPrivate = NewClass;
|
|
#if USE_UBER_GRAPH_PERSISTENT_FRAME
|
|
ClassPrivate->CreatePersistentUberGraphFrame((UObject*)this, /*bCreateOnlyIfEmpty =*/false, /*bSkipSuperClass =*/false, OldClass);
|
|
#endif
|
|
HashObject(this);
|
|
}
|
|
|
|
/**
|
|
* Checks to see if the object appears to be valid
|
|
* @return true if this appears to be a valid object
|
|
*/
|
|
bool UObjectBase::IsValidLowLevel() const
|
|
{
|
|
if (this == nullptr)
|
|
{
|
|
UE_LOG(LogUObjectBase, Warning, TEXT("NULL object"));
|
|
return false;
|
|
}
|
|
if (!ClassPrivate)
|
|
{
|
|
UE_LOG(LogUObjectBase, Warning, TEXT("Object is not registered"));
|
|
return false;
|
|
}
|
|
return GUObjectArray.IsValid(this);
|
|
}
|
|
|
|
bool UObjectBase::IsValidLowLevelFast(bool bRecursive /*= true*/) const
|
|
{
|
|
// As DEFAULT_ALIGNMENT is defined to 0 now, I changed that to the original numerical value here
|
|
const int32 AlignmentCheck = MIN_ALIGNMENT - 1;
|
|
|
|
// Check 'this' pointer before trying to access any of the Object's members
|
|
if ((this == nullptr) || (UPTRINT)this < 0x100)
|
|
{
|
|
UE_LOG(LogUObjectBase, Error, TEXT("\'this\' pointer is invalid."));
|
|
return false;
|
|
}
|
|
if ((UPTRINT)this & AlignmentCheck)
|
|
{
|
|
UE_LOG(LogUObjectBase, Error, TEXT("\'this\' pointer is misaligned."));
|
|
return false;
|
|
}
|
|
if (*(void**)this == nullptr)
|
|
{
|
|
UE_LOG(LogUObjectBase, Error, TEXT("Virtual functions table is invalid."));
|
|
return false;
|
|
}
|
|
|
|
// These should all be 0.
|
|
const UPTRINT CheckZero = (ObjectFlags & ~RF_AllFlags) | ((UPTRINT)ClassPrivate & AlignmentCheck) | ((UPTRINT)OuterPrivate & AlignmentCheck);
|
|
if (!!CheckZero)
|
|
{
|
|
UE_LOG(LogUObjectBase, Error, TEXT("Object flags are invalid or either Class or Outer is misaligned"));
|
|
return false;
|
|
}
|
|
// These should all be non-NULL (except CDO-alignment check which should be 0)
|
|
if (ClassPrivate == nullptr || ClassPrivate->ClassDefaultObject == nullptr || ((UPTRINT)ClassPrivate->ClassDefaultObject & AlignmentCheck) != 0)
|
|
{
|
|
UE_LOG(LogUObjectBase, Error, TEXT("Class pointer is invalid or CDO is invalid."));
|
|
return false;
|
|
}
|
|
// Avoid infinite recursion so call IsValidLowLevelFast on the class object with bRecirsive = false.
|
|
if (bRecursive && !ClassPrivate->IsValidLowLevelFast(false))
|
|
{
|
|
UE_LOG(LogUObjectBase, Error, TEXT("Class object failed IsValidLowLevelFast test."));
|
|
return false;
|
|
}
|
|
// Lightweight versions of index checks.
|
|
if (!GUObjectArray.IsValidIndex(this) || !NamePrivate.IsValidIndexFast())
|
|
{
|
|
UE_LOG(LogUObjectBase, Error, TEXT("Object array index or name index is invalid."));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void UObjectBase::EmitBaseReferences(UClass* RootClass)
|
|
{
|
|
static const FName ClassPropertyName(TEXT("Class"));
|
|
static const FName OuterPropertyName(TEXT("Outer"));
|
|
// Mark UObject class reference as persistent object reference so that it (ClassPrivate) doesn't get nulled when a class
|
|
// is marked as pending kill. Nulling ClassPrivate may leave the object in a broken state if it doesn't get GC'd in the same
|
|
// GC call as its class. And even if it gets GC'd in the same call as its class it may break inside of GC (for example when traversing TMap references)
|
|
RootClass->EmitObjectReference(STRUCT_OFFSET(UObjectBase, ClassPrivate), ClassPropertyName, GCRT_PersistentObject);
|
|
RootClass->EmitObjectReference(STRUCT_OFFSET(UObjectBase, OuterPrivate), OuterPropertyName, GCRT_PersistentObject);
|
|
RootClass->EmitExternalPackageReference();
|
|
}
|
|
|
|
#if USE_PER_MODULE_UOBJECT_BOOTSTRAP
|
|
static void UObjectReleaseModuleRegistrants(FName Module)
|
|
{
|
|
TMap<FName, TArray<FPendingRegistrant*>>& PerModuleMap = GetPerModuleBootstrapMap();
|
|
|
|
FName Package = IPluginManager::Get().PackageNameFromModuleName(Module);
|
|
|
|
FName ScriptName = *(FString(TEXT("/Script/")) + Package.ToString());
|
|
|
|
TArray<FPendingRegistrant*>* Array = PerModuleMap.Find(ScriptName);
|
|
if (Array)
|
|
{
|
|
SCOPED_BOOT_TIMING("UObjectReleaseModuleRegistrants");
|
|
for (FPendingRegistrant* PendingRegistration: *Array)
|
|
{
|
|
if (GLastPendingRegistrant)
|
|
{
|
|
GLastPendingRegistrant->NextAutoRegister = PendingRegistration;
|
|
}
|
|
else
|
|
{
|
|
check(!GFirstPendingRegistrant);
|
|
GFirstPendingRegistrant = PendingRegistration;
|
|
}
|
|
GLastPendingRegistrant = PendingRegistration;
|
|
}
|
|
UE_LOG(LogUObjectBootstrap, Verbose, TEXT("UObjectReleaseModuleRegistrants %d items in %s"), Array->Num(), *ScriptName.ToString());
|
|
PerModuleMap.Remove(ScriptName);
|
|
}
|
|
else
|
|
{
|
|
UE_LOG(LogUObjectBootstrap, Verbose, TEXT("UObjectReleaseModuleRegistrants no items in %s"), *ScriptName.ToString());
|
|
}
|
|
}
|
|
|
|
void UObjectReleaseAllModuleRegistrants()
|
|
{
|
|
SCOPED_BOOT_TIMING("UObjectReleaseAllModuleRegistrants");
|
|
TMap<FName, TArray<FPendingRegistrant*>>& PerModuleMap = GetPerModuleBootstrapMap();
|
|
for (auto& Pair: PerModuleMap)
|
|
{
|
|
for (FPendingRegistrant* PendingRegistration: Pair.Value)
|
|
{
|
|
if (GLastPendingRegistrant)
|
|
{
|
|
GLastPendingRegistrant->NextAutoRegister = PendingRegistration;
|
|
}
|
|
else
|
|
{
|
|
check(!GFirstPendingRegistrant);
|
|
GFirstPendingRegistrant = PendingRegistration;
|
|
}
|
|
GLastPendingRegistrant = PendingRegistration;
|
|
}
|
|
UE_LOG(LogUObjectBootstrap, Verbose, TEXT("UObjectReleaseAllModuleRegistrants %d items in %s"), Pair.Value.Num(), *Pair.Key.ToString());
|
|
}
|
|
PerModuleMap.Empty();
|
|
ProcessNewlyLoadedUObjects();
|
|
}
|
|
|
|
static void DumpPendingUObjectModules(const TArray<FString>& Args)
|
|
{
|
|
TMap<FName, TArray<FPendingRegistrant*>>& PerModuleMap = GetPerModuleBootstrapMap();
|
|
for (auto& Pair: PerModuleMap)
|
|
{
|
|
UE_LOG(LogUObjectBootstrap, Display, TEXT("Not yet loaded: %d items in %s"), Pair.Value.Num(), *Pair.Key.ToString());
|
|
}
|
|
}
|
|
|
|
static FAutoConsoleCommand DumpPendingUObjectModulesCmd(
|
|
TEXT("DumpPendingUObjectModules"),
|
|
TEXT("When doing per-module UObject bootstrapping, show the modules that are not yet loaded."),
|
|
FConsoleCommandWithArgsDelegate::CreateStatic(&DumpPendingUObjectModules));
|
|
|
|
#endif
|
|
|
|
/** Enqueue the registration for this object. */
|
|
void UObjectBase::Register(const TCHAR* PackageName, const TCHAR* InName)
|
|
{
|
|
TMap<UObjectBase*, FPendingRegistrantInfo>& PendingRegistrants = FPendingRegistrantInfo::GetMap();
|
|
|
|
FPendingRegistrant* PendingRegistration = new FPendingRegistrant(this);
|
|
PendingRegistrants.Add(this, FPendingRegistrantInfo(InName, PackageName));
|
|
|
|
#if USE_PER_MODULE_UOBJECT_BOOTSTRAP
|
|
if (FName(PackageName) != FName("/Script/CoreUObject"))
|
|
{
|
|
TMap<FName, TArray<FPendingRegistrant*>>& PerModuleMap = GetPerModuleBootstrapMap();
|
|
|
|
PerModuleMap.FindOrAdd(FName(PackageName)).Add(PendingRegistration);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
if (GLastPendingRegistrant)
|
|
{
|
|
GLastPendingRegistrant->NextAutoRegister = PendingRegistration;
|
|
}
|
|
else
|
|
{
|
|
check(!GFirstPendingRegistrant);
|
|
GFirstPendingRegistrant = PendingRegistration;
|
|
}
|
|
GLastPendingRegistrant = PendingRegistration;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Dequeues registrants from the list of pending registrations into an array.
|
|
* The contents of the array is preserved, and the new elements are appended.
|
|
*/
|
|
static void DequeuePendingAutoRegistrants(TArray<FPendingRegistrant>& OutPendingRegistrants)
|
|
{
|
|
// We process registrations in the order they were enqueued, since each registrant ensures
|
|
// its dependencies are enqueued before it enqueues itself.
|
|
FPendingRegistrant* NextPendingRegistrant = GFirstPendingRegistrant;
|
|
GFirstPendingRegistrant = NULL;
|
|
GLastPendingRegistrant = NULL;
|
|
while (NextPendingRegistrant)
|
|
{
|
|
FPendingRegistrant* PendingRegistrant = NextPendingRegistrant;
|
|
OutPendingRegistrants.Add(*PendingRegistrant);
|
|
NextPendingRegistrant = PendingRegistrant->NextAutoRegister;
|
|
delete PendingRegistrant;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Process the auto register objects adding them to the UObject array
|
|
*/
|
|
static void UObjectProcessRegistrants()
|
|
{
|
|
SCOPED_BOOT_TIMING("UObjectProcessRegistrants");
|
|
|
|
check(UObjectInitialized());
|
|
// Make list of all objects to be registered.
|
|
TArray<FPendingRegistrant> PendingRegistrants;
|
|
DequeuePendingAutoRegistrants(PendingRegistrants);
|
|
|
|
for (int32 RegistrantIndex = 0; RegistrantIndex < PendingRegistrants.Num(); ++RegistrantIndex)
|
|
{
|
|
const FPendingRegistrant& PendingRegistrant = PendingRegistrants[RegistrantIndex];
|
|
|
|
UObjectForceRegistration(PendingRegistrant.Object, false);
|
|
|
|
check(PendingRegistrant.Object->GetClass()); // should have been set by DeferredRegister
|
|
|
|
// Register may have resulted in new pending registrants being enqueued, so dequeue those.
|
|
DequeuePendingAutoRegistrants(PendingRegistrants);
|
|
}
|
|
}
|
|
|
|
void UObjectForceRegistration(UObjectBase* Object, bool bCheckForModuleRelease)
|
|
{
|
|
TMap<UObjectBase*, FPendingRegistrantInfo>& PendingRegistrants = FPendingRegistrantInfo::GetMap();
|
|
|
|
FPendingRegistrantInfo* Info = PendingRegistrants.Find(Object);
|
|
if (Info)
|
|
{
|
|
const TCHAR* PackageName = Info->PackageName;
|
|
#if USE_PER_MODULE_UOBJECT_BOOTSTRAP
|
|
if (bCheckForModuleRelease)
|
|
{
|
|
UObjectReleaseModuleRegistrants(FName(PackageName));
|
|
}
|
|
#endif
|
|
const TCHAR* Name = Info->Name;
|
|
PendingRegistrants.Remove(Object); // delete this first so that it doesn't try to do it twice
|
|
Object->DeferredRegister(UClass::StaticClass(), PackageName, Name);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Struct containing the function pointer and package name of a UStruct to be registered with UObject system
|
|
*/
|
|
struct FPendingStructRegistrant
|
|
{
|
|
class UScriptStruct* (*RegisterFn)();
|
|
const TCHAR* PackageName;
|
|
|
|
FPendingStructRegistrant() {}
|
|
FPendingStructRegistrant(class UScriptStruct* (*Fn)(), const TCHAR* InPackageName)
|
|
: RegisterFn(Fn), PackageName(InPackageName)
|
|
{
|
|
}
|
|
FORCEINLINE bool operator==(const FPendingStructRegistrant& Other) const
|
|
{
|
|
return RegisterFn == Other.RegisterFn;
|
|
}
|
|
};
|
|
|
|
static TArray<FPendingStructRegistrant>& GetDeferredCompiledInStructRegistration()
|
|
{
|
|
static TArray<FPendingStructRegistrant> DeferredCompiledInRegistration;
|
|
return DeferredCompiledInRegistration;
|
|
}
|
|
|
|
TMap<FName, UScriptStruct* (*)()>& GetDynamicStructMap()
|
|
{
|
|
static TMap<FName, UScriptStruct* (*)()> DynamicStructMap;
|
|
return DynamicStructMap;
|
|
}
|
|
|
|
void UObjectCompiledInDeferStruct(class UScriptStruct* (*InRegister)(), const TCHAR* PackageName, const TCHAR* ObjectName, bool bDynamic, const TCHAR* DynamicPathName)
|
|
{
|
|
if (!bDynamic)
|
|
{
|
|
// we do reregister StaticStruct in hot reload
|
|
FPendingStructRegistrant Registrant(InRegister, PackageName);
|
|
checkSlow(!GetDeferredCompiledInStructRegistration().Contains(Registrant));
|
|
GetDeferredCompiledInStructRegistration().Add(Registrant);
|
|
}
|
|
else
|
|
{
|
|
GetDynamicStructMap().Add(DynamicPathName, InRegister);
|
|
}
|
|
NotifyRegistrationEvent(PackageName, ObjectName, ENotifyRegistrationType::NRT_Struct, ENotifyRegistrationPhase::NRP_Added, (UObject * (*)())(InRegister), bDynamic);
|
|
}
|
|
|
|
class UScriptStruct* GetStaticStruct(class UScriptStruct* (*InRegister)(), UObject* StructOuter, const TCHAR* StructName, SIZE_T Size, uint32 Crc)
|
|
{
|
|
NotifyRegistrationEvent(*StructOuter->GetOutermost()->GetName(), StructName, ENotifyRegistrationType::NRT_Struct, ENotifyRegistrationPhase::NRP_Started);
|
|
UScriptStruct* Result = (*InRegister)();
|
|
NotifyRegistrationEvent(*StructOuter->GetOutermost()->GetName(), StructName, ENotifyRegistrationType::NRT_Struct, ENotifyRegistrationPhase::NRP_Finished);
|
|
return Result;
|
|
}
|
|
|
|
/**
|
|
* Struct containing the function pointer and package name of a UEnum to be registered with UObject system
|
|
*/
|
|
struct FPendingEnumRegistrant
|
|
{
|
|
class UEnum* (*RegisterFn)();
|
|
const TCHAR* PackageName;
|
|
|
|
FPendingEnumRegistrant() {}
|
|
FPendingEnumRegistrant(class UEnum* (*Fn)(), const TCHAR* InPackageName)
|
|
: RegisterFn(Fn), PackageName(InPackageName)
|
|
{
|
|
}
|
|
FORCEINLINE bool operator==(const FPendingEnumRegistrant& Other) const
|
|
{
|
|
return RegisterFn == Other.RegisterFn;
|
|
}
|
|
};
|
|
|
|
// Same thing as GetDeferredCompiledInStructRegistration but for UEnums declared in header files without UClasses.
|
|
static TArray<FPendingEnumRegistrant>& GetDeferredCompiledInEnumRegistration()
|
|
{
|
|
static TArray<FPendingEnumRegistrant> DeferredCompiledInRegistration;
|
|
return DeferredCompiledInRegistration;
|
|
}
|
|
|
|
TMap<FName, UEnum* (*)()>& GetDynamicEnumMap()
|
|
{
|
|
static TMap<FName, UEnum* (*)()> DynamicEnumMap;
|
|
return DynamicEnumMap;
|
|
}
|
|
|
|
void UObjectCompiledInDeferEnum(class UEnum* (*InRegister)(), const TCHAR* PackageName, const TCHAR* ObjectName, bool bDynamic, const TCHAR* DynamicPathName)
|
|
{
|
|
if (!bDynamic)
|
|
{
|
|
// we do reregister StaticStruct in hot reload
|
|
FPendingEnumRegistrant Registrant(InRegister, PackageName);
|
|
checkSlow(!GetDeferredCompiledInEnumRegistration().Contains(Registrant));
|
|
GetDeferredCompiledInEnumRegistration().Add(Registrant);
|
|
}
|
|
else
|
|
{
|
|
GetDynamicEnumMap().Add(DynamicPathName, InRegister);
|
|
}
|
|
NotifyRegistrationEvent(PackageName, ObjectName, ENotifyRegistrationType::NRT_Enum, ENotifyRegistrationPhase::NRP_Added, (UObject * (*)())(InRegister), bDynamic);
|
|
}
|
|
|
|
class UEnum* GetStaticEnum(class UEnum* (*InRegister)(), UObject* EnumOuter, const TCHAR* EnumName)
|
|
{
|
|
NotifyRegistrationEvent(*EnumOuter->GetOutermost()->GetName(), EnumName, ENotifyRegistrationType::NRT_Enum, ENotifyRegistrationPhase::NRP_Started);
|
|
UEnum* Result = (*InRegister)();
|
|
NotifyRegistrationEvent(*EnumOuter->GetOutermost()->GetName(), EnumName, ENotifyRegistrationType::NRT_Enum, ENotifyRegistrationPhase::NRP_Finished);
|
|
return Result;
|
|
}
|
|
|
|
static TArray<class UClass* (*)()>& GetDeferredCompiledInRegistration()
|
|
{
|
|
static TArray<class UClass* (*)()> DeferredCompiledInRegistration;
|
|
return DeferredCompiledInRegistration;
|
|
}
|
|
|
|
/** Classes loaded with a module, deferred until we register them all in one go */
|
|
static TArray<FFieldCompiledInInfo*>& GetDeferredClassRegistration()
|
|
{
|
|
static TArray<FFieldCompiledInInfo*> DeferredClassRegistration;
|
|
return DeferredClassRegistration;
|
|
}
|
|
|
|
#if WITH_HOT_RELOAD
|
|
/** Map of deferred class registration info (including size and reflection info) */
|
|
static TMap<FName, FFieldCompiledInInfo*>& GetDeferRegisterClassMap()
|
|
{
|
|
static TMap<FName, FFieldCompiledInInfo*> DeferRegisterClassMap;
|
|
return DeferRegisterClassMap;
|
|
}
|
|
|
|
/** Classes that changed during hot-reload and need to be re-instanced */
|
|
static TArray<FFieldCompiledInInfo*>& GetHotReloadClasses()
|
|
{
|
|
static TArray<FFieldCompiledInInfo*> HotReloadClasses;
|
|
return HotReloadClasses;
|
|
}
|
|
#endif
|
|
|
|
/** Removes prefix from the native class name */
|
|
FString UObjectBase::RemoveClassPrefix(const TCHAR* ClassName)
|
|
{
|
|
static const TCHAR* DeprecatedPrefix = TEXT("DEPRECATED_");
|
|
FString NameWithoutPrefix(ClassName);
|
|
NameWithoutPrefix.MidInline(1, MAX_int32, false);
|
|
if (NameWithoutPrefix.StartsWith(DeprecatedPrefix))
|
|
{
|
|
NameWithoutPrefix.MidInline(FCString::Strlen(DeprecatedPrefix), MAX_int32, false);
|
|
}
|
|
return NameWithoutPrefix;
|
|
}
|
|
|
|
void UClassCompiledInDefer(FFieldCompiledInInfo* ClassInfo, const TCHAR* Name, SIZE_T ClassSize, uint32 Crc)
|
|
{
|
|
const FName CPPClassName = Name;
|
|
#if WITH_HOT_RELOAD
|
|
// Check for existing classes
|
|
TMap<FName, FFieldCompiledInInfo*>& DeferMap = GetDeferRegisterClassMap();
|
|
FFieldCompiledInInfo** ExistingClassInfo = DeferMap.Find(CPPClassName);
|
|
ClassInfo->bHasChanged = !ExistingClassInfo || (*ExistingClassInfo)->Size != ClassInfo->Size || (*ExistingClassInfo)->Crc != ClassInfo->Crc;
|
|
if (ExistingClassInfo)
|
|
{
|
|
// Class exists, this can only happen during hot-reload
|
|
checkf(GIsHotReload, TEXT("Trying to recreate class '%s' outside of hot reload!"), *CPPClassName.ToString());
|
|
|
|
// Get the native name
|
|
FString NameWithoutPrefix = UObjectBase::RemoveClassPrefix(Name);
|
|
UClass* ExistingClass = FindObjectChecked<UClass>(ANY_PACKAGE, *NameWithoutPrefix);
|
|
|
|
if (ClassInfo->bHasChanged)
|
|
{
|
|
// Rename the old class and move it to transient package
|
|
ExistingClass->RemoveFromRoot();
|
|
ExistingClass->ClearFlags(RF_Standalone | RF_Public);
|
|
ExistingClass->GetDefaultObject()->RemoveFromRoot();
|
|
ExistingClass->GetDefaultObject()->ClearFlags(RF_Standalone | RF_Public);
|
|
const FName OldClassRename = MakeUniqueObjectName(GetTransientPackage(), ExistingClass->GetClass(), *FString::Printf(TEXT("HOTRELOADED_%s"), *NameWithoutPrefix));
|
|
ExistingClass->Rename(*OldClassRename.ToString(), GetTransientPackage());
|
|
ExistingClass->SetFlags(RF_Transient);
|
|
ExistingClass->AddToRoot();
|
|
|
|
// Make sure enums de-register their names BEFORE we create the new class, otherwise there will be name conflicts
|
|
TArray<UObject*> ClassSubobjects;
|
|
GetObjectsWithOuter(ExistingClass, ClassSubobjects);
|
|
for (auto ClassSubobject: ClassSubobjects)
|
|
{
|
|
if (auto Enum = dynamic_cast<UEnum*>(ClassSubobject))
|
|
{
|
|
Enum->RemoveNamesFromMasterList();
|
|
}
|
|
}
|
|
}
|
|
ClassInfo->OldClass = ExistingClass;
|
|
GetHotReloadClasses().Add(ClassInfo);
|
|
|
|
*ExistingClassInfo = ClassInfo;
|
|
}
|
|
else
|
|
{
|
|
DeferMap.Add(CPPClassName, ClassInfo);
|
|
}
|
|
#endif
|
|
// We will either create a new class or update the static class pointer of the existing one
|
|
GetDeferredClassRegistration().Add(ClassInfo);
|
|
}
|
|
|
|
TMap<FName, FDynamicClassStaticData>& GetDynamicClassMap()
|
|
{
|
|
static TMap<FName, FDynamicClassStaticData> DynamicClassMap;
|
|
return DynamicClassMap;
|
|
}
|
|
|
|
void UObjectCompiledInDefer(UClass* (*InRegister)(), UClass* (*InStaticClass)(), const TCHAR* Name, const TCHAR* PackageName, bool bDynamic, const TCHAR* DynamicPathName, void (*InInitSearchableValues)(TMap<FName, FName>&))
|
|
{
|
|
if (!bDynamic)
|
|
{
|
|
#if WITH_HOT_RELOAD
|
|
// Either add all classes if not hot-reloading, or those which have changed
|
|
TMap<FName, FFieldCompiledInInfo*>& DeferMap = GetDeferRegisterClassMap();
|
|
if (!GIsHotReload || DeferMap.FindChecked(Name)->bHasChanged)
|
|
#endif
|
|
{
|
|
FString NoPrefix(UObjectBase::RemoveClassPrefix(Name));
|
|
NotifyRegistrationEvent(PackageName, *NoPrefix, ENotifyRegistrationType::NRT_Class, ENotifyRegistrationPhase::NRP_Added, (UObject * (*)())(InRegister), false);
|
|
NotifyRegistrationEvent(PackageName, *(FString(DEFAULT_OBJECT_PREFIX) + NoPrefix), ENotifyRegistrationType::NRT_ClassCDO, ENotifyRegistrationPhase::NRP_Added, (UObject * (*)())(InRegister), false);
|
|
|
|
TArray<UClass* (*)()>& DeferredCompiledInRegistration = GetDeferredCompiledInRegistration();
|
|
checkSlow(!DeferredCompiledInRegistration.Contains(InRegister));
|
|
DeferredCompiledInRegistration.Add(InRegister);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FDynamicClassStaticData ClassFunctions;
|
|
ClassFunctions.ZConstructFn = InRegister;
|
|
ClassFunctions.StaticClassFn = InStaticClass;
|
|
if (InInitSearchableValues)
|
|
{
|
|
InInitSearchableValues(ClassFunctions.SelectedSearchableValues);
|
|
}
|
|
GetDynamicClassMap().Add(FName(DynamicPathName), ClassFunctions);
|
|
|
|
FString OriginalPackageName = DynamicPathName;
|
|
check(OriginalPackageName.EndsWith(Name));
|
|
OriginalPackageName.RemoveFromEnd(FString(Name));
|
|
check(OriginalPackageName.EndsWith(TEXT(".")));
|
|
OriginalPackageName.RemoveFromEnd(FString(TEXT(".")));
|
|
|
|
NotifyRegistrationEvent(*OriginalPackageName, Name, ENotifyRegistrationType::NRT_Class, ENotifyRegistrationPhase::NRP_Added, (UObject * (*)())(InRegister), true);
|
|
NotifyRegistrationEvent(*OriginalPackageName, *(FString(DEFAULT_OBJECT_PREFIX) + Name), ENotifyRegistrationType::NRT_ClassCDO, ENotifyRegistrationPhase::NRP_Added, (UObject * (*)())(InRegister), true);
|
|
}
|
|
}
|
|
|
|
/** Register all loaded classes */
|
|
void UClassRegisterAllCompiledInClasses()
|
|
{
|
|
#if WITH_HOT_RELOAD
|
|
TArray<UClass*> AddedClasses;
|
|
#endif
|
|
SCOPED_BOOT_TIMING("UClassRegisterAllCompiledInClasses");
|
|
|
|
TArray<FFieldCompiledInInfo*>& DeferredClassRegistration = GetDeferredClassRegistration();
|
|
for (const FFieldCompiledInInfo* Class: DeferredClassRegistration)
|
|
{
|
|
UClass* RegisteredClass = Class->Register();
|
|
#if WITH_HOT_RELOAD
|
|
if (GIsHotReload && Class->OldClass == nullptr)
|
|
{
|
|
AddedClasses.Add(RegisteredClass);
|
|
}
|
|
#endif
|
|
}
|
|
DeferredClassRegistration.Empty();
|
|
|
|
#if WITH_HOT_RELOAD
|
|
if (AddedClasses.Num() > 0)
|
|
{
|
|
FCoreUObjectDelegates::RegisterHotReloadAddedClassesDelegate.Broadcast(AddedClasses);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if WITH_HOT_RELOAD
|
|
/** Re-instance all existing classes that have changed during hot-reload */
|
|
void UClassReplaceHotReloadClasses()
|
|
{
|
|
TArray<FFieldCompiledInInfo*>& HotReloadClasses = GetHotReloadClasses();
|
|
|
|
if (FCoreUObjectDelegates::RegisterClassForHotReloadReinstancingDelegate.IsBound())
|
|
{
|
|
for (const FFieldCompiledInInfo* Class: HotReloadClasses)
|
|
{
|
|
check(Class->OldClass);
|
|
|
|
UClass* RegisteredClass = nullptr;
|
|
if (Class->bHasChanged)
|
|
{
|
|
RegisteredClass = Class->Register();
|
|
}
|
|
|
|
FCoreUObjectDelegates::RegisterClassForHotReloadReinstancingDelegate.Broadcast(Class->OldClass, RegisteredClass, Class->bHasChanged ? EHotReloadedClassFlags::Changed : EHotReloadedClassFlags::None);
|
|
}
|
|
}
|
|
|
|
FCoreUObjectDelegates::ReinstanceHotReloadedClassesDelegate.Broadcast();
|
|
HotReloadClasses.Empty();
|
|
}
|
|
|
|
#endif
|
|
|
|
/**
|
|
* Load any outstanding compiled in default properties
|
|
*/
|
|
static void UObjectLoadAllCompiledInDefaultProperties()
|
|
{
|
|
TRACE_LOADTIME_REQUEST_GROUP_SCOPE(TEXT("UObjectLoadAllCompiledInDefaultProperties"));
|
|
|
|
static FName LongEnginePackageName(TEXT("/Script/Engine"));
|
|
|
|
TArray<UClass* (*)()>& DeferredCompiledInRegistration = GetDeferredCompiledInRegistration();
|
|
|
|
const bool bHaveRegistrants = DeferredCompiledInRegistration.Num() != 0;
|
|
if (bHaveRegistrants)
|
|
{
|
|
SCOPED_BOOT_TIMING("UObjectLoadAllCompiledInDefaultProperties");
|
|
TArray<UClass*> NewClasses;
|
|
TArray<UClass*> NewClassesInCoreUObject;
|
|
TArray<UClass*> NewClassesInEngine;
|
|
TArray<UClass* (*)()> PendingRegistrants = MoveTemp(DeferredCompiledInRegistration);
|
|
for (UClass* (*Registrant)(): PendingRegistrants)
|
|
{
|
|
UClass* Class = Registrant();
|
|
UE_LOG(LogUObjectBootstrap, Verbose, TEXT("UObjectLoadAllCompiledInDefaultProperties After Registrant %s %s"), *Class->GetOutermost()->GetName(), *Class->GetName());
|
|
if (Class->GetOutermost()->GetFName() == GLongCoreUObjectPackageName)
|
|
{
|
|
NewClassesInCoreUObject.Add(Class);
|
|
}
|
|
else if (Class->GetOutermost()->GetFName() == LongEnginePackageName)
|
|
{
|
|
NewClassesInEngine.Add(Class);
|
|
}
|
|
else
|
|
{
|
|
NewClasses.Add(Class);
|
|
}
|
|
}
|
|
{
|
|
SCOPED_BOOT_TIMING("CoreUObject Classes");
|
|
for (UClass* Class: NewClassesInCoreUObject) // we do these first because we assume these never trigger loads
|
|
{
|
|
UE_LOG(LogUObjectBootstrap, Verbose, TEXT("GetDefaultObject Begin %s %s"), *Class->GetOutermost()->GetName(), *Class->GetName());
|
|
Class->GetDefaultObject();
|
|
UE_LOG(LogUObjectBootstrap, Verbose, TEXT("GetDefaultObject End %s %s"), *Class->GetOutermost()->GetName(), *Class->GetName());
|
|
}
|
|
}
|
|
{
|
|
SCOPED_BOOT_TIMING("Engine Classes");
|
|
for (UClass* Class: NewClassesInEngine) // we do these second because we want to bring the engine up before the game
|
|
{
|
|
UE_LOG(LogUObjectBootstrap, Verbose, TEXT("GetDefaultObject Begin %s %s"), *Class->GetOutermost()->GetName(), *Class->GetName());
|
|
Class->GetDefaultObject();
|
|
UE_LOG(LogUObjectBootstrap, Verbose, TEXT("GetDefaultObject End %s %s"), *Class->GetOutermost()->GetName(), *Class->GetName());
|
|
}
|
|
}
|
|
{
|
|
SCOPED_BOOT_TIMING("Other Classes");
|
|
for (UClass* Class: NewClasses)
|
|
{
|
|
UE_LOG(LogUObjectBootstrap, Verbose, TEXT("GetDefaultObject Begin %s %s"), *Class->GetOutermost()->GetName(), *Class->GetName());
|
|
Class->GetDefaultObject();
|
|
UE_LOG(LogUObjectBootstrap, Verbose, TEXT("GetDefaultObject End %s %s"), *Class->GetOutermost()->GetName(), *Class->GetName());
|
|
}
|
|
}
|
|
FFeedbackContext& ErrorsFC = UClass::GetDefaultPropertiesFeedbackContext();
|
|
if (ErrorsFC.GetNumErrors() || ErrorsFC.GetNumWarnings())
|
|
{
|
|
TArray<FString> AllErrorsAndWarnings;
|
|
ErrorsFC.GetErrorsAndWarningsAndEmpty(AllErrorsAndWarnings);
|
|
|
|
FString AllInOne;
|
|
UE_LOG(LogUObjectBase, Warning, TEXT("-------------- Default Property warnings and errors:"));
|
|
for (const FString& ErrorOrWarning: AllErrorsAndWarnings)
|
|
{
|
|
UE_LOG(LogUObjectBase, Warning, TEXT("%s"), *ErrorOrWarning);
|
|
AllInOne += ErrorOrWarning;
|
|
AllInOne += TEXT("\n");
|
|
}
|
|
FMessageDialog::Open(EAppMsgType::Ok, FText::Format(NSLOCTEXT("Core", "DefaultPropertyWarningAndErrors", "Default Property warnings and errors:\n{0}"), FText::FromString(AllInOne)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call StaticStruct for each struct...this sets up the internal singleton, and important works correctly with hot reload
|
|
*/
|
|
static void UObjectLoadAllCompiledInStructs()
|
|
{
|
|
SCOPED_BOOT_TIMING("UObjectLoadAllCompiledInStructs");
|
|
|
|
TArray<FPendingEnumRegistrant> PendingEnumRegistrants = MoveTemp(GetDeferredCompiledInEnumRegistration());
|
|
TArray<FPendingStructRegistrant> PendingStructRegistrants = MoveTemp(GetDeferredCompiledInStructRegistration());
|
|
|
|
{
|
|
SCOPED_BOOT_TIMING("UObjectLoadAllCompiledInStructs - CreatePackages (could be optimized!)");
|
|
// Load Enums first
|
|
for (const FPendingEnumRegistrant& EnumRegistrant: PendingEnumRegistrants)
|
|
{
|
|
// Make sure the package exists in case it does not contain any UObjects
|
|
CreatePackage(EnumRegistrant.PackageName);
|
|
}
|
|
for (const FPendingStructRegistrant& StructRegistrant: PendingStructRegistrants)
|
|
{
|
|
// Make sure the package exists in case it does not contain any UObjects or UEnums
|
|
CreatePackage(StructRegistrant.PackageName);
|
|
}
|
|
}
|
|
|
|
// Load Structs
|
|
|
|
for (const FPendingEnumRegistrant& EnumRegistrant: PendingEnumRegistrants)
|
|
{
|
|
EnumRegistrant.RegisterFn();
|
|
}
|
|
|
|
for (const FPendingStructRegistrant& StructRegistrant: PendingStructRegistrants)
|
|
{
|
|
StructRegistrant.RegisterFn();
|
|
}
|
|
}
|
|
|
|
void ProcessNewlyLoadedUObjects(FName Package, bool bCanProcessNewlyLoadedObjects)
|
|
{
|
|
SCOPED_BOOT_TIMING("ProcessNewlyLoadedUObjects");
|
|
#if USE_PER_MODULE_UOBJECT_BOOTSTRAP
|
|
if (Package != NAME_None)
|
|
{
|
|
UObjectReleaseModuleRegistrants(Package);
|
|
}
|
|
#endif
|
|
if (!bCanProcessNewlyLoadedObjects)
|
|
{
|
|
return;
|
|
}
|
|
LLM_SCOPE(ELLMTag::UObject);
|
|
DECLARE_SCOPE_CYCLE_COUNTER(TEXT("ProcessNewlyLoadedUObjects"), STAT_ProcessNewlyLoadedUObjects, STATGROUP_ObjectVerbose);
|
|
|
|
UClassRegisterAllCompiledInClasses();
|
|
|
|
const TArray<UClass* (*)()>& DeferredCompiledInRegistration = GetDeferredCompiledInRegistration();
|
|
const TArray<FPendingStructRegistrant>& DeferredCompiledInStructRegistration = GetDeferredCompiledInStructRegistration();
|
|
const TArray<FPendingEnumRegistrant>& DeferredCompiledInEnumRegistration = GetDeferredCompiledInEnumRegistration();
|
|
|
|
bool bNewUObjects = false;
|
|
while (GFirstPendingRegistrant || DeferredCompiledInRegistration.Num() || DeferredCompiledInStructRegistration.Num() || DeferredCompiledInEnumRegistration.Num())
|
|
{
|
|
bNewUObjects = true;
|
|
UObjectProcessRegistrants();
|
|
UObjectLoadAllCompiledInStructs();
|
|
|
|
FCoreUObjectDelegates::CompiledInUObjectsRegisteredDelegate.Broadcast(Package);
|
|
|
|
UObjectLoadAllCompiledInDefaultProperties();
|
|
}
|
|
#if WITH_HOT_RELOAD
|
|
UClassReplaceHotReloadClasses();
|
|
#endif
|
|
|
|
if (bNewUObjects && !GIsInitialLoad)
|
|
{
|
|
UClass::AssembleReferenceTokenStreams();
|
|
}
|
|
}
|
|
|
|
static int32 GVarMaxObjectsNotConsideredByGC;
|
|
static FAutoConsoleVariableRef CMaxObjectsNotConsideredByGC(
|
|
TEXT("gc.MaxObjectsNotConsideredByGC"),
|
|
GVarMaxObjectsNotConsideredByGC,
|
|
TEXT("Placeholder console variable, currently not used in runtime."),
|
|
ECVF_Default);
|
|
|
|
static int32 GSizeOfPermanentObjectPool;
|
|
static FAutoConsoleVariableRef CSizeOfPermanentObjectPool(
|
|
TEXT("gc.SizeOfPermanentObjectPool"),
|
|
GSizeOfPermanentObjectPool,
|
|
TEXT("Placeholder console variable, currently not used in runtime."),
|
|
ECVF_Default);
|
|
|
|
static int32 GMaxObjectsInEditor;
|
|
static FAutoConsoleVariableRef CMaxObjectsInEditor(
|
|
TEXT("gc.MaxObjectsInEditor"),
|
|
GMaxObjectsInEditor,
|
|
TEXT("Placeholder console variable, currently not used in runtime."),
|
|
ECVF_Default);
|
|
|
|
static int32 GMaxObjectsInGame;
|
|
static FAutoConsoleVariableRef CMaxObjectsInGame(
|
|
TEXT("gc.MaxObjectsInGame"),
|
|
GMaxObjectsInGame,
|
|
TEXT("Placeholder console variable, currently not used in runtime."),
|
|
ECVF_Default);
|
|
|
|
/**
|
|
* Final phase of UObject initialization. all auto register objects are added to the main data structures.
|
|
*/
|
|
void UObjectBaseInit()
|
|
{
|
|
SCOPED_BOOT_TIMING("UObjectBaseInit");
|
|
|
|
// Zero initialize and later on get value from .ini so it is overridable per game/ platform...
|
|
int32 MaxObjectsNotConsideredByGC = 0;
|
|
int32 SizeOfPermanentObjectPool = 0;
|
|
int32 MaxUObjects = 2 * 1024 * 1024; // Default to ~2M UObjects
|
|
bool bPreAllocateUObjectArray = false;
|
|
|
|
// To properly set MaxObjectsNotConsideredByGC look for "Log: XXX objects as part of root set at end of initial load."
|
|
// in your log file. This is being logged from LaunchEnglineLoop after objects have been added to the root set.
|
|
|
|
// Disregard for GC relies on seekfree loading for interaction with linkers. We also don't want to use it in the Editor, for which
|
|
// FPlatformProperties::RequiresCookedData() will be false. Please note that GIsEditor and FApp::IsGame() are not valid at this point.
|
|
if (FPlatformProperties::RequiresCookedData())
|
|
{
|
|
FString Value;
|
|
bool bIsCookOnTheFly = FParse::Value(FCommandLine::Get(), TEXT("-filehostip="), Value);
|
|
if (bIsCookOnTheFly)
|
|
{
|
|
GCreateGCClusters = false;
|
|
}
|
|
else
|
|
{
|
|
GConfig->GetInt(TEXT("/Script/Engine.GarbageCollectionSettings"), TEXT("gc.MaxObjectsNotConsideredByGC"), MaxObjectsNotConsideredByGC, GEngineIni);
|
|
|
|
// Not used on PC as in-place creation inside bigger pool interacts with the exit purge and deleting UObject directly.
|
|
GConfig->GetInt(TEXT("/Script/Engine.GarbageCollectionSettings"), TEXT("gc.SizeOfPermanentObjectPool"), SizeOfPermanentObjectPool, GEngineIni);
|
|
}
|
|
|
|
// Maximum number of UObjects in cooked game
|
|
GConfig->GetInt(TEXT("/Script/Engine.GarbageCollectionSettings"), TEXT("gc.MaxObjectsInGame"), MaxUObjects, GEngineIni);
|
|
|
|
// If true, the UObjectArray will pre-allocate all entries for UObject pointers
|
|
GConfig->GetBool(TEXT("/Script/Engine.GarbageCollectionSettings"), TEXT("gc.PreAllocateUObjectArray"), bPreAllocateUObjectArray, GEngineIni);
|
|
}
|
|
else
|
|
{
|
|
#if IS_PROGRAM
|
|
// Maximum number of UObjects for programs can be low
|
|
MaxUObjects = 300000; // Default to 100K for programs
|
|
GConfig->GetInt(TEXT("/Script/Engine.GarbageCollectionSettings"), TEXT("gc.MaxObjectsInProgram"), MaxUObjects, GEngineIni);
|
|
#else
|
|
// Maximum number of UObjects in the editor
|
|
GConfig->GetInt(TEXT("/Script/Engine.GarbageCollectionSettings"), TEXT("gc.MaxObjectsInEditor"), MaxUObjects, GEngineIni);
|
|
#endif
|
|
}
|
|
|
|
if (MaxObjectsNotConsideredByGC <= 0 && SizeOfPermanentObjectPool > 0)
|
|
{
|
|
// If permanent object pool is enabled but disregard for GC is disabled, GC will mark permanent object pool objects
|
|
// as unreachable and may destroy them so disable permanent object pool too.
|
|
// An alternative would be to make GC not mark permanent object pool objects as unreachable but then they would have to
|
|
// be considered as root set objects because they could be referencing objects from outside of permanent object pool.
|
|
// This would be inconsistent and confusing and also counter productive (the more root set objects the more expensive MarkAsUnreachable phase is).
|
|
SizeOfPermanentObjectPool = 0;
|
|
UE_LOG(LogInit, Warning, TEXT("Disabling permanent object pool because disregard for GC is disabled (gc.MaxObjectsNotConsideredByGC=%d)."), MaxObjectsNotConsideredByGC);
|
|
}
|
|
|
|
// Log what we're doing to track down what really happens as log in LaunchEngineLoop doesn't report those settings in pristine form.
|
|
UE_LOG(LogInit, Log, TEXT("%s for max %d objects, including %i objects not considered by GC, pre-allocating %i bytes for permanent pool."),
|
|
bPreAllocateUObjectArray ? TEXT("Pre-allocating") : TEXT("Presizing"),
|
|
MaxUObjects, MaxObjectsNotConsideredByGC, SizeOfPermanentObjectPool);
|
|
|
|
GUObjectAllocator.AllocatePermanentObjectPool(SizeOfPermanentObjectPool);
|
|
GUObjectArray.AllocateObjectPool(MaxUObjects, MaxObjectsNotConsideredByGC, bPreAllocateUObjectArray);
|
|
|
|
void InitAsyncThread();
|
|
InitAsyncThread();
|
|
|
|
// Note initialized.
|
|
Internal::GetUObjectSubsystemInitialised() = true;
|
|
|
|
UObjectProcessRegistrants();
|
|
}
|
|
|
|
/**
|
|
* Final phase of UObject shutdown
|
|
*/
|
|
void UObjectBaseShutdown()
|
|
{
|
|
void ShutdownAsyncThread();
|
|
ShutdownAsyncThread();
|
|
|
|
GUObjectArray.ShutdownUObjectArray();
|
|
Internal::GetUObjectSubsystemInitialised() = false;
|
|
}
|
|
|
|
/**
|
|
* Helper function that can be used inside the debuggers watch window. E.g. "DebugFName(Class)".
|
|
*
|
|
* @param Object Object to look up the name for
|
|
* @return Associated name
|
|
*/
|
|
const TCHAR* DebugFName(UObject* Object)
|
|
{
|
|
if (Object)
|
|
{
|
|
// Hardcoded static array. This function is only used inside the debugger so it should be fine to return it.
|
|
static TCHAR TempName[256];
|
|
FName Name = Object->GetFName();
|
|
FCString::Strcpy(TempName, *FName::SafeString(Name.GetDisplayIndex(), Name.GetNumber()));
|
|
return TempName;
|
|
}
|
|
else
|
|
{
|
|
return TEXT("NULL");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper function that can be used inside the debuggers watch window. E.g. "DebugFName(Object)".
|
|
*
|
|
* @param Object Object to look up the name for
|
|
* @return Fully qualified path name
|
|
*/
|
|
const TCHAR* DebugPathName(UObject* Object)
|
|
{
|
|
if (Object)
|
|
{
|
|
// Hardcoded static array. This function is only used inside the debugger so it should be fine to return it.
|
|
static TCHAR PathName[1024];
|
|
PathName[0] = 0;
|
|
|
|
// Keep track of how many outers we have as we need to print them in inverse order.
|
|
UObject* TempObject = Object;
|
|
int32 OuterCount = 0;
|
|
while (TempObject)
|
|
{
|
|
TempObject = TempObject->GetOuter();
|
|
OuterCount++;
|
|
}
|
|
|
|
// Iterate over each outer + self in reverse oder and append name.
|
|
for (int32 OuterIndex = OuterCount - 1; OuterIndex >= 0; OuterIndex--)
|
|
{
|
|
// Move to outer name.
|
|
TempObject = Object;
|
|
for (int32 i = 0; i < OuterIndex; i++)
|
|
{
|
|
TempObject = TempObject->GetOuter();
|
|
}
|
|
|
|
// Dot separate entries.
|
|
if (OuterIndex != OuterCount - 1)
|
|
{
|
|
FCString::Strcat(PathName, TEXT("."));
|
|
}
|
|
// And app end the name.
|
|
FCString::Strcat(PathName, DebugFName(TempObject));
|
|
}
|
|
|
|
return PathName;
|
|
}
|
|
else
|
|
{
|
|
return TEXT("None");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper function that can be used inside the debuggers watch window. E.g. "DebugFName(Object)".
|
|
*
|
|
* @param Object Object to look up the name for
|
|
* @return Fully qualified path name prepended by class name
|
|
*/
|
|
const TCHAR* DebugFullName(UObject* Object)
|
|
{
|
|
if (Object)
|
|
{
|
|
// Hardcoded static array. This function is only used inside the debugger so it should be fine to return it.
|
|
static TCHAR FullName[1024];
|
|
FullName[0] = 0;
|
|
|
|
// Class Full.Path.Name
|
|
FCString::Strcat(FullName, DebugFName(Object->GetClass()));
|
|
FCString::Strcat(FullName, TEXT(" "));
|
|
FCString::Strcat(FullName, DebugPathName(Object));
|
|
|
|
return FullName;
|
|
}
|
|
else
|
|
{
|
|
return TEXT("None");
|
|
}
|
|
}
|
|
|
|
#if WITH_HOT_RELOAD
|
|
namespace
|
|
{
|
|
struct FObjectCompiledInfo
|
|
{
|
|
/** Registered struct info (including size and reflection info) */
|
|
static TMap<TTuple<UObject*, FName>, FObjectCompiledInfo>& GetRegisteredInfo()
|
|
{
|
|
static TMap<TTuple<UObject*, FName>, FObjectCompiledInfo> StructOrEnumCompiledInfoMap;
|
|
return StructOrEnumCompiledInfoMap;
|
|
}
|
|
|
|
FObjectCompiledInfo(SIZE_T InClassSize, uint32 InCrc)
|
|
: Size(InClassSize), Crc(InCrc)
|
|
{
|
|
}
|
|
|
|
SIZE_T Size;
|
|
uint32 Crc;
|
|
};
|
|
|
|
template <typename TType>
|
|
TType* FindExistingObjectIfHotReload(UObject* Outer, const TCHAR* Name, SIZE_T Size, uint32 Crc)
|
|
{
|
|
TTuple<UObject*, FName> Key(Outer, Name);
|
|
|
|
bool bChanged = true;
|
|
if (FObjectCompiledInfo* Info = FObjectCompiledInfo::GetRegisteredInfo().Find(Key))
|
|
{
|
|
// Hot-reloaded struct
|
|
bChanged = Info->Size != Size || Info->Crc != Crc;
|
|
|
|
Info->Size = Size;
|
|
Info->Crc = Crc;
|
|
}
|
|
else
|
|
{
|
|
// New struct
|
|
FObjectCompiledInfo::GetRegisteredInfo().Add(Key, FObjectCompiledInfo(Size, Crc));
|
|
}
|
|
|
|
if (!GIsHotReload)
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
TType* Existing = FindObject<TType>(Outer, Name);
|
|
if (!Existing)
|
|
{
|
|
// New type added during hot-reload
|
|
UE_LOG(LogClass, Log, TEXT("Could not find existing type %s for HotReload. Assuming new"), Name);
|
|
return nullptr;
|
|
}
|
|
|
|
// Existing type, make sure we destroy the old one if it has changed
|
|
if (bChanged)
|
|
{
|
|
// Make sure the old struct is not used by anything
|
|
Existing->ClearFlags(RF_Standalone | RF_Public);
|
|
Existing->RemoveFromRoot();
|
|
const FName OldRename = MakeUniqueObjectName(GetTransientPackage(), Existing->GetClass(), *FString::Printf(TEXT("HOTRELOADED_%s"), Name));
|
|
Existing->Rename(*OldRename.ToString(), GetTransientPackage());
|
|
return nullptr;
|
|
}
|
|
|
|
UE_LOG(LogClass, Log, TEXT("%s HotReload."), Name);
|
|
return Existing;
|
|
}
|
|
} // namespace
|
|
#endif // WITH_HOT_RELOAD
|
|
|
|
UScriptStruct* FindExistingStructIfHotReloadOrDynamic(UObject* Outer, const TCHAR* StructName, SIZE_T Size, uint32 Crc, bool bIsDynamic)
|
|
{
|
|
#if WITH_HOT_RELOAD
|
|
UScriptStruct* Result = FindExistingObjectIfHotReload<UScriptStruct>(Outer, StructName, Size, Crc);
|
|
#else
|
|
UScriptStruct* Result = nullptr;
|
|
#endif
|
|
if (!Result && bIsDynamic)
|
|
{
|
|
Result = Cast<UScriptStruct>(StaticFindObjectFast(UScriptStruct::StaticClass(), Outer, StructName));
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
UEnum* FindExistingEnumIfHotReloadOrDynamic(UObject* Outer, const TCHAR* EnumName, SIZE_T Size, uint32 Crc, bool bIsDynamic)
|
|
{
|
|
#if WITH_HOT_RELOAD
|
|
UEnum* Result = FindExistingObjectIfHotReload<UEnum>(Outer, EnumName, Size, Crc);
|
|
#else
|
|
UEnum* Result = nullptr;
|
|
#endif
|
|
if (!Result && bIsDynamic)
|
|
{
|
|
Result = Cast<UEnum>(StaticFindObjectFast(UEnum::StaticClass(), Outer, EnumName));
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
UObject* ConstructDynamicType(FName TypePathName, EConstructDynamicType ConstructionSpecifier)
|
|
{
|
|
UObject* Result = nullptr;
|
|
if (FDynamicClassStaticData* ClassConstructFn = GetDynamicClassMap().Find(TypePathName))
|
|
{
|
|
if (ConstructionSpecifier == EConstructDynamicType::CallZConstructor)
|
|
{
|
|
UClass* DynamicClass = ClassConstructFn->ZConstructFn();
|
|
check(DynamicClass);
|
|
DynamicClass->AssembleReferenceTokenStream();
|
|
Result = DynamicClass;
|
|
}
|
|
else if (ConstructionSpecifier == EConstructDynamicType::OnlyAllocateClassObject)
|
|
{
|
|
Result = ClassConstructFn->StaticClassFn();
|
|
check(Result);
|
|
}
|
|
}
|
|
else if (UScriptStruct * (**StaticStructFNPtr)() = GetDynamicStructMap().Find(TypePathName))
|
|
{
|
|
Result = (*StaticStructFNPtr)();
|
|
}
|
|
else if (UEnum * (**StaticEnumFNPtr)() = GetDynamicEnumMap().Find(TypePathName))
|
|
{
|
|
Result = (*StaticEnumFNPtr)();
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
FName GetDynamicTypeClassName(FName TypePathName)
|
|
{
|
|
FName Result = NAME_None;
|
|
if (GetDynamicClassMap().Find(TypePathName))
|
|
{
|
|
Result = UDynamicClass::StaticClass()->GetFName();
|
|
}
|
|
else if (GetDynamicStructMap().Find(TypePathName))
|
|
{
|
|
Result = UScriptStruct::StaticClass()->GetFName();
|
|
}
|
|
else if (GetDynamicEnumMap().Find(TypePathName))
|
|
{
|
|
Result = UEnum::StaticClass()->GetFName();
|
|
}
|
|
if (false && Result == NAME_None)
|
|
{
|
|
UE_LOG(LogUObjectBase, Warning, TEXT("GetDynamicTypeClassName %s not found."), *TypePathName.ToString());
|
|
UE_LOG(LogUObjectBase, Warning, TEXT("---- classes"));
|
|
for (auto& Pair: GetDynamicClassMap())
|
|
{
|
|
UE_LOG(LogUObjectBase, Warning, TEXT(" %s"), *Pair.Key.ToString());
|
|
}
|
|
UE_LOG(LogUObjectBase, Warning, TEXT("---- structs"));
|
|
for (auto& Pair: GetDynamicStructMap())
|
|
{
|
|
UE_LOG(LogUObjectBase, Warning, TEXT(" %s"), *Pair.Key.ToString());
|
|
}
|
|
UE_LOG(LogUObjectBase, Warning, TEXT("---- enums"));
|
|
for (auto& Pair: GetDynamicEnumMap())
|
|
{
|
|
UE_LOG(LogUObjectBase, Warning, TEXT(" %s"), *Pair.Key.ToString());
|
|
}
|
|
UE_LOG(LogUObjectBase, Fatal, TEXT("GetDynamicTypeClassName %s not found."), *TypePathName.ToString());
|
|
}
|
|
UE_CLOG(Result == NAME_None, LogUObjectBase, Warning, TEXT("GetDynamicTypeClassName %s not found."), *TypePathName.ToString());
|
|
return Result;
|
|
}
|
|
|
|
UPackage* FindOrConstructDynamicTypePackage(const TCHAR* PackageName)
|
|
{
|
|
UPackage* Package = Cast<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), nullptr, PackageName));
|
|
if (!Package)
|
|
{
|
|
Package = CreatePackage(PackageName);
|
|
if (!GEventDrivenLoaderEnabled)
|
|
{
|
|
Package->SetPackageFlags(PKG_CompiledIn);
|
|
}
|
|
}
|
|
check(Package);
|
|
return Package;
|
|
}
|
|
|
|
TMap<FName, FName>& GetConvertedDynamicPackageNameToTypeName()
|
|
{
|
|
static TMap<FName, FName> ConvertedDynamicPackageNameToTypeName;
|
|
return ConvertedDynamicPackageNameToTypeName;
|
|
}
|