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
    {
        /*
         * Declaration shaped for Karma's game code
         * 
         * Contains reference to default constructor (defined in this file) and definition
         * for "Super", the base class and StaticClass()
         * 
         * Note: UObject's base class is UObject
         */
        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->GetInternalIndex())->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);
    }
}