UObjectGlobals.h

Go to the documentation of this file.

 
#pragma once
 
#include "krpch.h"
 
namespace Karma
{
    class UObject;
    class AActor;
    class UClass;
    class UPackage;

    #define INVALID_OBJECT  (UObject*)-1

    typedef signed int          int32;

    template<typename Enum>
    constexpr bool EnumHasAnyFlags(Enum Flags, Enum Contains)
    {
        return(((__underlying_type(Enum))Flags) & (__underlying_type(Enum))Contains) != 0;
    }

    enum EClassFlags
    {
        CLASS_None = 0x00000000u,
        CLASS_Abstract = 0x00000001u,
        CLASS_DefaultConfig = 0x00000002u,
        CLASS_Config = 0x00000004u,
        CLASS_Transient = 0x00000008u,
        CLASS_Optional = 0x00000010u,
        CLASS_MatchedSerializers = 0x00000020u,
        CLASS_ProjectUserConfig = 0x00000040u,
        CLASS_Native = 0x00000080u,
        //CLASS_NoExport UE_DEPRECATED(5.1, "CLASS_NoExport should no longer be used. It is no longer being set by engine code.") = 0x00000100u,
        CLASS_NotPlaceable = 0x00000200u,
        CLASS_PerObjectConfig = 0x00000400u,

        CLASS_ReplicationDataIsSetUp = 0x00000800u,

        CLASS_EditInlineNew = 0x00001000u,
        CLASS_CollapseCategories = 0x00002000u,
        CLASS_Interface = 0x00004000u,
        //CLASS_CustomConstructor UE_DEPRECATED(5.1, "CLASS_CustomConstructor should no longer be used. It is no longer being set by engine code.") = 0x00008000u,
        CLASS_Const = 0x00010000u,

        CLASS_NeedsDeferredDependencyLoading = 0x00020000u,

        CLASS_CompiledFromBlueprint = 0x00040000u,

        CLASS_MinimalAPI = 0x00080000u,

        CLASS_RequiredAPI = 0x00100000u,

        CLASS_DefaultToInstanced = 0x00200000u,

        CLASS_TokenStreamAssembled = 0x00400000u,
        CLASS_HasInstancedReference = 0x00800000u,
        CLASS_Hidden = 0x01000000u,
        CLASS_Deprecated = 0x02000000u,
        CLASS_HideDropDown = 0x04000000u,
        CLASS_GlobalUserConfig = 0x08000000u,
        CLASS_Intrinsic = 0x10000000u,
        CLASS_Constructed = 0x20000000u,
        CLASS_ConfigDoNotCheckDefaults = 0x40000000u,
        CLASS_NewerVersionExists = 0x80000000u,
    };

    enum EPackageFlags
    {
        PKG_None = 0x00000000,  
        PKG_NewlyCreated = 0x00000001,  
        PKG_ClientOptional = 0x00000002,  
        PKG_ServerSideOnly = 0x00000004,   
        PKG_CompiledIn = 0x00000010,   
        PKG_ForDiffing = 0x00000020,  
        PKG_EditorOnly = 0x00000040,  
        PKG_Developer = 0x00000080,    
        PKG_UncookedOnly = 0x00000100,  
        PKG_Cooked = 0x00000200,  
        PKG_ContainsNoAsset = 0x00000400,    
        PKG_NotExternallyReferenceable = 0x00000800,   
        //  PKG_Unused                      = 0x00001000,
        PKG_UnversionedProperties = 0x00002000,   
        PKG_ContainsMapData = 0x00004000,   
        PKG_IsSaving = 0x00008000,  
        PKG_Compiling = 0x00010000,    
        PKG_ContainsMap = 0x00020000,    
        PKG_RequiresLocalizationGather = 0x00040000,  
        //  PKG_Unused                      = 0x00080000,
        PKG_PlayInEditor = 0x00100000,  
        PKG_ContainsScript = 0x00200000,  
        PKG_DisallowExport = 0x00400000,  
        //  PKG_Unused                      = 0x00800000,
        //  PKG_Unused                      = 0x01000000,
        //  PKG_Unused                      = 0x02000000,
        //  PKG_Unused                      = 0x04000000,
        PKG_CookGenerated = 0x08000000,    
        PKG_DynamicImports = 0x10000000,  
        PKG_RuntimeGenerated = 0x20000000,  
        PKG_ReloadingForCooker = 0x40000000,   
        PKG_FilterEditorOnly = 0x80000000,  
 
        // Transient Flags are cleared when serializing to or from PackageFileSummary
        PKG_TransientFlags = PKG_NewlyCreated | PKG_IsSaving | PKG_ReloadingForCooker,
    };

    enum EObjectFlags
    {
        // Do not add new flags unless they truly belong here. There are alternatives.
        // if you change any the bit of any of the RF_Load flags, then you will need legacy serialization
        RF_NoFlags = 0x00000000,  
 
        // This first group of flags mostly has to do with what kind of object it is. Other than transient, these are the persistent object flags.
        // The garbage collector also tends to look at these.
        RF_Public = 0x00000001,    
        RF_Standalone = 0x00000002,    
        RF_MarkAsNative = 0x00000004,    
        RF_Transactional = 0x00000008,  
        RF_ClassDefaultObject = 0x00000010,    
        RF_ArchetypeObject = 0x00000020,  
        RF_Transient = 0x00000040,  
 
        // This group of flags is primarily concerned with garbage collection.
        RF_MarkAsRootSet = 0x00000080,  
        RF_TagGarbageTemp = 0x00000100,    
 
        // The group of flags tracks the stages of the lifetime of a uobject
        RF_NeedInitialization = 0x00000200,    
        RF_NeedLoad = 0x00000400,    
        RF_KeepForCooker = 0x00000800,  
        RF_NeedPostLoad = 0x00001000,    
        RF_NeedPostLoadSubobjects = 0x00002000,    
        RF_NewerVersionExists = 0x00004000,    
        RF_BeginDestroyed = 0x00008000,    
        RF_FinishDestroyed = 0x00010000,  
 
        // Misc. Flags
        RF_BeingRegenerated = 0x00020000,    
        RF_DefaultSubObject = 0x00040000,    
        RF_WasLoaded = 0x00080000,  
        RF_TextExportTransient = 0x00100000,  
        RF_LoadCompleted = 0x00200000,  
        RF_InheritableComponentTemplate = 0x00400000, 
        RF_DuplicateTransient = 0x00800000,    
        RF_StrongRefOnFrame = 0x01000000,    
        RF_NonPIEDuplicateTransient = 0x02000000,    
        RF_Dynamic /*UE_DEPRECATED(5.0, "RF_Dynamic should no longer be used. It is no longer being set by engine code.")*/ = 0x04000000, 
        RF_WillBeLoaded = 0x08000000,    
        RF_HasExternalPackage = 0x10000000,    
 
        // RF_Garbage and RF_PendingKill are mirrored in EInternalObjectFlags because checking the internal flags is much faster for the Garbage Collector
        // while checking the object flags is much faster outside of it where the Object pointer is already available and most likely cached.
        // RF_PendingKill is mirrored in EInternalObjectFlags because checking the internal flags is much faster for the Garbage Collector
        // while checking the object flags is much faster outside of it where the Object pointer is already available and most likely cached.
 
        RF_PendingKill /*UE_DEPRECATED(5.0, "RF_PendingKill should not be used directly. Make sure references to objects are released using one of the existing engine callbacks or use weak object pointers.")*/ = 0x20000000,   
        RF_Garbage /*UE_DEPRECATED(5.0, "RF_Garbage should not be used directly. Use MarkAsGarbage and ClearGarbage instead.")*/ = 0x40000000,    
        RF_AllocatedInSharedPage = 0x80000000   
    };

    enum class EInternalObjectFlags : int32
    {
        None = 0,
 
        LoaderImport = 1 << 20, 
        Garbage = 1 << 21, 
        PersistentGarbage = 1 << 22, 
        ReachableInCluster = 1 << 23, 
        ClusterRoot = 1 << 24, 
        Native = 1 << 25, 
        Async = 1 << 26, 
        AsyncLoading = 1 << 27, 
        Unreachable = 1 << 28, 
        PendingKill /*UE_DEPRECATED(5.0, "PendingKill flag should no longer be used. Use Garbage flag instead.")*/ = 1 << 29, 
        RootSet = 1 << 30, 
        PendingConstruction = 1 << 31, 
 
        GarbageCollectionKeepFlags = Native | Async | AsyncLoading | LoaderImport,
        MirroredFlags = Garbage | PendingKill, 
 
        //~ Make sure this is up to date!
        AllFlags = LoaderImport | Garbage | PersistentGarbage | ReachableInCluster | ClusterRoot | Native | Async | AsyncLoading | Unreachable | PendingKill | RootSet | PendingConstruction
    };

    struct FUObjectItem
    {
        class UObjectBase* m_Object;

        int32_t m_InternalFlags;

        FUObjectItem() : m_Object(nullptr), m_InternalFlags(0)
        {
        }
 
        // Non-copyable
        FUObjectItem(FUObjectItem&&) = delete;
        FUObjectItem(const FUObjectItem&) = delete;
        FUObjectItem& operator=(FUObjectItem&&) = delete;
        FUObjectItem& operator=(const FUObjectItem&) = delete;

        FORCEINLINE void SetFlags(EInternalObjectFlags FlagsToSet)
        {
            KR_CORE_ASSERT((int32_t(FlagsToSet) & ~int32_t(EInternalObjectFlags::AllFlags)) == 0, "");
 
            m_InternalFlags = int32_t(FlagsToSet);
        }

        FORCEINLINE EInternalObjectFlags GetFlags() const
        {
            //return FPlatformAtomics::AtomicRead_Relaxed((int32*)&Flags);
            return EInternalObjectFlags(m_InternalFlags);
        }

        FORCEINLINE bool HasAnyFlags(EInternalObjectFlags InFlags) const
        {
                return !!(m_InternalFlags & int32_t(InFlags));
        }
    };

    class KARMA_API FUObjectArray : public KarmaVector<FUObjectItem*>
    {
    public:
        class TIterator
        {
        public:
            enum EEndTagType
            {
                EndTag
            };

            TIterator(const FUObjectArray& InArray, bool bOnlyGCedObjects = false) :
                m_Array(InArray),
                m_Index(-1),
                m_CurrentObject(nullptr)
            {
                if (bOnlyGCedObjects)
                {
                    //m_Index = m_Array.ObjLastNonGCIndex;
                }
                Advance();
            }

            TIterator(EEndTagType, const TIterator& InIter) :
                m_Array(InIter.m_Array)
            {
                m_Index = m_Array.Num();
            }

            FORCEINLINE void operator++()
            {
                Advance();
            }

            bool operator==(const TIterator& Rhs) const { return m_Index == Rhs.m_Index; }

            bool operator!=(const TIterator& Rhs) const { return m_Index != Rhs.m_Index; }

            FORCEINLINE explicit operator bool() const
            {
                return !!m_CurrentObject;
            }

            FORCEINLINE bool operator !() const
            {
                return !(bool)*this;
            }

            FORCEINLINE int32 GetIndex() const
            {
                return m_Index;
            }
 
        protected:

            FORCEINLINE FUObjectItem* GetObject() const
            {
                return m_CurrentObject;
            }

            FORCEINLINE bool Advance()
            {
                //@todo UE check this for LHS on Index on consoles
                FUObjectItem* NextObject = nullptr;
                m_CurrentObject = nullptr;
                while(++m_Index < m_Array.GetObjectsList().size())
                {
                    NextObject = m_Array.GetObjectsList()[m_Index];
                    if (NextObject->m_Object)
                    {
                        m_CurrentObject = NextObject;
                        return true;
                    }
                }
                return false;
            }

            const FUObjectArray& GetIteratedArray() const
            {
                return m_Array;
            }
 
        private:
            const FUObjectArray& m_Array;
            int32_t m_Index;

            mutable FUObjectItem* m_CurrentObject;
        };
 
    public:
        void AddUObject(UObject* Object);

        const std::vector<FUObjectItem*>& GetObjectsList() const { return m_Elements; }

        bool IsValid(const UObjectBase* Object) const;
    };

    class KarmaClassObjectMap : public KarmaMap<UClass*, KarmaVector<UObject*>*>
    {
    public:

        KarmaClassObjectMap()
        {}

        ~KarmaClassObjectMap();

        KarmaVector<UObject*>* FindClassObjects(const UClass* Key);

        KarmaVector<UObject*>* FindOrAddClass(const UClass* Key);
    };

    extern KARMA_API FUObjectArray GUObjectStore;

    extern KARMA_API KarmaClassObjectMap m_ClassToObjectVectorMap;

    struct FStaticConstructObjectParameters
    {
        const UClass* m_Class;

        UObject* m_Outer;

        std::string m_Name;

        EObjectFlags m_SetFlags = EObjectFlags::RF_NoFlags;

        EInternalObjectFlags m_InternalSetFlags = EInternalObjectFlags::None;

        bool m_bCopyTransientsFromClassDefaults = false;

        bool m_bAssumeTemplateIsArchetype = false;

        UObject* m_Template = nullptr;

        //FObjectInstancingGraph* InstanceGraph = nullptr;

        //UPackage* ExternalPackage = nullptr;

        //TFunction<void()> PropertyInitCallback;

        //FObjectInstancingGraph* InstanceGraph = nullptr;
 
    private:
        //FObjectInitializer::FOverrides* SubobjectOverrides = nullptr;
 
    public:
 
        //COREUOBJECT_API FStaticConstructObjectParameters(const UClass* InClass);
 
        //friend FObjectInitializer;
    };

namespace ECastCheckedType
{
    enum Type
    {
        NullAllowed,
        NullChecked
    };
};

template <class T, class U>
FORCEINLINE T* CastChecked(const U& Src, ECastCheckedType::Type CheckType = ECastCheckedType::NullChecked)
{
    if (Src)
    {
        T* Result = static_cast<T*>(Src);// this line may need some generalization, I will come back later
        if (!Result)
        {
            KR_CORE_ERROR("Casting failed");
        }
 
        return Result;
    }
 
    if (CheckType == ECastCheckedType::NullChecked)
    {
        KR_CORE_ASSERT(false, "Attempting to cast nullptr");
    }
 
    return nullptr;
}

KARMA_API UObject* StaticConstructObject_Internal(const FStaticConstructObjectParameters& Params);

KARMA_API UObject* StaticAllocateObject(const UClass* Class, UObject* InOuter, const std::string& name, EObjectFlags SetFlags = EObjectFlags::RF_NoFlags, EInternalObjectFlags InternalSetFlags = EInternalObjectFlags::None);
 

template< class T >
FUNCTION_NON_NULL_RETURN_START
T* NewObject(UObject* Outer, const UClass* Class, std::string name = "No_Name", EObjectFlags Flags = RF_NoFlags, UObject* Template = nullptr, bool bCopyTransientsFromClassDefaults = false/*, FObjectInstancingGraph* InInstanceGraph = nullptr, UPackage* ExternalPackage = nullptr*/)
FUNCTION_NON_NULL_RETURN_END
{
    if (name == "")
    {
        KR_CORE_ASSERT(false, "NewObject with empty name can't be used to create default subobjects");
        //FObjectInitializer::AssertIfInConstructor(Outer, TEXT("NewObject with empty name can't be used to create default subobjects (inside of UObject derived class constructor) as it produces inconsistent object names. Use ObjectInitializer.CreateDefaultSubobject<> instead."));
    }
 
    FStaticConstructObjectParameters Params;
    Params.m_Class = Class;
    Params.m_Outer = Outer;
    Params.m_Name = name;
    Params.m_SetFlags = Flags;
    Params.m_Class = Class;
    //Params.m_Template = Template;
    Params.m_bCopyTransientsFromClassDefaults = bCopyTransientsFromClassDefaults;
    //Params.InstanceGraph = InInstanceGraph;
    //Params.ExternalPackage = ExternalPackage;
 
    return static_cast<T*>(StaticConstructObject_Internal(Params));
}
/*
template< class T >
FUNCTION_NON_NULL_RETURN_START*/
//T* NewObject(UObject* Outer, const std::string& Name, EObjectFlags Flags = RF_NoFlags, UObject* Template = nullptr, bool bCopyTransientsFromClassDefaults = false/*, FObjectInstancingGraph* InInstanceGraph = nullptr*/)
/*FUNCTION_NON_NULL_RETURN_END
{
    if (Name == "")
    {
        KR_CORE_ASSERT(false, "NewObject with empty name can't be used to create default subobjects");
        //FObjectInitializer::AssertIfInConstructor(Outer, TEXT("NewObject with empty name can't be used to create default subobjects (inside of UObject derived class constructor) as it produces inconsistent object names. Use ObjectInitializer.CreateDefaultSubobject<> instead."));
    }
 
    FStaticConstructObjectParameters Params;// (T::StaticClass());
    Params.m_Outer = Outer;
    Params.m_Name = Name;
    Params.m_SetFlags = Flags;
    //Params.Template = Template;
    Params.m_bCopyTransientsFromClassDefaults = bCopyTransientsFromClassDefaults;
    Params.m_Class = T::StaticClass<T>();
    //Params.InstanceGraph = InInstanceGraph;
 
    return static_cast<T*>(StaticConstructObject_Internal(Params));
}*/

KARMA_API UObject* StaticFindObjectFastInternal(const UClass* ObjectClass, const UObject* ObjectPackage, const std::string& ObjectName, bool bExactClass = false, EObjectFlags ExcludeFlags = RF_NoFlags, EInternalObjectFlags ExclusiveInternalFlags = EInternalObjectFlags::None);

 KARMA_API UObject* StaticFindObject(UClass* Class, UObject* InOuter, const std::string& Name, bool ExactClass = false);

template< class T >
inline KARMA_API T* FindObject(UObject* Outer, const std::string& Name, bool ExactClass = false)
{
    return (T*)StaticFindObjectFastInternal(T::StaticClass(), Outer, Name, ExactClass);
}

KARMA_API UPackage* CreatePackage(const std::string& PackageName);

KARMA_API void GetObjectsOfClass(const UClass* ClassToLookFor, KarmaVector<UObject *>& Results, bool bIncludeDerivedClasses = true, EObjectFlags ExcludeFlags = RF_ClassDefaultObject, EInternalObjectFlags ExclusionInternalFlags = EInternalObjectFlags::None);

KARMA_API void ForEachObjectOfClass(const UClass* ClassToLookFor, std::function<void(UObject*)> Operation, bool bIncludeDerivedClasses = true, EObjectFlags ExcludeFlags = RF_ClassDefaultObject, EInternalObjectFlags ExclusionInternalFlags = EInternalObjectFlags::None);

typedef void (*FUObjectAllocatorCallback)(void* InObject, const std::string& InName, size_t InSize, size_t InAlignment, class UClass* InClass);

KARMA_API extern void RegisterUObjectsStatisticsCallback(FUObjectAllocatorCallback dumpCallback);

KARMA_API void CacheObject(class UObject* Object);
 
// Global Internal functions
extern void StaticUObjectInit();
extern UPackage* GetTransientPackage();

    class KARMA_API FObjectInitializer
    {
        public:
            FObjectInitializer();

            FObjectInitializer(UObject* InObj, UObject* InObjectArchetype, bool bInCopyTransientsFromClassDefaults, bool  bInShouldInitializeProps, struct FObjectInstancingGraph* InInstanceGraph = nullptr);
 
            ~FObjectInitializer();

            FORCEINLINE UObject* GetObj() const
            {
                return m_Object;
            }
 
        private:
            friend class UObject;
 
            template<class T>
            friend void InternalConstructor(const class FObjectInitializer& X);

            void PostConstructInit();

            static void InitProperties(UObject* Object, UClass* DefaultsClass, UObject* DefaultData, bool   bCopyTransientsFromClassDefaults);
 
        private:
            UObject* m_Object;

            UObject* m_ObjectArchetype;

            bool m_bCopyTransientsFromClassDefaults;

            bool m_bShouldInitializePropsFromArchetype;

            bool m_bSubobjectClassInitializationAllowed;

            UObject* m_LastConstructedObject;
    };
}