BlueprintSupport.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "HAL/ThreadSingleton.h"
#include "Internationalization/Text.h"
#include "UObject/NameTypes.h"
#include "UObject/UObjectGlobals.h"
 
class FObjectInitializer;
class UClass;
class UObject;
class UPackage;
class UScriptStruct;
class UStruct;
struct FUObjectSerializeContext;
class ITargetPlatform;
 
struct FBlueprintTags
{
    static COREUOBJECT_API const FName GeneratedClassPath;
    static COREUOBJECT_API const FName ParentClassPath;
    static COREUOBJECT_API const FName NativeParentClassPath;
    static COREUOBJECT_API const FName ClassFlags;
    static COREUOBJECT_API const FName BlueprintType;
    static COREUOBJECT_API const FName BlueprintDescription;
    static COREUOBJECT_API const FName BlueprintDisplayName;
    static COREUOBJECT_API const FName BlueprintCategory;
    static COREUOBJECT_API const FName IsDataOnly;
    static COREUOBJECT_API const FName ImplementedInterfaces;
    static COREUOBJECT_API const FName FindInBlueprintsData;
    static COREUOBJECT_API const FName UnversionedFindInBlueprintsData;
    static COREUOBJECT_API const FName NumReplicatedProperties;
    static COREUOBJECT_API const FName NumNativeComponents;
    static COREUOBJECT_API const FName NumBlueprintComponents;
    static COREUOBJECT_API const FName BlueprintPathWithinPackage;
};
 
struct FBlueprintWarningDeclaration
{
    FBlueprintWarningDeclaration(FName InWarningIdentifier, FText InWarningDescription)
        : WarningIdentifier(InWarningIdentifier)
        , WarningDescription( InWarningDescription )
    {
    }
 
    FName WarningIdentifier;
    FText WarningDescription;
};
 
typedef void (*FFlushReinstancingQueueFPtr)();
typedef void (*FFlushCompilationQueueFPtr)(FUObjectSerializeContext*);
typedef void (*FClassReparentingFPtr)(const TMap<UClass*, UClass*>&);
 
struct FBlueprintSupport
{
    static void DuplicateAllFields(class UStruct* StructToDuplicate, class FDuplicateDataWriter& Writer);
 
    static bool UseDeferredDependencyLoading();
    static bool IsDeferredExportCreationDisabled();
    static bool IsDeferredCDOInitializationDisabled();
 
    static void FlushReinstancingQueue();
    static void FlushCompilationQueue(FUObjectSerializeContext* InLoadContext = nullptr);
    COREUOBJECT_API static void SetFlushReinstancingQueueFPtr(FFlushReinstancingQueueFPtr Ptr); 
    COREUOBJECT_API static void SetFlushCompilationQueueFPtr(FFlushCompilationQueueFPtr Ptr);
 
    COREUOBJECT_API static void ReparentHierarchies(const TMap<UClass*, UClass*>& OldClassToNewClass);
    COREUOBJECT_API static void SetClassReparentingFPtr(FClassReparentingFPtr Ptr);
 
    COREUOBJECT_API static bool IsDeferredDependencyPlaceholder(const UObject* LoadedObj);
 
#if WITH_EDITOR
    COREUOBJECT_API static void RegisterDeferredDependenciesInStruct(const UStruct* Struct, void* StructData);
#endif
 
    COREUOBJECT_API static void RepairDeferredDependenciesInObject(UObject* Object);
 
    static bool IsInBlueprintPackage(UObject* LoadedObj);
 
    COREUOBJECT_API static void RegisterBlueprintWarning(const FBlueprintWarningDeclaration& Warning);
    COREUOBJECT_API static const TArray<FBlueprintWarningDeclaration>& GetBlueprintWarnings();
    COREUOBJECT_API static void UpdateWarningBehavior(const TArray<FName>& WarningIdentifiersToTreatAsError, const TArray<FName>& WarningIdentifiersToSuppress);
    COREUOBJECT_API static bool ShouldTreatWarningAsError(FName WarningIdentifier);
    COREUOBJECT_API static bool ShouldSuppressWarning(FName WarningIdentifier);
 
    COREUOBJECT_API static bool IsClassPlaceholder(const UClass* Class);
 
#if WITH_EDITOR
    COREUOBJECT_API static void ValidateNoRefsToOutOfDateClasses();
 
    COREUOBJECT_API static void ValidateNoExternalRefsToSkeletons();
#endif
};
 
struct FScopedPlaceholderRawContainerTracker
{
public:
    COREUOBJECT_API FScopedPlaceholderRawContainerTracker(void* InData);
    COREUOBJECT_API ~FScopedPlaceholderRawContainerTracker();
 
private:
    void* Data;
};
 
#if WITH_EDITOR
struct FScopedClassDependencyGather
{
public:
    COREUOBJECT_API FScopedClassDependencyGather(UClass* ClassToGather, FUObjectSerializeContext* InLoadContext);
    COREUOBJECT_API ~FScopedClassDependencyGather();
 
    static COREUOBJECT_API TArray<UClass*> const& GetCachedDependencies();
 
private:
    bool bAuthoritativeClass;
 
    static UClass* BatchAuthorityClass;
 
    static TArray<UClass*> BatchClassDependencies;
 
    FUObjectSerializeContext* LoadContext;
 
    FScopedClassDependencyGather();
};
 
#endif // WITH_EDITOR
 
struct FDeferredInitializationTrackerBase
{
public:
    virtual ~FDeferredInitializationTrackerBase() {}
 
    FObjectInitializer* Add(const UObject* InitDependency, const FObjectInitializer& DeferringInitializer);
 
    void ResolveArchetypeInstances(UObject* ArchetypeKey);
 
    bool IsInitializationDeferred(const UObject* Object) const;
 
    virtual bool DeferPreload(UObject* Object);
 
protected:
    bool IsResolving(UObject* ArchetypeInstance) const;
 
    virtual bool ResolveDeferredInitialization(UObject* ResolvingObject, UObject* ArchetypeInstance);
 
    void PreloadDeferredDependents(UObject* ArchetypeInstance);
 
protected:
#if USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
    friend struct FDeferredObjInitializationHelper;
#endif
 
    TMultiMap<const UObject*, UObject*> ArchetypeInstanceMap;
    TMap<UObject*, FObjectInitializer> DeferredInitializers;
    TArray<UObject*> ResolvingObjects;
    TMultiMap<UObject*, UObject*> DeferredPreloads;
};
 
struct FDeferredCdoInitializationTracker : FDeferredInitializationTrackerBase, TThreadSingleton<FDeferredCdoInitializationTracker>
{
public:
    //~ FDeferredInitializationTrackerBase interface
    virtual bool DeferPreload(UObject* Object) override;
};
 
struct FDeferredSubObjInitializationTracker : FDeferredInitializationTrackerBase, TThreadSingleton<FDeferredSubObjInitializationTracker>
{
protected:
    //~ FDeferredInitializationTrackerBase interface
    virtual bool ResolveDeferredInitialization(UObject* ResolvingObject, UObject* ArchetypeInstance) override;
};
 
struct FDeferredObjInitializationHelper
{
    static FObjectInitializer* DeferObjectInitializerIfNeeded(const FObjectInitializer& DeferringInitializer);
 
    static bool DeferObjectPreload(UObject* Object);
 
    static void ResolveDeferredInitsFromArchetype(UObject* Archetype);
};