unreal3对象管理模块分析

凡是稍微大一点的引擎框架，必然都要自己搞一套对象管理机制，如mfc、qt、glib等等，unreal自然也不例外。

究其原因，还是c++这种静态语言天生的不足，缺乏运行时类型操作功能，对于复杂庞大的逻辑层来说极为不便，查错和调优都很困难。

因此，这类框架自制对象管理模块的功能通常都包括：

1、运行时类型信息获取

  a、总共有哪些类，各自之间的继承关系怎样？简单来说，能否在运行时print一个类的继承链图出来。

  b、给你一个最基类指针，你能准确知道他实际是哪个子类的，有哪些方法、属性？

2、运行时类型创建及调用

  a、给你一个字符串名字，能否创建该类的对象？

  b、给你一些字符串方法或属性名，能否调用之？包括正确的参数和返回值处理

3、对象生命期的管理

  a、所有已创建的对象，是否都能追踪遍历？

  b、对象所占据内存，是否都有分门别类统计？

  c、对象是否支持gc？

4、各种杂项

  a、对象是否支持序列化？

  b、对象是否支持由脚本创建调用？

  c、对象是否支持设计时模式？也就是在编辑里呈现出另一种效果，可即时修改属性观察变化。

 

以上种种，通常都被各类框架不厌其烦的实现很多次了，即使在自己写的稍大一点的项目里，也或多或少做过类似的事，区别只是所谓商业级引擎，会做得更极致，更完善罢了。

而这些功能，其实都是java里的标配，在c++里却不得不各种重新发明轮子，这也说明c++在大工程架构方面先天不足，惟一的优势就是速度快，而游戏引擎极其注重性能，所以不得不在c++的基础上，重新添加大量类Java功能，以求性能和易用的结合。

 

在unreal3里，实现此模块的两个核心类分别是：

1、UObject：基本上是所有逻辑层类的祖基类，“一切皆是对象”，而每个对象必定属于一个类型，所以UObject里面有一个UClass* Class字段，就指向它的类型

2、UClass：这个就是表示一个类型的类，与UObject有大量的子类不同，UClass没有子类，它只是用不同的实例（携带不同属性）来表示各种类型。

举例来说，UObject的两个子类UCommandlet和UComponent，分别代表命令小工具和组件，它们各自有一个对应的UClass实例来描述自身类型信息。每一个Unrealscript类，也都有一个UClass实例与之对应。

这些UClass实例的创建过程也正好分类两类：

一是native类，即生成了C++头文件的，那么其中就包含相应的创建代码，相当于是手动写死链接的。

二是纯脚本类，它们的UClass实例是在加载Package时，由解析代码动态创建的。

 

UObject类型系统的实现：

在每个UObject子类的声明里，都有类似如下的宏：

DECLARE_ABSTRACT_CLASS(UCommandlet,UObject,0|CLASS_Transient,Core)

其中DECLARE_ABSTRACT_CLASS可能有DECLARE_CLASS、DECLARE_CASTED_CLASS、DECLARE_CLASS_INTRINSIC等变种，用于设定继承时的各类性质差别，其核心最后都转到【DECLARE_BASE_CLASS_LIGHTWEIGHT】：

#define DECLARE_BASE_CLASS_LIGHTWEIGHT( TClass, TSuperClass, TStaticFlags, TStaticCastFlags, TPackage ) \
public: \
    friend void AutoCheckNativeClassSizes##TPackage( UBOOL& Mismatch ); \
    /* Identification */ \
    enum {StaticClassFlags=TStaticFlags}; \
    enum {StaticClassCastFlags=TStaticCastFlags}; \
    private: \
    static UClass* PrivateStaticClass; \
    TClass & operator=(TClass const &);   \
    public: \
    typedef TSuperClass Super;\
    typedef TClass ThisClass;\
    static UClass* GetPrivateStaticClass##TClass( const TCHAR* Package ); \
    static void InitializePrivateStaticClass##TClass(); \
    static UClass* StaticClass() \
    { \
        if (!PrivateStaticClass) \
        { \
            PrivateStaticClass = GetPrivateStaticClass##TClass( TEXT(#TPackage) ); \
            InitializePrivateStaticClass##TClass(); \
        } \
        return PrivateStaticClass; \
    } \
    void* operator new( const size_t InSize, UObject* InOuter=(UObject*)GetTransientPackage(), FName InName=NAME_None, EObjectFlags InSetFlags=0 ) \
        { return StaticAllocateObject( StaticClass(), InOuter, InName, InSetFlags ); } \
    void* operator new( const size_t InSize, EInternal* InMem ) \
        { return (void*)InMem; }

这里的关键：

1、static UClass* PrivateStaticClass; 这就是每个类型对应的那个UClass*实例了

2、static UClass* StaticClass(); 这个就是初始化函数，在程序启动时，每个包每个(native)类的该函数都会被调用，相当于注册，其中通过GetPrivateStaticClasssXXX来创建UClass*实例，然后调用InitializePrivateStaticClassXXX来初始化其属性。这两个函数的实现在后面说明。

3、重载了两个new操作符，也就是设定了其内存分配函数到自己的StaticAllocateObject中，里面执行大量跟踪统计逻辑。

 

然后在每个UObject子类的实现中，都有如下宏：

IMPLEMENT_CLASS(UCommandlet);

最后展开为：

#define IMPLEMENT_CLASS_LIGHTWEIGHT(TClass) \
    UClass* TClass::PrivateStaticClass = NULL; \
    UClass* TClass::GetPrivateStaticClass##TClass( const TCHAR* Package ) \
    { \
        UClass* ReturnClass; \
        ReturnClass = ::new UClass \
        ( \
            EC_StaticConstructor, \
            sizeof(TClass), \
            StaticClassFlags, \
            StaticClassCastFlags, \
            TEXT(#TClass) + 1 + ((StaticClassFlags & CLASS_Deprecated) ? 11 : 0), \
            Package, \
            StaticConfigName(), \
            RF_Public | RF_Standalone | RF_Transient | RF_Native | RF_RootSet | RF_DisregardForGC, \
            (void(*)(void*))TClass::InternalConstructor, \
            (void(UObject::*)())&TClass::StaticConstructor, \
            (void(UObject::*)())&TClass::InitializeIntrinsicPropertyValues \
        ); \
        check(ReturnClass); \
        return ReturnClass; \
    } \
    /* Called from ::StaticClass after GetPrivateStaticClass */ \
    void TClass::InitializePrivateStaticClass##TClass() \
    { \
        InitializePrivateStaticClass( TClass::Super::StaticClass(), TClass::PrivateStaticClass, TClass::WithinClass::StaticClass() ); \
    }

这里就是GetPrivateStaticClasssXXX和InitializePrivateStaticClassXXX的定义了。

GetPrivateStaticClasssXXX里面：以【EC_StaticConstructor模式】（一般静态链接都是这种，如使用dll动态链接则会走另一套流程）new了一个UClass出来，注意这里new前面的::，即全局默认new，并非上面被重载过的StaticAllocateObject，也就是说UClass是一类特殊的UObject，它的内存分配不需要走专用流程，最后其返回值会存在PrivateStaticClass静态变量，达到每个类一个UClass*实例的目的。

InitializePrivateStaticClassXXX里面：以父类的UClass、自己的UClass、外包类的UClass为参数，调用InitializePrivateStaticClass进行初始化，其内容也很简单：

void InitializePrivateStaticClass( class UClass* TClass_Super_StaticClass, class UClass* TClass_PrivateStaticClass, class UClass* TClass_WithinClass_StaticClass )
{
    /* No recursive ::StaticClass calls allowed. Setup extras. */
    if (TClass_Super_StaticClass != TClass_PrivateStaticClass)
    {
        TClass_PrivateStaticClass->SuperStruct = TClass_Super_StaticClass;
    }
    else
    {
        TClass_PrivateStaticClass->SuperStruct = NULL;
    }
    TClass_PrivateStaticClass->ClassWithin = TClass_WithinClass_StaticClass;
    TClass_PrivateStaticClass->SetClass(UClass::StaticClass());

    /* Perform UObject native registration. */
    if( TClass_PrivateStaticClass->GetInitialized() && TClass_PrivateStaticClass->GetClass()==TClass_PrivateStaticClass->StaticClass() )
    {
        TClass_PrivateStaticClass->Register();
    }
}

除了设置SuperStruct、ClassWithin等字段引用相应对象外，有趣的一句是setClass那里：它将自己设成了自己的Class。

前面说过“一切皆是对象”、“对象必有类型”，那么推出“类型也必是对象”，于是“类型对象也要有类型”，似乎要陷入死循环了，这里就用此种特殊的方式终止了循环：当一个对象的Class属性指向UClass::StaticClass()时，它自身必是一个UClass对象。

另外，注意InitializePrivateStaticClassXXX的实参：它本是在当前类的StaticClass中被调用，但又调用了另2个类的StaticClass()函数（加上UClass::StaticClass()就有3个），所以可能引发递归调用：

上例发生的原因是：首先调用根基类UObject::StaticClass()，在创建好它的UClass实例后调InitializePrivateStaticClass做初始化，其中又调用到UClass::StaticClass()（setClass那句），而UClass的WithinClass为UPackage，所以又进入了UPackage::StaticClass()……

直到各种基类初始化完成后，才逐步下降还原到当前层。

而顶层的UObject中，也声明了必要的边界条件以结束此递归：

class UObject
#if VTABLE_AT_END_OF_CLASS
    : public UObjectBase
#endif
{
    // Declarations.
    DECLARE_BASE_CLASS(UObject,UObject,CLASS_Abstract|CLASS_NoExport,CASTCLASS_None,Core)
    typedef UObject WithinClass;
    ……
}

在这里，TSuperClass和WithinClass都声明为自身，这样一旦PrivateStaticClass被赋值后，后续对StaticClass的调用就不会再转入InitializePrivateStaticClassXXX，而是直接返回已有的PrivateStaticClass了。

 

原理大致就如上，再从整体角度观察一下实际流程：

1、每个工程都有一个AutoInitializeRegistrantsXXX函数（XXX为工程名，如Core，Engine），它主要就是对本工程的所有UObject子类调用StaticClass()做初始化，这个函数是由编译解析脚本时自动生成的。（脚本相关内容后面再详说）

void AutoInitializeRegistrantsCore( INT& Lookup )
{
    AUTO_INITIALIZE_REGISTRANTS_CORE
}

#define AUTO_INITIALIZE_REGISTRANTS_CORE \
    UObject::StaticClass(); \
    GNativeLookupFuncs.Set(FName("Object"), GCoreUObjectNatives); \
    UCommandlet::StaticClass(); \
    UHelpCommandlet::StaticClass(); \
    UComponent::StaticClass(); \
    UDistributionFloat::StaticClass(); \
    GNativeLookupFuncs.Set(FName("DistributionFloat"), GCoreUDistributionFloatNatives); \
    UDistributionVector::StaticClass(); \
    GNativeLookupFuncs.Set(FName("DistributionVector"), GCoreUDistributionVectorNatives); \
    UExporter::StaticClass(); \

由于上面提到递归调用问题，各类初始的顺序不一定与代码所写一样，以AUTO_INITIALIZE_REGISTRANTS_CORE为例，它里面各类的实际顺序如下：（倒过来看）

 

第一个是UObject，第二个是UClass，可见其重要性。

2、这些AutoInitializeRegistrantsXXX函数在程序启动时被调用，它们为所包含的所有UObject子类调用StaticClass()函数

3、每个UObject子类的StaticClass()函数里会new出其对应的UClass*实例，存放在该类的PrivateStaticClass静态变量上。

 

以上就是各类及其UClass生成的过程了，至于UClass里面到底有什么，后续再分析。