1
00:00:04,110 --> 00:00:05,100
‫欢迎回来｡

2
00:00:05,370 --> 00:00:12,150
‫所以我们已经创建了一个新的封装组件指针, 并对其进行了正向声明, 这样我们就不必在base upon

3
00:00:12,150 --> 00:00:15,390
‫h中包含头文件｡

4
00:00:15,450 --> 00:00:25,410
‫现在是时候为我们的基本POM构建一个capsule组件子对象了, 完成后, 我们将把根组件设置为capsule.

5
00:00:26,380 --> 00:00:30,010
‫那么, 我们实际上如何构建一个you capsule组件呢？

6
00:00:30,130 --> 00:00:31,750
‫这个过程非常不真实｡

7
00:00:31,750 --> 00:00:37,300
‫引擎特定的虚幻引擎已创建默认子对象｡

8
00:00:37,450 --> 00:00:39,880
‫这是一个模板函数｡

9
00:00:39,910 --> 00:00:46,060
‫模板函数适应所选的类型, 因此我们可以选择特定的类型并创建默认值｡

10
00:00:46,060 --> 00:00:48,460
‫子对象将适应该类型｡

11
00:00:48,460 --> 00:00:53,290
‫我们传入要构造的类型, 创建默认子对象｡

12
00:00:53,590 --> 00:00:57,210
‫与常规函数不同, 它有这些尖括号｡

13
00:00:57,220 --> 00:01:00,400
‫这是我们传入要构造的类型的地方｡

14
00:01:00,430 --> 00:01:04,930
‫现在创建默认子对象也需要在括号中使用一个参数｡

15
00:01:04,930 --> 00:01:08,140
‫这将是我们分配给子对象的名称｡

16
00:01:08,140 --> 00:01:12,220
‫这与变量名不同, 它是作为字符串文字传入的｡

17
00:01:12,550 --> 00:01:13,960
‫这里有一个例子｡

18
00:01:13,960 --> 00:01:17,170
‫假设我们希望创建一个u静态网格组件｡

19
00:01:17,350 --> 00:01:24,700
‫因此, 我们调用create default子对象, 并结束我们在类型为u的静态网格组件中传递的尖括号,

20
00:01:24,700 --> 00:01:27,190
‫并在括号中为给予命名｡

21
00:01:27,190 --> 00:01:31,300
‫现在您已经看到, 对于String Literal, 应该使用文本宏｡

22
00:01:31,300 --> 00:01:35,200
‫所以我们在这里使用文本宏传递字符串｡

23
00:01:35,230 --> 00:01:38,890
‫现在, 正如我提到的, 这是Unreal Engine使用的内部名称｡

24
00:01:38,920 --> 00:01:41,080
‫还有其他函数使用此函数｡

25
00:01:41,080 --> 00:01:45,130
‫例如, 有一个名为“按名称获取默认子对象”的函数｡

26
00:01:45,160 --> 00:01:50,890
‫它检索属于特定对象的子对象, 你可以调用它, 传入一个特定的名称,

27
00:01:50,890 --> 00:01:54,190
‫它将查找具有所选名称的子对象｡

28
00:01:54,370 --> 00:01:59,440
‫因此, 创建默认子对象的整个函数调用如下所示｡

29
00:01:59,620 --> 00:02:03,580
‫类型放在尖括号中, 名称放在圆括号中｡

30
00:02:03,580 --> 00:02:09,460
‫现在create default子对象返回新创建的组件的地址｡

31
00:02:09,460 --> 00:02:15,910
‫在我们的例子中, 如果我们传入use static mesh组件作为类型, 那么我们会得到use

32
00:02:15,910 --> 00:02:21,970
‫static mesh组件的地址, 我们可以将其存储在指针中, 因为指针存储的是对象的地址｡

33
00:02:21,970 --> 00:02:26,050
‫因此, 假设我们创建一个使用静态网格组件指针的网格｡

34
00:02:26,050 --> 00:02:33,220
‫然后, 我们可以获取创建默认子对象返回地址, 并将该地址存储在网格指针中｡

35
00:02:33,700 --> 00:02:40,960
‫现在, 您已经了解了创建默认子对象的工作原理, 您将使用它来构造一个胶囊组件对象｡

36
00:02:40,990 --> 00:02:47,230
‫您将在基本PON构造函数中执行此操作, 使用create default

37
00:02:47,230 --> 00:02:54,310
‫sub object构造一个胶囊组件, 将您的胶囊组件和尖括号作为要构造的类型传递给胶囊碰撞器,

38
00:02:54,310 --> 00:02:58,540
‫并将其封装在括号中的文本宏中｡

39
00:02:58,900 --> 00:03:03,880
‫暂停视频, 现在将其添加到构造函数中的基点CP｡

40
00:03:07,720 --> 00:03:08,170
‫好吧, 我会的

41
00:03:08,170 --> 00:03:09,430
‫所以我们在巴斯池塘｡

42
00:03:09,640 --> 00:03:13,270
‫CP, 我们想构建一个胶囊组件｡

43
00:03:13,270 --> 00:03:22,150
‫所以我们将使用我们的capsule comp变量, 并将create default sub对象返回的值赋值给它｡

44
00:03:22,510 --> 00:03:29,620
‫现在, 正如我们所看到的, 这个模板函数有尖括号和圆括号,

45
00:03:29,620 --> 00:03:34,480
‫我们看到类型放在尖括号里, 我们将使用U封装组件｡

46
00:03:34,570 --> 00:03:41,320
‫对于括号, 我们将使用文本宏, 我们将称之为胶囊对撞机｡

47
00:03:42,160 --> 00:03:43,210
‫好了

48
00:03:43,390 --> 00:03:48,870
‫现在, 我们将使用capsule组件来构造这种类型的对象｡

49
00:03:48,880 --> 00:03:52,450
‫当我们使用一个类型时, 我们包括它的头文件｡

50
00:03:52,960 --> 00:03:56,290
‫现在, 让我们看看当我们试图编译时会发生什么｡

51
00:03:56,320 --> 00:04:00,560
‫同样, 您可以使用实时编码, 也可以在这里使用VZ代码进行编译｡

52
00:04:00,580 --> 00:04:03,820
‫在本节中, 我将使用VTS代码进行编译｡

53
00:04:03,820 --> 00:04:09,550
‫所以你可以知道, 当我编译的时候, 我已经关闭了Unreal Engine编辑器, 我只是从这里编译｡

54
00:04:09,550 --> 00:04:14,770
‫我想在这里看到错误消息, VTS代码现在正在尝试在这里编译｡

55
00:04:14,770 --> 00:04:17,950
‫我们得到的错误与上一个视频中看到的错误不同｡

56
00:04:17,980 --> 00:04:21,430
‫使用未定义的u型胶囊组件｡

57
00:04:21,610 --> 00:04:27,970
‫这一次, 我们尝试在CPP文件中使用U封装组件类型来构造一个对象｡

58
00:04:28,180 --> 00:04:33,190
‫这里的错误代码的情况下, 你想谷歌这种特定类型的错误的更多信息.

59
00:04:33,610 --> 00:04:40,150
‫在这节课中, 我们已经看到了两种不同类型的编译错误, 我们也知道了这个错误的原因.

60
00:04:40,150 --> 00:04:42,700
‫我们还没有把你的胶囊组件包括进去｡

61
00:04:42,820 --> 00:04:50,530
‫这里是Unreal Engine文档中的U封装组件, 这里是我们需要的该类型的include｡

62
00:04:50,530 --> 00:04:56,710
‫我将把它复制并粘贴到Base Pond CPP的顶部｡

63
00:04:56,740 --> 00:05:02,890
‫现在如果我尝试再次编译, 编译成功, 我们不会看到错误｡

64
00:05:03,100 --> 00:05:04,870
‫我现在要关闭终端｡

65
00:05:04,990 --> 00:05:07,510
‫我们已经创建了胶囊组件｡

66
00:05:07,540 --> 00:05:11,920
‫接下来, 我想做的是确保capsule组件是根｡

67
00:05:11,950 --> 00:05:18,890
‫现在, 我们了解了如何在C++中通过单击和拖动将一个组件指定为根和蓝图｡

68
00:05:18,910 --> 00:05:20,430
‫这也很简单｡

69
00:05:20,440 --> 00:05:26,590
‫我们只需要取根组件变量, 并将capsule comp值赋给它｡

70
00:05:26,800 --> 00:05:30,520
‫现在, 我们已经指定capsule comp应该是根组件｡

71
00:05:30,790 --> 00:05:32,290
‫让我们再编译一次｡

72
00:05:32,470 --> 00:05:36,910
‫现在, 在成功编译之后, 我想跳回到编辑器｡

73
00:05:37,000 --> 00:05:37,350
‫好吧, 我会的

74
00:05:37,360 --> 00:05:42,570
‫我已经打开了编辑器, 我将把我的基类——, C++类拖进去｡

75
00:05:42,580 --> 00:05:44,100
‫现在看看这个

76
00:05:44,110 --> 00:05:46,330
‫我们看到一个胶囊组件｡

77
00:05:46,420 --> 00:05:48,260
‫现在在世界上, 出班轮｡

78
00:05:48,280 --> 00:05:53,870
‫它显示了我刚才拖进来的基础——现在在详细信息面板中的搜索上方被选中｡

79
00:05:53,890 --> 00:05:58,660
‫我可以将它拖下来, 看到这个底座上的所有组件——｡

80
00:05:58,660 --> 00:06:03,430
‫我们所看到的是这个胶囊组件, 因为这是它唯一的组件｡

81
00:06:03,520 --> 00:06:09,490
‫现在我们已经添加了我们的capsule组件, 当我们在Unreal Engine编辑器中实际添加该类的实例时,

82
00:06:09,490 --> 00:06:13,120
‫我们可以看到结果｡

83
00:06:13,760 --> 00:06:19,970
‫总之, 我们已经学习了如何从C++中构造一个胶囊组件, 并且通过将根组件变量的值赋给胶囊组件,

84
00:06:19,970 --> 00:06:25,070
‫使其成为根组件｡

85
00:06:25,100 --> 00:06:29,600
‫在下一个视频中, 我们将在C++类的基础上添加更多组件｡

86
00:06:29,810 --> 00:06:30,770
‫到时候见