1
00:00:04,080 --> 00:00:05,730
‫你好, 欢迎回来｡

2
00:00:05,760 --> 00:00:10,380
‫现在, 我们准备旋转炮塔, 我们想使用鼠标来完成此操作｡

3
00:00:10,380 --> 00:00:14,790
‫我们在上一个视频中追踪到的位置｡

4
00:00:14,880 --> 00:00:22,200
‫所以当我移动鼠标光标时, 炮塔会旋转并朝向鼠标光标的方向｡

5
00:00:22,320 --> 00:00:31,080
‫而且即使我在视口中单击并开始播放, 我仍然可以四处移动鼠标光标来旋转炮塔并设置其方向｡

6
00:00:31,110 --> 00:00:35,850
‫这将使我能够瞄准时, 我有能力发射炮弹｡

7
00:00:35,880 --> 00:00:36,200
‫好吧, 我会的

8
00:00:36,240 --> 00:00:41,770
‫所以要做到这一点, 我们需要找到我们希望炮塔指向的方向｡

9
00:00:41,790 --> 00:00:46,410
‫一旦我们找到了方向, 我们就可以设置炮塔网格旋转｡

10
00:00:46,500 --> 00:00:53,500
‫现在, 为了得到我们希望炮塔指向的方向, 我们需要做一些矢量数学｡

11
00:00:53,520 --> 00:00:59,570
‫我们要找的是从坦克炮塔到目标位置的方位｡

12
00:00:59,580 --> 00:01:06,960
‫现在我们可以很容易地得到我们的坦克或其任何组件的位置, 如坦克的炮塔的位置｡

13
00:01:06,990 --> 00:01:09,600
‫我们把这个位置称为炮塔位置｡

14
00:01:09,600 --> 00:01:13,440
‫而且我们也知道如何才能得到追踪头的位置｡

15
00:01:13,470 --> 00:01:15,800
‫我们称之为追踪命中位置｡

16
00:01:15,810 --> 00:01:20,760
‫我们感兴趣的是从炮塔位置到追踪目标位置的矢量｡

17
00:01:20,760 --> 00:01:23,100
‫我们称这个向量为目标向量｡

18
00:01:23,130 --> 00:01:27,030
‫现在, 通过矢量数学来达到目标实际上非常简单｡

19
00:01:27,060 --> 00:01:33,120
‫要获得从起点到终点的矢量, 始终是终点减去起点｡

20
00:01:33,420 --> 00:01:39,270
‫所以如果我们用我们的轨迹, 命中位置, 减去炮塔的矢量位置,

21
00:01:39,270 --> 00:01:41,620
‫那么由此得到的矢量就是目标｡

22
00:01:41,640 --> 00:01:47,160
‫现在, 一旦我们有了两个目标的方向向量, 我们想把它转换成一个旋转,

23
00:01:47,160 --> 00:01:49,530
‫这样我们就可以设置坦克炮塔的旋转｡

24
00:01:49,530 --> 00:01:53,750
‫向量类型有一个内置的函数, 称为旋转｡

25
00:01:53,760 --> 00:02:02,260
‫所以如果我们取目标向量并调用rotation, 这将返回对应于该方向的F旋转器｡

26
00:02:02,280 --> 00:02:04,430
‫现在我们确实需要记住一些事情｡

27
00:02:04,440 --> 00:02:14,620
‫跟踪命中结果通常会在地面上, 从坦克炮塔到跟踪命中结果的矢量不会与地面平行｡

28
00:02:14,640 --> 00:02:20,850
‫这意味着如果我们把坦克炮塔的旋转方向设置为我们从那个方向矢量得到的旋转方向,

29
00:02:20,850 --> 00:02:29,310
‫我们可能会得到这样的结果, 炮塔朝下倾斜朝向地面, 但我们不希望坦克炮塔向下旋转｡

30
00:02:29,310 --> 00:02:31,350
‫我们希望它仍然指向前方｡

31
00:02:31,350 --> 00:02:33,780
‫所以这就是我们想要的结果｡

32
00:02:33,810 --> 00:02:39,180
‫换句话说, 我们只想改变坦克炮塔旋转的是的分量｡

33
00:02:39,180 --> 00:02:44,550
‫这样它就指向了正确的方向, 但仍然与地面保持平行｡

34
00:02:44,550 --> 00:02:51,600
‫我们只改变了它的偏航角, 所以让我们跳回到VS代码, 并创建一个函数来旋转坦克炮塔｡

35
00:02:51,630 --> 00:02:57,210
‫现在我们要旋转坦克上的炮塔, 但我们也想旋转我们的塔敌人上的炮塔, 塔很快就会从base

36
00:02:57,210 --> 00:03:04,290
‫pon衍生出来, 这意味着如果我们创建一个旋转炮塔功能, 我们可以把它放在base

37
00:03:04,290 --> 00:03:08,820
‫pong类中｡

38
00:03:08,820 --> 00:03:12,930
‫这样水箱和塔都能继承这个功能｡

39
00:03:12,930 --> 00:03:18,480
‫由于我们计划在塔和罐中使用它, 我们可以使此功能受到保护｡

40
00:03:18,720 --> 00:03:24,630
‫所以我将添加一个protected区域, 在protected区域中放置的任何函数和变量都可以在这些子类中访问,

41
00:03:24,630 --> 00:03:29,220
‫但不能在任何其他类中访问｡

42
00:03:29,220 --> 00:03:32,580
‫所以它几乎和私有变量一样受限制｡

43
00:03:32,580 --> 00:03:34,860
‫现在这个函数可以返回void｡

44
00:03:34,860 --> 00:03:37,710
‫我把这个叫做旋转炮塔｡

45
00:03:38,850 --> 00:03:44,690
‫为了转动炮塔, 我需要一个目的地｡

46
00:03:44,700 --> 00:03:49,620
‫这可以是一个f向量, 我们可以称之为注视目标｡

47
00:03:49,620 --> 00:03:56,490
‫如果我们有一个函数, 可以传递到世界上的某个位置,

48
00:03:56,490 --> 00:04:00,360
‫那么这个函数应该会导致炮塔向那个位置旋转.

49
00:04:00,360 --> 00:04:04,680
‫因此, 让我们继续, 并提供一个功能定义旋转炮塔｡

50
00:04:04,680 --> 00:04:11,280
‫所以这里在基本兵CP下的构造函数中, 我要实现旋转炮塔｡

51
00:04:11,280 --> 00:04:16,680
‫当然, 我需要一个基本的兵类名称和作用域解析操作符｡

52
00:04:16,680 --> 00:04:21,180
‫现在我已经有了旋转炮塔, 让我们来想想我们将如何实现它｡

53
00:04:21,180 --> 00:04:30,120
‫我们需要的第一件事是目标向量从炮塔组件的向量到鼠标光标下的轨迹命中结果｡

54
00:04:30,120 --> 00:04:38,970
‫这可以是一个局部F向量, 我们将把它设为某个向量数学的结果｡

55
00:04:38,970 --> 00:04:43,350
‫记住, 这将是目的地减去起点｡

56
00:04:43,350 --> 00:04:50,910
‫目的地是观察目标, 而起点是坦克炮塔的位置, 换句话说,

57
00:04:50,910 --> 00:04:54,030
‫就是炮塔的位置.

58
00:04:54,030 --> 00:04:59,880
‫因此, 我们可以说炮塔网格, 我们可以得到炮塔网格的位置｡

59
00:04:59,880 --> 00:05:07,290
‫现在, 获取组件的全局位置的方法是使用此函数获取组件位置｡

60
00:05:07,290 --> 00:05:09,630
‫它属于使用场景组件类｡

61
00:05:09,630 --> 00:05:11,460
‫所以所有场景组件都有它｡

62
00:05:11,460 --> 00:05:15,690
‫因此, 从炮塔网格, 我们将调用获取组件位置｡

63
00:05:16,340 --> 00:05:24,290
‫因此, 观察目标减去炮塔网格位置, 得到了从炮塔网格到观察目标的矢量｡

64
00:05:24,320 --> 00:05:30,590
‫现在, 正如我提到的, 我们可以使用F向量旋转函数获得从目标到目标的EF旋转器｡

65
00:05:30,590 --> 00:05:40,100
‫所以我们要做一个F旋转器, 我们可以称之为注视旋转, 我们将它设置为等于目标点旋转｡

66
00:05:40,280 --> 00:05:41,570
‫这是一个函数调用｡

67
00:05:41,570 --> 00:05:46,700
‫现在我们有了对应于这个目标方向向量的旋转器｡

68
00:05:46,700 --> 00:05:49,550
‫但问题是我们只关心雅｡

69
00:05:49,550 --> 00:05:51,680
‫我们不想改变音高或角色｡

70
00:05:51,680 --> 00:05:57,290
‫我们只想绕z轴旋转炮塔, 并保持它与地面平行｡

71
00:05:57,290 --> 00:05:59,420
‫现在我们可以用很多种方法来做｡

72
00:05:59,420 --> 00:06:05,870
‫首先, 我们可以看看旋转, 俯仰和调零｡

73
00:06:05,870 --> 00:06:08,180
‫换句话说, 将其设置为零｡

74
00:06:08,210 --> 00:06:14,240
‫我们也可以看看旋转点的作用, 并将其归零｡

75
00:06:14,240 --> 00:06:21,020
‫现在, 当我们将俯仰和滚转设置为零后, 我们就得到了想要的旋转, 这只是一个分量｡

76
00:06:21,020 --> 00:06:22,460
‫这是一种方法｡

77
00:06:22,460 --> 00:06:26,450
‫另一种方法是使用F旋转器构造函数重载之一｡

78
00:06:26,450 --> 00:06:34,820
‫如果我们用圆括号表示f旋转器, 并传入一些值, 如第一个输入的零点F,

79
00:06:34,820 --> 00:06:38,300
‫弹出窗口告诉我第一个输入是音高｡

80
00:06:38,300 --> 00:06:43,880
‫然后对丫的我们就可以利用来进行目标轮换了｡

81
00:06:44,330 --> 00:06:44,990
‫是的, 我知道

82
00:06:44,990 --> 00:06:47,960
‫对于这个角色, 我们可以用零点F.

83
00:06:47,960 --> 00:06:55,820
‫现在, 它所做的是创建一个新的F旋转体, 零表示音高, 零表示角色,

84
00:06:55,820 --> 00:06:59,420
‫以及两个目标旋转返回的旋转体分量｡

85
00:06:59,420 --> 00:07:05,300
‫因此, 这个函数返回的值与我们在这里对这三行所做的结果相同｡

86
00:07:05,300 --> 00:07:11,990
‫因为它更简洁, 更优雅,

87
00:07:11,990 --> 00:07:19,370
‫我想我更愿意使用它, 这样我们就可以用调用F旋转器构造函数返回的F旋转器, 初始化旋转向量了.

88
00:07:19,370 --> 00:07:21,380
‫所以我要把这条线去掉｡

89
00:07:21,380 --> 00:07:23,360
‫现在我们来看看旋转｡

90
00:07:23,360 --> 00:07:29,000
‫在此功能中要做的最后一件事是设置炮塔捣碎的旋转｡

91
00:07:29,000 --> 00:07:38,270
‫现在我们可以为给定的组件设置旋转再使用此功能设置世界旋转, 这属于使用场景组件｡

92
00:07:38,270 --> 00:07:44,300
‫我们之所以使用设置单词旋转而不是添加某种局部旋转偏移量,

93
00:07:44,300 --> 00:07:50,420
‫是因为我们在世界空间中有一个旋转, 两个目标是一个世界空间方向向量｡

94
00:07:50,420 --> 00:07:56,750
‫我们将在世界空间中获取炮塔网格位置, 并减去世界空间中的目的位置｡

95
00:07:56,750 --> 00:07:58,850
‫所以这是一个世界空间方向｡

96
00:07:58,850 --> 00:08:02,450
‫因此看旋转是一个世界空间旋转｡

97
00:08:02,450 --> 00:08:06,140
‫因此, 我们将在炮塔网格上使用设置世界旋转｡

98
00:08:06,290 --> 00:08:13,280
‫所以我们会说炮塔网格, 设置世界旋转, 然后我们会传入旋转｡

99
00:08:13,280 --> 00:08:19,550
‫所以现在我们有了一个功能, 可以在世界上的任何目标, 并转动炮塔网格, 以查看它,

100
00:08:19,550 --> 00:08:22,550
‫但它不会向下旋转网格｡

101
00:08:22,550 --> 00:08:28,100
‫它只会改变它的偏航角, 所以它会以坦克炮塔应该旋转的方式旋转｡

102
00:08:28,100 --> 00:08:31,100
‫因此, 我们现在有了一个旋转转台的功能｡

103
00:08:31,130 --> 00:08:38,870
‫我要挑战你们调用这个函数来设置炮塔的旋转, 在坦克类中调用旋转炮塔函数.

104
00:08:38,870 --> 00:08:40,730
‫这是一个受保护的函数｡

105
00:08:40,730 --> 00:08:43,070
‫所以坦克类可以访问它｡

106
00:08:43,070 --> 00:08:51,410
‫现在旋转炮塔取一个F矢量, 看看目标, 你要用我们的线轨迹得到的F命中结果中的那个弹着点｡

107
00:08:51,410 --> 00:08:57,170
‫所以我打算让你自己在代码中找到调用这个函数的正确位置｡

108
00:08:57,410 --> 00:09:00,920
‫所以暂停视频和放置旋转炮塔功能｡

109
00:09:00,920 --> 00:09:02,870
‫叫坦克班来｡

110
00:09:06,000 --> 00:09:06,150
‫好吧, 我会的

111
00:09:06,300 --> 00:09:09,960
‫现在我们有了旋转炮塔功能, 我们可以调用它了｡

112
00:09:10,140 --> 00:09:18,200
‫我将进入tank up, 这是if检查中的tick函数, 用于控制器引用｡

113
00:09:18,210 --> 00:09:25,860
‫我有我的命中结果, 在调用了游标下的get hit result之后, 命中结果将有有效的数据｡

114
00:09:25,860 --> 00:09:30,480
‫实际上, 我们使用的是命中结果影响点并绘制调试球体｡

115
00:09:30,510 --> 00:09:35,370
‫现在, 由于我不再需要绘制调试球体, 我将继续并删除它｡

116
00:09:35,370 --> 00:09:39,900
‫我将把我们保护函数称为旋转炮塔

117
00:09:39,900 --> 00:09:45,750
‫为了查看目标, 我将传入命中结果点弹着点｡

118
00:09:47,140 --> 00:09:53,320
‫所以现在每一帧我们都要把炮塔旋转到命中结果中的撞击点｡

119
00:09:53,350 --> 00:10:00,130
‫在编译之前, 我不再使用draw debug helper, 所以我将删除该头文件｡

120
00:10:00,340 --> 00:10:00,820
‫好吧, 我会的

121
00:10:00,850 --> 00:10:02,590
‫现在我准备编译｡

122
00:10:02,970 --> 00:10:03,360
‫好吧, 我会的

123
00:10:03,370 --> 00:10:05,050
‫我回到编辑室了｡

124
00:10:05,080 --> 00:10:09,440
‫让我们点击播放来看看｡

125
00:10:09,460 --> 00:10:11,460
‫这是惊人的｡

126
00:10:11,470 --> 00:10:12,910
‫我还能滚来滚去｡

127
00:10:12,910 --> 00:10:18,910
‫我可以移动我的鼠标, 无论我移动鼠标光标, 炮塔都在旋转｡

128
00:10:18,910 --> 00:10:20,350
‫所以这是真棒｡

129
00:10:20,600 --> 00:10:25,750
‫好的, 在我们结束之前, 我想先解决几个问题｡

130
00:10:25,750 --> 00:10:28,900
‫我希望这是漂亮的和抛光, 看起来很棒｡

131
00:10:28,930 --> 00:10:36,890
‫现在, 当我将鼠标光标移动到靠近水箱中心的位置, 然后穿过水箱时, 会出现第一个问题｡

132
00:10:36,910 --> 00:10:42,670
‫你会看到在某个点上旋转的速度非常快｡

133
00:10:42,670 --> 00:10:48,250
‫如果我们随意地移动鼠标, 那看起来就不太好了｡

134
00:10:48,250 --> 00:10:49,480
‫断了｡

135
00:10:49,480 --> 00:10:50,890
‫我们没有平稳的移动｡

136
00:10:50,890 --> 00:10:52,270
‫所以这是一个问题｡

137
00:10:52,300 --> 00:10:59,890
‫另一个问题是, 如果我点击鼠标, 然后滚动到边缘, 当我向上移动鼠标光标时,

138
00:10:59,890 --> 00:11:03,750
‫我会看到炮塔向另一个方向移动.

139
00:11:03,760 --> 00:11:05,730
‫那到底是怎么回事？

140
00:11:05,740 --> 00:11:06,910
‫好吧, 让我们来看看｡

141
00:11:06,910 --> 00:11:10,240
‫我们将返回到VS代码, 我想取回我的调试球体｡

142
00:11:10,240 --> 00:11:16,240
‫回到坦克中, 我将在旋转炮塔之前转到tick函数, 并再次调用draw debug

143
00:11:16,240 --> 00:11:19,240
‫sphere｡

144
00:11:19,450 --> 00:11:26,380
‫现在对于我正在经过的世界, 得到世界为中心, 我正在经过的, 命中结果点,

145
00:11:26,380 --> 00:11:35,350
‫撞击点为半径, 我将使用25个点, F段可以是12, 颜色可以是F, 红色持久线可以是假的,

146
00:11:35,350 --> 00:11:38,440
‫寿命可以是负的｡

147
00:11:38,440 --> 00:11:40,480
‫我们之前做过同样事情

148
00:11:40,690 --> 00:11:42,280
‫所以我要保存此通知｡

149
00:11:42,280 --> 00:11:48,700
‫我没有添加头文件, 因为默认情况下, 调试助手实际上是包含的, 所以从技术上讲,

150
00:11:48,700 --> 00:11:50,830
‫我们不需要它｡

151
00:11:50,830 --> 00:11:56,740
‫我将在编辑器中保存跳转, 进行实时编码启动, 然后按“播放”｡

152
00:11:56,740 --> 00:11:58,600
‫现在我有了调试球体｡

153
00:11:58,600 --> 00:12:07,240
‫让我们到世界的边缘, 我把鼠标光标移到它福尔斯到深渊的地方｡

154
00:12:07,240 --> 00:12:10,330
‫这就是我们的问题所在

155
00:12:10,330 --> 00:12:15,940
‫你看, 当我们的光标移动到那里时, 我们在光标下没有命中结果,

156
00:12:15,940 --> 00:12:18,730
‫因为那里没有任何东西可以让我们从中获得命中结果｡

157
00:12:18,730 --> 00:12:22,120
‫因此, 我们的弹着点没有定义｡

158
00:12:22,120 --> 00:12:25,570
‫所以我们需要的是线路追踪的线索｡

159
00:12:25,600 --> 00:12:28,810
‫现在, 虚幻引擎有很多工具, 我们可以使用｡

160
00:12:28,810 --> 00:12:35,170
‫我现在要做的就是点击这里的下拉菜单, 打开我的位置演员面板, 选择这个显示音量的图标,

161
00:12:35,170 --> 00:12:38,380
‫得到一个阻塞音量｡

162
00:12:38,380 --> 00:12:39,820
‫这是阻塞体积｡

163
00:12:39,820 --> 00:12:41,710
‫我会把一个拖进去｡

164
00:12:41,740 --> 00:12:44,020
‫所以现在我有了这个阻塞体积｡

165
00:12:44,110 --> 00:12:48,190
‫默认情况下, 阻塞卷应该是不可见的｡

166
00:12:48,190 --> 00:12:54,130
‫如果我进入细节面板,

167
00:12:54,130 --> 00:13:00,940
‫向下滚动到碰撞, 我会看到它的碰撞预设是无形的墙, 这似乎表明它应该阻止几乎所有的东西｡

168
00:13:00,940 --> 00:13:08,680
‫它唯一没有阻塞的是可见性通道, 我们的线跟踪恰好是针对可见性通道进行跟踪的｡

169
00:13:08,680 --> 00:13:13,630
‫在我们的世界中, 任何阻挡可见性通道的东西都将被我们的线路跟踪击中｡

170
00:13:13,630 --> 00:13:16,540
‫但这本书不会｡

171
00:13:16,540 --> 00:13:17,860
‫它应该是隐形的｡

172
00:13:17,860 --> 00:13:22,690
‫好吧, 我们可以去碰撞预设, 打开下拉菜单, 并选择定制｡

173
00:13:22,720 --> 00:13:28,300
‫这将允许我们改变它, 这样我就可以将碰撞响应设置为可见性通道｡

174
00:13:28,300 --> 00:13:29,170
‫是个街区｡

175
00:13:29,170 --> 00:13:34,960
‫现在我有了一个不可见体积, 但它被设置为阻挡可见性通道,

176
00:13:34,960 --> 00:13:40,180
‫这意味着像我们这样逆着可见性通道追踪的线迹将击中它｡

177
00:13:40,180 --> 00:13:45,580
‫所以我能做的就是把这个块体积放大｡

178
00:13:45,580 --> 00:13:47,800
‫我把它放在墙外｡

179
00:13:47,800 --> 00:13:53,440
‫事实上, 我可以把它放在墙的边界上, 我会把它放低一点,

180
00:13:53,440 --> 00:13:55,900
‫这样它就和墙重叠了.

181
00:13:55,900 --> 00:14:03,550
‫这样我们就有了一个看不见的屏障, 我将继续在Y方向上放大它｡

182
00:14:03,550 --> 00:14:09,880
‫我把这个又大又好的放在中间, 给予一点填充物.

183
00:14:09,880 --> 00:14:14,050
‫我还要在Z方向上放大它｡

184
00:14:14,050 --> 00:14:18,460
‫现在它很好很大我们的线路追踪应该能找到它｡

185
00:14:18,460 --> 00:14:20,080
‫让我们来验证一下这个理论｡

186
00:14:20,110 --> 00:14:23,170
‫让我们在视口中单击并转到墙上｡

187
00:14:23,170 --> 00:14:30,250
‫果然, 我的线跟踪击中了阻塞体积, 我没有问题,

188
00:14:30,250 --> 00:14:34,240
‫我的炮塔捕捉到一些未定义的位置｡

189
00:14:34,240 --> 00:14:40,810
‫它很可能是朝向世界的原点, 因为撞击点矢量都是零.

190
00:14:40,810 --> 00:14:43,660
‫现在如果我走到这面墙前, 我也会遇到同样的问题｡

191
00:14:43,660 --> 00:14:46,270
‫所以我们需要这些阻塞体积｡

192
00:14:46,600 --> 00:14:48,950
‫都在我们这一层的周围｡

193
00:14:48,970 --> 00:14:50,590
‫这很简单

194
00:14:50,590 --> 00:14:54,820
‫我需要做的就是复制这个阻塞卷｡

195
00:14:54,820 --> 00:14:59,290
‫现在, 我可以从透视视图变更为上正投影视图｡

196
00:14:59,290 --> 00:15:06,070
‫我选择顶部, 用鼠标滚轮滚动, 按住alt键, 复制这面墙,

197
00:15:06,070 --> 00:15:11,620
‫在这里放一面, 然后按E键进入旋转模式｡

198
00:15:11,620 --> 00:15:14,740
‫所以我将保持alt并旋转90度｡

199
00:15:14,740 --> 00:15:21,010
‫这会给予我一个副本, 然后我会按两个u, 启动我的翻译模式, 我会把它移到这边,

200
00:15:21,010 --> 00:15:26,920
‫按住Alt键, 把副本拖到那边.

201
00:15:26,920 --> 00:15:28,720
‫所以现在我们有四面墙｡

202
00:15:28,720 --> 00:15:34,990
‫现在我可以从俯视图回到透视图, 然后按播放键, 现在我可以走到任何一面墙,

203
00:15:34,990 --> 00:15:40,240
‫不管我被覆盖在哪面墙上, 看起来都很棒｡

204
00:15:40,240 --> 00:15:42,340
‫这就解决了我们的一个问题｡

205
00:15:42,340 --> 00:15:43,720
‫但是另一个呢？

206
00:15:43,720 --> 00:15:49,360
‫如果我们移动鼠标靠近我们的坦克, 我们仍然有这种零星的行为｡

207
00:15:49,360 --> 00:15:51,880
‫所以我也想处理这个问题｡

208
00:15:51,880 --> 00:15:56,770
‫现在, 我可以处理这个问题的方法是对旋转进行插值｡

209
00:15:56,770 --> 00:16:02,650
‫因此,

210
00:16:02,650 --> 00:16:08,740
‫我们可以使用插值函数来代替直接设置该旋转值, 该插值函数将以平滑的方式将该旋转移向我们提供的目标｡

211
00:16:08,740 --> 00:16:10,270
‫让我们来看看它是如何工作的｡

212
00:16:10,270 --> 00:16:15,970
‫现在, 我希望这个插值函数在我们的旋转炮塔函数中, 这样我们就可以返回到基本兵,

213
00:16:15,970 --> 00:16:22,750
‫向下旋转炮塔, 而不是设置我们的世界旋转, 让炮塔查看旋转,

214
00:16:22,750 --> 00:16:28,240
‫我们可以将其设置为等于插值函数返回的值｡

215
00:16:28,240 --> 00:16:34,720
‫我将删除, 看看旋转, 我们将调用F数学库中的一个函数, 称为R

216
00:16:34,720 --> 00:16:38,590
‫inter2｡

217
00:16:39,100 --> 00:16:44,530
‫现在, 我们的in two设计用于处理旋转器的插值｡

218
00:16:44,530 --> 00:16:49,720
‫现在, 它的第一个输入参数是一个常量F旋转器引用, 称为current｡

219
00:16:49,720 --> 00:16:53,650
‫这是我们试图改变的事物的当前值｡

220
00:16:53,650 --> 00:16:59,560
‫我们试图改变的是我们的炮塔旋转, 我们可以从我们的炮塔网格｡

221
00:16:59,560 --> 00:17:05,920
‫所以我们会说转塔网格, 我们要使用的函数是获得组件旋转｡

222
00:17:05,920 --> 00:17:10,420
‫所以这很像获取组件位置, 只是它获取了旋转｡

223
00:17:10,420 --> 00:17:14,200
‫现在, 下一个输入是名为Target的F旋转器｡

224
00:17:14,200 --> 00:17:15,310
‫这就是价值｡

225
00:17:15,310 --> 00:17:21,430
‫我们希望这个炮塔网格旋转能够顺利地接近｡

226
00:17:21,430 --> 00:17:23,890
‫这将是我们对旋转的看法｡

227
00:17:23,890 --> 00:17:26,620
‫所以我要说看看旋转｡

228
00:17:26,620 --> 00:17:28,630
‫下一个输入是Delta时间｡

229
00:17:28,630 --> 00:17:30,640
‫所以我们知道德尔塔时间的重要性｡

230
00:17:30,640 --> 00:17:37,030
‫如果我们在移动或旋转物体, 我们希望这种移动与帧速率无关｡

231
00:17:37,030 --> 00:17:39,700
‫因此, 我们可以得到德尔塔时间｡

232
00:17:39,700 --> 00:17:46,210
‫我可以简单地包括游戏静态, 如果你有一个很好的记忆力, 你会记得,

233
00:17:46,210 --> 00:17:49,150
‫包括是命运斜线游戏静态｡

234
00:17:49,150 --> 00:17:57,700
‫我在这里得到了游戏静态数据, 这样我就可以访问静态函数, 得到世界增量秒数,

235
00:17:57,700 --> 00:18:01,150
‫记住这需要一个世界上下文对象｡

236
00:18:01,150 --> 00:18:04,030
‫所以我要把这个传给那个｡

237
00:18:04,030 --> 00:18:06,340
‫最后, 我们需要一个内部速度｡

238
00:18:06,340 --> 00:18:12,280
‫内部速度的值越高, 我们向目标插值的速度就越快｡

239
00:18:12,280 --> 00:18:18,550
‫如果我把它设为一个值, 比如说, 5F, 那么我们会很慢地进行插值｡

240
00:18:18,580 --> 00:18:20,470
‫让我们看看现在的情况｡

241
00:18:20,470 --> 00:18:25,030
‫所有这些都在一条线上, 并在屏幕上运行｡

242
00:18:25,030 --> 00:18:32,440
‫所以我要做的就是把设置世界旋转的输入放在它自己的线上, 就像这样｡

243
00:18:32,440 --> 00:18:34,060
‫所以就这样｡

244
00:18:34,060 --> 00:18:39,820
‫然后是我们的解释器, 它有这四个输入参数, 也在屏幕上运行｡

245
00:18:39,820 --> 00:18:43,270
‫所以我要让他们各走各的路｡

246
00:18:43,270 --> 00:18:49,420
‫这样我们就可以看到所有的输入, 而不需要像那样滚动屏幕｡

247
00:18:49,420 --> 00:18:49,840
‫好吧, 我会的

248
00:18:49,840 --> 00:18:54,220
‫我将继续保存它, 并开始实时编码｡

249
00:18:54,220 --> 00:19:01,480
‫现在如果我按下播放键, 移动鼠标, 注意到旋转需要一段时间｡

250
00:19:01,480 --> 00:19:06,430
‫这是因为我们是平滑地向目标旋转插值｡

251
00:19:06,430 --> 00:19:07,780
‫这太棒了

252
00:19:07,780 --> 00:19:09,340
‫这正是我想要的｡

253
00:19:09,340 --> 00:19:14,950
‫不管我怎么移动鼠标, 我永远不会得到那种敏捷的､ 断断续续的移动｡

254
00:19:15,040 --> 00:19:20,170
‫现在, 五是一个非常慢的互联网速度, 但我们可以改变它｡

255
00:19:20,170 --> 00:19:21,820
‫我们可以再快一点｡

256
00:19:21,820 --> 00:19:30,040
‫我将其设置为25, 看看效果如何, 然后让您决定您的游戏所需的值｡

257
00:19:30,040 --> 00:19:34,450
‫所以再一次, 开始实时编码并按播放｡

258
00:19:34,510 --> 00:19:39,010
‫现在我有一个非常快的插值, 但它不是抢购｡

259
00:19:39,010 --> 00:19:42,910
‫它仍然很快, 但它不是一个瞬间的快照｡

260
00:19:42,910 --> 00:19:46,360
‫所以只要我们不做这样的事情, 嗯, 我们就不会得到它｡

261
00:19:46,540 --> 00:19:47,860
‫疯狂的行为｡

262
00:19:47,860 --> 00:19:53,500
‫当然, 如果你想要一个较慢的旋转, 你现在知道怎么做了, 我们已经完成了绘制调试球体,

263
00:19:53,500 --> 00:19:56,220
‫所以我会继续删除它｡

264
00:19:56,230 --> 00:19:56,650
‫好吧, 我会的

265
00:19:56,650 --> 00:20:02,920
‫总之, 我们已经设置了炮塔旋转, 我们正在传递一个目标, 这是一个F向量,

266
00:20:02,920 --> 00:20:05,800
‫对应于世界上的一个点｡

267
00:20:05,800 --> 00:20:08,080
‫现在我们只使用跟踪命中结果｡

268
00:20:08,110 --> 00:20:13,090
‫现在我们把这个函数放在pong基类中, 并使其成为protected,

269
00:20:13,090 --> 00:20:15,880
‫这意味着我们可以继承tank类中的函数｡

270
00:20:15,880 --> 00:20:21,190
‫一旦我们准备好创建一个基于base的塔类, 那么这个塔类将继承这个旋转塔函数,

271
00:20:21,190 --> 00:20:24,610
‫我们可以重用它｡

272
00:20:24,610 --> 00:20:26,050
‫我们只要通过就行了｡

273
00:20:26,050 --> 00:20:32,380
‫在对Target的新看法中, 我们将致力于创建一个从base派生的塔类——在后面的讲座中｡

274
00:20:32,380 --> 00:20:33,250
‫我很快就会见到你的｡