UE4——反射原理（一）

向右看齐 2022-12-31 05:29 409阅读 0赞

UE4——反射原理（一）

上一篇文章
里面提到了UE4反射系统的基本原理与应用，这次我们通过代码来深入研究一下UE4的反射系统，因为反射系统在UE4中牵扯的东西较多，所以我打算分几篇文章分析。我这里假定读者对UE4有一定的了解并且有一定的C++基础，如果不了解UE4如何使用，那么请先学会如何使用UE4引擎，否则看起来可能会比较困难。

以下是我整理的一个跟反射系统相关的类图：
在这里插入图片描述
由于最上面的类图尺寸过大，上传后的图片并不是特别清晰，高清原图可以在这里下载。

从上面可以看出UObject是整个反射系统核心，UE4中支持反射的类型在上一篇文章中已经说过，包括 C++类、结构体、函数 、成员变量以及枚举，也支持TArray（只支持一些如TArray和TSubclassOf的模板类型，并且它们的模板类型不能是嵌套的类型），但是TMap不支持。而这些东西的支持与上面的类是分不开的，比如UClass、UBlueprintGeneratedClass、UFunction、UEnum、以及UProperty，以及继承自它们的子类。每一个继承UObject且支持反射系统类型都有一个相对应 的UClass,或者它的子类（比如蓝图对应的课表UBlueprintGeneratedClass类，它继承自UClass），如果是特定的蓝图类型，比如动作蓝图、Widget蓝图等，如上图所示。UMetaData是元数据，它存储了一些编辑器需要的额外信息，比如它的分类（Category ）、提示（Tooltip）等，最终打包的时候是不会用到这些信息的。至于我们反射系统里需要访问的float、int32等变量，则都是由继承自UProperty的子类来表示的，具体 可以根据上图所列出的对象去代码里面去找对应的类去看它具体的实现。

下面我们以一个最简单的代码示例来说明UE4中反射的实现过程，首先我创建了一个名为ReflectionStudy的工程（只有Basic Code），这样做是为了方便分析代码，一开始提到的文章中说过，如果你想让你实现的类支持反射，那么必须遵循相关的准则，比如要使用UENUM()、UCLASS()、USTRUCT()、UFUNCTION()、以及UPROPERTY()等，UHT会根据这些宏来生成对应的支持反射的代码。下面我们分别展开来分析这些代码，它生成的代码都存放在你的工程ReflectionStudy\Intermediate\Build\Win64\UE4Editor\Inc\ReflectionStudy路径下。
里面一般分为几类文件：
1.ReflectionStudy.generated.cpp 一个工程只有一个，这个文件是用来为每个支持反射的类生成反射信息的代码，比如注册属性、添加源数据等。

  1. ReflectionStudy.generated.dep.h 这个文件里面就是包含了上面1. ReflectionStudy.generated.cpp用到的头文件。
    3.ReflectionStudyClasses.h
    4.*.generated.h 这个就是为每个支持反射的头文件生成的对应的宏的代码。

类

类的定义

我们以下面的代码为例来讲解，为了查看一些用法的具体实现，我们特意加了以下几个 属性和方法。

  1. // Fill out your copyright notice in the Description page of Project Settings.
  3. #pragma once
  5. #include "GameFramework/GameMode.h"
  6. #include "ReflectionStudyGameMode.generated.h"
  8. /**
  9. *
  10. */
  11. UCLASS()
  12. class REFLECTIONSTUDY_API AReflectionStudyGameMode : public AGameMode
  13. {
  15. GENERATED_BODY()
  18. protected:
  19. UPROPERTY(BlueprintReadWrite, Category = "AReflectionStudyGameMode")
  20. float Score;
  22. UFUNCTION(BlueprintCallable, Category = "AReflectionStudyGameMode")
  23. void CallableFuncTest();
  25. UFUNCTION(BlueprintNativeEvent, Category = "AReflectionStudyGameMode")
  26. void NavtiveFuncTest();
  28. UFUNCTION(BlueprintImplementableEvent, Category = "AReflectionStudyGameMode")
  29. void ImplementableFuncTest();
  30. };

UHT生成的.generated.h文件

因为对应的ReflectionStudyGameMode.generated.h头文件较长，所以我们只把关键的部分列出来讲解。

  1. #define ReflectionStudy_Source_ReflectionStudy_ReflectionStudyGameMode_h_14_RPC_WRAPPERS_NO_PURE_DECLS \
  2.     virtual void NavtiveFuncTest_Implementation(); \
  3.  \
  4.     DECLARE_FUNCTION(execNavtiveFuncTest) \
  5.     { \
  6.         P_FINISH; \
  7.         P_NATIVE_BEGIN; \
  8.         this->NavtiveFuncTest_Implementation(); \
  9.         P_NATIVE_END; \
  10.     } \
  11.  \
  12.     DECLARE_FUNCTION(execCallableFuncTest) \
  13.     { \
  14.         P_FINISH; \
  15.         P_NATIVE_BEGIN; \
  16.         this->CallableFuncTest(); \
  17.         P_NATIVE_END; \
  18.     }

可以看到，我们上面定义的函数，UHT帮我们自动生成了如上代码，至于为什么会生成这样的函数，那是因为UE4蓝图调用约定，每个函数前面要加一个exec前缀，关于蓝图的实现因为我目前也了解的也不是很清楚，所以可能会在后面出一个对蓝图实现的介绍，这些函数都是由UE4虚拟机调用过来的，如果包含参数和返回值，那么还会有相应的从虚拟机栈上取参数和设置返回值的代码，读者可以自行去验证。

  1. define ReflectionStudy_Source_ReflectionStudy_ReflectionStudyGameMode_h_14_INCLASS_NO_PURE_DECLS \
  2.     private: \
  3.     static void StaticRegisterNativesAReflectionStudyGameMode(); \
  4.     friend REFLECTIONSTUDY_API class UClass* Z_Construct_UClass_AReflectionStudyGameMode(); \
  5.     public: \
  6.     DECLARE_CLASS(AReflectionStudyGameMode, AGameMode, COMPILED_IN_FLAGS(0 | CLASS_Transient | CLASS_Config), 0, TEXT("/Script/ReflectionStudy"), NO_API) \
  7.     DECLARE_SERIALIZER(AReflectionStudyGameMode) \
  8.     /** Indicates whether the class is compiled into the engine */ \
  9.     enum {
  10.     IsIntrinsic=COMPILED_IN_INTRINSIC};

StaticRegisterNativesAReflectionStudyGameMode 这个函数是用来 注册C++原生函数暴露给虚拟机使用的。

friend REFLECTIONSTUDY_API class UClass* Z_Construct_UClass_AReflectionStudyGameMode(); 声明友元函数，这个函数是用来构建此类对应的UClass的

DECLARE_CLASS 此宏比较复杂，主要是定义了StaticClass() 等，具体实现请读者打开它的定义就可以看到。

DECLARE_SERIALIZER 定义序列化代码。

enum {IsIntrinsic=COMPILED_IN_INTRINSIC}; 正如注释所说，就是用来标记这个类是否是编译到引擎中的

  1. #define ReflectionStudy_Source_ReflectionStudy_ReflectionStudyGameMode_h_14_ENHANCED_CONSTRUCTORS \
  2.     /** Standard constructor, called after all reflected properties have been initialized */ \
  3.     NO_API AReflectionStudyGameMode(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get()) : Super(ObjectInitializer) {
  4.      }; \
  5. private: \
  6.     /** Private copy-constructor, should never be used */ \
  7.     NO_API AReflectionStudyGameMode(const AReflectionStudyGameMode& InCopy); \
  8. public: \
  9.     DECLARE_VTABLE_PTR_HELPER_CTOR(NO_API, AReflectionStudyGameMode); \
  10. DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(AReflectionStudyGameMode); \
  11.     DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(AReflectionStudyGameMode)

NO_API AReflectionStudyGameMode(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get()) : Super(ObjectInitializer) { }; \定义一个标准构造函数，在所有反射属性都初始化之后调用。

NO_API AReflectionStudyGameMode(const AReflectionStudyGameMode& InCopy); \ 防止调用拷贝构造函数

DECLARE_VTABLE_PTR_HELPER_CTOR(NO_API, AReflectionStudyGameMode); \ DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(AReflectionStudyGameMode); \ 热加载相关，这是UE4里面比较牛逼的功能，我们这里也不详细讨论，这个如果以后对这块理解了也会单独开个专题进行讲解。

DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL 定义了一个默认构造函数，如下代码所示：
static void __DefaultConstructor(const FObjectInitializer& X) { new((EInternal*)X.GetObj())TClass(X); }

  1. #define ReflectionStudy_Source_ReflectionStudy_ReflectionStudyGameMode_h_14_GENERATED_BODY \
  3. PRAGMA_DISABLE_DEPRECATION_WARNINGS \
  5. public: \
  7.     ReflectionStudy_Source_ReflectionStudy_ReflectionStudyGameMode_h_14_RPC_WRAPPERS_NO_PURE_DECLS \
  9.     ReflectionStudy_Source_ReflectionStudy_ReflectionStudyGameMode_h_14_CALLBACK_WRAPPERS \
  11.     ReflectionStudy_Source_ReflectionStudy_ReflectionStudyGameMode_h_14_INCLASS_NO_PURE_DECLS \
  13.     ReflectionStudy_Source_ReflectionStudy_ReflectionStudyGameMode_h_14_ENHANCED_CONSTRUCTORS \
  15. private: \
  17. PRAGMA_ENABLE_DEPRECATION_WARNINGS

这段代码就是对上述解释宏的引用，配合下面这个宏最终就实现了在class中定义一个GENERATED_BODY()就可以把上面所有定义的内容包含到该类中。

  1. #undef CURRENT_FILE_ID
  3. #define CURRENT_FILE_ID ReflectionStudy_Source_ReflectionStudy_ReflectionStudyGameMode_h

所有GENERATED_BODY()相关的宏定义如下

  1. // This pair of macros is used to help implement GENERATED_BODY() and GENERATED_USTRUCT_BODY()
  3. #define BODY_MACRO_COMBINE_INNER(A,B,C,D) A##B##C##D
  5. #define BODY_MACRO_COMBINE(A,B,C,D) BODY_MACRO_COMBINE_INNER(A,B,C,D)
  6. #define GENERATED_BODY_LEGACY(...) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_GENERATED_BODY_LEGACY)
  7. #define GENERATED_BODY(...) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_GENERATED_BODY)
  9. #define GENERATED_USTRUCT_BODY(...) GENERATED_BODY()
  10. #define GENERATED_UCLASS_BODY(...) GENERATED_BODY_LEGACY()
  11. #define GENERATED_UINTERFACE_BODY(...) GENERATED_BODY_LEGACY()
  12. #define GENERATED_IINTERFACE_BODY(...) GENERATED_BODY_LEGACY()

至此ReflectionStudyGameMode.generated.h文件里面的内容就基本分析完了，下面我们来看ReflectionStudy.generated.cpp里面对应的代码，结合前面的解释，相信你对整个UE4的反射系统就有一个大体的了解了。

.generated.cpp文件中相关内容

  1. FName REFLECTIONSTUDY_ImplementableFuncTest = FName(TEXT("ImplementableFuncTest"));
  2. FName REFLECTIONSTUDY_NavtiveFuncTest = FName(TEXT("NavtiveFuncTest"));
  3.     void AReflectionStudyGameMode::ImplementableFuncTest()
  4.     {
  6.         ProcessEvent(FindFunctionChecked(REFLECTIONSTUDY_ImplementableFuncTest),NULL);
  7.     }
  8.     void AReflectionStudyGameMode::NavtiveFuncTest()
  9.     {
  11.         ProcessEvent(FindFunctionChecked(REFLECTIONSTUDY_NavtiveFuncTest),NULL);
  12.     }
  13.     void AReflectionStudyGameMode::StaticRegisterNativesAReflectionStudyGameMode()
  14.     {
  16.         FNativeFunctionRegistrar::RegisterFunction(AReflectionStudyGameMode::StaticClass(), "CallableFuncTest",(Native)&AReflectionStudyGameMode::execCallableFuncTest);
  17.         FNativeFunctionRegistrar::RegisterFunction(AReflectionStudyGameMode::StaticClass(), "NavtiveFuncTest",(Native)&AReflectionStudyGameMode::execNavtiveFuncTest);
  18.     }
  19.     IMPLEMENT_CLASS(AReflectionStudyGameMode, 3618622309);

刚接触UE4的时候，如果是BlueprintImplementabeEvent的函数，是不是发现不需要自己去实现，那么当时有没有觉得怪异呢，上面的代码就解释清楚了，那是UE4帮我们实现了，可以看到它调用了ProcessEvent方法，这个方法在UObject中实现的。

StaticRegisterNativesAReflectionStudyGameMode 向AReflectionStudyGameMode::StaticClass()返回的UClass里面添加原生的C++函数。

IMPLEMENT_CLASS 定义了一个静态全局变量，用于在程序启动的时候注册UClass。

  1. UFunction* Z_Construct_UFunction_AReflectionStudyGameMode_CallableFuncTest()
  2.     {
  4.         UObject* Outer=Z_Construct_UClass_AReflectionStudyGameMode();
  5.         static UFunction* ReturnFunction = NULL;
  6.         if (!ReturnFunction)
  7.         {
  9.             ReturnFunction = new(EC_InternalUseOnlyConstructor, Outer, TEXT("CallableFuncTest"), RF_Public|RF_Transient|RF_MarkAsNative) UFunction(FObjectInitializer(), NULL, 0x04080401, 65535);
  10.             ReturnFunction->Bind();
  11.             ReturnFunction->StaticLink();
  12. #if WITH_METADATA
  13.             UMetaData* MetaData = ReturnFunction->GetOutermost()->GetMetaData();
  14.             MetaData->SetValue(ReturnFunction, TEXT("Category"), TEXT("AReflectionStudyGameMode"));
  15.             MetaData->SetValue(ReturnFunction, TEXT("ModuleRelativePath"), TEXT("ReflectionStudyGameMode.h"));
  16. #endif
  17.         }
  18.         return ReturnFunction;
  19.     }

这个函数向AReflectionStudyGameMode返回的UClass类里面注册名为CallableFuncTest的函数，而#if WITH_METADATA里面就是我们前面提到的元数据，可以注意其中我们类中指定的Category分类就在这里指定的，放在了它的（UPackage中）UMetaData中。Z_Construct_UFunction_AReflectionStudyGameMode_ImplementableFuncTest()和Z_Construct_UFunction_AReflectionStudyGameMode_NavtiveFuncTest()实现方式和上面基本一样，这里我就不写出来了。

  1. UClass* Z_Construct_UClass_AReflectionStudyGameMode()
  2.     {
  4.         static UClass* OuterClass = NULL;
  5.         if (!OuterClass)
  6.         {
  8.             Z_Construct_UClass_AGameMode();
  9.             Z_Construct_UPackage__Script_ReflectionStudy();
  10.             OuterClass = AReflectionStudyGameMode::StaticClass();
  11.             if (!(OuterClass->ClassFlags & CLASS_Constructed))
  12.             {
  14.                 UObjectForceRegistration(OuterClass);
  15.                 OuterClass->ClassFlags |= 0x2090028C;
  17.                 OuterClass->LinkChild(Z_Construct_UFunction_AReflectionStudyGameMode_CallableFuncTest());
  18.                 OuterClass->LinkChild(Z_Construct_UFunction_AReflectionStudyGameMode_ImplementableFuncTest());
  19.                 OuterClass->LinkChild(Z_Construct_UFunction_AReflectionStudyGameMode_NavtiveFuncTest());
  21. PRAGMA_DISABLE_DEPRECATION_WARNINGS
  22.                 UProperty* NewProp_Score = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("Score"), RF_Public|RF_Transient|RF_MarkAsNative) UFloatProperty(CPP_PROPERTY_BASE(Score, AReflectionStudyGameMode), 0x0020080000000004);
  23. PRAGMA_ENABLE_DEPRECATION_WARNINGS
  24.                 OuterClass->AddFunctionToFunctionMapWithOverriddenName(Z_Construct_UFunction_AReflectionStudyGameMode_CallableFuncTest(), "CallableFuncTest"); // 3059784748
  25.                 OuterClass->AddFunctionToFunctionMapWithOverriddenName(Z_Construct_UFunction_AReflectionStudyGameMode_ImplementableFuncTest(), "ImplementableFuncTest"); // 4773450
  26.                 OuterClass->AddFunctionToFunctionMapWithOverriddenName(Z_Construct_UFunction_AReflectionStudyGameMode_NavtiveFuncTest(), "NavtiveFuncTest"); // 2500148308
  27.                 OuterClass->ClassConfigName = FName(TEXT("Game"));
  28.                 OuterClass->StaticLink();
  29. #if WITH_METADATA
  30.                 UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
  31.                 MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("Info Rendering MovementReplication Replication Actor Input Movement Collision Rendering Utilities|Transformation"));
  32.                 MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("ReflectionStudyGameMode.h"));
  33.                 MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("ReflectionStudyGameMode.h"));
  34.                 MetaData->SetValue(OuterClass, TEXT("ShowCategories"), TEXT("Input|MouseInput Input|TouchInput"));
  35.                 MetaData->SetValue(NewProp_Score, TEXT("Category"), TEXT("AReflectionStudyGameMode"));
  36.                 MetaData->SetValue(NewProp_Score, TEXT("ModuleRelativePath"), TEXT("ReflectionStudyGameMode.h"));
  37. #endif
  38.             }
  39.         }
  40.         check(OuterClass->GetClass());
  41.         return OuterClass;
  42.     }

这个函数的作用就是来生成AReflectionStudyGameMode的UClass对象，并注册所有的UFunction 和UProperty

Z_Construct_UClass_AGameMode(); 因为它继承自AGameMode所以AGameMode的UClass必须有效。

Z_Construct_UPackage__Script_ReflectionStudy(); 确保UPackage已经创建。

#if WITH_METADATA 宏中代码也是用于创建元数据。

  1. static FCompiledInDefer Z_CompiledInDefer_UClass_AReflectionStudyGameMode(Z_Construct_UClass_AReflectionStudyGameMode, &AReflectionStudyGameMode::StaticClass, TEXT("AReflectionStudyGameMode"), false, nullptr, nullptr);
  2. DEFINE_VTABLE_PTR_HELPER_CTOR(AReflectionStudyGameMode);

第一行代码用于存放创建UClass的一个静态函数，之后将会执行这个静态生成UClass函数

DEFINE_VTABLE_PTR_HELPER_CTOR 定义一个参数为FVTableHelper构造函数。

  1. UPackage* Z_Construct_UPackage__Script_ReflectionStudy()
  2. {
  4.     static UPackage* ReturnPackage = NULL;
  5.     if (!ReturnPackage)
  6.     {
  8.         ReturnPackage = CastChecked<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), NULL, FName(TEXT("/Script/ReflectionStudy")), false, false));
  9.         ReturnPackage->SetPackageFlags(PKG_CompiledIn | 0x00000000);
  10.         FGuid Guid;
  11.         Guid.A = 0x00B770A5;
  12.         Guid.B = 0x8BECE3AF;
  13.         Guid.C = 0x00000000;
  14.         Guid.D = 0x00000000;
  15.         ReturnPackage->SetGuid(Guid);
  17.     }
  18.     return ReturnPackage;
  19. }

用于返当前模块的UPackage，上面的代码中会用到这个参数GetOuterMost()函数，返回的就是这个UPackage。

发表评论

表情：
评论列表 （有 0 条评论，409人围观）

还没有评论，来说两句吧...

相关阅读