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
了解使用矩陣插座的另一種應用。