Object.h

Go to the documentation of this file.

 
#pragma once
 
#include "UObjectBase.h"
#include "GFrameworkMacros.h"
 
namespace Karma
{
    class UClass;
 
    typedef UClass* (*StaticClassFunctionType)();
 
    template<class T>
    void InternalConstructor(const FObjectInitializer& X)
    {
        T::__DefaultConstructor(X);
    }
 
    KARMA_API void GetPrivateStaticClassBody(
        const std::string& PackageName,
        const std::string& Name,
        UClass*& ReturnClass,
        /*void(*RegisterNativeFunc)(),*/
        size_t InSize,
        size_t InAlignment,
        /*EClassFlags InClassFlags,
        EClassCastFlags InClassCastFlags,
        const TCHAR* InConfigName,*/
        ClassConstructorType InClassConstructor,
        /*UClass::ClassVTableHelperCtorCallerType InClassVTableHelperCtorCaller,
        FUObjectCppClassStaticFunctions&& InCppClassStaticFunctions,*/
        StaticClassFunctionType InSuperClassFn
        /*UClass::StaticClassFunctionType InWithinClassFn*/);
 
    KARMA_API void InitializePrivateStaticClass(
        class UClass* TClass_Super_StaticClass,
        class UClass* TClass_PrivateStaticClass,
        class UClass* TClass_WithinClass_StaticClass,
        const std::string& PackageName,
        const std::string& Name
    );
 
    class KARMA_API UObject : public UObjectBase
    {
        // In UE, this is done in ObjectMacros.h, #define DECLARE_CLASS
        DECLARE_KARMA_CLASS(UObject, UObject)
 
    private:
        //UClass* m_StaticClass;
 
    public:
        UObject();
 
        static const char* StaticConfigName()
        {
            return "Engine";
        }
 
        virtual void FinishDestroy();
 
        virtual const std::string& GetDesc() { static std::string someString = "";  return someString; }
 
    public:
        virtual class UWorld* GetWorld() const;
 
        bool IsValidChecked(const UObject* Test);
 
        virtual void BeginDestroy();
 
#if WITH_EDITOR
        virtual bool Modify(bool bAlwaysMarkDirty = true);
 
        bool CanModify() const;
#else
        FORCEINLINE bool Modify(bool bAlwaysMarkDirty = true) { return false; }
#endif
 
        bool IsSelected() const;
    };
 
    FORCEINLINE bool TentativeFlagChecks(const UObject* Test)
    {
        KR_CORE_ASSERT(GUObjectStore.IndexToObject(Test->GetInterIndex())->HasAnyFlags(EInternalObjectFlags(int32_t(EInternalObjectFlags::PendingKill) | int32_t(EInternalObjectFlags::Garbage))) == Test->HasAnyFlags(EObjectFlags(RF_PendingKill | RF_Garbage)), "");
 
        return !Test->HasAnyFlags(EObjectFlags(RF_PendingKill | RF_Garbage));
    }
 
    FORCEINLINE bool IsValid(const UObject* Test)
    {
        return Test && /*FInternalUObjectBaseUtilityIsValidFlagsChecker::CheckObjectValidBasedOnItsFlags(Test)*/ TentativeFlagChecks(Test);
    }
}