Blueprint.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Misc/Guid.h"
#include "UObject/Class.h"
#include "Templates/SubclassOf.h"
#include "Engine/EngineTypes.h"
#include "EdGraph/EdGraphPin.h"
#include "Engine/BlueprintCore.h"
#include "Blueprint/BlueprintPropertyGuidProvider.h"
#include "UObject/SoftObjectPath.h"
#include "Blueprint/BlueprintSupport.h"
 
#if WITH_EDITOR
#include "EngineLogs.h"
#include "Kismet2/CompilerResultsLog.h"
#endif
 
#include "Blueprint.generated.h"
 
enum class EBlueprintCompileOptions;
class ITargetPlatform;
class UActorComponent;
class UEdGraph;
class FKismetCompilerContext;
class UInheritableComponentHandler;
class UBlueprintExtension;
class UBlueprintGeneratedClass;
class FBlueprintActionDatabaseRegistrar;
struct FBPComponentClassOverride;
struct FDiffResults;
 
UENUM()
enum EBlueprintStatus : int
{
    BS_Unknown,
    BS_Dirty,
    BS_Error,
    BS_UpToDate,
    BS_BeingCreated,
    BS_UpToDateWithWarnings,
    BS_MAX,
};
 
 
UENUM()
enum EBlueprintType : int
{
    BPTYPE_Normal               UMETA(DisplayName="Blueprint Class"),
    BPTYPE_Const                UMETA(DisplayName="Const Blueprint Class"),
    BPTYPE_MacroLibrary         UMETA(DisplayName="Blueprint Macro Library"),
    BPTYPE_Interface            UMETA(DisplayName="Blueprint Interface"),
    BPTYPE_LevelScript          UMETA(DisplayName="Level Blueprint"),
    BPTYPE_FunctionLibrary      UMETA(DisplayName="Blueprint Function Library"),
 
    BPTYPE_MAX,
};
 
 
namespace EKismetCompileType
{
    enum Type
    {
        SkeletonOnly,
        Full,
        StubAfterFailure, 
        BytecodeOnly,
        // Cpp type was removed with BP nativization
    };
};
 
UCLASS(deprecated)
class UDEPRECATED_Breakpoint : public UObject
{
    GENERATED_BODY()
};
 
UENUM()
enum class EBlueprintCompileMode : uint8
{
    Default UMETA(DisplayName="Use Default", ToolTip="Use the default setting."),
    Development UMETA(ToolTip="Always compile in development mode (even when cooking)."),
    FinalRelease UMETA(ToolTip="Always compile in final release mode.")
};
 
USTRUCT()
struct FBlueprintMacroCosmeticInfo
{
    GENERATED_BODY()
 
    // Does this macro contain one or more latent nodes?
    bool bContainsLatentNodes;
 
    FBlueprintMacroCosmeticInfo()
        : bContainsLatentNodes(false)
    {
    }
};
 
struct FKismetCompilerOptions
{
public:
    EKismetCompileType::Type    CompileType;
 
    bool bSaveIntermediateProducts;
 
    bool bRegenerateSkelton;
 
    bool bIsDuplicationInstigated;
 
    bool bReinstanceAndStubOnFailure;
 
    bool bSkipDefaultObjectValidation;
 
    bool bSkipFiBSearchMetaUpdate;
 
    bool bUseDeltaSerializationDuringReinstancing;
 
    bool bSkipNewVariableDefaultsDetection;
 
    TSharedPtr<FString> OutHeaderSourceCode;
    TSharedPtr<FString> OutCppSourceCode;
 
    bool DoesRequireBytecodeGeneration() const
    {
        return (CompileType == EKismetCompileType::Full) 
            || (CompileType == EKismetCompileType::BytecodeOnly);
    }
 
    FKismetCompilerOptions()
        : CompileType(EKismetCompileType::Full)
        , bSaveIntermediateProducts(false)
        , bRegenerateSkelton(true)
        , bIsDuplicationInstigated(false)
        , bReinstanceAndStubOnFailure(true)
        , bSkipDefaultObjectValidation(false)
        , bSkipFiBSearchMetaUpdate(false)
    {
    };
};
 
USTRUCT()
struct FBPVariableMetaDataEntry
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, Category=BPVariableMetaDataEntry)
    FName DataKey;
 
    UPROPERTY(EditAnywhere, Category=BPVariableMetaDataEntry)
    FString DataValue;
 
    FBPVariableMetaDataEntry() {}
    FBPVariableMetaDataEntry(const FName InKey, FString InValue)
        : DataKey(InKey)
        , DataValue(MoveTemp(InValue))
    {}
};
 
 
USTRUCT()
struct FBPVariableDescription
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, Category=BPVariableDescription)
    FName VarName;
 
    UPROPERTY()
    FGuid VarGuid;
 
    UPROPERTY(EditAnywhere, Category=BPVariableDescription)
    struct FEdGraphPinType VarType;
 
    UPROPERTY(EditAnywhere, Category=BPVariableDescription)
    FString FriendlyName;
 
    UPROPERTY(EditAnywhere, Category=BPVariableDescription)
    FText Category;
 
    UPROPERTY(EditAnywhere, Category=BPVariableDescription)
    uint64 PropertyFlags;
 
    UPROPERTY(EditAnywhere, Category=BPVariableRepNotify)
    FName RepNotifyFunc;
 
    UPROPERTY(EditAnywhere, Category=BPVariableDescription)
    TEnumAsByte<ELifetimeCondition> ReplicationCondition;
 
    UPROPERTY(EditAnywhere, Category=BPVariableDescription)
    TArray<struct FBPVariableMetaDataEntry> MetaDataArray;
 
    UPROPERTY(EditAnywhere, Category=BPVariableDescription)
    FString DefaultValue;
 
    ENGINE_API FBPVariableDescription();
 
    ENGINE_API void SetMetaData(FName Key, FString Value);
    ENGINE_API const FString& GetMetaData(FName Key) const;
    ENGINE_API void RemoveMetaData(FName Key);
    ENGINE_API int32 FindMetaDataEntryIndexForKey(FName Key) const;
    ENGINE_API bool HasMetaData(FName Key) const;
    
};
 
 
USTRUCT()
struct FBPInterfaceDescription
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TSubclassOf<class UInterface>  Interface;
 
    UPROPERTY()
    TArray<TObjectPtr<UEdGraph>> Graphs;
 
 
    FBPInterfaceDescription()
        : Interface(nullptr)
    { }
};
 
 
USTRUCT()
struct FEditedDocumentInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    FSoftObjectPath EditedObjectPath;
 
    UPROPERTY()
    FDeprecateSlateVector2D SavedViewOffset;
 
    UPROPERTY()
    float SavedZoomAmount;
 
    FEditedDocumentInfo()
        : SavedViewOffset(0.0f, 0.0f)
        , SavedZoomAmount(-1.0f)
        , EditedObject_DEPRECATED(nullptr)
    { }
 
    FEditedDocumentInfo(UObject* InEditedObject)
        : EditedObjectPath(InEditedObject)
        , SavedViewOffset(0.0f, 0.0f)
        , SavedZoomAmount(-1.0f)
        , EditedObject_DEPRECATED(nullptr)
    { }
 
    FEditedDocumentInfo(UObject* InEditedObject, const UE::Slate::FDeprecateVector2DParameter& InSavedViewOffset, float InSavedZoomAmount)
        : EditedObjectPath(InEditedObject)
        , SavedViewOffset(InSavedViewOffset)
        , SavedZoomAmount(InSavedZoomAmount)
        , EditedObject_DEPRECATED(nullptr)
    { }
 
    void PostSerialize(const FArchive& Ar)
    {
        if (Ar.IsLoading() && EditedObject_DEPRECATED)
        {
            // Convert hard to soft reference.
            EditedObjectPath = EditedObject_DEPRECATED;
            EditedObject_DEPRECATED = nullptr;
        }
    }
 
    friend bool operator==(const FEditedDocumentInfo& LHS, const FEditedDocumentInfo& RHS)
    {
        return LHS.EditedObjectPath == RHS.EditedObjectPath && LHS.SavedViewOffset == RHS.SavedViewOffset && LHS.SavedZoomAmount == RHS.SavedZoomAmount;
    }
 
private:
    // Legacy hard reference is now serialized as a soft reference (see above).
    UPROPERTY()
    TObjectPtr<UObject> EditedObject_DEPRECATED;
};
 
template<>
struct TStructOpsTypeTraits<FEditedDocumentInfo> : public TStructOpsTypeTraitsBase2<FEditedDocumentInfo>
{
    enum
    {
        WithPostSerialize = true
    };
};
 
USTRUCT()
struct FBPEditorBookmarkNode
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    FGuid NodeGuid;
 
    UPROPERTY()
    FGuid ParentGuid;
 
    UPROPERTY()
    FText DisplayName;
 
    friend bool operator==(const FBPEditorBookmarkNode& LHS, const FBPEditorBookmarkNode& RHS)
    {
        return LHS.NodeGuid == RHS.NodeGuid;
    }
};
 
UENUM()
enum class EShouldCookBlueprintPropertyGuids
{
    No,
    Yes,
    Inherit,
};
 
#if WITH_EDITOR
enum class EGetObjectOrWorldBeingDebuggedFlags
{
    None = 0,
    IgnorePendingKill = 1 << 0
};
 
ENUM_CLASS_FLAGS(EGetObjectOrWorldBeingDebuggedFlags);
#endif
 
 
UCLASS(config=Engine, MinimalAPI)
class UBlueprint : public UBlueprintCore, public IBlueprintPropertyGuidProvider
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY(meta=(NoResetToDefault))
    TSubclassOf<UObject> ParentClass;
 
    UPROPERTY(AssetRegistrySearchable)
    TEnumAsByte<enum EBlueprintType> BlueprintType;
 
    UPROPERTY(config)
    uint8 bRecompileOnLoad:1;
 
    UPROPERTY(transient)
    uint8 bHasBeenRegenerated:1;
 
    UPROPERTY(transient)
    uint8 bIsRegeneratingOnLoad:1;
 
#if WITH_EDITORONLY_DATA
 
    UPROPERTY(transient)
    uint8 bBeingCompiled:1;
 
    UPROPERTY(transient)
    uint8 bIsNewlyCreated : 1;
 
    UPROPERTY(transient)
    uint8 bForceFullEditor : 1;
 
    UPROPERTY(transient)
    uint8 bQueuedForCompilation : 1 ;
 
    UPROPERTY(EditAnywhere, Category=BlueprintOptions)
    uint8 bRunConstructionScriptOnDrag : 1;
 
    UPROPERTY(EditAnywhere, Category=BlueprintOptions)
    uint8 bRunConstructionScriptInSequencer : 1;
 
    UPROPERTY(EditAnywhere, Category=ClassOptions, AdvancedDisplay)
    uint8 bGenerateConstClass : 1;
 
    UPROPERTY(EditAnywhere, Category = ClassOptions, AdvancedDisplay)
    uint8 bGenerateAbstractClass : 1;
 
    UPROPERTY(transient)
    uint8 bDisplayCompilePIEWarning:1;
 
    UPROPERTY(EditAnywhere, Category=ClassOptions, AdvancedDisplay)
    uint8 bDeprecate:1;
 
    UPROPERTY()
    mutable uint8 bDuplicatingReadOnly:1;
 
    UPROPERTY(EditAnywhere, Category=ClassOptions, AdvancedDisplay, meta=(DisplayName="Should Cook Property Guids?"))
    EShouldCookBlueprintPropertyGuids ShouldCookPropertyGuidsValue = EShouldCookBlueprintPropertyGuids::Inherit;
 
    ENGINE_API bool ShouldCookPropertyGuids() const;
 
public:
    UPROPERTY(EditAnywhere, Category=ClassOptions, AdvancedDisplay)
    EBlueprintCompileMode CompileMode;
 
    UPROPERTY(transient)
    TEnumAsByte<enum EBlueprintStatus> Status;
 
    UPROPERTY(EditAnywhere, Category=BlueprintOptions, DuplicateTransient)
    FString BlueprintDisplayName;
 
    UPROPERTY(EditAnywhere, Category=BlueprintOptions, meta=(MultiLine=true), DuplicateTransient)
    FString BlueprintDescription;
 
    UPROPERTY(EditAnywhere, Category = BlueprintOptions, AssetRegistrySearchable)
    FString BlueprintNamespace;
 
    UPROPERTY(EditAnywhere, Category=BlueprintOptions)
    FString BlueprintCategory;
 
    UPROPERTY(EditAnywhere, Category=BlueprintOptions)
    TArray<FString> HideCategories;
 
#endif //WITH_EDITORONLY_DATA
 
    UPROPERTY()
    int32 BlueprintSystemVersion;
 
    UPROPERTY()
    TObjectPtr<class USimpleConstructionScript> SimpleConstructionScript;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TArray<TObjectPtr<UEdGraph>> UbergraphPages;
 
    UPROPERTY()
    TArray<TObjectPtr<UEdGraph>> FunctionGraphs;
 
    UPROPERTY()
    TArray<TObjectPtr<UEdGraph>> DelegateSignatureGraphs;
 
    UPROPERTY()
    TArray<TObjectPtr<UEdGraph>> MacroGraphs;
 
    UPROPERTY(transient, duplicatetransient)
    TArray<TObjectPtr<UEdGraph>> IntermediateGeneratedGraphs;
 
    UPROPERTY(transient, duplicatetransient)
    TArray<TObjectPtr<UEdGraph>> EventGraphs;
 
    UPROPERTY(Transient)
    TMap<TObjectPtr<UEdGraph>, FBlueprintMacroCosmeticInfo> PRIVATE_CachedMacroInfo;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY()
    TArray<TObjectPtr<class UActorComponent>> ComponentTemplates;
 
    UPROPERTY()
    TArray<TObjectPtr<class UTimelineTemplate>> Timelines;
 
    UPROPERTY()
    TArray<FBPComponentClassOverride> ComponentClassOverrides;
 
    UPROPERTY()
    TObjectPtr<class UInheritableComponentHandler> InheritableComponentHandler;
 
#if WITH_EDITORONLY_DATA
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnExtensionAdded, UBlueprintExtension*);
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnExtensionRemoved, UBlueprintExtension*);
 
    UPROPERTY()
    TArray<FBPVariableDescription> NewVariables;
 
    UPROPERTY()
    TArray<FBPVariableDescription> GeneratedVariables;
 
    UPROPERTY()
    TArray<FName> CategorySorting;
 
    UPROPERTY(AssetRegistrySearchable)
    TSet<FString> ImportedNamespaces;
 
    UPROPERTY(AssetRegistrySearchable)
    TArray<struct FBPInterfaceDescription> ImplementedInterfaces;
    
    UPROPERTY()
    TArray<struct FEditedDocumentInfo> LastEditedDocuments;
 
    UPROPERTY()
    TMap<FGuid, struct FEditedDocumentInfo> Bookmarks;
 
    UPROPERTY()
    TArray<FBPEditorBookmarkNode> BookmarkNodes;
 
    // moved to FPerBlueprintSettings
    UPROPERTY()
    TArray<TObjectPtr<class UDEPRECATED_Breakpoint>> Breakpoints_DEPRECATED;
 
    // moved to FPerBlueprintSettings
    UPROPERTY()
    TArray<FEdGraphPinReference> WatchedPins_DEPRECATED;
 
    UPROPERTY()
    TArray<TObjectPtr<class UEdGraphPin_Deprecated>> DeprecatedPinWatches;
 
    UPROPERTY()
    TMap<FName, int32> ComponentTemplateNameIndex;
 
    UPROPERTY(transient)
    TMap<FName, FName> OldToNewComponentTemplateNames;
 
    UE_DEPRECATED(5.1, "Please do not access this member directly; Instead use: UBlueprint::GetExtensions / UBlueprint::AddExtension / UBlueprint::RemoveExtension[At].")
    UPROPERTY()
    TArray<TObjectPtr<UBlueprintExtension>> Extensions;
 
    FOnExtensionAdded OnExtensionAdded;
 
    FOnExtensionRemoved OnExtensionRemoved;
#endif // WITH_EDITORONLY_DATA
 
public:
 
#if WITH_EDITOR
    DECLARE_EVENT_OneParam( UBlueprint, FChangedEvent, class UBlueprint* );
    FChangedEvent& OnChanged() { return ChangedEvent; }
 
    void BroadcastChanged() { ChangedEvent.Broadcast(this); }
 
    DECLARE_EVENT_OneParam(UBlueprint, FCompiledEvent, class UBlueprint*);
    FCompiledEvent& OnCompiled() { return CompiledEvent; }
    void BroadcastCompiled() { CompiledEvent.Broadcast(this); }
 
    ENGINE_API TArrayView<const TObjectPtr<UBlueprintExtension>> GetExtensions() const;
 
    ENGINE_API int32 AddExtension(const TObjectPtr<UBlueprintExtension>& InExtension);
 
    ENGINE_API int32 RemoveExtension(const TObjectPtr<UBlueprintExtension>& InExtension);
 
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    template <class PREDICATE_CLASS>
    int32 RemoveAllExtension(const PREDICATE_CLASS& Predicate)
    {
        auto BroadcastRemovePredicate = [&Predicate, this](UBlueprintExtension* InExtension)
        {
            bool NotMatch = !::Invoke(Predicate, InExtension); // use a ! to guarantee it can't be anything other than zero or one
 
            if (!NotMatch)
            {
                OnExtensionRemoved.Broadcast(InExtension);
            }
 
            return !NotMatch;
        };
 
        return Extensions.RemoveAll(BroadcastRemovePredicate);
    }
PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
#endif // WITH_EDITOR
 
    virtual bool IsValidForBytecodeOnlyRecompile() const { return true; }
    
    virtual bool ShouldAutomaticallyRegisterInputOnConstruction() const { return false; }
 
#if WITH_EDITORONLY_DATA
    DECLARE_EVENT_OneParam(UBlueprint, FOnSetObjectBeingDebugged, UObject* /*InDebugObj*/);
    FOnSetObjectBeingDebugged& OnSetObjectBeingDebugged() { return OnSetObjectBeingDebuggedDelegate; }
 
protected:
    TWeakObjectPtr< UObject > CurrentObjectBeingDebugged;
 
    FString ObjectPathToDebug;
 
    TWeakObjectPtr< class UWorld > CurrentWorldBeingDebugged;
 
    FOnSetObjectBeingDebugged OnSetObjectBeingDebuggedDelegate;
 
public:
 
    UPROPERTY(VisibleAnywhere, Instanced, Category=Thumbnail)
    TObjectPtr<class UThumbnailInfo> ThumbnailInfo;
 
    UPROPERTY(transient, duplicatetransient)
    uint32 CrcLastCompiledCDO;
 
    UPROPERTY(transient, duplicatetransient)
    uint32 CrcLastCompiledSignature;
 
    UPROPERTY(transient, duplicatetransient)
    bool bCachedDependenciesUpToDate;
 
    UPROPERTY(transient, duplicatetransient)
    TSet<TWeakObjectPtr<UBlueprint>> CachedDependencies;
 
    UPROPERTY(transient, duplicatetransient)
    TSet<TWeakObjectPtr<UBlueprint>> CachedDependents;
 
    UPROPERTY(transient, duplicatetransient)
    TSet<TWeakObjectPtr<UStruct>> CachedUDSDependencies;
 
    // If this BP is just a duplicate created for a specific compilation, the reference to original GeneratedClass is needed
    UPROPERTY(transient, duplicatetransient)
    TObjectPtr<UClass> OriginalClass;
 
    bool IsUpToDate() const
    {
        return BS_UpToDate == Status || BS_UpToDateWithWarnings == Status;
    }
 
    bool IsPossiblyDirty() const
    {
        return (BS_Dirty == Status) || (BS_Unknown == Status);
    }
#endif // WITH_EDITORONLY_DATA
 
#if WITH_EDITOR
    virtual bool RequiresForceLoadMembers(UObject* InObject) const { return true; }
 
    static ENGINE_API bool ForceLoad(UObject* Obj);
 
    static ENGINE_API void ForceLoadMembers(UObject* InObject);
 
    static ENGINE_API void ForceLoadMembers(UObject* InObject, const UBlueprint* InBlueprint);
 
    static ENGINE_API bool ValidateGeneratedClass(const UClass* InClass);
 
    ENGINE_API UActorComponent* FindTemplateByName(const FName& TemplateName) const;
 
    ENGINE_API class UTimelineTemplate* FindTimelineTemplateByVariableName(const FName& TimelineName);  
 
    ENGINE_API const class UTimelineTemplate* FindTimelineTemplateByVariableName(const FName& TimelineName) const;  
 
    void GetBlueprintClassNames(FName& GeneratedClassName, FName& SkeletonClassName, FName NameOverride = NAME_None) const
    {
        FName NameToUse = (NameOverride != NAME_None) ? NameOverride : GetFName();
 
        const FString GeneratedClassNameString = FString::Printf(TEXT("%s_C"), *NameToUse.ToString());
        GeneratedClassName = FName(*GeneratedClassNameString);
 
        const FString SkeletonClassNameString = FString::Printf(TEXT("SKEL_%s_C"), *NameToUse.ToString());
        SkeletonClassName = FName(*SkeletonClassNameString);
    }
    
    void GetBlueprintCDONames(FName& GeneratedClassName, FName& SkeletonClassName, FName NameOverride = NAME_None) const
    {
        FName NameToUse = (NameOverride != NAME_None) ? NameOverride : GetFName();
 
        const FString GeneratedClassNameString = FString::Printf(TEXT("Default__%s_C"), *NameToUse.ToString());
        GeneratedClassName = FName(*GeneratedClassNameString);
 
        const FString SkeletonClassNameString = FString::Printf(TEXT("Default__SKEL_%s_C"), *NameToUse.ToString());
        SkeletonClassName = FName(*SkeletonClassNameString);
    }
 
    ENGINE_API virtual UClass* GetBlueprintClass() const;
 
    // Should the generic blueprint factory work for this blueprint?
    virtual bool SupportedByDefaultBlueprintFactory() const
    {
        return true;
    }
 
    // Compile this prefab, overriding this methods give a chance to derived classes to specify extra default compilation flags
    ENGINE_API virtual EBlueprintCompileOptions GetDefaultCompileOptions() const;
 
    ENGINE_API virtual void SetObjectBeingDebugged(UObject* NewObject);
 
    ENGINE_API virtual void UnregisterObjectBeingDebugged();
 
    ENGINE_API virtual void SetWorldBeingDebugged(UWorld* NewWorld);
 
    ENGINE_API virtual void GetReparentingRules(TSet< const UClass* >& AllowedChildrenOfClasses, TSet< const UClass* >& DisallowedChildrenOfClasses) const;
 
    virtual bool AlwaysCompileOnLoad() const { return false; }
 
    ENGINE_API virtual bool CanAlwaysRecompileWhilePlayingInEditor() const;
 
private:
 
    ENGINE_API void DebuggingWorldRegistrationHelper(UObject* ObjectProvidingWorld, UObject* ValueToRegister);
    
    static void ForceLoadGraph(UObject* Object);
public:
 
    UObject* GetObjectBeingDebugged(EGetObjectOrWorldBeingDebuggedFlags InFlags = EGetObjectOrWorldBeingDebuggedFlags::None) const
    {
        const bool bEvenIfPendingKill = EnumHasAnyFlags(InFlags, EGetObjectOrWorldBeingDebuggedFlags::IgnorePendingKill);
        return CurrentObjectBeingDebugged.Get(bEvenIfPendingKill);
    }
 
    const FString& GetObjectPathToDebug() const
    {
        return ObjectPathToDebug;
    }
 
    class UWorld* GetWorldBeingDebugged(EGetObjectOrWorldBeingDebuggedFlags InFlags = EGetObjectOrWorldBeingDebuggedFlags::None) const
    {
        const bool bEvenIfPendingKill = EnumHasAnyFlags(InFlags, EGetObjectOrWorldBeingDebuggedFlags::IgnorePendingKill);
        return CurrentWorldBeingDebugged.Get(bEvenIfPendingKill);
    }
 
    ENGINE_API virtual bool RenameGeneratedClasses(const TCHAR* NewName = nullptr, UObject* NewOuter = nullptr, ERenameFlags Flags = REN_None);
 
    //~ Begin UObject Interface (WITH_EDITOR)
    ENGINE_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
    ENGINE_API virtual bool Rename(const TCHAR* NewName = nullptr, UObject* NewOuter = nullptr, ERenameFlags Flags = REN_None) override;
    ENGINE_API virtual UClass* RegenerateClass(UClass* ClassToRegenerate, UObject* PreviousCDO) override;
    ENGINE_API virtual void PostLoad() override;
#if WITH_EDITORONLY_DATA
    static ENGINE_API void DeclareConstructClasses(TArray<FTopLevelAssetPath>& OutConstructClasses, const UClass* SpecificSubclass);
#endif
    ENGINE_API virtual bool Modify(bool bAlwaysMarkDirty = true) override;
    ENGINE_API virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const override;
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    ENGINE_API virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const override;
protected:
    ENGINE_API virtual void ThreadedPostLoadAssetRegistryTagsOverride(FPostLoadAssetRegistryTagsContext& Context) const override;
public:
    UE_DEPRECATED(5.5, "This function is no longer called. See UObject::PostLoadAssetRegistryTags for more information.")
    static ENGINE_API void PostLoadBlueprintAssetRegistryTags(const FAssetData& InAssetData, TArray<FAssetRegistryTag>& OutTagsAndValuesToUpdate);
    
    static ENGINE_API void PostLoadBlueprintAssetRegistryTags(FPostLoadAssetRegistryTagsContext& Context);
    ENGINE_API virtual FPrimaryAssetId GetPrimaryAssetId() const override;
    ENGINE_API virtual void BeginCacheForCookedPlatformData(const ITargetPlatform *TargetPlatform) override;
    ENGINE_API virtual bool IsCachedCookedPlatformDataLoaded(const ITargetPlatform* TargetPlatform) override;
    ENGINE_API virtual void ClearAllCachedCookedPlatformData() override;
    ENGINE_API virtual void BeginDestroy() override;
    //~ End UObject Interface
 
    ENGINE_API void RemoveChildRedirectors();
 
    ENGINE_API void RemoveGeneratedClasses();
 
    ENGINE_API virtual FString GetFriendlyName() const;
 
    ENGINE_API virtual bool AllowsDynamicBinding() const;
 
    ENGINE_API virtual bool SupportsInputEvents() const;
 
    ENGINE_API bool ChangeOwnerOfTemplates();
 
    ENGINE_API UInheritableComponentHandler* GetInheritableComponentHandler(bool bCreateIfNecessary);
 
    ENGINE_API virtual void GatherDependencies(TSet<TWeakObjectPtr<UBlueprint>>& InDependencies) const;
 
    ENGINE_API virtual void ReplaceDeprecatedNodes();
 
    ENGINE_API virtual void ClearEditorReferences();
 
    ENGINE_API virtual EDataValidationResult IsDataValid(class FDataValidationContext& Context) const override;
 
    ENGINE_API virtual bool FindDiffs(const UBlueprint* OtherBlueprint, FDiffResults& Results) const;
 
    ENGINE_API void ConformNativeComponents();
#endif  //#if WITH_EDITOR
 
    //~ Begin IBlueprintPropertyGuidProvider interface
    ENGINE_API virtual FName FindBlueprintPropertyNameFromGuid(const FGuid& PropertyGuid) const override final;
    ENGINE_API virtual FGuid FindBlueprintPropertyGuidFromName(const FName PropertyName) const override final;
    //~ End IBlueprintPropertyGuidProvider interface
 
    //~ Begin UObject Interface
#if WITH_EDITORONLY_DATA
    ENGINE_API virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
    ENGINE_API virtual void GetPreloadDependencies(TArray<UObject*>& OutDeps) override;
#endif // WITH_EDITORONLY_DATA
#if WITH_EDITOR
    ENGINE_API virtual void OnCookEvent(UE::Cook::ECookEvent CookEvent, UE::Cook::FCookEventContext& CookContext) override;
#endif
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual FString GetDesc(void) override;
    ENGINE_API virtual void TagSubobjects(EObjectFlags NewFlags) override;
    ENGINE_API virtual bool NeedsLoadForClient() const override;
    ENGINE_API virtual bool NeedsLoadForServer() const override;
    ENGINE_API virtual bool NeedsLoadForEditorGame() const override;
    ENGINE_API virtual bool HasNonEditorOnlyReferences() const override;
    //~ End UObject Interface
 
#if WITH_EDITORONLY_DATA
    static ENGINE_API UBlueprint* GetBlueprintFromClass(const UClass* InClass);
 
    static ENGINE_API bool GetBlueprintHierarchyFromClass(const UClass* InClass, TArray<UBlueprint*>& OutBlueprintParents);
#endif
 
    static ENGINE_API bool GetBlueprintHierarchyFromClass(const UClass* InClass, TArray<UBlueprintGeneratedClass*>& OutBlueprintParents);
 
private:
    static ENGINE_API bool GetBlueprintHierarchyFromClass(const UClass* InClass, TArray<IBlueprintPropertyGuidProvider*>& OutBlueprintParents);
 
public:
#if WITH_EDITOR
    static ENGINE_API bool IsBlueprintHierarchyErrorFree(const UClass* InClass);
#endif
 
    template<class TFieldType>
    static FName GetFieldNameFromClassByGuid(const UClass* InClass, const FGuid VarGuid)
    {
        FProperty* AssertPropertyType = (TFieldType*)0;
 
        TArray<IBlueprintPropertyGuidProvider*> BlueprintPropertyGuidProviders;
        UBlueprint::GetBlueprintHierarchyFromClass(InClass, BlueprintPropertyGuidProviders);
 
        for (IBlueprintPropertyGuidProvider* BlueprintPropertyGuidProvider : BlueprintPropertyGuidProviders)
        {
            const FName FoundPropertyName = BlueprintPropertyGuidProvider->FindBlueprintPropertyNameFromGuid(VarGuid);
            if (FoundPropertyName != NAME_None)
            {
                return FoundPropertyName;
            }
        }
 
        return NAME_None;
    }
 
    template<class TFieldType>
    static bool GetGuidFromClassByFieldName(const UClass* InClass, const FName VarName, FGuid& VarGuid)
    {
        FProperty* AssertPropertyType = (TFieldType*)0;
 
        TArray<IBlueprintPropertyGuidProvider*> BlueprintPropertyGuidProviders;
        UBlueprint::GetBlueprintHierarchyFromClass(InClass, BlueprintPropertyGuidProviders);
 
        for (IBlueprintPropertyGuidProvider* BlueprintPropertyGuidProvider : BlueprintPropertyGuidProviders)
        {
            const FGuid FoundPropertyGuid = BlueprintPropertyGuidProvider->FindBlueprintPropertyGuidFromName(VarName);
            if (FoundPropertyGuid.IsValid())
            {
                VarGuid = FoundPropertyGuid;
                return true;
            }
        }
 
        return false;
    }
    
#if WITH_EDITOR
    static ENGINE_API FName GetFunctionNameFromClassByGuid(const UClass* InClass, const FGuid FunctionGuid);
    static ENGINE_API bool GetFunctionGuidFromClassByFieldName(const UClass* InClass, const FName FunctionName, FGuid& FunctionGuid);
 
    ENGINE_API UEdGraph* GetLastEditedUberGraph() const;
 
    /* Notify the blueprint when a graph is renamed to allow for additional fixups. */
    virtual void NotifyGraphRenamed(class UEdGraph* Graph, FName OldName, FName NewName) { }
#endif
 
#if WITH_EDITOR
    static ENGINE_API UClass* GetBlueprintParentClassFromAssetTags(const FAssetData& BlueprintAsset);
#endif
 
    ENGINE_API ETimelineSigType GetTimelineSignatureForFunctionByName(const FName& FunctionName, const FName& ObjectPropertyName);
 
    static int32 GetCurrentBlueprintSystemVersion()
    {
        return 2;
    }
 
    ENGINE_API void GetAllGraphs(TArray<UEdGraph*>& Graphs) const;
 
    virtual void GetTypeActions(FBlueprintActionDatabaseRegistrar& ActionRegistrar) const {}
 
    virtual void GetInstanceActions(FBlueprintActionDatabaseRegistrar& ActionRegistrar) const {}
 
    virtual bool ShouldBeMarkedDirtyUponTransaction() const { return true; }
 
#if WITH_EDITOR
private:
 
    FChangedEvent ChangedEvent;
 
    FCompiledEvent CompiledEvent;
 
public:
    FCompilerResultsLog* CurrentMessageLog;
 
    TSharedPtr<FCompilerResultsLog> UpgradeNotesLog;
 
    TSharedPtr<FCompilerResultsLog> PreCompileLog;
 
    template<typename... ArgTypes>
    void Message_Note(const FString& MessageToLog, ArgTypes... Args)
    {
        if (CurrentMessageLog)
        {
            CurrentMessageLog->Note(*MessageToLog, Forward<ArgTypes>(Args)...);
        }
        else
        {
            UE_LOG(LogBlueprint, Log, TEXT("[%s] %s"), *GetName(), *MessageToLog);
        }
    }
 
    template<typename... ArgTypes>
    void Message_Warn(const FString& MessageToLog, ArgTypes... Args)
    {
        if (CurrentMessageLog)
        {
            CurrentMessageLog->Warning(*MessageToLog, Forward<ArgTypes>(Args)...);
        }
        else
        {
            UE_LOG(LogBlueprint, Warning, TEXT("[%s] %s"), *GetName(), *MessageToLog);
        }
    }
 
    template<typename... ArgTypes>
    void Message_Error(const FString& MessageToLog, ArgTypes... Args)
    {
        if (CurrentMessageLog)
        {
            CurrentMessageLog->Error(*MessageToLog, Forward<ArgTypes>(Args)...);
        }
        else
        {
            UE_LOG(LogBlueprint, Error, TEXT("[%s] %s"), *GetName(), *MessageToLog);
        }
    }
#endif
    
#if WITH_EDITORONLY_DATA
protected:
    ENGINE_API virtual void LoadModulesRequiredForCompilation();
#endif
 
#if WITH_EDITOR
 
public:
    virtual bool SupportsGlobalVariables() const { return true; }
 
    virtual bool SupportsLocalVariables() const { return true; }
 
    virtual bool SupportsFunctions() const { return true; }
 
    virtual bool AllowFunctionOverride(const UFunction* const InFunction) const { return true; }
        
    virtual bool SupportsMacros() const { return true; }
 
    virtual bool SupportsDelegates() const { return true; }
 
    virtual bool SupportsEventGraphs() const { return true; }
 
    virtual bool SupportsAnimLayers() const { return false; }
 
    virtual bool ExportGraphToText(UEdGraph* InEdGraph, FString& OutText) { return false; }
 
    virtual bool CanImportGraphFromText(const FString& InClipboardText) { return false; }
 
    virtual bool TryImportGraphFromText(const FString& InClipboardText, UEdGraph** OutGraphPtr = nullptr) { return false; }
 
#endif
};
 
 
template<>
inline FName UBlueprint::GetFieldNameFromClassByGuid<UFunction>(const UClass* InClass, const FGuid FunctionGuid)
{
#if WITH_EDITOR
    return GetFunctionNameFromClassByGuid(InClass, FunctionGuid);
#else   // WITH_EDITOR
    return NAME_None;
#endif  // WITH_EDITOR
}
 
template<>
inline bool UBlueprint::GetGuidFromClassByFieldName<UFunction>(const UClass* InClass, const FName FunctionName, FGuid& FunctionGuid)
{
#if WITH_EDITOR
    return GetFunctionGuidFromClassByFieldName(InClass, FunctionName, FunctionGuid);
#else   // WITH_EDITOR
    return false;
#endif  // WITH_EDITOR
}