WEBVTT

00:00:00.412 --> 00:00:03.977
您好，歡迎使用藝術家腳本。我叫Sybren。

00:00:03.977 --> 00:00:07.312
在這一集中，我們將介紹“自描繪屬性”。

00:00:08.373 --> 00:00:14.273
在上一個視頻中，我們創建了一個面板，並向其中添加了現有屬性。

00:00:14.273 --> 00:00:15.738
這已經非常強大。

00:00:15.776 --> 00:00:20.381
如果這足以滿足您的情況，請不要使其變得更加複雜。

00:00:22.058 --> 00:00:23.158
越簡單越好。

00:00:24.567 --> 00:00:30.452
但是，在某些情況下，您想將自己的數據附加到Blender中的事物上。

00:00:31.542 --> 00:00:34.562
首先，讓我們看一下其中的屬性。

00:00:34.687 --> 00:00:37.772
在整個系列中，您已經看到了諸如

00:00:38.381 --> 00:00:42.231
object.location”或“
context.scene”之類的現有屬性。

00:00:44.477 --> 00:00:47.457
然後，您可以在“自描繪屬性”面板。

00:00:48.013 --> 00:00:52.808
也許您還看到了這些屬性，這些地方的“編輯”按鈕消失了，

00:00:52.808 --> 00:00:57.488
並且顯示了“API Define”，這意味著它是從Python描繪的。

00:00:58.667 --> 00:01:01.807
這也是我們將在本視頻中看到的內容。

00:01:02.138 --> 00:01:07.713
為了給我們一個具體的目標，我們將創建一個Mass
OBJ Importer。

00:01:07.818 --> 00:01:11.343
每個場景都會獲得一個包含以下內容的屬性

00:01:11.343 --> 00:01:14.913
包含其OBJ文件的文件夾的路徑。接著，

00:01:15.360 --> 00:01:20.510
我們將創建一個運算符，從該文件夾加載所有OBJ文件。

00:01:20.510 --> 00:01:26.645
最後，我們將研究創建一個從磁盤重新加載這些OBJ文件的運算符。

00:01:27.100 --> 00:01:28.150
所以這樣

00:01:28.410 --> 00:01:31.100
您可以一鍵重載所有OBJ文件。

00:01:31.986 --> 00:01:35.451
這是很多工作。因此，讓我們開始吧。

00:01:35.846 --> 00:01:40.516
對於本集，我們將創建一個新的Add-on，我已經開始了。

00:01:40.777 --> 00:01:43.052
我添加了一個新的Python文件。

00:01:43.118 --> 00:01:47.528
我已將其安裝為插件，並將其加載到我的編輯器中，

00:01:47.528 --> 00:01:49.348
這是Visual Studio代碼。

00:01:49.348 --> 00:01:55.158
我將快速解決這個問題，因為您在之前的視頻中已經看過所有這些內容。

00:01:56.874 --> 00:02:03.109
如果您還沒有看到它，請觀看有關創建自己的插件和創建用戶界面的視頻。

00:02:03.336 --> 00:02:06.406
因此，我們從BL信息字典開始。

00:02:06.406 --> 00:02:11.306
我已將名稱設置為“腳本腳本添加程序的藝術家”“大量導入程序”。

00:02:11.306 --> 00:02:13.811
其餘信息幾乎與您期望的一樣，

00:02:14.695 --> 00:02:16.585
接下來是“導入bpy”。

00:02:17.351 --> 00:02:22.111
然後，我想在那裡的面板中提供我們要做的所有事情。

00:02:22.397 --> 00:02:28.667
我們可以顯示按鈕，我們可以顯示屬性，我們可以做我們想做的所有事情。

00:02:28.667 --> 00:02:31.417
我通過複製代碼創建了一個新面板

00:02:31.417 --> 00:02:35.367
我們對猴子網格的代碼，然後對其進行調整。

00:02:35.367 --> 00:02:38.137
因此，除了具有標籤“mass import”(質量導入)外，

00:02:38.469 --> 00:02:41.604
它幾乎相同，並且也反映在類名中。

00:02:42.000 --> 00:02:44.820
現在稱為“查看3D PT批量導入”

00:02:48.485 --> 00:02:54.565
我們將要畫些東西，但還不是。然後，我們當然具有註冊和註銷功能。

00:02:54.781 --> 00:02:59.901
這些對於任何插件都是必需的。我們將向該文件添加更多的類。

00:03:01.029 --> 00:03:04.659
因此，我們將有一個運算子進行批量導入。

00:03:04.659 --> 00:03:07.104
然後我們還會有一個運算符

00:03:07.104 --> 00:03:11.529
一次重新導入一個對象，然後再執行一個運算子

00:03:12.400 --> 00:03:14.925
大量重新導入所有導入的對象。

00:03:16.033 --> 00:03:20.208
因此，我們將擁有更多。而且我不想複製粘貼

00:03:20.208 --> 00:03:23.708
“bpy.utils.unregister類”，然後確保

00:03:23.987 --> 00:03:29.232
在未註冊的目錄中，還復製到unregister類，並管理所有這些。

00:03:30.514 --> 00:03:33.859
因此，我創建了一個列表，而不是

00:03:33.859 --> 00:03:37.939
稱為Blender Classes，其中只有我們現在擁有的面板。

00:03:39.396 --> 00:03:41.981
然後，在註冊和註銷之前，

00:03:41.981 --> 00:03:44.676
我們使用前循環對其進行循環。

00:03:44.676 --> 00:03:51.031
因此，對於Blender類和Blender類，將超過此列表。
對於該列表中的每個項目，

00:03:51.551 --> 00:03:55.906
它將調用“bpy.utils.register類”或“取消註冊類”

00:03:55.906 --> 00:04:01.646
這使得以後添加新內容變得容易一些，因為可以將新類添加到此列表中。

00:04:02.733 --> 00:04:05.388
現在，我們的代碼非常簡單。

00:04:05.388 --> 00:04:10.688
讓我們看一下它實際上在Blender中有效，這樣我們就可以確定

00:04:10.688 --> 00:04:15.628
當我們開始添加內容時，我們是在實際有效的基礎上添加的。

00:04:15.628 --> 00:04:19.028
因此，在用戶首選項中，啟用插件。

00:04:19.173 --> 00:04:24.158
然後在這裡的“猴子”選項卡中，我們可以看到“批量導入”面板。

00:04:24.158 --> 00:04:28.623
當然，還沒有畫出來，但這就是我們所期望的。

00:04:28.623 --> 00:04:34.288
因此，根據我們的代碼「在面板本身存在的情況下進行註冊和註銷」，

00:04:34.755 --> 00:04:35.945
這都是正確的。

00:04:37.596 --> 00:04:41.646
好的。因此，讓我們開始創建我們想要的屬性。

00:04:42.162 --> 00:04:44.242
實際上，這很簡單。

00:04:46.103 --> 00:04:51.793
您知道“bpy.types”中有很多東西，並且我們希望在場景中包含

00:04:53.371 --> 00:04:56.191
我們想要的OBJ文件的導入路徑。

00:04:58.429 --> 00:05:03.919
因此，我們從“bpy.types.Scene”開始，
使用大寫字母“Scenene”，

00:05:04.219 --> 00:05:07.929
“.”然後是我們財產的名稱。

00:05:08.568 --> 00:05:10.823
我們稱之為“大量導入路徑”。

00:05:10.932 --> 00:05:15.967
現在，這與將自己的屬性添加到自己的運算符非常相似，

00:05:15.992 --> 00:05:20.332
除了，與運算子一起分類別，我們可以使用

00:05:20.513 --> 00:05:23.358
聲明屬性，現在該類已經存在。

00:05:24.924 --> 00:05:29.369
因此，我們無法對其添加任何內容。所以有點不同。

00:05:29.369 --> 00:05:34.464
因此，我們使用“=”符號代替使用“：”，然後再次分配屬性。

00:05:37.882 --> 00:05:43.357
它們甚至是道具的路徑，文件路徑或目錄路徑只是一個字符串。

00:05:47.436 --> 00:05:49.826
這樣就給我們一個String屬性。

00:05:50.690 --> 00:05:54.965
現在為用戶界面，我們可能要給它起一個好名字。

00:05:55.000 --> 00:05:58.500
因此，我們將其稱為“obj文件夾”，

00:05:58.500 --> 00:06:04.495
並且它們總是以“，”結尾，因為那樣，我可以在下一行添加內容

00:06:04.495 --> 00:06:06.555
而無需返回並再次添加“，”。

00:06:07.701 --> 00:06:13.026
這是有效的Python，它使您的更改更加本地化。您現在可以添加

00:06:13.697 --> 00:06:16.672
其他內容，而無需更改上面的行。

00:06:18.209 --> 00:06:22.899
這在Register函數中，因此我們在其中添加了一個屬性。

00:06:22.899 --> 00:06:28.249
當然，我們必須在“取消註冊”中再次將其刪除以清理所做的事情。

00:06:28.264 --> 00:06:33.454
然後，基本上，您接受該內容，然後說“刪除”該屬性。

00:06:34.467 --> 00:06:38.497
這就告訴Python，只需刪除它即可。這就足夠了。

00:06:39.813 --> 00:06:42.528
讓我們看看它在Blender中的外觀。

00:06:42.573 --> 00:06:48.678
在這裡，我們必須重新加載我們的代碼。在Blender 2.83及更高版本中，

00:06:48.678 --> 00:06:52.078
可以在這裡使用重新加載腳本來做到這一點。

00:06:52.078 --> 00:06:55.898
如果您使用的是Blender的舊版本，請按F3，

00:06:55.898 --> 00:06:59.983
然後輸入“重新加載腳本”。他們倆都做同樣的事情。

00:06:59.983 --> 00:07:06.683
除了通過菜單，您可以在按Q時將其添加到快捷菜單中。這是我將使用的方法

00:07:07.076 --> 00:07:11.006
從現在開始。因此，我們重新加載了代碼。

00:07:11.006 --> 00:07:12.791
讓我們來看看場景。

00:07:15.897 --> 00:07:19.022
妳去 我們擁有自己的屬性“大量導入路徑”。

00:07:20.232 --> 00:07:27.277
默認值是空的，因為我們沒有設置任何默認值，它就在這裡，每個場景都會有它。

00:07:28.583 --> 00:07:31.048
我們還可以從Python更改屬性。

00:07:31.579 --> 00:07:35.809
請注意此處的“場景”選項卡中的“自描繪屬性”面板。

00:07:38.931 --> 00:07:42.946
看一看，當我實際分配一個值時會發生什麼。

00:07:46.654 --> 00:07:49.854
您必須使用鼠標一點點才能使其重繪。

00:07:49.854 --> 00:07:54.614
但是您可以看到，現在，我們已經為其分配了一個值。

00:07:54.614 --> 00:07:57.219
它實際上存儲在“自描繪屬性”中。

00:07:58.359 --> 00:08:02.469
它是API描繪的，這意味著您不能只刪除它。

00:08:03.763 --> 00:08:09.688
這是像這樣使用“屬性”的主要優點之一，而不是僅單擊此處的“添加”按鈕

00:08:11.338 --> 00:08:12.788
並創建一個新的。

00:08:14.059 --> 00:08:18.184
通過Python創建它時，可以確保該屬性在那裡。

00:08:18.184 --> 00:08:22.444
即使未設置，也將具有默認值。因此，不必擔心。

00:08:25.072 --> 00:08:28.207
另一個優點是，我們可以設置子類型。

00:08:28.836 --> 00:08:32.806
這將向Blender指示我們正在談論的字符串類型。

00:08:33.992 --> 00:08:35.927
所以這將是一條路徑，

00:08:36.183 --> 00:08:42.273
如果它有個小按鈕，您可以使用文件瀏覽器為您選擇路徑，那就太好了，

00:08:43.846 --> 00:08:46.316
無需在Python控制台中鍵入它。

00:08:46.771 --> 00:08:51.656
一旦正確設置了子類型，所有這些操作都將由Blender完成。

00:08:51.656 --> 00:08:52.426
來做吧。

00:08:54.153 --> 00:08:55.533
子類型已設置

00:08:58.351 --> 00:09:02.646
按Subtype參數，然後傳遞一個表示Subtype的字符串。

00:09:04.496 --> 00:09:06.836
為了找到特定屬性的子類型，

00:09:08.829 --> 00:09:11.009
您可以返回Blender，"幫助"，

00:09:13.746 --> 00:09:18.686
Python，API參考，並蒐索“bpy.props.string屬性”

00:09:18.686 --> 00:09:21.136
然後它會告訴您有哪個子類型。

00:09:22.497 --> 00:09:26.522
在我們的情況下，它是目錄路徑或“目錄路徑”。

00:09:27.800 --> 00:09:33.975
現在，讓我們重新加載代碼，並在接口的這一角看到這裡發生的情況。

00:09:36.158 --> 00:09:39.428
妳去 它具有瀏覽按鈕，您可以選擇目錄。

00:09:43.277 --> 00:09:49.652
因為我將其設置為傻值，所以它僅從傻目錄開始，因為它不是有效路徑。

00:09:51.694 --> 00:09:54.539
但是如果我將其更改為“//”，則表示

00:09:56.515 --> 00:09:58.295
Blend文件的當前目錄，

00:10:00.462 --> 00:10:04.797
它將在這裡打開它，我可以導航到OBJ文件目錄，

00:10:05.935 --> 00:10:08.945
單擊“接受”，然後在此處設置路徑。

00:10:10.963 --> 00:10:17.158
這正是我們想要的，當然，除了我們希望在自己的面板中執行此行為。

00:10:18.397 --> 00:10:21.172
來做吧。在我們的面板代碼中

00:10:21.172 --> 00:10:28.197
我們可以刪除通行證，因為我們實際上將要做一些事情，讓我們從獲取佈局開始。

00:10:30.523 --> 00:10:34.448
我們以前沒有這樣做，但是確實知道每個“自我”(某物)

00:10:35.049 --> 00:10:44.234
我們將做一個小小的舞蹈，看看是否在該類中描繪了，
如果沒有，請看一下父級，是否在該類中描繪了，

00:10:44.234 --> 00:10:48.179
如果沒有的話，看看祖父母等等。所以我們說

00:10:48.179 --> 00:10:53.314
“layout=self.layout”，我們只跳舞一次，然後只使用layout對象。

00:10:55.145 --> 00:10:56.545
讓我們添加一列，

00:10:59.187 --> 00:11:02.827
然後添加屬性。該屬性是在場景中描繪的，

00:11:04.281 --> 00:11:06.781
即“context.scene”。 屬性名稱是

00:11:09.347 --> 00:11:11.562
“大量導入路徑”。這就對了。

00:11:15.003 --> 00:11:18.358
重新加載代碼，然後有“屬性”瀏覽按鈕。

00:11:21.156 --> 00:11:27.466
現在，讓我們創建一個運算符，該運算符從該目錄導入所有OBJ文件。

00:11:27.466 --> 00:11:32.036
我想命名相似名稱導入OBJ文件已經存在的運算子。

00:11:35.303 --> 00:11:40.438
因此，讓我們來看一下。那就是“bpy.ops.import_scene.obj”

00:11:41.726 --> 00:11:44.556
所以我們打電話給我們的接線員

00:11:44.556 --> 00:11:49.326
“導入scene.obj質量”。所以在這裡，我們有一個空運算符。

00:11:49.326 --> 00:11:53.151
您之前已經看過。我只是以不同的方式命名這些，

00:11:53.151 --> 00:11:56.866
稱為“imports scene.obj mass”，它具有Execute函數。

00:11:57.036 --> 00:12:00.876
我把這個小註釋作為參考，然後它稱為

00:12:00.876 --> 00:12:01.896
“self.report”。

00:12:01.896 --> 00:12:07.896
這採用的報告類型可以是信息，警告或錯誤，然後是未報告的字符串。

00:12:10.317 --> 00:12:13.837
它返回“已取消”，因為尚未執行任何操作。

00:12:14.028 --> 00:12:16.873
同樣，我正在採取一些小步驟。

00:12:16.873 --> 00:12:23.978
我首先確保您的打印機在那裡，並且已正確註冊。然後，我們可以將其添加到面板中。

00:12:23.978 --> 00:12:29.773
我們可以單擊該按鈕，可以看到它可以工作，然後再添加更多的複雜性。

00:12:29.773 --> 00:12:31.538
所以運算子在這裡。

00:12:31.538 --> 00:12:36.108
現在，我複製了此名稱，然後轉到Blender classes列表，

00:12:36.108 --> 00:12:39.993
我將名稱添加到列表中，並負責註冊和註銷。

00:12:40.232 --> 00:12:43.137
現在剩下的就是將其添加到面板中。

00:12:44.400 --> 00:12:47.630
因此，我們需要的只是“BL ID名稱”。

00:12:49.267 --> 00:12:55.617
粘貼它，保存在Blender中，重新加載腳本。我們有一個按鈕，我們單擊它。

00:12:55.974 --> 00:13:00.269
它說“沒有代碼可從/ /加載”，這是我們期望的錯誤。

00:13:01.850 --> 00:13:08.750
現在，下一步是找到obj文件，然後將其導入。之後，我們希望能夠

00:13:08.750 --> 00:13:11.645
重新導入它們。所以我們必須跟踪

00:13:11.645 --> 00:13:13.965
從哪個文件導入了哪個對象。

00:13:14.603 --> 00:13:20.193
最好的方法是向對像類型添加另一個屬性。所以現在就開始做

00:13:20.296 --> 00:13:22.581
在我們開始導入它們之前。

00:13:24.271 --> 00:13:29.711
在這裡，在Register函數中，我們將執行與場景相同的操作，

00:13:29.711 --> 00:13:31.346
但然後到一個對象。

00:13:33.709 --> 00:13:36.399
然後，它也變成了String屬性，

00:13:41.656 --> 00:13:45.636
但隨後使用OBJ文件而不是OBJ文件夾。

00:13:45.636 --> 00:13:51.386
因此，文件夾和文件名的組合將為我們提供OBJ文件的最終路徑。

00:13:51.467 --> 00:13:57.767
因為沒有僅文件名的子類型，所以僅用於完整的文件路徑或完整的目錄路徑。

00:13:59.426 --> 00:14:03.746
僅將其保留為字符串，並且不描繪任何子類型。

00:14:04.003 --> 00:14:08.968
因此，在查看導入之前，請將此屬性添加到面板中。

00:14:10.374 --> 00:14:14.799
我們在這裡有面板代碼，讓我們為此創建一個新列。

00:14:23.041 --> 00:14:27.361
那裡，我們擁有屬性。但是請記住“context.object”

00:14:27.361 --> 00:14:30.686
可以是無，所以我們必須對此加一點警惕。

00:14:42.953 --> 00:14:49.338
在Python中，沒有一個被認為是錯誤的，而在實際對像中則被認為是正確的。

00:14:49.338 --> 00:14:56.193
因此，如果“context.object”的求值結果為“true”，
則它是真實對象，然後繪製該屬性。

00:14:56.193 --> 00:14:57.643
它將評估為“假”

00:14:57.643 --> 00:15:00.793
如果沒有活動對象，則它將繪製標籤。

00:15:01.451 --> 00:15:02.431
試一試吧。

00:15:05.551 --> 00:15:10.771
在這裡，我們有了我們的屬性，可以將其設置為“每個對象”，

00:15:11.569 --> 00:15:12.589
如你看到的。

00:15:15.058 --> 00:15:17.308
現在讓我們構建導入本身。

00:15:17.462 --> 00:15:23.492
因此，在這裡，我們有大量進口商運營商。讓我們寫一些佈局

00:15:23.492 --> 00:15:26.712
它應該做什麼。它必須找到目標文件，

00:15:29.628 --> 00:15:30.893
對於每個文件，

00:15:33.474 --> 00:15:34.249
導入它

00:15:37.144 --> 00:15:41.544
並在“對象屬性”中記錄其文件名。讓我們看看第一步。

00:15:43.146 --> 00:15:45.861
實際上，這將採取一些步驟。

00:15:46.341 --> 00:15:49.991
因為要查找文件，我們必須使用Python功能。

00:15:50.362 --> 00:15:55.242
而且Python無法理解相對於當前Blend文件的Blender特定的“//”含義。

00:15:57.464 --> 00:16:01.899
因此，我們必須將其轉換為Python可以理解的內容，

00:16:01.899 --> 00:16:06.544
然後使用它來查找OBJ文件，然後將其轉換回

00:16:06.544 --> 00:16:09.634
Blender可以理解的東西，然後導入文件。

00:16:09.634 --> 00:16:14.179
首先，我們必須將“//”轉換為絕對值，這是通過...

00:16:14.179 --> 00:16:17.539
“bpy.path.abspath”中的functin完成的

00:16:23.747 --> 00:16:27.782
“bpy.path.abspath(context.scene.mass_import_path”

00:16:28.346 --> 00:16:32.146
將為我們提供我們要導入的文件的絕對路徑。

00:16:32.146 --> 00:16:36.466
我們可以通過在錯誤消息中報告此內容來進行檢查。

00:16:37.501 --> 00:16:41.726
只是暫停視頻，嘗試一下，然後再回到這裡。

00:16:42.273 --> 00:16:47.673
現在，我們必須將其轉換為Python的Path，Lib庫中的path對象。

00:16:55.950 --> 00:17:03.650
然後，我們可以使用此導入路徑變量來查找所有OBJ文件，
並像這樣一遍遍地遍歷它們。

00:17:13.771 --> 00:17:20.076
這將找到與“*
.obj”匹配的所有內容，因此文件或目錄以該“obj”結尾。

00:17:21.158 --> 00:17:25.473
從現在開始，我將假設您不會創建任何子目錄

00:17:25.542 --> 00:17:26.307
“(something).obj”，

00:17:27.701 --> 00:17:31.711
並且所有內容都是我們導入的實際OBJ文件。

00:17:32.263 --> 00:17:34.993
現在，我們要做的就是導入它。

00:17:35.912 --> 00:17:36.932
在Blender中

00:17:38.233 --> 00:17:43.883
轉到OBJ導入程序，然後按Ctrl C，然後按Ctrl V，代碼。

00:17:53.231 --> 00:17:59.136
這會將我們擁有的該路徑對象轉換回字符串，以便Blender能夠理解它。

00:18:01.077 --> 00:18:04.062
然後，這整行將導入OBJ文件。

00:18:05.978 --> 00:18:11.893
現在，我們已經介紹了導入的每個文件，剩下的就是記錄其文件名。

00:18:15.513 --> 00:18:18.178
此Import運算符的部分工作是

00:18:18.714 --> 00:18:22.989
它取消選擇所有內容，然後選擇要導入的對象。

00:18:23.501 --> 00:18:29.726
這意味著我們可以遍歷所有選定的對象，然後將其自描繪屬性分配給它們。

00:18:47.654 --> 00:18:51.144
這就是為什麼我如此喜歡Path Lib對象的原因。

00:18:52.988 --> 00:18:57.973
如果您只想擁有路徑的文件名部分，則使用起來非常簡單，

00:18:58.262 --> 00:19:00.242
只需執行“path.name”即可。

00:19:01.804 --> 00:19:05.304
如果要使用驅動器對象，請執行“.drive”

00:19:05.772 --> 00:19:10.147
這是一種非常面向對象的Paths方法，我非常喜歡。

00:19:13.208 --> 00:19:16.923
現在我們正在導入。我們記錄文件名的來源。

00:19:17.692 --> 00:19:19.872
所以應該在.....嘗試一下。

00:19:20.597 --> 00:19:22.417
我將扔掉現有的物體，

00:19:24.772 --> 00:19:27.142
瀏覽到我的OBJ文件目錄，

00:19:28.571 --> 00:19:33.096
然後批量導入所有內容，然後就可以了。文件已導入。

00:19:33.668 --> 00:19:39.253
它們都是源文件，每個文件的OBJ文件名都設置為它們的來源。

00:19:42.122 --> 00:19:46.982
現在，剩下要做的就是讓運算子重新加載OBJ文件。

00:19:47.174 --> 00:19:53.289
為了簡單起見，我們不要大量地這樣做，只需重新加載活動對象即可。

00:19:53.289 --> 00:19:55.824
這意味著從場景中刪除對象

00:19:55.824 --> 00:19:58.444
然後再次從OBJ文件加載它。

00:19:58.444 --> 00:20:03.304
當然，在我們從場景中刪除之前，我們必須確保

00:20:03.304 --> 00:20:08.379
我們存儲了對象的變換，以便在重新加載它時可以將其還原。

00:20:08.379 --> 00:20:10.889
這樣就可以以相同的方式定位

00:20:10.889 --> 00:20:13.404
就像我們重新加載之前一樣

00:20:13.404 --> 00:20:15.994
讓我們從一個新的運算符開始。

00:20:17.787 --> 00:20:23.712
我們稱其為“obj reload”。在這裡，我選擇了一些文本，按Ctrl D，

00:20:23.712 --> 00:20:26.407
將選擇該文本的下一個出現位置。

00:20:26.814 --> 00:20:29.394
然後，我可以點擊“重新加載”。

00:20:29.394 --> 00:20:33.369
以及類名和ID名，我們將更改為“obj reload”。

00:20:36.297 --> 00:20:41.837
假設“重新加載大量導入的obj”，然後我們可以編寫Execute函數。

00:20:42.653 --> 00:20:45.713
對於此代碼，我將假定每個OBJ

00:20:45.849 --> 00:20:51.714
裡面有一個物體。您可以擴展代碼，以便它可以處理OBJ的多個對象。

00:20:51.995 --> 00:20:54.345
但是現在讓我們保持簡單。

00:20:55.667 --> 00:21:00.027
我們將多次引用活動對象，因此讓我們簡化生活。

00:21:03.763 --> 00:21:08.498
只需將其稱為“ob”即可，讓我們再次為自己做一些概述。

00:21:09.128 --> 00:21:11.453
首先，我們必須存儲

00:21:11.808 --> 00:21:13.253
我們想要記住的。

00:21:15.568 --> 00:21:17.488
從場景中刪除對象，

00:21:18.763 --> 00:21:20.453
加載OBJ文件，

00:21:21.865 --> 00:21:23.685
並恢復我們所記得的。

00:21:25.260 --> 00:21:29.615
加載OBJ文件不會自動設置我們的自描繪屬性。

00:21:30.447 --> 00:21:36.122
最後，這就是我們要還原的內容。而且我們也希望能夠還原轉換。

00:21:41.096 --> 00:21:42.856
讓我們記住文件名。

00:21:47.027 --> 00:21:52.342
讓我們複製矩陣。如果我不打算複製矩陣，那麼變量矩陣世界

00:21:55.885 --> 00:22:01.995
將是對對象矩陣的引用。如果我們刪除該對象，則該引用將不再有效，

00:22:03.892 --> 00:22:06.167
您可以獲得各種奇怪的結果。

00:22:08.081 --> 00:22:14.381
現在，從場景中刪除對象實際上意味著從其所在的所有集合中刪除對象。

00:22:15.222 --> 00:22:19.842
幸運的是，Blender為我們提供了所有這些收藏的清單。

00:22:30.954 --> 00:22:33.654
這將取消所有集合中對象的鏈接。

00:22:35.295 --> 00:22:42.195
問題是，當然，一旦我們從第一個集合中取消對象的鏈接，我們就會循環

00:22:45.123 --> 00:22:49.243
會改變。在循環中進行更改永遠不是一個好主意。

00:22:49.243 --> 00:22:50.668
我們可以做到“list(ob.user_collections)”

00:22:53.985 --> 00:22:56.380
這將為我們創建一個新列表。

00:22:57.087 --> 00:23:03.482
該新列表是一個副本，因此不會通過從那些集合中刪除對象來對其進行更改，

00:23:03.905 --> 00:23:05.995
從而使此for循環安全。

00:23:06.241 --> 00:23:11.111
如果需要，您現在也可以從“bpy.data”中刪除該對象，

00:23:11.111 --> 00:23:15.151
但這只有在沒有其他引用的情況下才是安全的。

00:23:16.135 --> 00:23:17.840
再次，Blender營救。

00:23:23.371 --> 00:23:26.156
“ob.users”將為我們提供該用戶數。

00:23:26.678 --> 00:23:33.193
在整個Blend文件中的不同位置使用“材質”和“網格”時，
也會看到一個很小的小方塊。

00:23:37.781 --> 00:23:45.376
如果該數字為0，則表示該對像不再使用，
們實際上可以將其從Blender的內存中刪除。

00:23:50.171 --> 00:23:53.061
從這一點開始，我們不再引用

00:23:55.608 --> 00:23:58.238
“ob”，因為它已從Blender中刪除。

00:23:59.578 --> 00:24:02.298
因此，為了防止再次使用它，

00:24:04.609 --> 00:24:08.854
我只是說“del ob”。這將從Python的內存中刪除“ob”名稱。

00:24:11.583 --> 00:24:15.268
這意味著，如果我在這裡說“ob.location”，

00:24:16.872 --> 00:24:22.187
Python會對我們大喊大叫，因為在此行之後，它不再知道“

00:24:22.187 --> 00:24:26.047
ob”的含義。 對我們自己來說只是一點點安全

00:24:26.615 --> 00:24:29.610
這樣我們就不會使用不再有效的東西。

00:24:31.188 --> 00:24:34.623
現在。我們需要再次加載OBJ文件

00:24:34.623 --> 00:24:38.578
我們之前做過的 因此，讓我們看一下該代碼。

00:24:38.578 --> 00:24:43.198
我們必須再次執行此技巧，然後僅對一個對象執行此行。

00:24:44.851 --> 00:24:47.921
因此，我們將其放入一個函數中

00:24:47.921 --> 00:24:49.991
我們可以從兩個地方呼叫。

00:25:06.756 --> 00:25:10.396
在這裡，我創建了一個帶場景的新函數，

00:25:10.862 --> 00:25:13.397
這意味著它將返回“pathLib.path”。

00:25:15.300 --> 00:25:19.990
我非常喜歡這種表示法，因為這樣，您可以看到

00:25:19.990 --> 00:25:24.665
返回什麼，而不必深入研究代碼，看看會發生什麼。

00:25:25.217 --> 00:25:27.347
Python不會對此進行檢查，

00:25:27.947 --> 00:25:31.212
因此，您有責任切實履行自己的諾言。

00:25:31.212 --> 00:25:36.252
現在，此代碼與此幾乎相同，並返回了新的路徑對象。

00:25:36.252 --> 00:25:38.757
這意味著我們可以刪除這一行

00:25:39.410 --> 00:25:41.940
我們可以在這裡執行“mass_import_path(context.scene)”。

00:25:48.160 --> 00:25:53.915
我專門通過了這個場景，而不是上下文。必須在這裡解決一個小錯誤。

00:25:56.353 --> 00:25:59.618
我明確地通過了場景而不是整個上下文。

00:26:01.238 --> 00:26:07.833
如果我們要傳遞上下文，效果會很好，但是您將看不到上下文的哪一部分

00:26:08.569 --> 00:26:10.829
實際上是由該功能使用的。

00:26:11.723 --> 00:26:15.528
這就是為什麼我要傳遞場景本身而不是上下文。

00:26:16.218 --> 00:26:18.533
當然，我們也可以傳遞“

00:26:21.301 --> 00:26:24.761
context.scene(大量導入路徑)”，但這會使調用時間更長一些，

00:26:24.761 --> 00:26:27.326
我認為這是一個很好的中間立場。

00:26:27.326 --> 00:26:32.341
但是，當然，您可以使用自己認為最好的方法來處理代碼。

00:26:32.341 --> 00:26:37.641
現在，我們有了要獲取的代碼導入路徑，我們可以複製此行

00:26:37.641 --> 00:26:39.651
進入我們的Reload運算符。

00:26:41.436 --> 00:26:43.656
然後我們可以得到這條線，

00:26:46.573 --> 00:26:47.588
放到這裡

00:26:48.273 --> 00:26:53.203
現在，我們要做的就是從目錄的“導入路徑”到“導入文件路徑”，

00:26:56.460 --> 00:26:59.450
這是一個文件名。導入文件路徑是

00:27:01.664 --> 00:27:04.879
“import_ path / mass_import_fname”是我們在那裡複製的。

00:27:12.719 --> 00:27:15.709
Python中的路徑對象支持此“/”表示法。

00:27:16.513 --> 00:27:19.408
它會自動在任何平台上正常工作。

00:27:19.744 --> 00:27:25.044
在Windows上，它使用反斜杠；
在Linux和Mac OS上，它使用“/”。

00:27:26.015 --> 00:27:32.175
現在我們已經構建了文件名，可以將其傳遞給加載OBJ文件的運算子。

00:27:32.175 --> 00:27:36.340
現在，剩下的就是還原我們想要還原的內容。

00:27:36.849 --> 00:27:42.044
同樣，我們必須遍歷所選對象，並設置“批量導入”文件名。

00:27:52.253 --> 00:27:54.773
現在，我們必須還原矩陣。

00:27:59.650 --> 00:28:02.065
會告訴Blender運算子做了工作。

00:28:06.378 --> 00:28:08.468
然後我們修復兩個錯字。

00:28:08.851 --> 00:28:13.356
這裡的“：”和這裡必須使用“collection”，而不是“collections”。

00:28:16.865 --> 00:28:22.975
最後，我們要做的是註冊和註銷運算子，並在面板上添加一個按鈕。

00:28:26.032 --> 00:28:29.857
我們複製了類名，並將其添加到此列表中。

00:28:33.306 --> 00:28:37.161
我們複製BL ID名稱並將其添加到面板中，

00:28:42.756 --> 00:28:43.746
保存文件，

00:28:45.135 --> 00:28:48.060
重新加載腳本，然後點擊按鈕。

00:28:51.101 --> 00:28:53.351
如您所見，我們單擊它。

00:28:53.372 --> 00:28:57.642
在導入OBJ文件中使用時，不再有活動對象，

00:28:59.292 --> 00:29:03.282
僅選擇導入的對象，在這種情況下為Suzanne。

00:29:05.059 --> 00:29:08.689
現在，讓我們看看它是否真正重新加載。

00:29:08.771 --> 00:29:11.776
我在其中放置了一個新文件“cube.obj”，

00:29:12.541 --> 00:29:15.526
現在應該用該多維數據集替換Suzanne。

00:29:16.578 --> 00:29:19.373
而且確實如此，所以我們有了它。

00:29:19.373 --> 00:29:24.008
我們的代碼正在運行，我們可以批量加載OBJ文件，

00:29:24.008 --> 00:29:27.058
並且可以選擇要重新加載的單個對象。

00:29:27.526 --> 00:29:31.631
我將其保留為練習為您提供一個批量重載運算符，

00:29:32.378 --> 00:29:36.958
該運算符可對所有對像或僅對所有選定對象進行迭代。

00:29:37.685 --> 00:29:42.975
我會留給你。這就是“藝術家腳本”這一集的內容。這不是最後一次

00:29:44.796 --> 00:29:50.611
我們將討論自描繪屬性，但我認為該視頻已經播放了足夠長的時間。

00:29:50.611 --> 00:29:56.111
如果你有任何問題或評論，將它們留在下面，我們很快會再見。