WEBVTT

00:00:00.153 --> 00:00:03.643
您好，欢迎使用艺术家脚本。我叫Sybren。

00:00:03.643 --> 00:00:07.823
在这一集中，我将向您展示如何创建自己的运算符。

00:00:08.974 --> 00:00:15.799
到当前为止，我们仅创建了代码片段，您可以使用它们，但是它们不是最用户友好的。

00:00:15.799 --> 00:00:20.674
许多人问过创建菜单和按钮以及自描绘面板和内容的方法。

00:00:22.138 --> 00:00:24.443
在本集中，我们将不再关注。

00:00:25.572 --> 00:00:30.762
但是，我们将考虑一个必要的第一步，即创建您的第一个运算符。

00:00:33.508 --> 00:00:36.088
我们将看看运算符的确切含义，

00:00:36.922 --> 00:00:42.392
然后，我们将了解如何创建自己的运算符以及如何使它成为现实。

00:00:42.392 --> 00:00:44.967
通过向其传递参数来提高灵活性。

00:00:44.967 --> 00:00:49.397
然后，我们通过将运算符限制为特定的上下文来得出结论。

00:00:49.397 --> 00:00:54.502
运算符(operator)应在菜单，按钮和热键以及应由其运行的代码之间粘合。

00:00:56.364 --> 00:00:57.489
在第一集中

00:00:57.492 --> 00:01:04.122
我们已经通过将运算符从菜单和按钮复制粘贴到我们自己的脚本中来与他们进行合作。

00:01:04.851 --> 00:01:06.341
运营商可以实施

00:01:06.341 --> 00:01:09.081
在Blender中使用C编程语言编写。

00:01:10.127 --> 00:01:12.902
或者，它们当然可以用Python编写。

00:01:13.187 --> 00:01:16.277
无论如何制造，它们都具有相同的成分。

00:01:18.009 --> 00:01:20.544
首先是一个标识符。因此，

00:01:20.544 --> 00:01:27.089
这就是您要放在“bpy.ops”之后的内容，例如，在此运算符中，它远非完整，

00:01:29.090 --> 00:01:32.650
但是我们正在创建它。所以在这个例子中

00:01:33.154 --> 00:01:35.699
“bpy.ops.sfa.example”。

00:01:37.260 --> 00:01:40.310
这些总是形式“某些类别 句号 一个名称”。

00:01:42.205 --> 00:01:46.940
最好选择一个已经存在的类别，例如对象或网格或雕刻

00:01:49.399 --> 00:01:51.889
或任何适合您的运算符的东西。

00:01:52.872 --> 00:01:58.722
但是正如您所看到的，您也可以创建自己的。然后，我们有一个标签。

00:01:58.722 --> 00:02:03.482
这就是菜单项和按钮上显示的内容，并以工具提示显示说明。

00:02:05.395 --> 00:02:07.350
然后，一切都合并了

00:02:07.385 --> 00:02:09.980
类别(Class)这是我们待会儿要讨论的问题。

00:02:12.358 --> 00:02:16.493
现在，仅将其视为收集运算符所有成分的锅具。

00:02:19.919 --> 00:02:21.039
你可以看到

00:02:21.039 --> 00:02:22.739
该类以运算符命名。

00:02:22.739 --> 00:02:27.949
因此，我们用大写字母表示类别，然后将OT作为运算符类型，

00:02:27.949 --> 00:02:29.669
然后其余的标识符。

00:02:31.686 --> 00:02:36.896
到当前为止，我们已经看到了描述，但是还没有看到实际的代码。

00:02:36.896 --> 00:02:39.671
可以用不同的方式添加用于不同的目的。

00:02:39.671 --> 00:02:42.591
因此，这里有从简单到复杂的可能性。

00:02:43.554 --> 00:02:47.644
您具有“运行”，这是您放置的位置代码的主要功能。

00:02:48.900 --> 00:02:52.795
如果要创建600只猴子，则可以在这里进行。

00:02:54.088 --> 00:02:56.978
运行功能也是直接从Python调用什麽。

00:02:58.505 --> 00:03:03.380
因此，如果您呼出运算符，例如“bpy.something.something”

00:03:03.380 --> 00:03:05.190
那就是被调用的函数。

00:03:06.099 --> 00:03:10.749
然后我们有“Invoke”，当调用菜单的运算符时调用此函数

00:03:11.333 --> 00:03:12.373
或一个按钮。

00:03:13.223 --> 00:03:19.423
如果您想做一些额外的事情，在这种情况下，您想要有一些稍微不同的行为，

00:03:19.423 --> 00:03:24.358
那麽您可以在Invoke中运行此操作，然后从那里调用Execute函数。

00:03:25.203 --> 00:03:28.113
现在，我们进入最复杂的模态模型。

00:03:29.023 --> 00:03:33.203
模态功能适用于需要较长时间运行的特殊运算符。

00:03:34.764 --> 00:03:42.004
这会收到各种事件在Blender中，
当您移动鼠标时，单击按钮，然后使用键盘，就可以了。

00:03:43.996 --> 00:03:48.231
诸如Blender Cloud，纹理浏览器或CG美洲狮之类的东西，

00:03:48.231 --> 00:03:51.111
Retopo，Float，已实施，就象这样。

00:03:51.111 --> 00:03:56.266
如果所有这些之后，如果您不确定要使用哪个功能，请保持简单，

00:03:56.266 --> 00:03:57.886
只需使用运行功能。

00:03:57.886 --> 00:04:02.861
如果结果证明您无法做自己想做的事，那麽您就有具体的理由

00:04:03.378 --> 00:04:08.048
看一些更复杂的东西。但在此之前，只需保持简单即可。

00:04:09.982 --> 00:04:14.242
现在，让我们将其转换为可以使用的实际运算符。

00:04:14.242 --> 00:04:16.087
让我们再制造一些猴子。

00:04:16.941 --> 00:04:19.606
让我们从删除不需要的内容开始。

00:04:19.754 --> 00:04:25.269
让我们保持简单，只是一个Execute函数。如果您看一下网格运算符，

00:04:29.592 --> 00:04:34.182
您会看到，它们以“bpy.ops网格原始猴子添加”或

00:04:34.182 --> 00:04:37.672
“bpy.ops网格原始ico球形添加”开头

00:04:40.728 --> 00:04:45.338
因此，所有创建新网格对象的运算符都以“网格”开头。

00:04:45.723 --> 00:04:47.943
因此，让我们继续这样做。

00:04:49.327 --> 00:04:53.847
因此，ID名称变为“mesh”，我们将创建一个猴子网格。

00:04:57.265 --> 00:05:01.605
猴子网格，标签为“猴子网格”，工具提示将为

00:05:05.862 --> 00:05:07.697
“让我们散播一些喜悦”

00:05:10.449 --> 00:05:13.809
然后我们必须更改类名称，即成为类别

00:05:13.809 --> 00:05:14.884
“mesh_ot_monkey_grid”。

00:05:22.236 --> 00:05:27.616
Execute函数必须运行某些操作，但还必须告诉Blender一切是否成功。

00:05:30.936 --> 00:05:33.726
这样一切都很好，您返回“完成”

00:05:36.872 --> 00:05:39.722
这告诉Blender代码实际上运行得很好，

00:05:41.704 --> 00:05:46.219
但是也许您的运算符无法工作，也许是为了拉伸网格

00:05:46.819 --> 00:05:48.689
且网格没有任何顶点。

00:05:50.801 --> 00:05:54.646
因此，在这种情况下，您将返回“已取消”。

00:05:55.032 --> 00:05:59.162
还有其他一些选项，它们都在菜单中进行了描述。

00:06:00.451 --> 00:06:05.081
去那里您可以转到“帮助”，然后转到“Python API参考”，

00:06:05.081 --> 00:06:08.016
然后转到有关“bpy.ops”的部分。

00:06:09.333 --> 00:06:12.333
所以我们假设
一切都会正常进行，

00:06:14.565 --> 00:06:15.995
我们将返回“完成”。

00:06:16.613 --> 00:06:21.683
现在，我们要做的就是将代码放入此处以创建我们的猴子网格。

00:06:23.568 --> 00:06:28.913
因此，让我们复制“脚本艺术家”第3章中的代码，并将其放在此处。

00:06:28.913 --> 00:06:32.683
因此，这会在25行中创建600只猴子，

00:06:35.935 --> 00:06:38.085
它们之间有一个Blender单元。

00:06:40.182 --> 00:06:44.562
运算符几乎已经完成了。所以我们这里有所有的成分。

00:06:46.292 --> 00:06:51.662
现在我们唯一需要做的就是告诉Blender这个操作项存在，这叫做注册。

00:06:56.249 --> 00:06:59.299
幸运的是，这很简单，我们只称

00:06:59.299 --> 00:07:05.804
“bpy.utils.register_class”，然后是类的名称，
在本例中为“网眼OT猴子网格”。

00:07:08.099 --> 00:07:08.944
为了对称，

00:07:09.454 --> 00:07:13.274
还应该有取消注册功能。这样看起来象这样。

00:07:15.123 --> 00:07:18.658
代替调用“注册类”，它被称为“取消注册类”。

00:07:20.051 --> 00:07:25.166
基本上，它撤消了寄存器功能的作用，然后，我们快要完成了。

00:07:26.513 --> 00:07:28.638
如您所知，当您拥有

00:07:29.000 --> 00:07:32.395
这样的函数，运行脚本时不会自动调用它。

00:07:34.974 --> 00:07:36.289
有一个小窍门。

00:07:38.042 --> 00:07:42.517
如果您在此处添加这样的魔术，它看起来会有些奇怪。

00:07:44.862 --> 00:07:50.617
但是从根本上讲，这意味着，如果运行此脚本，则应调用register函数。

00:07:53.341 --> 00:07:59.411
Blender可以通过多种方式访问​​脚本，运行脚本，也可以从其他方式导入脚本，

00:08:03.786 --> 00:08:08.331
就象我们导入BPY一样，其他代码也可以导入此文档。

00:08:09.991 --> 00:08:15.866
因此，从其他位置导入与运行之间是有区别的。而且只有在运行时，

00:08:16.149 --> 00:08:20.359
它应该调用Register函数吗，这就是这段代码的作用。

00:08:24.235 --> 00:08:28.820
现在，我们可以做的就是将其命名为“monkey_grid.py”

00:08:30.638 --> 00:08:31.493
很好

00:08:32.913 --> 00:08:34.218
然后点击播放。

00:08:36.486 --> 00:08:39.366
而且什麽也没发生，这是一件好事。

00:08:41.432 --> 00:08:46.312
我们没有看到任何错误消息，我们的代码也没有显示任何消息。

00:08:47.131 --> 00:08:49.541
因此，这里的沉默是件好事。

00:08:50.872 --> 00:08:53.662
那麽，让我们看看现在会发生什麽，

00:08:55.478 --> 00:08:58.013
“bpy.ops.mesh.monkey_grid”

00:09:02.922 --> 00:09:05.642
好了 我们可以创建一个猴子抓地力。

00:09:05.954 --> 00:09:11.039
运算符在那里。让我们散布一些喜悦。我们不要在这里称呼它。

00:09:11.039 --> 00:09:15.654
让我们看看是否可以在F3菜单中找到我们的新运算符

00:09:17.582 --> 00:09:21.977
和猴子在一起，还有你的猴子网格。所以这真的很酷。

00:09:22.232 --> 00:09:24.432
按“输入”运行它。如您所见，

00:09:25.777 --> 00:09:29.002
Blender现在冻结一只正在制造600只猴子。

00:09:29.469 --> 00:09:36.399
这就是当您运行需要花一些时间在Execute函数中
并且没关系的事情时发生的情况。

00:09:36.686 --> 00:09:37.686
该代码是

00:09:37.946 --> 00:09:43.361
此Blend文档。因此，让我们看看创建新的Blend文档时会发生什麽。

00:09:47.355 --> 00:09:49.710
如您所见，运算符仍在那儿。

00:09:49.897 --> 00:09:51.977
已加载到Blender的内存中。

00:09:53.744 --> 00:09:56.234
它已注册，并且一直在发送。

00:09:56.509 --> 00:10:00.899
现在，让我们看看会发生什麽如果重新启动Blender。

00:10:05.265 --> 00:10:08.185
现在，猴子网格运算符不再存在。

00:10:08.587 --> 00:10:16.137
这是因为，Blender不仅运行了可以在Blend文档中找到的所有脚本，
还必须告诉它首先运行该脚本。

00:10:17.638 --> 00:10:21.258
您必须确保文本文档的名称以“.py”结尾，

00:10:23.205 --> 00:10:25.015
然后在文本菜单中，

00:10:25.462 --> 00:10:27.782
您可以选中已注册复选框。

00:10:29.487 --> 00:10:32.212
现在，保存，重新启动Blender，

00:10:36.687 --> 00:10:41.477
现在就在那里。因此，让我们玩得开心，并添加一些参数。

00:10:42.304 --> 00:10:47.019
添加立方体时，在此处左侧看到的内容称为“重做”面板。

00:10:47.747 --> 00:10:50.717
打开它时，您会看到不同的参数

00:10:51.295 --> 00:10:53.660
您可以设置。所以发生的是

00:10:53.660 --> 00:10:55.470
当您更改参数值时，

00:10:56.332 --> 00:11:00.732
Blenderoa会自动地按下“撤消”按钮和重新运行运算符。

00:11:03.196 --> 00:11:08.151
这就是为什麽将其称为“重做”面板的原因，因为它一直在重做。

00:11:08.151 --> 00:11:12.131
因此，让我们向运算符添加对“重做”面板的支持。

00:11:12.499 --> 00:11:14.869
我们首先声明我们想要的属性。

00:11:16.397 --> 00:11:21.692
这将是X方向上的猴子数，Y方向上的猴子数以及猴子的大小。

00:11:23.362 --> 00:11:28.932
就象运算符位于“bpy.ops”中一样，属性也位于“bpy.props”中。

00:11:31.046 --> 00:11:34.206
再说一遍，如果你想要获取更多信息，

00:11:34.206 --> 00:11:39.411
只需转到“帮助”，“Python”，“API参考”，然后单击“bpy.props”部分。

00:11:40.376 --> 00:11:42.371
我给你看看起来象什麽。

00:11:42.862 --> 00:11:46.932
我们称其为“count x：bpy.props.IntProperty”。

00:11:54.878 --> 00:11:59.308
IN代表整数，表示整数，因为我们不能有半只猴子。

00:12:01.150 --> 00:12:03.835
所以计数X必须是一或二或三，

00:12:05.264 --> 00:12:07.469
但永远不能象2.5一样。

00:12:09.195 --> 00:12:13.295
因此，它仅是整数，它声明我们要拥有该属性。

00:12:16.817 --> 00:12:20.657
这里的“：”和此处的“=”符号之间有很大的区别。

00:12:25.333 --> 00:12:27.638
这将一个名称设置为一个值，

00:12:28.237 --> 00:12:32.752
这是为了只需设置。我们必须设置“BL ID名称”以匹配

00:12:33.846 --> 00:12:38.886
“猴子网格”使其工作。但是在这里我们并没有真正设置任何东西。

00:12:39.969 --> 00:12:45.019
我们只是向Blender声明，这是一个IN属性，请相应运行操作。

00:12:47.095 --> 00:12:50.350
您可以在此处添加一些参数以更改行为。

00:12:51.028 --> 00:12:53.573
首先，我们应该设置一个名称。

00:12:54.973 --> 00:12:58.168
我们可以称它为X。这可能有点神秘。

00:12:58.168 --> 00:13:00.348
但就当前而言，会做到的。

00:13:00.486 --> 00:13:02.406
我们可以添加一个描述，

00:13:03.772 --> 00:13:05.612
“X方向上的猴子数”。

00:13:09.619 --> 00:13:11.869
因此，我们将其复制到Y。

00:13:17.291 --> 00:13:21.966
将此Y命名为“Y方向上的猴子数”，并命名为任意大小，

00:13:23.436 --> 00:13:26.626
这就是另一个“bpy.props.FloatProperty”

00:13:30.856 --> 00:13:34.906
float代表浮点数，是仅十进制数字的技术术语。

00:13:40.844 --> 00:13:47.084
“名称=大小”和“描述=每只猴子的大小”，这为我们提供了属性，但尚未使用。

00:13:54.367 --> 00:13:55.627
让我们来看看

00:13:55.627 --> 00:13:58.532
在我们应该使用它们的Execute函数中。

00:13:59.014 --> 00:14:05.409
这个注释必须走，因为我们不再在25行中创建600只猴子，但是它非常灵活。

00:14:07.731 --> 00:14:10.246
因此，让我们暂时将其删除。

00:14:13.105 --> 00:14:15.135
现在我们必须访问属性。

00:14:15.940 --> 00:14:21.115
因此，我们已经声明了它们，并且此“自我”使我们可以访问实际值。

00:14:22.749 --> 00:14:27.839
“自我”是很重要的事情，在这里我不会详细介绍它所代表的含义。

00:14:28.886 --> 00:14:31.066
只要知道，如果您声明

00:14:32.187 --> 00:14:37.622
此处的属性为count X，
那麽您可以在此处以“self.count X”访问它。

00:14:39.210 --> 00:14:40.620
所以猴子总数

00:14:42.812 --> 00:14:45.292
是X和Y方向上的猴子数，

00:14:47.727 --> 00:14:50.892
这里的25是X方向上的猴子数。

00:14:59.272 --> 00:15:01.982
然后，剩下的就是设置一个大小，

00:15:03.876 --> 00:15:04.771
就是这样。

00:15:05.235 --> 00:15:06.135
试一试吧。

00:15:09.796 --> 00:15:12.386
让我们看看控制台中发生了什麽。

00:15:17.465 --> 00:15:21.910
在这里，您可以看到我们的属性，X，Y，大小，

00:15:22.367 --> 00:15:26.247
它们都等于0，因为我们尚未设置任何默认值。

00:15:34.890 --> 00:15:37.220
那里，我们有我们的三只猴子。

00:15:38.401 --> 00:15:43.466
在我们从视口实际调用它之前，让我们设置一些明智的默认值。

00:15:49.778 --> 00:15:50.883
默认值为3。

00:15:53.526 --> 00:15:57.916
对于Y，默认值为2，我故意在其中选择不同的值。

00:15:59.244 --> 00:16:00.344
这是默认值。

00:16:00.344 --> 00:16:05.509
因此，当有人单击猴子网格按钮或从F3列表中选择它时，

00:16:05.930 --> 00:16:07.790
这将是他们所追求的。

00:16:07.810 --> 00:16:13.115
因为他们看到3x2的网格，所以他们立即知道需要进行哪些更改。

00:16:15.060 --> 00:16:21.675
如果他们想将3更改为4，只需将3更改为4，而不必考虑是X方向还是Y方向。

00:16:24.409 --> 00:16:29.334
因此，如果我们给他们相同的默认值，那麽他们将看不到它。

00:16:29.797 --> 00:16:31.677
然后，他们将拥有

00:16:31.872 --> 00:16:36.402
例如哪个方向是X，哪个方向是Y，我想更改哪个值。

00:16:36.983 --> 00:16:39.808
这就是为什麽我给他们独特的价值观。

00:16:45.758 --> 00:16:48.353
最后，默认大小，再次运行，

00:16:52.836 --> 00:16:54.261
删除所有内容。

00:17:00.544 --> 00:17:03.029
在这里，您可以看到默认值。

00:17:03.029 --> 00:17:07.164
当我们运行时没有任何值时，它将仅使用默认值。

00:17:10.655 --> 00:17:12.340
与F3菜单相同。

00:17:13.745 --> 00:17:17.975
还剩下一个步骤，那就是获得“重做”面板。我们有属性，

00:17:19.696 --> 00:17:22.011
因此，Blender知道该去哪里。

00:17:24.155 --> 00:17:27.190
只是还不知道我们是否支持该Redo面板。

00:17:29.622 --> 00:17:32.367
因此，让我们告诉Blender我们这样做。

00:17:35.686 --> 00:17:39.151
这是通过“bl选项”完成的。默认值为“注册”，

00:17:41.156 --> 00:17:45.891
并且我们必须在其中添加“撤消”。这将为我们提供最终成分。

00:17:52.859 --> 00:17:53.699
这就对了，

00:17:55.460 --> 00:18:00.390
现在我们可以使它们变大和变小，甚至为它们提供无效的值。

00:18:01.741 --> 00:18:07.151
因此，为了让人们使用起来愉快，我们应该对滑块进行真正的设置，

00:18:08.082 --> 00:18:11.387
以便，您可以在此处选择所有明智的值。

00:18:12.126 --> 00:18:14.156
幸运的是，这很简单。

00:18:16.345 --> 00:18:18.415
我们可以设置最小值为1。

00:18:19.792 --> 00:18:24.417
因为创建0个猴子没有意义。甚至更少地制造负数猴子。

00:18:26.544 --> 00:18:30.844
因此，让我们尝试1。现在将最大数量设置为10。

00:18:35.871 --> 00:18:38.506
我们可以对Y计数做同样的事情，

00:18:39.241 --> 00:18:43.736
我们可以将大小0设置为最小值，将最大值设置为1。

00:18:54.474 --> 00:18:58.684
现在，我们可以拖拉，并且一切仍然美好而理智。

00:19:02.654 --> 00:19:07.159
您会看到，当这些数字增加时，它已经变得有点慢了。

00:19:08.036 --> 00:19:10.846
而且我们仍然无法达到之前的600

00:19:12.292 --> 00:19:16.467
即使我在此处键入100，它也会被最大程度地切断。

00:19:18.006 --> 00:19:21.036
因此，这就是Blender具有软限制的原因。

00:19:21.036 --> 00:19:26.191
硬限制是我们现在设置的，即属性值的绝对限制。而软限制是

00:19:27.681 --> 00:19:29.971
拖动时滑块将运行的操作。

00:19:33.271 --> 00:19:39.246
因此，如果您想允许最大值大于10或大小大于1，但仍然需要这些限制

00:19:42.849 --> 00:19:47.484
作为滑块的极限，您可以将最大值更改为柔和的最大值。

00:19:50.119 --> 00:19:55.669
我们现在拥有的最小值实际上是最小值，因为创建0个猴子没有意义，

00:19:55.669 --> 00:20:01.364
负数的猴子是不可能的。同样，创建一个负大小的猴子也是不可能的。

00:20:01.364 --> 00:20:04.034
因此，让我们将最大值更改为soft。

00:20:15.123 --> 00:20:17.473
现在，拖动仍然是相同的，

00:20:20.563 --> 00:20:24.653
但是我们可以将其设置为创建比拖动更多的猴子。

00:20:27.286 --> 00:20:29.731
现在，让我们回到该类声明。

00:20:30.528 --> 00:20:34.783
我将进一步解释有关类如何以初始方式工作的信息，

00:20:36.758 --> 00:20:39.428
我希望不要过多地讨论技术细节。

00:20:40.276 --> 00:20:42.311
类使用称为继承的系统，

00:20:43.242 --> 00:20:46.517
就象与人一样，它就象一个父子结构。

00:20:49.085 --> 00:20:53.850
因此，在这种情况下，“bpy.types.operator”是父级，

00:20:55.160 --> 00:20:58.445
并且“网格OT猴子网格”是访问到子级。

00:20:59.230 --> 00:21:03.765
如果您问孩子一个您知道答案的问题，例如您想吃饼干，

00:21:06.540 --> 00:21:09.085
当然，孩子会立即不答应父母。

00:21:11.327 --> 00:21:17.042
但是，如果您询问税收，那麽“妈妈，请帮助我，因为我什麽都不知道！”

00:21:18.301 --> 00:21:21.101
然后孩子顺从这个问题交给父母。

00:21:23.941 --> 00:21:27.011
大致上，类与Python中的工作方式相同。

00:21:30.871 --> 00:21:32.841
我们可以不用“bl”选项。

00:21:33.740 --> 00:21:37.325
我们的孩子对此一无所知。于是Python问父母。

00:21:40.488 --> 00:21:45.853
当我们想拥有不同的东西时，我们可以为孩子和班级添加“bl”选项。

00:21:48.781 --> 00:21:52.016
然后，首先要问因此优先于父母的意愿。

00:21:56.019 --> 00:22:00.519
因此，我们总是有幸运的孩子们得到他们想要的所有cookie。

00:22:02.335 --> 00:22:06.395
在结束本视频之前，我还有两件事我想告诉你。

00:22:07.600 --> 00:22:10.225
再次，我们看一下Execute函数。

00:22:11.077 --> 00:22:16.967
您会看到它获得了一个上下文参数，这非常类似于我们之前所见的上下文。

00:22:18.414 --> 00:22:23.179
它给我们“上下文对象”，“context.scene”，“context.selected对象”，

00:22:25.976 --> 00:22:31.451
您之前在“
bpy.context”中看到的所有这些内容也都到达了这里，

00:22:31.451 --> 00:22:34.771
但是随后专门针对此运算符进行了本地化。

00:22:36.262 --> 00:22:42.867
因此，作为一般经验法则，如果您有一个获取上下文的函数，请使用该上下文。

00:22:43.358 --> 00:22:45.513
请勿使用“ bpy.context。

00:22:46.238 --> 00:22:51.978
因此，如果您想在此Execute函数中对所有选定的姿势骨骼进行操作，

00:22:52.828 --> 00:22:55.828
您将使用“context.selected姿势骨骼”。

00:23:01.506 --> 00:23:07.476
另一个功能是我想向您展示的第二件事，另一个获得上下文的功能是Poll功能，

00:23:09.785 --> 00:23:15.620
而且它的编写方式有点怪异，但只要从我这里获取，它就可以那样工作。

00:23:27.580 --> 00:23:30.840
同样，您在此函数中获得一个上下文。

00:23:30.840 --> 00:23:34.675
但是，除了做类似的事情，而不是运行动作，

00:23:36.921 --> 00:23:40.131
此功能旨在检查是否可以运行此操作。

00:23:42.376 --> 00:23:48.416
因此，每次应该在菜单中显示此运算符时，Blender都会调用此轮询功能，

00:23:50.503 --> 00:23:54.698
或作为面板上的按钮。我可以告诉你这是如何工作的。

00:23:55.681 --> 00:24:01.156
现在，返回“true”，这意味着它始终象以前一样被允许。 和以前一样，

00:24:04.855 --> 00:24:06.900
它显示在F3菜单中。

00:24:08.996 --> 00:24:10.686
当我碰到“假(False)”的时候，

00:24:12.799 --> 00:24:16.609
它永远不会出现在任何地方，这是没有用的。

00:24:17.171 --> 00:24:20.251
让我们对其进行调整，使其更加有用。

00:24:22.246 --> 00:24:24.721
您可以在控制台中看到这里

00:24:27.268 --> 00:24:31.598
我们有自动完成功能，这在Python控制台中很有意义。

00:24:32.333 --> 00:24:34.493
但是那个运算符不起作用

00:24:36.623 --> 00:24:41.533
在3D视口中，因为上下文错误。这也是我们可以做的事情。

00:24:44.053 --> 00:24:46.983
现在，当我再次将其更改为“真(true)”时，

00:24:51.333 --> 00:24:55.493
Monkey网格运算符也会在Python出现的上下文中显示。

00:24:57.165 --> 00:25:01.705
它会显示在Blender中的任何位置，这并不是正确的方法。

00:25:03.276 --> 00:25:06.686
让我们再看一看在该上下文中的变量处。

00:25:09.224 --> 00:25:14.739
“Context.area”为您提供了Blender用户界面中
当前处于活动状态的区域。

00:25:16.386 --> 00:25:20.041
因此，在这种情况下，它将是控制台。

00:25:20.041 --> 00:25:23.186
但是如果鼠标在这里，我们拉出3个菜单，

00:25:23.186 --> 00:25:28.411
然后突然之间，它的3D视口处于活动状态，这里就是“大纲视图”。

00:25:29.803 --> 00:25:33.768
所以Blender中的每个区域都有自己的区域类型

00:25:33.950 --> 00:25:39.290
我们可以在“投票”功能中使用该功能，以确保它仅在该地区有效

00:25:42.644 --> 00:25:44.754
我不喜欢的一件事是猜测。

00:25:45.619 --> 00:25:51.619
因此，我们现在知道控制台的“区域类型”是“控制台”，但是在3D视口中是吗？

00:25:51.835 --> 00:25:56.715
是“3D视图”吗？“3D_view”，是“3D视口”吗？

00:25:59.527 --> 00:26:02.972
我不知道。因此，让我们让脚本告诉我们。

00:26:05.822 --> 00:26:09.712
我可以说“打印我的区域是context.area.type”

00:26:17.124 --> 00:26:21.764
让我们看看将所有这些打印稿发送到的终端上发生了什麽。

00:26:24.894 --> 00:26:29.569
在这里，您看到了控制台，然后立即看到它被称为

00:26:30.235 --> 00:26:36.720
“我的区域是3D视图”。当我在大纲视图中运行此操作时，
“我的区域就是大纲视图”。

00:26:37.404 --> 00:26:40.249
如果我在“属性”面板中运行此操作，

00:26:40.288 --> 00:26:41.703
我的区域是属性。

00:26:42.653 --> 00:26:47.668
这样，您就可以使用这些打印语句来知道必须放置在什麽位置。

00:26:50.141 --> 00:26:53.876
现在，我们知道了要为3D视口使用哪个值。

00:26:53.917 --> 00:26:55.892
因此，让我们开始吧。

00:26:56.327 --> 00:27:00.502
如果“context.area.type = view 3D”，则返回“true”。

00:27:05.033 --> 00:27:07.178
否则，我们可以返回“false”。

00:27:09.045 --> 00:27:11.275
让我们看看它是如何工作的。

00:27:15.231 --> 00:27:17.161
在这里，它仍然显示。

00:27:18.809 --> 00:27:24.929
但是这里不再存在，当然，这里和那里现在只显示在我们希望它显示的位置。

00:27:28.924 --> 00:27:30.059
最后一件事，

00:27:31.588 --> 00:27:35.973
这种结构，我也从经验丰富的进程员那里看到很多。

00:27:37.506 --> 00:27:39.321
它比必要的更为复杂。

00:27:40.731 --> 00:27:43.546
因为这个家伙已经是对或错的表达。

00:27:47.644 --> 00:27:53.674
因此，基本上，代码在说什麽，如果这个东西的价值，这个选定的表达式，

00:27:56.940 --> 00:27:59.790
如果该事物的值为true，则返回true；

00:28:00.864 --> 00:28:03.784
如果该事物的值为false，则返回false。

00:28:05.345 --> 00:28:07.270
所以这基本上意味着

00:28:07.892 --> 00:28:11.022
返回该事物的值，您当然可以这样写。

00:28:19.609 --> 00:28:22.144
这就是“艺术家脚本”这一集的内容。

00:28:22.960 --> 00:28:28.230
如果您有任何疑问或意见，请在下面发表评论，我们很快会再见。