WEBVTT

1
00:00:00.440 --> 00:00:02.620
您好，欢迎来到艺术家脚本。

2
00:00:02.630 --> 00:00:06.860
我的名字是Sybren，在本集中我们将讨论资产链接

3
00:00:07.240 --> 00:00:10.920
因为这集的代码比之前的多了许多。

4
00:00:10.920 --> 00:00:13.140
而且程式码也变得越来越复杂。

5
00:00:13.150 --> 00:00:16.860
我已将最终添加内容放在影片说明的连结中，以便您

6
00:00:16.860 --> 00:00:20.650
可以下载它并在观看此影片时将其用作参考。

7
00:00:20.940 --> 00:00:24.190
现在我们就去混合云来看看定居者计画。

8
00:00:24.190 --> 00:00:27.830
这是一个公共项目，因此您不需要混合云订阅来存取它

9
00:00:27.840 --> 00:00:31.860
它将作为本集艺术家脚本编写的一个很好的例子。

10
00:00:32.240 --> 00:00:35.360
我还在视频说明中添加了该项目的链接

11
00:00:35.840 --> 00:00:38.270
这是定居者的搅拌机云的动画

12
00:00:38.270 --> 00:00:42.360
项目是典型的此类动画项目

13
00:00:42.360 --> 00:00:45.550
有一组，每组都包含此中的资产

14
00:00:45.550 --> 00:00:48.890
像左边的岩石和植物这样的情况。

15
00:00:48.890 --> 00:00:51.730
您可以在设定开发中看到不同的混合文件

16
00:00:51.730 --> 00:00:54.460
对于岩石资产和正确的 I 资产。

17
00:00:54.640 --> 00:00:57.050
它们都连结到此处的环境文件中。

18
00:00:57.050 --> 00:00:59.170
您可以下载债务人试用版。

19
00:00:59.180 --> 00:01:03.160
只需单击此处的下载按钮，就会为您提供以下文件

20
00:01:04.140 --> 00:01:07.290
这里。我已将文件解压缩到亚特兰大沙漠。它有一个

21
00:01:07.560 --> 00:01:11.740
小笔记和集合目录。结束目录包含环境资产。

22
00:01:11.740 --> 00:01:13.770
所以沙漠植物和岩石。

23
00:01:13.920 --> 00:01:15.910
笔记有一些阴影，因为我们不会寻找

24
00:01:15.910 --> 00:01:19.350
这些和性发现亚特兰大沙漠点融合。

25
00:01:19.540 --> 00:01:22.040
我已经创建了我们要使用的 Jason 文件

26
00:01:22.040 --> 00:01:24.660
当然可以在准备影片时使用

27
00:01:24.940 --> 00:01:26.880
我们有一个新的工厂

28
00:01:26.880 --> 00:01:29.160
我们将从头开始自动建置。

29
00:01:29.540 --> 00:01:31.480
现在，在我们开始 Ultimate NG 之前，

30
00:01:31.480 --> 00:01:34.670
看看搅拌机本身和手动总是好的

31
00:01:34.670 --> 00:01:37.060
完成您希望脚本执行的步骤。

32
00:01:37.070 --> 00:01:39.950
所以通常你会花一段时间然后链接，

33
00:01:40.940 --> 00:01:44.450
岩石说，你会去环境资产

34
00:01:44.840 --> 00:01:47.850
那里有我们想要连结的集合。

35
00:01:47.860 --> 00:01:49.060
命名如下，

36
00:01:49.060 --> 00:01:51.290
你有 EN 破折号，代表环境

37
00:01:51.300 --> 00:01:53.750
资产，然后是名称和编号。

38
00:01:53.760 --> 00:01:55.470
所以我们想要拥有所有的 N 块岩石，

39
00:01:55.470 --> 00:01:59.530
我们希望岩石中的一切都光滑，就像整个事情一样。

40
00:01:59.540 --> 00:02:00.080
一，

41
00:02:00.080 --> 00:02:02.010
我们不要那 11 件事，你已经可以了

42
00:02:02.010 --> 00:02:04.160
看到的是所有的集合都有一定的前缀

43
00:02:04.340 --> 00:02:07.960
我们可以在脚本中使用它，以便它自动选择正确的。

44
00:02:08.039 --> 00:02:12.660
所以，灰岩下划线 s 底线。这适用于第一组

45
00:02:13.240 --> 00:02:17.690
和 Ian dash rock underscore 平滑底线将适用于第二组。

46
00:02:17.710 --> 00:02:19.660
现在让我们连结其中之一。

47
00:02:20.540 --> 00:02:25.150
您单击一个连结并自动将其实例化到场景中。

48
00:02:25.160 --> 00:02:28.320
如果你想将其连结到我们在脚本中看到的自己，

49
00:02:28.330 --> 00:02:31.500
我们必须进一步调查这到底是什么。

50
00:02:31.510 --> 00:02:35.750
所以我们这里是一个对象，其实是空对象

51
00:02:36.140 --> 00:02:38.110
将实例 ng 设定为集合

52
00:02:38.300 --> 00:02:41.110
激发摇滚停止混合系列

53
00:02:41.280 --> 00:02:42.350
此外，

54
00:02:42.630 --> 00:02:45.010
空的当然是同一个集合的一部分

55
00:02:45.010 --> 00:02:47.010
这就是它出现在我们场景中的原因。

56
00:02:47.020 --> 00:02:48.540
所以这就是我们必须要做的。

57
00:02:48.720 --> 00:02:50.800
我们必须从林肯收藏

58
00:02:50.800 --> 00:02:53.210
摇滚停止混合到当前混合文件中。

59
00:02:53.220 --> 00:02:55.090
然后我们必须创建一个空的

60
00:02:55.090 --> 00:02:58.160
空将将该集合实例化到我们的场景中。

61
00:02:58.340 --> 00:03:03.060
现在与我们之前所做的相反，我们不打算使用连结运算子。

62
00:03:03.120 --> 00:03:05.880
从 python 中使用它非常困难，而且有很多

63
00:03:05.880 --> 00:03:08.570
如果你去帮助python，更好的方法，

64
00:03:08.580 --> 00:03:09.760
API参考

65
00:03:10.440 --> 00:03:15.060
然后对于 bP 资料库，你会发现它是一个函式库。

66
00:03:15.060 --> 00:03:18.560
B型pi资料库的资料块，点击它

67
00:03:18.940 --> 00:03:22.010
在这里您将进入载入功能。

68
00:03:22.170 --> 00:03:26.250
这就是我们将要使用的资料来载入的库

69
00:03:26.590 --> 00:03:27.920
这需要一个档案路径，

70
00:03:28.010 --> 00:03:30.880
它需要一个可以设定为 true 的连结参数，如果

71
00:03:30.880 --> 00:03:32.770
你想要连结这就是我们想要做的。

72
00:03:32.780 --> 00:03:34.960
否则它将取决于当前文件

73
00:03:35.440 --> 00:03:37.370
如果档案路径是，relatives 应该是 true

74
00:03:37.370 --> 00:03:39.960
被解释为相对于当前混合文件

75
00:03:40.440 --> 00:03:42.740
以下是如何使用此功能的一些范例。

76
00:03:42.930 --> 00:03:45.610
该函数实际上充当上下文管理器，

77
00:03:45.620 --> 00:03:49.130
这表示您将它与 with 语句一起使用。

78
00:03:49.150 --> 00:03:51.360
with 语句有一个缩排的主体

79
00:03:52.240 --> 00:03:55.030
所以你必须用 then 你在这里有一个表达 then

80
00:03:55.030 --> 00:03:58.560
正如我们从前所知道的那样，科林又来了。

81
00:03:58.940 --> 00:04:01.620
然后你又得到了一些程式码

82
00:04:01.630 --> 00:04:04.660
缩排称为 with 语句的主体。

83
00:04:05.040 --> 00:04:08.230
现在 with 语句在进入之前做了一些事情

84
00:04:08.230 --> 00:04:10.490
身体然后做其他事情

85
00:04:10.500 --> 00:04:12.780
退出身体你可以用这个

86
00:04:12.780 --> 00:04:15.790
诸如打开文件和读取内容之类的事情

87
00:04:15.930 --> 00:04:18.480
然后确保当 with 语句

88
00:04:18.480 --> 00:04:21.630
决赛结束后自动关闭再次清理。

89
00:04:21.640 --> 00:04:22.460
我该走了。

90
00:04:23.040 --> 00:04:25.740
在这种情况下，它会加载混合文件并且它

91
00:04:25.750 --> 00:04:29.840
在资料中公开混合文件的内容

92
00:04:30.030 --> 00:04:32.780
然后你可以将数据分配给任何数据

93
00:04:32.780 --> 00:04:35.180
您想要从该混合文件连结的区块，

94
00:04:35.310 --> 00:04:37.260
数据来自和数据至。

95
00:04:37.440 --> 00:04:40.970
它们看起来与您已经知道的数据的 b 部分非常相似。

96
00:04:40.970 --> 00:04:44.760
所以它有一个点青少年点集合物件等。

97
00:04:45.340 --> 00:04:49.400
唯一的区别是它们并不是真正的物体、场景或集合。

98
00:04:49.530 --> 00:04:51.160
它们只是一个名字清单。

99
00:04:51.540 --> 00:04:55.000
这样我们就可以根据场景的名称采取行动。集合的名称。

100
00:04:55.000 --> 00:04:56.060
物件的名称

101
00:04:56.440 --> 00:04:58.770
无论我们给数据取什么名字

102
00:04:58.780 --> 00:05:01.420
当 with 语句被执行时，最终会被导入

103
00:05:01.430 --> 00:05:04.370
在此范例中，它附加了

104
00:05:04.370 --> 00:05:06.520
scene 呼叫 scene 到目前的 Blend 档案。

105
00:05:06.530 --> 00:05:10.550
这取决于连结的预设值是 false。这就是预设行为。

106
00:05:10.720 --> 00:05:13.070
没有给出连结参数。所以它会附加

107
00:05:13.360 --> 00:05:15.160
下面这里。你会看到一个例子

108
00:05:15.340 --> 00:05:18.360
带有连结。真的。这样将连结而不是附加

109
00:05:18.740 --> 00:05:22.750
数据点场景。反对等的措施已列出

110
00:05:22.940 --> 00:05:26.460
就像我们以前见过的那样。所以我们也可以为它们添加一些东西。

111
00:05:26.470 --> 00:05:29.840
与来自集合的数据类似也是

112
00:05:29.840 --> 00:05:32.860
集合名称列表，以便我们可以循环这些名称。

113
00:05:33.410 --> 00:05:36.680
这意味著我们可以循环遍历集合，查看它们的名称，

114
00:05:36.770 --> 00:05:40.040
看看是否带有我们想要的前缀和 if。

115
00:05:40.040 --> 00:05:43.060
因此，我们将它们附加到资料点集合列表中。

116
00:05:43.440 --> 00:05:46.110
现在让我们回到搅拌机并编写一些程式码

117
00:05:46.110 --> 00:05:48.570
稍微探索一下，看看它的行为。

118
00:05:48.710 --> 00:05:51.830
所以丽贝卡搅拌机，这一切都会看起来

119
00:05:51.830 --> 00:05:54.630
现在我们已经很熟悉了，我们正在导入 beep。

120
00:05:54.630 --> 00:05:55.090
I

121
00:05:55.280 --> 00:05:59.570
我们设定一个档案路径，因为我已将此档案储存在 set 目录中，所以我们

122
00:05:59.570 --> 00:06:03.860
必须向上一个目录然后两端，然后我们就有摇滚停止混合。

123
00:06:04.440 --> 00:06:07.620
其余部分与我们已经看到的范例非常相似。

124
00:06:07.630 --> 00:06:10.180
所以我们有BP资料库加载

125
00:06:10.190 --> 00:06:12.450
那么最终的路径和连结等于 true 因为

126
00:06:12.450 --> 00:06:17.250
我们想要链接，然后我们就可以得到我们预期的从 适应 到 的数据。

127
00:06:17.940 --> 00:06:21.800
现在我们在这里所做的就是列印集合中的数据

128
00:06:21.800 --> 00:06:25.310
看看我们的特定文件到底有什么，

129
00:06:25.320 --> 00:06:29.250
点击播放，然后我们进入启动搅拌机的终端。

130
00:06:29.640 --> 00:06:33.430
如果您使用的是 Windows，您可以转到窗口，然后转到总系统控制台

131
00:06:33.570 --> 00:06:34.860
为了看到这个

132
00:06:35.240 --> 00:06:37.900
在这里我们看到集合名称列表。

133
00:06:37.910 --> 00:06:41.770
就像我们在搅拌机本身中看到的那样，当我们手动完成所有步骤时。

134
00:06:41.880 --> 00:06:45.750
现在，即使我们实际上还没有连结该混合文件中的任何内容，

135
00:06:45.800 --> 00:06:47.250
它确实有一些效果。

136
00:06:47.340 --> 00:06:48.760
如果你看一下大纲

137
00:06:50.540 --> 00:06:54.510
您可以看到它确实加载了我们想要的 Rock Stop 混合文件。

138
00:06:54.540 --> 00:06:56.360
所以它已经在做一些事情了

139
00:06:56.940 --> 00:06:58.540
现在我们有了名单，

140
00:06:58.590 --> 00:07:00.630
让我们对找到的名称进行一些过滤

141
00:07:00.640 --> 00:07:04.350
有趣的是，实际上将它们连结到当前的混合档案中

142
00:07:04.840 --> 00:07:10.460
为了这。我们首先确定我们的前缀。所以记住我们有两组岩石。

143
00:07:10.470 --> 00:07:13.570
我们现在只关注其中一个，稍后我们再做另一个。

144
00:07:13.580 --> 00:07:17.950
从 n 破折号开始，并将分数作为底线

145
00:07:18.440 --> 00:07:19.850
我们可以删除这个列印

146
00:07:20.240 --> 00:07:26.660
只需说出集合资料中的集合名称

147
00:07:28.440 --> 00:07:33.760
如果它不以我们的前缀开头，我们就不感兴趣。

148
00:07:33.760 --> 00:07:36.100
因此，我们使用 continue 关键字来跳过它们。

149
00:07:36.110 --> 00:07:40.570
这只会告诉 for 回圈转到下一个元素并跳过主体的其余部分。

150
00:07:40.580 --> 00:07:43.990
在其他情况下，尽管我们有前缀，这意味著我们

151
00:07:43.990 --> 00:07:47.130
必须告诉 Blender 我们实际上想要连结这个集合。

152
00:07:48.240 --> 00:07:51.320
这意味著我们必须对点资料执行一些操作

153
00:07:51.500 --> 00:07:54.600
并表示我们可以附加该清单。

154
00:07:54.820 --> 00:07:56.250
让我们尝试一下。

155
00:07:59.240 --> 00:08:00.350
这会工作得很好

156
00:08:01.740 --> 00:08:05.060
现在我们可以在大纲中开启这个文件

157
00:08:05.840 --> 00:08:09.200
我们可以看到这些集合已被添加到其中。

158
00:08:09.210 --> 00:08:12.050
这些正是我们想要的系列

159
00:08:12.050 --> 00:08:14.270
我们不想要的收藏品不在这里。

160
00:08:14.270 --> 00:08:16.060
所以我们的程式码正在做正确的事情。

161
00:08:16.410 --> 00:08:19.010
现在剩下的就是建立一个空的实例

162
00:08:19.010 --> 00:08:22.960
这些集合，然后将这些空连结到同一个集合。

163
00:08:23.440 --> 00:08:27.330
她体内的这些数据有些特别。

164
00:08:27.330 --> 00:08:32.169
使用资料到点集合是一个名称列表，但是一旦使用

165
00:08:32.169 --> 00:08:37.640
主体已完成并部署载入的资料库实际上已经载入了我们需要的内容

166
00:08:37.909 --> 00:08:41.500
资料到点集合不再是集合名称清单。

167
00:08:41.919 --> 00:08:45.250
它实际上是连结的集合的列表。

168
00:08:45.540 --> 00:08:49.350
所以我们能做的就是循环它们。

169
00:08:50.940 --> 00:08:55.050
现在，这里的 cole 首先是第一个集合，然后是第二个集合，依此类推。

170
00:08:55.540 --> 00:08:56.870
现在让我们建立一个空的

171
00:09:00.840 --> 00:09:02.750
它应该以他们的收藏命名

172
00:09:03.080 --> 00:09:04.650
并且它不应该有任何数据。

173
00:09:05.140 --> 00:09:08.130
这样搅拌机就知道这个物件应该是一个

174
00:09:08.130 --> 00:09:10.940
空的，没有相机或测量任何其他东西。

175
00:09:10.950 --> 00:09:15.060
现在我们必须设定一些属性，让我们看看这些属性是什么。

176
00:09:16.940 --> 00:09:19.460
所以为了测试我加了一个空的空，

177
00:09:22.640 --> 00:09:26.990
我必须设定 Lisbon，它是实例类型的物件。

178
00:09:27.000 --> 00:09:29.560
当然，我们必须将集合设定为

179
00:09:29.570 --> 00:09:31.740
收藏之一，你就拥有了。

180
00:09:31.740 --> 00:09:32.860
这就是我们需要做的。

181
00:09:33.340 --> 00:09:37.110
但是在这里，你说它是实例集合。所以我们必须设定

182
00:09:37.360 --> 00:09:38.650
实例下划线类型

183
00:09:39.040 --> 00:09:40.930
和实例下划线集合。

184
00:09:41.230 --> 00:09:45.850
我猜测实例下划线类型必须具有值集合

185
00:09:46.440 --> 00:09:48.360
但我们总是可以查一下。当然。

186
00:09:49.640 --> 00:09:49.790
是的。

187
00:09:50.470 --> 00:09:54.260
现在你就得到了它。实例类型应设定为大写集合。

188
00:09:55.540 --> 00:09:57.550
那我们就复制这个吧。

189
00:09:58.040 --> 00:09:58.240
是的。

190
00:10:00.230 --> 00:10:01.760
然后我们就有了

191
00:10:03.040 --> 00:10:06.030
实例集合当然是集合

192
00:10:06.030 --> 00:10:08.260
我们想要举例说明哪个是煤炭。

193
00:10:09.940 --> 00:10:13.060
这会造成空虚，但它还不是我们理智的一部分。

194
00:10:13.540 --> 00:10:16.980
现在我认为创建一个特别的收藏来拥有是很好的

195
00:10:16.980 --> 00:10:20.160
所有这些都是空的，而不是放在顶层。

196
00:10:20.540 --> 00:10:24.860
因此，在开始执行此操作之前，我们要确保该集合存在。

197
00:10:25.540 --> 00:10:25.750
好的

198
00:10:26.840 --> 00:10:28.400
视为蜂鸣声。

199
00:10:28.400 --> 00:10:32.720
当我们将其更改为完成所有工作的运算符时，我稍后会看到上下文。

200
00:10:32.720 --> 00:10:36.860
当然，我们使用场景的上下文，而不是上下文。那个场景。

201
00:10:36.870 --> 00:10:38.660
但现在这就够了

202
00:10:39.040 --> 00:10:44.310
假设我们想要的集合

203
00:10:44.310 --> 00:10:47.050
将一切连结起来应该称为环境。

204
00:10:47.440 --> 00:10:48.180
现在

205
00:10:48.310 --> 00:10:51.350
我想创建这个集合，但前提是它尚不存在。

206
00:10:51.510 --> 00:10:55.930
最简单的方法就是要表现得好像它已经存在一样

207
00:10:56.070 --> 00:10:58.850
然后看看当它还不存在时会发生什么错误。

208
00:10:58.920 --> 00:11:00.910
然后简单处理了那个案子。

209
00:11:01.840 --> 00:11:03.460
所以让我们先做简单的事。

210
00:11:03.840 --> 00:11:06.360
假设它已经存在。

211
00:11:06.940 --> 00:11:11.050
然后我们就可以透过场景存取这个集合

212
00:11:13.940 --> 00:11:15.560
像这样。

213
00:11:15.940 --> 00:11:17.650
它只会给我们一个集合

214
00:11:18.440 --> 00:11:19.960
如果它还不存在。

215
00:11:20.640 --> 00:11:20.850
好的

216
00:11:21.240 --> 00:11:21.450
毫米。

217
00:11:21.940 --> 00:11:23.650
这将引发一个关键错误。

218
00:11:24.240 --> 00:11:25.840
现在我们已经获得了所需的资讯。

219
00:11:25.840 --> 00:11:30.660
让我们回到之前所做的程式码。我们想使用尝试并接受

220
00:11:31.040 --> 00:11:37.060
所以我们告诉 python 为我们尝试这个。

221
00:11:40.840 --> 00:11:48.160
如果失败，我们将不得不创建一个新的集合。

222
00:11:48.640 --> 00:11:48.950
好的。

223
00:11:51.540 --> 00:11:56.160
然后，一旦创建了该集合，我们就必须将其添加到同一个集合中。

224
00:11:59.540 --> 00:11:59.860
好的。

225
00:12:01.140 --> 00:12:03.140
所以现在这段程式码将只使用现有的

226
00:12:03.140 --> 00:12:05.240
集合（如果存在）并建立一个新集合。

227
00:12:05.240 --> 00:12:08.160
如果现在还没有我们想要连结到的集合。

228
00:12:08.170 --> 00:12:09.860
我们能做到，他们就是这样。

229
00:12:10.240 --> 00:12:10.470
是的。

230
00:12:11.040 --> 00:12:11.240
是的。

231
00:12:13.880 --> 00:12:15.350
这将使连结器为空。

232
00:12:18.940 --> 00:12:21.710
您可以看到现在运行的时间要长得多。

233
00:12:21.900 --> 00:12:24.850
在这里，我们将所有阿萨德都连结到了文件中。

234
00:12:26.770 --> 00:12:27.730
它们都是空的

235
00:12:27.860 --> 00:12:29.660
它们都在环境集合中。

236
00:12:31.240 --> 00:12:33.660
我们没有任何我们不想拥有的东西

237
00:12:34.140 --> 00:12:35.230
现在作为最后的润色。

238
00:12:35.230 --> 00:12:39.480
让我们沿著 X 轴将所有空的东西排成一行，这样

239
00:12:39.480 --> 00:12:43.490
它们很好地分散开来，而不是全部集中在一个地方。

240
00:12:43.490 --> 00:12:47.390
我们必须追踪前一个空的 X. 位置。

241
00:12:47.400 --> 00:12:50.660
所以让我们从零开始

242
00:12:51.710 --> 00:12:54.290
让我们把每个空的东西交给搅拌机

243
00:12:54.470 --> 00:12:57.370
现在它们已连结到场景，我们可以设定它们的位置。

244
00:12:58.140 --> 00:12:58.350
好的。

245
00:13:00.840 --> 00:13:03.950
然后我们可以将位置 X 增加步骤 X。

246
00:13:03.960 --> 00:13:06.640
这样下一个空的就会使用下一个位置。

247
00:13:07.210 --> 00:13:12.160
即删除所有MT。再次运行脚本

248
00:13:18.540 --> 00:13:20.850
他们都整齐地排列在那里。

249
00:13:22.140 --> 00:13:24.470
我们的脚本正在运行，但它非常有限。

250
00:13:24.640 --> 00:13:27.630
如果我们想载入具有不同前缀的资源，我们

251
00:13:27.630 --> 00:13:30.750
必须去更改原始码中的这个前缀。

252
00:13:30.750 --> 00:13:31.880
再次运行脚本，

253
00:13:32.060 --> 00:13:35.360
如果我们想从不同的混合文件加载，我们必须再次这样做。

254
00:13:35.550 --> 00:13:38.310
如果您想将空物体连结到不同的场景集合中

255
00:13:38.320 --> 00:13:40.780
我们必须再次编辑脚本并再次运行它。

256
00:13:41.340 --> 00:13:45.410
如果我们有一个包含所有这些资讯的文件，那就更好了

257
00:13:45.410 --> 00:13:47.960
包含哪些混合档案使用哪些前缀

258
00:13:47.960 --> 00:13:49.950
使用要连结到的集合。

259
00:13:50.540 --> 00:13:54.050
然后我们可以将程式码放入不需要更改的附加元件中

260
00:13:54.440 --> 00:13:57.620
和其他项目细节放入单独的文件中。

261
00:13:57.740 --> 00:14:00.380
在我们这样做之前，让我们复制我们的程式码，

262
00:14:00.380 --> 00:14:02.330
将其放入单独的python堆中

263
00:14:02.340 --> 00:14:05.180
并将一些程式码混入单独的函数中

264
00:14:05.360 --> 00:14:08.200
这样我们就可以使用一些更高层级的构建块

265
00:14:08.200 --> 00:14:11.450
stata 一直在查看一大堆程式码。

266
00:14:11.940 --> 00:14:14.160
所以让我们复制现在拥有的内容

267
00:14:14.840 --> 00:14:18.740
并转到附加元件。我已经做好准备了，我们已经见过很多次了。

268
00:14:18.750 --> 00:14:21.460
这只是一个带有账单信息的 python 文件

269
00:14:22.040 --> 00:14:23.180
我们改进了蜂鸣声。我

270
00:14:23.360 --> 00:14:25.650
我已经添加了一个空的运算符

271
00:14:25.650 --> 00:14:27.880
执行函数或会感觉出来。

272
00:14:28.010 --> 00:14:30.220
它被添加到导入选单中，以便我们

273
00:14:30.220 --> 00:14:33.050
可以只汇入文件，然后从 Jason 载入内容

274
00:14:33.640 --> 00:14:36.210
我们有搅拌机类，其中有操作员

275
00:14:36.210 --> 00:14:39.850
类别以及我们之前见过的注册和未注册的函数。

276
00:14:40.240 --> 00:14:43.260
最重要的是，让我们贴上程式码

277
00:14:43.260 --> 00:14:46.450
我们刚刚复制了，让我们把它变成一些函数。

278
00:14:46.940 --> 00:14:50.130
所以这里同时发生了一些事情。

279
00:14:50.250 --> 00:14:53.090
第一个位元将资料连结到目前混合档案。

280
00:14:53.100 --> 00:14:56.690
然后我们有一些程式码可以为我们创建一个集合（如果它还不存在）。

281
00:14:56.700 --> 00:14:58.770
所以实际上这是完全不同的事情所以

282
00:14:58.770 --> 00:15:00.700
可以移动到不同的功能。

283
00:15:01.100 --> 00:15:04.400
然后我们查看连结到混合文件中的所有集合。

284
00:15:04.410 --> 00:15:06.760
所以这其实属于程式码的第一部分。

285
00:15:08.640 --> 00:15:13.650
因此，让我们取出这部分并开始为其编写一个单独的函数。

286
00:15:14.140 --> 00:15:14.350
嗯。

287
00:15:14.740 --> 00:15:19.050
我们称之为确保集合，因为它确保集合存在。

288
00:15:19.560 --> 00:15:21.250
它需要访问现场。

289
00:15:22.250 --> 00:15:24.460
当然它需要知道集合名称。

290
00:15:26.280 --> 00:15:29.360
然后我们声明它将返回集合。

291
00:15:29.740 --> 00:15:31.960
让我们将程式码移到这里

292
00:15:40.120 --> 00:15:42.360
并更改该集合名称。

293
00:15:42.940 --> 00:15:48.360
现在我们要做的就是返回集合的链接，然后这个功能就完成了。

294
00:15:48.840 --> 00:15:50.850
现在我们有其他程式码需要研究。

295
00:15:52.840 --> 00:15:53.250
是的

296
00:15:54.040 --> 00:15:56.060
我们将此函数称为连结到场景的函数。

297
00:15:56.190 --> 00:16:00.460
它将把档案路径作为参数，而不是在这里硬编码。

298
00:16:01.040 --> 00:16:04.760
同样，它将采用前缀作为参数，而不是在这里进行硬编码。

299
00:16:05.340 --> 00:16:09.280
然后我们有一个集合的链接，然后是位置。

300
00:16:09.280 --> 00:16:13.190
为什么稍后我们将连结来自多个的多组资产

301
00:16:13.190 --> 00:16:16.440
混合文件然后将它们放在不同的行中是很好的。

302
00:16:16.440 --> 00:16:20.470
这就是我在这里添加位置 Y 参数的原因。

303
00:16:20.480 --> 00:16:21.970
现在外套的其余部分需要

304
00:16:21.980 --> 00:16:24.360
发明它是因为它需要成为函数的一部分

305
00:16:24.740 --> 00:16:27.820
当然现在我们还必须设置野外位置

306
00:16:28.180 --> 00:16:29.860
所以我们可以这样做。

307
00:16:31.140 --> 00:16:35.160
现在我们有两个函数，我们可以从操作符中呼叫它们

308
00:16:35.540 --> 00:16:39.110
仍然具有我们之前使用的相同硬编码值

309
00:16:39.120 --> 00:16:41.470
这样至少我们可以看到他们正在工作。

310
00:16:42.740 --> 00:16:48.260
因此，首先我们必须建立集合的连结。

311
00:16:48.840 --> 00:16:49.980
是的。

312
00:16:51.700 --> 00:16:55.170
然后我们可以呼叫连结到一个场景

313
00:16:55.170 --> 00:16:58.810
与我们之前使用的相同的档案路径和相同的前缀。

314
00:16:58.820 --> 00:17:01.960
然后是收藏。然后是我们想要连结到的集合。

315
00:17:03.140 --> 00:17:06.349
现在我们只使用零作为狂野位置。

316
00:17:07.140 --> 00:17:10.349
现在当然你必须启用你的我不知道你是怎么做到的

317
00:17:10.940 --> 00:17:13.400
现在你必须安装并启用你的 Adam。

318
00:17:13.410 --> 00:17:16.060
如果您想回顾一下这是如何完成的。

319
00:17:16.069 --> 00:17:19.510
寻找从脚本调用的艺术家章节的脚本以添加到那里。

320
00:17:19.510 --> 00:17:20.450
一切都解释清楚了。

321
00:17:20.839 --> 00:17:23.770
现在您必须从 Jason 提交导入连结资源

322
00:17:23.780 --> 00:17:26.450
您可以看到一切都按预期进行。

323
00:17:27.740 --> 00:17:31.420
现在是时候查看我已经提到过几次的 Jason 档案了。

324
00:17:31.430 --> 00:17:36.050
Jason 代表 javascript 物件表示法，它是一种非常常见的档案格式。

325
00:17:36.060 --> 00:17:40.750
它不是最容易使用的，但它是可行的，而且并不那么复杂。

326
00:17:40.750 --> 00:17:44.770
python 内建了对解析这些档案和保存这些档案的支援。

327
00:17:44.940 --> 00:17:48.170
所以对于我们的案例来说，这是一个相当方便的免费文件

328
00:17:48.340 --> 00:17:48.660
这里。

329
00:17:48.660 --> 00:17:53.420
如果要开启花括号，您会看到该文件的高级概述

330
00:17:53.420 --> 00:17:55.650
一个关闭文件并在卷曲内

331
00:17:55.650 --> 00:17:58.690
大括号里你有一个基本上是Python字典的东西。

332
00:17:58.700 --> 00:18:02.560
所以它是引号之间的名称，并且该名称具有值

333
00:18:03.140 --> 00:18:04.140
在这种情况下

334
00:18:04.270 --> 00:18:05.560
这是另一本字典。

335
00:18:06.440 --> 00:18:10.280
所以在这里我们说这些是我们的收藏品，我们想要收藏。

336
00:18:10.280 --> 00:18:12.770
我们想要岩石，我们想要植物

337
00:18:13.440 --> 00:18:14.760
并且在每个内

338
00:18:15.140 --> 00:18:18.550
我们说连结将包含文件和前缀列表

339
00:18:18.550 --> 00:18:21.460
我们想要将场景连结到这个集合中。

340
00:18:21.470 --> 00:18:24.890
所以你在这里看到了一个清单。它与 python 具有相同的表示法。

341
00:18:24.890 --> 00:18:27.870
所以有了这些块状括号之类的东西。

342
00:18:27.910 --> 00:18:32.060
其中我们有一个字典列表（在本例中为字典）。

343
00:18:32.060 --> 00:18:32.450
再次，

344
00:18:32.460 --> 00:18:36.270
每个字典都有一个档案并且有一个前缀

345
00:18:36.280 --> 00:18:38.930
从该文件连结到的所有集合。

346
00:18:38.940 --> 00:18:40.860
我们对植物做了类似的事。

347
00:18:40.870 --> 00:18:45.350
我们有一个链接，然后是文件，前缀文件，前缀文件，

348
00:18:45.350 --> 00:18:47.380
在这种情况下，前缀有三个。

349
00:18:47.380 --> 00:18:47.770
甚至

350
00:18:48.940 --> 00:18:53.820
现在我们可以删除这个连结并将这些资讯直接放入植物中。

351
00:18:53.830 --> 00:18:56.420
但我总是喜欢有一点点

352
00:18:56.420 --> 00:18:59.490
更明确，这也将给你以后的机会。

353
00:18:59.490 --> 00:19:01.430
如果你想添加一些额外的东西。

354
00:19:01.440 --> 00:19:07.270
也许呃，也许你想要一些可见的东西，但默认或不可见，或者也许你

355
00:19:07.270 --> 00:19:11.720
想要仅在某些视图层中启用或不透过将其放在连结下来启用。

356
00:19:11.720 --> 00:19:12.060
K.

357
00:19:12.060 --> 00:19:15.450
您可以稍后为自己的工作流程新增多个按键

358
00:19:15.450 --> 00:19:18.850
让我们保持简单并编写一些加载该文件的程式码，

359
00:19:19.170 --> 00:19:22.190
然后将其转换为我们可以使用的python资料结构。

360
00:19:22.740 --> 00:19:24.560
那么让我们注解掉这两行。

361
00:19:25.050 --> 00:19:28.190
我们将把它们留在身边作为我们的参考。之后，

362
00:19:28.740 --> 00:19:32.850
首先载入 Jason 文件，为此我们需要 Jason 模组。

363
00:19:33.240 --> 00:19:38.840
这是内建在 python 中的，因此我们只需导入 Jason 即可存取它。

364
00:19:38.850 --> 00:19:42.250
我认为将 Jason 文件放在 Blend 文件旁边是一个很好的做法，

365
00:19:42.250 --> 00:19:45.220
这意味著我们想用斜线斜线符号来写它，

366
00:19:45.230 --> 00:19:47.730
这意味著我们必须先翻译文件。

367
00:19:47.740 --> 00:19:51.860
这可以透过传递斜杠 ss 点 Jason 档案名称来完成

368
00:19:52.040 --> 00:19:53.960
透过飞行员通过它的路径

369
00:19:54.140 --> 00:19:56.270
这会解决这个问题。

370
00:19:56.640 --> 00:20:00.960
所以现在我们需要做的就是打开文件并将其输入 Jason 库。

371
00:20:01.540 --> 00:20:05.590
我将复制和贴上一些代码而不是输入，因为现在

372
00:20:05.590 --> 00:20:09.360
我们有很多 python 程式码可以自动完成并显示

373
00:20:09.360 --> 00:20:13.950
资讯弹出视窗和所有内容，因为我放大了该影片的编辑器

374
00:20:13.960 --> 00:20:17.560
会阻挡很多事情并且比任何事情都更令人分心。

375
00:20:18.540 --> 00:20:20.270
这就是打开文件的方式，

376
00:20:20.840 --> 00:20:24.410
你可以用开启的Jason档名来表示，如档所示

377
00:20:24.680 --> 00:20:26.640
这将打开文件进行读取

378
00:20:26.940 --> 00:20:29.930
一旦 with 语句完成，它将再次关闭它，

379
00:20:29.930 --> 00:20:33.780
确保我们不会在网路上留下任何打开的文件句柄。

380
00:20:33.900 --> 00:20:35.170
这不是一个这样的问题，

381
00:20:35.240 --> 00:20:39.330
但在 Windows 上这是一个问题，因为如果档案是由一个程式开启的，

382
00:20:39.340 --> 00:20:42.000
另一个程式将无法读取或写入该文件，

383
00:20:42.000 --> 00:20:43.850
您甚至无法删除该档案。

384
00:20:44.040 --> 00:20:47.180
因此，请务必确保在开启文件后将其关闭。

385
00:20:47.310 --> 00:20:50.160
with 语句是实现此目的的完美方法。

386
00:20:50.740 --> 00:20:52.270
当我们打开文件后

387
00:20:52.640 --> 00:20:56.710
我们可以将其传递给 Jason download，它将档案作为第一个参数。

388
00:20:56.740 --> 00:21:00.460
这将载入档案并将其解析为 python 资料结构。

389
00:21:01.240 --> 00:21:03.980
这意味著这里的连结资讯是一个字典。

390
00:21:03.990 --> 00:21:08.000
如果您想确切地查看其中的内容，可以使用 print 语句，运行程式码

391
00:21:08.200 --> 00:21:09.760
然后你就可以亲自看看了。

392
00:21:10.240 --> 00:21:13.280
回到我们的 Jason 文件，我们知道它代表

393
00:21:13.280 --> 00:21:17.930
具有一个称为集合的键的字典，其中包含另一个字典。

394
00:21:17.940 --> 00:21:19.860
那么让我们看看如何在 python 中存取它。

395
00:21:21.370 --> 00:21:23.050
你会把这个连结拿来当混蛋。

396
00:21:23.440 --> 00:21:28.350
我们得到了键集合，我们可以透过取得键值对来循环它

397
00:21:28.530 --> 00:21:31.230
为此，我们使用 dot items 函数

398
00:21:31.600 --> 00:21:36.060
字典上的点项给了我们一些可以用 for 回圈回圈的东西

399
00:21:36.440 --> 00:21:39.520
它会让你了解关键和价值

400
00:21:39.870 --> 00:21:43.550
在我们的例子中，它会带给我们那本字典的岩石。

401
00:21:44.140 --> 00:21:46.660
然后穿上第二本字典。

402
00:21:47.240 --> 00:21:50.260
所以呼叫名称是第一位的，呼叫讯息是它的

403
00:21:50.260 --> 00:21:53.770
字典，然后在第二次迭代中调用名称是植物

404
00:21:53.970 --> 00:21:56.270
然后调用info就是植物词典。

405
00:21:56.740 --> 00:22:01.270
所以我们要做的第一件事就是确保这个集合确实存在。

406
00:22:02.440 --> 00:22:05.560
我们有一个函数可以做到这一点。所以让我们移动该程式码

407
00:22:06.600 --> 00:22:07.660
并把它放在这里。

408
00:22:08.340 --> 00:22:11.590
而不是将环境当作艺术收藏，

409
00:22:11.660 --> 00:22:14.460
我们当然从 Jason 档案中取得集合名称。

410
00:22:15.660 --> 00:22:18.800
现在可能也是保存文件的好时机。

411
00:22:18.820 --> 00:22:23.350
在搅拌机中重新加载，看看它实际上为您创建了这些集合。

412
00:22:23.460 --> 00:22:25.900
这只是第一步，看看它是否有效。

413
00:22:26.180 --> 00:22:30.350
并且运行它两次以查看当集合已经存在时它仍然有效。

414
00:22:31.340 --> 00:22:33.590
所以接下来我们要做的就是看一下

415
00:22:33.590 --> 00:22:36.460
在该连结键和其中的列表。

416
00:22:37.040 --> 00:22:39.670
因此，呼叫连结将为我们提供此列表

417
00:22:41.840 --> 00:22:44.670
当然，因为它是一个列表，我们可以循环它

418
00:22:44.680 --> 00:22:47.750
它将为我们提供带有文件和前缀的字典。

419
00:22:47.870 --> 00:22:50.360
让我们变得更容易一点

420
00:22:51.340 --> 00:22:56.670
取得档案和前缀键并将它们的值储存在这些变数中。

421
00:22:57.340 --> 00:23:00.270
因此，对于第一次迭代，错误路径将是

422
00:23:00.640 --> 00:23:01.360
这条路

423
00:23:02.940 --> 00:23:04.770
这个前缀将是

424
00:23:05.440 --> 00:23:06.260
这个前缀

425
00:23:08.140 --> 00:23:11.050
现在剩下的就是将一切与场景连结起来。

426
00:23:12.840 --> 00:23:15.770
但不是使用她的心脏涂层文件路径

427
00:23:17.380 --> 00:23:21.350
我们从相邻文件中获取文件路径，并且前缀相同。

428
00:23:22.940 --> 00:23:25.080
现在我们必须确保白色位置

429
00:23:25.080 --> 00:23:28.120
增加，但并非所有内容都以 Y0 结束。

430
00:23:28.130 --> 00:23:32.170
因此我们可以像之前的解释那样做同样的事情。

431
00:23:34.940 --> 00:23:40.800
我们可以从零开始位置 Y，然后将其传递到这里。完成此操作后。

432
00:23:40.800 --> 00:23:45.720
我们需要做的就是用步长增加野生位置，仅此而已。

433
00:23:45.740 --> 00:23:47.770
让我们回到搅拌机并看看它的实际情况。

434
00:23:49.520 --> 00:23:52.450
让我们删除所有内容，包括集合

435
00:23:57.240 --> 00:24:00.960
就是这样。我们有岩石，我们有植物

436
00:24:03.740 --> 00:24:08.270
文件中的所有内容都可供您开始装饰您的布景。

437
00:24:08.840 --> 00:24:10.270
现在这是最后一步

438
00:24:10.700 --> 00:24:13.720
假设资产文件发生了变化并且添加了新的内容。

439
00:24:13.950 --> 00:24:16.750
这不会自动载入到该文件中。

440
00:24:16.820 --> 00:24:20.170
如果我们再次重新运行该运算符，它将再次建立所有空的。

441
00:24:20.180 --> 00:24:22.840
包括文件中已经存在的内容。

442
00:24:22.890 --> 00:24:25.380
这是对创建空的一个小过滤器

443
00:24:25.430 --> 00:24:27.920
这样她的外套就不会试图重新创造一个空的。

444
00:24:27.920 --> 00:24:29.060
如果它已经在那里了

445
00:24:29.440 --> 00:24:32.940
为此，我们必须转到连结以查看连结事物的函数

446
00:24:32.940 --> 00:24:36.970
已经链接的很好，搅拌机会自动为我们跳过这些。

447
00:24:36.980 --> 00:24:40.660
所以我们实际上只需要担心空的创建。

448
00:24:41.240 --> 00:24:43.570
所以我们现在处于创建一个新空的行。

449
00:24:43.580 --> 00:24:47.190
因此，在此之前我们想要进行检查，我认为这是一个很好的方法。

450
00:24:47.200 --> 00:24:50.580
集合名称也将用作空名称。

451
00:24:50.590 --> 00:24:54.450
因此，如果连结到物件的集合名称已存在，

452
00:24:54.450 --> 00:24:57.260
我们知道空的已经在那里，我们可以保留它

453
00:24:58.240 --> 00:25:03.250
所以我将以此作为一种方式。所以我们不应该看到任何新的东西。弹出这里。

454
00:25:03.260 --> 00:25:05.890
当然你也可以在大纲中看到它

455
00:25:05.890 --> 00:25:08.140
呃这些数字不应该增加

456
00:25:08.140 --> 00:25:09.960
因为一切都已经加载了

457
00:25:14.240 --> 00:25:16.270
那里。你拥有它一切都很好。

458
00:25:17.140 --> 00:25:19.780
这就是本期艺术家脚本的内容。

459
00:25:19.900 --> 00:25:23.250
当然这只是个开始，但你可以想像

460
00:25:23.260 --> 00:25:27.610
当你可以将资讯储存到相邻文件中时，事情就会变得非常强大，

461
00:25:27.620 --> 00:25:31.410
将其加载到搅拌机中并使用它来刺激某些集合。

462
00:25:31.420 --> 00:25:34.860
当然集合也可以由连结集合组成。

463
00:25:35.040 --> 00:25:38.610
因此，您使用此工具建立的集合也可以是

464
00:25:38.610 --> 00:25:41.960
例如，您可以立即将其储存为快照档案的集合。

465
00:25:42.140 --> 00:25:45.900
因此，我现在将其留给您的想像和工作流程。

466
00:25:45.900 --> 00:25:48.320
就是这样 如果您有任何问题或意见，

467
00:25:48.320 --> 00:25:50.560
把它们留在下面，我很快就会见到你