WEBVTT

00:00.000 --> 00:04.720
Blender 4.2 已经发布了，我想藉此机会回顾其中的一些内容

00:04.721 --> 00:06.560
对于几何节点来说是新的东西。

00:07.340 --> 00:10.260
在本影片中，我们将了解新的矩阵插座。

00:10.880 --> 00:13.139
还有另一个有关新内容的视频

00:13.140 --> 00:15.380
您可以稍后查看节点工具。

00:15.880 --> 00:20.540
如果您前往 Blender.org 上的发布节点页面并向下卷动到

00:20.541 --> 00:23.624
几何节点部分，你发现有一个整体

00:23.625 --> 00:26.600
现在矩阵几何节点中的新套接字类型。

00:27.140 --> 00:32.500
这里的这个小示范文件展示了如何使用这个新套接字来处理

00:32.501 --> 00:35.580
转变比以前容易得多。

00:35.980 --> 00:40.280
在本例中，为这堆披萨盒制作一个小型的堆叠修改器。

00:40.780 --> 00:44.560
首先让我简单介绍一下这个新套接字的用途是什么

00:44.561 --> 00:47.508
类型是，然后引导您完成创建

00:47.509 --> 00:50.141
此演示中的修改器更详细一些。

00:50.920 --> 00:53.060
那么，矩阵的意义何在？

00:53.061 --> 00:57.200
嗯，有很多数学背景可以涵盖

00:57.201 --> 01:00.500
谈论矩阵，但这现在并不重要。

01:01.160 --> 01:05.200
在搅拌机中使用矩阵插座需要了解的最重要的事情

01:05.201 --> 01:09.557
几何节点是 4x4 矩阵是一个非常

01:09.558 --> 01:12.841
表示转换的有用方法。

01:13.220 --> 01:15.260
这也是搅拌机在幕后所做的事。

01:16.100 --> 01:22.000
一般来说，转换由翻译的三个部分组成，

01:23.160 --> 01:24.500
旋转和缩放。

01:24.860 --> 01:31.840
因此，不要将矩阵视为网格或 4x4，这并没有多大帮助

01:31.841 --> 01:36.300
为了了解到底发生了什么，你可以在

01:36.301 --> 01:40.980
平移、旋转和缩放变换的背景。

01:40.981 --> 01:46.468
因此，为此，在搅拌机中创建矩阵的最简单方法

01:46.469 --> 01:51.000
几何节点现在是使用组合变换节点。

01:52.020 --> 01:54.784
在那里，您只需选择插入您的值即可

01:54.785 --> 01:58.720
平移、旋转和缩放，然后得到矩阵。

01:59.680 --> 02:05.400
但您也可以直接从物件中检索转换。

02:05.680 --> 02:10.040
因此，在此立方体的修改器上，例如，让我们拖放

02:10.041 --> 02:14.900
相机物件进入节点树，在那里你可以看到除了

02:14.901 --> 02:18.158
物件的位置、旋转和变换

02:18.159 --> 02:22.400
缩放后，我们也得到了作为一个套接字的变换矩阵。

02:23.040 --> 02:26.456
这个转换套接字现在封装了所有

02:26.457 --> 02:30.120
转换来自这三个单独套接字的讯息。

02:31.200 --> 02:34.140
这可以使节点树中的处理变得更加容易。

02:34.940 --> 02:43.000
例如，如果我们现在想要将立方体移到与

02:43.001 --> 02:47.801
相机，我们可以轻松地使用变换来做到这一点

02:47.802 --> 02:51.980
几何节点，然后将其设定为矩阵模式。

02:53.020 --> 02:57.660
然后将相机的变换连接到操作的变换

02:57.661 --> 03:00.482
将立方体直接放入完全相同的立方体中

03:00.483 --> 03:04.181
与相机一样的位置、旋转和缩放。

03:04.360 --> 03:08.180
所以，如果你现在移动它，你会看到它是如何真正受到限制的

03:08.181 --> 03:11.540
直接相机，全部使用几何节点。

03:12.840 --> 03:16.400
在使用位置、旋转和缩放之前这是可能的，

03:17.080 --> 03:19.000
但这会有点乏味。

03:19.480 --> 03:22.960
现在透过这个转变，我们还可以做一些额外的事情。

03:23.880 --> 03:26.900
例如，我们可以将它与另一个变换结合。

03:27.580 --> 03:29.960
因此，让我们使用组合变换节点。

03:29.961 --> 03:33.271
然后进行这两个转换

03:33.272 --> 03:36.700
我们可以立即使用乘法矩阵节点。

03:37.800 --> 03:41.620
再说一遍，我不会深入探讨其工作原理的数学细节，

03:42.320 --> 03:46.066
但两个矩阵相乘基本上意味著

03:46.067 --> 03:49.260
在此背景下结合这两种转换。

03:49.880 --> 03:55.720
因此，如果我将两个矩阵插入此处，然后在

03:55.721 --> 03:59.458
翻译，你可以看到它是如何移动立方体的

03:59.459 --> 04:03.380
除了我们对相机所做的转换之外。

04:04.100 --> 04:10.000
但在这里，您可以看到我们插入正 X 的平移向量

04:10.001 --> 04:15.340
value 实际上并没有沿著物件的 X 轴移动立方体。

04:16.100 --> 04:20.300
这就是这两个输入的顺序发挥作用的地方。

04:20.301 --> 04:27.640
由于我们首先对相机进行了变换，这意味著这

04:27.641 --> 04:32.200
变换发生在相机的空间。

04:33.220 --> 04:37.480
因此，我们目前正在沿著相机的 X 轴移动立方体。

04:39.620 --> 04:45.100
如果我颠倒这两个输入的顺序，您可以看到这个向量现在如何

04:45.101 --> 04:49.600
对立方体物件的 X 轴有影响。

04:49.601 --> 04:52.647
所以，这是需要警惕的事情

04:52.648 --> 04:55.741
您正在组合矩阵进行转换。

04:56.600 --> 05:00.336
您可以做的另一件事，例如，改变

05:00.337 --> 05:03.800
周围的变换是矩阵的逆。

05:04.420 --> 05:07.820
对于转换来说，这也正是你想像的那样。

05:08.140 --> 05:11.980
它透过做完全相反的事情来反转转换。

05:11.981 --> 05:17.861
这些不同空间之间的转换

05:17.862 --> 05:21.920
从全局到局部以及不同物件之间等。

05:22.560 --> 05:24.700
很快就会变得非常复杂。

05:25.240 --> 05:30.280
因此，将整个转换概念结合到一个

05:30.281 --> 05:35.480
具有简单应用程式的单一套接字，而不必处理它们

05:35.481 --> 05:38.120
分别作为位置、旋转和比例。

05:38.900 --> 05:44.680
此矩阵插座的另一个面向是它不仅适用于

05:44.681 --> 05:47.780
从这些链结携带的单一矩阵。

05:48.260 --> 05:54.541
由于它是一种全新的套接字类型，因此它也可以应用于栏位和属性。

05:54.760 --> 05:59.840
因此，我们可以为几何图形的每个元素储存一个完整的变换矩阵，

06:00.480 --> 06:02.560
例如，对于网格的每个点。

06:03.080 --> 06:06.540
当我们查看演示文件时，这很快就会派上用场。

06:07.760 --> 06:10.580
好吧，让我们开始堆放一些披萨盒。

06:11.480 --> 06:15.800
如果您从发行说明页面下载演示文件，您可以看到

06:15.801 --> 06:21.820
这是一个相对简单的场景，这个人开著 Vespa 运载披萨盒。

06:23.140 --> 06:27.760
披萨堆上只有一个修改器可以为您提供一些控制

06:27.761 --> 06:30.555
控制堆叠的高度，然后

06:30.556 --> 06:33.421
一些额外的随机化设定。

06:35.200 --> 06:39.064
这在很大程度上依赖于矩阵的使用

06:39.065 --> 06:42.700
在这些不同的盒子之间传播转换。

06:43.860 --> 06:51.320
因此，例如，当我增加随机旋转或

06:51.321 --> 06:57.200
随机偏移，披萨盒不只是简单地单独移动。

06:57.940 --> 06:59.620
它们都互相影响。

06:59.621 --> 07:04.360
所以，就像在一堆真正的披萨盒上一样，如果我只是画一个非常粗糙的

07:04.361 --> 07:11.380
例如，下面的盒子的方向会影响上面的盒子。

07:11.780 --> 07:15.168
所以，如果有一个稍微倾斜的盒子，

07:15.169 --> 07:18.941
它上面的那些也会有倾斜。

07:19.720 --> 07:25.400
以前这不是那么容易做到的，但现在有了矩阵节点，这很漂亮

07:25.401 --> 07:31.640
很容易获得一个元素的变换来影响它上面的其他元素。

07:32.220 --> 07:33.700
那么，让我们来看看它是如何运作的。

07:34.740 --> 07:40.460
这个范例案例的另一个方面是，当我启动时你可以清楚地看到

07:40.461 --> 07:44.050
数字非常高，有轻微的反弹

07:44.051 --> 07:49.660
当 Vespa 车抖动时，它穿过披萨堆。

07:49.880 --> 07:52.860
这实际上是从底部一直到顶部。

07:53.520 --> 07:59.800
为此，它还在非常简单的模拟设定中使用矩阵插座。

08:01.140 --> 08:03.296
当然，这可能会违反法律

08:03.297 --> 08:06.821
物理学来创造这种非常有趣的效果。

08:07.180 --> 08:09.280
那么，让我们开始堆叠这些盒子。

08:10.200 --> 08:13.040
首先，我们将从一个全新的立方体开始。

08:14.340 --> 08:18.362
在那里，我将进入编辑模式，然后将其缩放到 0.5

08:18.363 --> 08:22.900
大小，因为这意味著每条边都是一个单位。

08:24.260 --> 08:28.317
然后在Z轴上移动0.5，即

08:28.318 --> 08:32.120
意味著它很好地站在原点上。

08:33.200 --> 08:35.240
这对于节点设定很有用。

08:36.200 --> 08:40.000
因此，让我们先建立一个新的几何节点修改器。

08:40.940 --> 08:43.200
我们称之为披萨堆。

08:44.060 --> 08:47.220
现在让我们开始为此堆叠设定基础。

08:47.221 --> 08:51.124
我想从一大堆实例开始

08:51.125 --> 08:54.480
这个立方体，这将是我的披萨盒。

08:55.800 --> 08:58.320
为此，我将从

08:58.321 --> 09:02.181
点节点给我一堆基点。

09:02.800 --> 09:04.480
现在将其设定为 25。

09:05.720 --> 09:09.040
然后是点节点上的实例。

09:10.160 --> 09:14.900
我们将实例化的几何体将是我从立方体的输入。

09:15.900 --> 09:18.874
正如您在电子表格编辑器中看到的，现在

09:18.875 --> 09:21.741
我们最终得到了同一个立方体的 25 个实例。

09:22.340 --> 09:26.238
所以让我们把它们再压扁一点，做成披萨盒的形状

09:26.239 --> 09:29.880
透过使用随机值节点然后调整设定。

09:30.900 --> 09:33.999
因此，让我们从 XY 轴上的一个开始，但是

09:34.000 --> 09:38.620
稍微高一点可以有更多的随机性到 1.5。

09:38.820 --> 09:41.740
然后在 Z 轴上，我只想要低值。

09:41.741 --> 09:46.560
所以我们从 0.05 到 0.3。

09:47.200 --> 09:49.620
然后我们就得到了形状的各种变化。

09:51.080 --> 09:57.840
现在，所有这些不同的实例都有其精确的尺寸作为比例。

09:58.580 --> 10:03.480
我们可以简单地将其与实例缩放节点一起使用。

10:04.840 --> 10:10.040
这就是我们获取每个立方体的高度资讯的地方。

10:10.041 --> 10:12.640
这就是我们创建堆叠所需的东西。

10:13.220 --> 10:15.485
为了更好地了解我们所看到的内容，

10:15.486 --> 10:18.801
让我进入这个物件的本地视图。

10:18.840 --> 10:21.500
那么我们现在要如何将这些盒子放到正确的位置呢？

10:21.820 --> 10:25.298
我们将用来定位这些的主节点

10:25.299 --> 10:28.501
instances 是集合实例变换节点。

10:29.060 --> 10:32.632
这让我们可以直接设定精确的转换

10:32.633 --> 10:36.140
所有这些盒子都使用新的矩阵插座。

10:36.141 --> 10:44.360
因此，如果我现在添加一个组合变换节点，您可以看到所有比例

10:44.361 --> 10:47.078
我们之前一直在随机化，现在已经设定了

10:47.079 --> 10:49.760
回到该节点中定义的内容。

10:50.540 --> 10:55.440
因此，让我们结合其中的实例规模，以确保我们保持这一点。

10:56.000 --> 11:00.200
然后是平移和旋转，我们可以设定为任何其他值，

11:00.540 --> 11:02.580
这些将应用于所有实例。

11:02.581 --> 11:07.040
现在我们只需要找出每个实例的实际位置。

11:07.900 --> 11:10.840
为此，我将向您展示一个非常有用的小技巧。

11:11.740 --> 11:14.040
让我们使用累积字段节点。

11:14.880 --> 11:21.000
所以这个节点的作用是对于几何域，在我们的例子中

11:21.001 --> 11:26.660
将是实例域，它经历所有不同的元素

11:26.661 --> 11:33.400
在同一组内，然后累积某个栏位的值。

11:34.540 --> 11:38.560
在我们的例子中，这将是一个变换栏位。

11:39.300 --> 11:41.620
因此，让我们设定要转换的资料类型。

11:42.280 --> 11:46.600
然后这个节点将会遍历所有单独的

11:46.601 --> 11:50.580
这些立方体的实例，然后累积变换。

11:50.940 --> 11:56.480
因此，每个立方体不再只知道自己的变换，而是经历

11:56.481 --> 11:59.585
所有先前的并将它们添加到每个的顶部

11:59.586 --> 12:02.240
其他，这正是我们这个堆叠所需要的。

12:02.740 --> 12:04.020
让我向您展示它是如何工作的。

12:04.480 --> 12:10.700
让我们将该节点的尾随输出连接到一个单独的变换节点。

12:10.940 --> 12:15.680
为此，我们只需要平移和旋转，因此我们将其插入我们的

12:15.681 --> 12:18.860
合并节点，因为比例已经处理完毕。

12:19.140 --> 12:24.020
现在这个累加字段节点的输入什么都没有，所以我们不是

12:24.021 --> 12:27.520
对每个实例应用任何转换。

12:28.100 --> 12:34.020
但现在，当我使用另一个组合变换节点来给我一个矩阵栏位时，

12:34.420 --> 12:40.220
我调整这些值，你可以看到每个立方体是如何移动的

12:40.221 --> 12:46.300
比之前所有的加起来还要多，而不是一次全部移动。

12:46.840 --> 12:50.680
旋转和缩放也是如此。

12:51.340 --> 12:56.540
所以你可以看到，仅使用变换的概念是非常有用的

12:56.541 --> 13:00.000
积累，而不是自己做所有的数学。

13:01.020 --> 13:05.600
所以之前所有的披萨盒都会影响上面的披萨盒。

13:07.060 --> 13:12.100
现在让我再次将其归零，然后我们可以实际使用精确的

13:12.101 --> 13:15.262
我们拥有的资讯规模超过了所有

13:15.263 --> 13:18.460
这些立方体用于它们的平移偏移。

13:18.461 --> 13:25.240
我们只需要 Z 分量，所以让我们使用一个乘法节点并将其与

13:25.241 --> 13:28.820
001 抵消 X 和 Y 分量。

13:29.320 --> 13:33.040
当我们连接它时，您已经可以看到它是如何完美工作的。

13:33.720 --> 13:41.180
所以现在发生的事情是每个立方体都被

13:41.181 --> 13:45.840
之前立方体的所有大小的累积。

13:45.841 --> 13:50.780
所以这个立方体被精确地设定为两者高度的组合

13:50.781 --> 13:56.061
在它之前，然后将下一个立方体设置在它之前的三个立方体之上，依此类推。

13:56.920 --> 14:01.980
如果我改变随机尺度的范围，你就能真正看到它是如何运作的

14:01.981 --> 14:06.060
完美，即使我所有这些立方体的高度都非常不同。

14:06.640 --> 14:11.160
这已经是一个非常有用的小型堆叠设置，您可以在更多情况下使用它

14:11.161 --> 14:15.120
也适用于其他应用程式的通用方式，只需几个节点。

14:15.760 --> 14:18.560
现在，让我们给这个堆叠更多的变化。

14:18.860 --> 14:21.618
让我们将其作为我们的主要堆叠部分

14:21.619 --> 14:25.400
修改器，然后也为旋转添加一些变化。

14:25.740 --> 14:31.480
为此，我们只需将其连接到一个随机值节点，您就可以

14:31.481 --> 14:33.560
已经看到它是如何自行崩溃的。

14:34.100 --> 14:38.400
让我们把范围从负一到一，让它以零为中心，

14:38.760 --> 14:42.480
然后按一个值缩放向量。

14:43.360 --> 14:46.640
所以现在我们可以很好地控制这种效果的强度。

14:47.140 --> 14:51.460
在这里你可以看到这基本上就是我们在最终设定中要控制的内容

14:51.461 --> 14:53.680
堆叠倾斜方式存在一些变化。

14:54.180 --> 14:57.860
如果我改变随机种子，它就会改变整体形状。

14:58.820 --> 15:02.220
再说一遍，这与我们只是旋转时的情况有很大不同

15:02.221 --> 15:07.401
所有的披萨盒都是独立的，因为它们确实会相互影响。

15:07.980 --> 15:12.200
因此，让我们做同样的事情来对翻译进行轻微的偏移。

15:13.000 --> 15:20.841
我将添加另一个添加节点，然后使用另一个随机值节点。

15:21.500 --> 15:25.080
但我们不希望 z 方向有任何偏移，所以让我们将其设为零，

15:26.020 --> 15:30.100
然后我们希望它以零为中心，所以让我们将最小界限设为

15:30.101 --> 15:32.257
负一个，然后再加一个比例

15:32.258 --> 15:35.421
节点来控制该效果的强度。

15:37.180 --> 15:42.040
现在我们可以非常轻松地将它们公开为修改器中的可控参数

15:42.041 --> 15:46.420
透过输入输入并建立新的群组输入。

15:47.680 --> 15:51.420
只需确保相应地命名它们，这样您就不会忘记它们的实际含义。

15:52.500 --> 15:54.980
我们也公开纸箱的数量。

15:55.340 --> 15:58.320
就这样，大部分设定已经完成。

15:58.580 --> 16:02.726
我们可以动态控制数量和随机性

16:02.727 --> 16:06.400
偏移量，给了我们一堆非常狂野的披萨盒。

16:07.860 --> 16:10.349
接下来，让我们创造弹跳效果

16:10.350 --> 16:13.080
随著晚祷的颤抖，整个堆叠都在颤抖。

16:13.620 --> 16:15.500
这个想法非常简单。

16:16.040 --> 16:18.841
此设定已经有一个空控件

16:18.842 --> 16:21.360
随著车辆的移动而弹跳。

16:21.640 --> 16:26.640
然后我们将用它来移动最底部的披萨盒。

16:27.440 --> 16:30.720
我们基本上只是将其严格限制于此。

16:30.721 --> 16:36.260
然后我们将创建一个模拟来获取偏移量

16:36.261 --> 16:38.860
转换并将其在堆叠中移动。

16:39.280 --> 16:42.630
因此，移动所有内容将会有一点延迟

16:42.631 --> 16:46.080
透过这种转变，顶部的额外披萨盒。

16:46.820 --> 16:49.760
每一帧，它都会在堆叠中进一步移动一点。

16:49.960 --> 16:52.260
就这样，一路走到山顶。

16:52.920 --> 16:55.886
让我们从这个设定开始

16:55.887 --> 16:58.840
更多空间，然后新增到模拟区域。

16:58.841 --> 17:03.300
为了熟悉模拟区域的一般工作原理，还有

17:03.301 --> 17:06.620
如果您想查看 Blender YouTube 频道上的另一个影片。

17:07.120 --> 17:10.140
在这里我不打算详细解释这一点。

17:10.840 --> 17:13.819
但本质上它的工作原理是我们得到一些

17:13.820 --> 17:16.600
几何体位于模拟的第一帧。

17:17.180 --> 17:22.060
然后对于之后的每一帧，都会发生一个模拟循环

17:22.061 --> 17:24.920
输出节点和输入节点之间。

17:25.440 --> 17:30.540
我们在一帧上传递的所有内容都会在下一帧中传回。

17:31.580 --> 17:34.375
在本例中，我们要模拟的数据

17:34.376 --> 17:37.360
over 将成为一个新的矩阵属性。

17:38.220 --> 17:42.060
选择此模拟后，我们进入属性面板，

17:42.320 --> 17:46.260
然后在节点面板中，新增一个新的模拟资料条目。

17:47.180 --> 17:51.280
我们将其称为变换，然后将套接字类型变更为矩阵。

17:51.960 --> 17:54.818
在这里我们还需要记住我们的几何形状

17:54.819 --> 17:59.300
正在使用的是由实例而不是网格组成的。

17:59.460 --> 18:03.180
所以属性域也需要改为实例。

18:04.300 --> 18:07.100
让我们做一个非常小的测试设定来看看它是如何运作的。

18:07.620 --> 18:10.435
所以让我们新增另一个集合实例转换

18:10.436 --> 18:13.021
节点，然后连接该变换属性。

18:13.460 --> 18:15.900
以及具有控制移位点击的检视器节点。

18:16.360 --> 18:20.020
现在它只是将所有变换重设为 1。

18:20.240 --> 18:26.640
但是如果我们连接它来完成循环，然后还要进行乘法

18:27.860 --> 18:34.000
与另一个变换矩阵，然后输入一些值，我们可以看到

18:34.001 --> 18:38.740
现在这实际上如何改变立方体随时间的变换。

18:39.180 --> 18:44.840
因此，对于每一帧，此转换都会套用在前一个状态之上。

18:45.320 --> 18:47.420
这就是模拟正在做的事情。

18:48.240 --> 18:50.280
所以这工作得很好。

18:50.900 --> 18:52.820
现在让我们摆脱这些节点。

18:53.920 --> 18:58.828
我希望能够控制第一个披萨盒

18:58.829 --> 19:02.660
在堆叠中，控制器从车辆上空出。

19:04.100 --> 19:06.020
因此，让我们新增一个物件资讯节点。

19:06.380 --> 19:08.680
然后我已经把空的地方放好了。

19:08.880 --> 19:14.140
所以现在我可以使用吸管工具将摆动控制选择为空。

19:15.200 --> 19:18.780
让我们将位置设为相对，使其进入正确的空间。

19:18.781 --> 19:23.120
现在我们可以使用变换输出将其放到正确的位置。

19:23.440 --> 19:27.540
但我们只希望这种情况发生在堆叠中的第一个披萨盒上。

19:28.440 --> 19:29.980
所以让我们使用一个开关节点。

19:31.840 --> 19:38.640
对于开关输入，我们可以将索引与零进行比较，并检查仅

19:38.641 --> 19:42.740
当索引等于零时，我们要设定此变换。

19:43.360 --> 19:47.260
但现在我们实际上需要将这些资讯应用到我们的堆叠中。

19:47.261 --> 19:52.620
现在，我们只在随机化设定的最后将所有盒子堆叠起来。

19:53.120 --> 19:57.780
所以我想做的就是将其与我们正在进行的模拟结合。

19:58.260 --> 20:01.680
我们的做法与之前的做法非常相似。

20:02.180 --> 20:07.801
因此，让我们将模拟的输出与另一个累加字段节点结合。

20:07.860 --> 20:10.480
确保将网域设定为实例。

20:12.900 --> 20:15.380
然后这也会积累

20:15.381 --> 20:17.940
整个堆叠中的所有转换。

20:18.400 --> 20:22.860
我们将从模拟中得到的转换只是

20:22.861 --> 20:26.040
将是我们从边界获得的额外偏移量。

20:26.640 --> 20:31.140
因此，让我们将这两个变换与另一个乘法矩阵节点结合。

20:31.760 --> 20:36.020
让我们将第一个槽中的偏移量连接起来，然后将堆叠连接到第二个槽。

20:36.740 --> 20:41.280
您可以看到堆叠如何已经捕捉到空的控制项。

20:41.920 --> 20:45.832
这是有效的，因为第一个披萨盒是

20:45.833 --> 20:49.160
从模拟中准确取得此变换集。

20:49.600 --> 20:53.085
然后累加字段节点会给我们这个

20:53.086 --> 20:56.120
对其顶部的所有框也进行精确变换。

20:57.080 --> 21:02.800
我们在使用前导输出时所使用的原因

21:02.801 --> 21:07.495
之前的尾随输出现在是您想要的偏移量

21:07.496 --> 21:11.500
包括每个框本身的变换值。

21:11.501 --> 21:16.640
所以这里使用了边界的偏移变换

21:16.641 --> 21:20.140
盒子本身加上所有先前的盒子的总和。

21:20.700 --> 21:24.420
对于堆叠本身，我们不想考虑

21:24.421 --> 21:27.540
盒子本身的高度，但仅限于先前的高度。

21:28.220 --> 21:32.199
现在透过这个基本设定整个堆叠

21:32.200 --> 21:35.121
与空的控制一起完美移动。

21:35.500 --> 21:37.120
但这其实并不是我们想要的。

21:37.620 --> 21:42.520
现在我们已经有了存储在第一个披萨盒上的空的边界，让我们

21:42.521 --> 21:45.740
尝试将其传播到每个帧的堆叠中。

21:46.000 --> 21:51.860
因此，我们不是不储存任何内容作为其他框的转换

21:51.861 --> 21:57.160
将获取前一帧的信息，然后使用评估的

21:57.161 --> 22:02.740
索引节点将其插入开关的错误输入。

22:03.040 --> 22:05.660
确保将网域设定为实例。

22:06.360 --> 22:13.561
然后对于索引输入，我们将复制该索引节点并减一。

22:14.400 --> 22:17.764
这将随著每一帧通过

22:17.765 --> 22:21.300
下面的盒子的变换一直通过堆叠。

22:22.180 --> 22:25.420
此时我们遇到了一个小问题，所有内容都消失了

22:26.140 --> 22:31.040
但当你仔细观察时，这种情况发生在几个画面内。

22:32.280 --> 22:33.840
一切都在缩小。

22:34.780 --> 22:38.480
原因是规模上有差异

22:38.481 --> 22:42.280
披萨盒物件和控制器之间为空。

22:42.720 --> 22:47.880
在这里，我们并不真正关心比例，我们只想让物体旋转和偏移。

22:48.180 --> 22:51.864
所以我们能做的就是先单独进行，然后将其组合起来

22:51.865 --> 22:56.360
单独的变换组件并忽略比例。

22:58.060 --> 23:00.631
现在披萨盒太大了，但我们可以

23:00.632 --> 23:03.241
手动将它们缩小到我们需要的大小。

23:03.900 --> 23:08.000
如果我玩这个，你会发现现在它工作得非常好。

23:08.180 --> 23:11.735
对于每一帧，从第一个盒子的反弹是

23:11.736 --> 23:15.081
像波一样在堆叠中传播。

23:16.660 --> 23:20.255
如果我增加堆叠的大小，我们需要返回

23:20.256 --> 23:23.100
到第一帧才能真正看到效果。

23:24.360 --> 23:27.260
但你可以看到这种效果是如何非常清晰可见的。

23:27.800 --> 23:30.795
实际改变堆叠的高度

23:30.796 --> 23:33.640
我们需要稍微改变一下设定。

23:33.641 --> 23:39.020
而不是仅仅透过模拟输入传递几何图形，然后

23:39.021 --> 23:43.684
稍后使用它将存储第一帧

23:43.685 --> 23:47.120
模拟正在运行，我们需要以不同的方式传递它。

23:47.500 --> 23:55.060
因此，让我们在模拟中新增一个范例索引节点，将其设为矩阵，然后

23:55.061 --> 24:02.280
实例，而不是直接使用模拟中的矩阵输入

24:02.281 --> 24:07.329
从同一个索引精确取样

24:07.330 --> 24:12.021
然后连接模拟的外部。

24:13.100 --> 24:19.020
这意味著我们在每一帧中都会使用更改后的高度更新新堆叠

24:19.021 --> 24:22.332
可以有不同数量的实例，然后

24:22.333 --> 24:25.500
从前一帧中采样模拟资料。

24:26.720 --> 24:31.120
现在，如果我回放模拟，您可以看到我们如何动态更改

24:31.121 --> 24:34.100
堆叠的高度和模拟会适应该高度。

24:34.340 --> 24:38.140
这些是完成的演示设置中最重要的方面。

24:38.480 --> 24:42.600
我在演示文件中做了一些额外的事情，所以如果您是

24:42.601 --> 24:45.740
有兴趣的你可以看看，但我希望这应该给

24:45.741 --> 24:48.340
您可以很好地了解自己所看到的内容。

24:48.780 --> 24:50.770
这涵盖了您需要了解的大部分内容

24:50.771 --> 24:53.900
开始在 Blender 4.2 中使用矩阵套接字。

24:53.980 --> 24:57.540
请务必查看有关节点工具中的新功能的视频

24:57.541 --> 25:00.160
了解使用矩阵插座的另一种应用。