Share
Wir haben uns zuvor mit dem Hinzufügen eigener Tools zum Editor von Unity beschäftigt. jetzt, in diesem kurzen Tutorial, werde ich Ihnen den Umgang mit den Assets per Skript in Unity vorstellen. Wir verwalten Pfade, erstellen vorgefertigte Dateien, erzeugen eine Textur und speichern sie in einem Bild. Schließlich erstellen wir auch eine Materialdatei, die das generierte Bild verwendet, und dies alles wird durch Code ausgeführt.
Werfen wir einen Blick auf das Endergebnis, auf das wir hinarbeiten:
Erstellen Sie ein leeres Projekt. Wir werden hier nichts Besonderes verwenden, also sollten wir uns überhaupt nicht darum kümmern, etwas zu importieren. Sobald dies erledigt ist, erstellen Sie ein Editor-Skript. Unity erlaubt uns, die Editor-Klassen nur zu verwenden, wenn wir unser Skript in einem Ordner mit dem Namen Editor. Da das in unserem Projekt noch nicht existiert, müssen wir es schaffen.
Jetzt erstellen wir ein Skript darin.
Lassen Sie uns unser Skript aufräumen. Neben der Basisfunktionalität möchten wir auch die Editor-Klassen verwenden können. Wir müssen sein UnityEditor verwenden und die Klasse unseres Skripts sollte das erweitern Editor Klasse statt MonoBehaviour wie normale Spielobjekte.
mit UnityEngine; using System.Collections; UnityEditor verwenden; öffentliche Klasse Beispiele: Editor
In unserer ersten Funktion arbeiten wir mit Prefabs, nennen wir es a PrefabRoutine.
öffentliche Klasse Beispiele: Editor void PrefabRoutine ()
Um diese Funktion einfach aus dem Editor heraus auszuführen, fügen Sie sie als ein MenuItem.
Accentsconagua
public class Beispiele: Editor [MenuItem ("Examples / Prefab Routine")] void PrefabRoutine () Abgesehen davon, dass die Einheit wissen lässt, dass diese Funktion von der aus ausführbar ist Beispiele-> Prefab-Routine ", Wir müssen diese Funktion auch statisch machen.
öffentliche Klasse Beispiele: Editor [MenuItem ("Examples / Prefab-Routine")] statischer void PrefabRoutine () Wenn Sie jetzt zum Editor zurückkehren (und das Menü aktualisieren), werden Sie feststellen, dass es ein neues Menü mit dem Namen gibt Beispiele Dort.
Wenn Sie das auswählen Prefab-Routine Nichts wird passieren, da unsere Funktion leer ist.
Um unser Projekt so zu gestalten, wie wir es uns wünschen, müssen wir wissen, wie man Ordner erstellt, damit wir alles bewegen können. Das Erstellen eines Ordners aus dem Skript ist sehr unkompliziert. Alles, was wir tun müssen, ist, Unity mitzuteilen, wo der Ordner platziert werden soll. Um einen Ordner zu erstellen, müssen wir ihn verwenden AssetDatabase Klasse.
[MenuItem ("Examples / Prefab Routine")] statisch void PrefabRoutine () AssetDatabase.CreateFolder ("Assets", "Prefab Folder"); "Vermögenswerte" ist der Name des übergeordneten Ordners des Verzeichnisses, das erstellt werden soll. In unserem Fall ist dies der Hauptordner des Projekts, in dem alle unsere Assets importiert / erstellt werden.
Beachten Sie, dass Sie auch .NET verwenden können Verzeichnis Klasse. Dadurch können Sie auch die Dateien der Verzeichnisse löschen, verschieben oder darauf zugreifen. Um diese Klasse verwenden zu können, müssen Sie es sein mit System.IO.
Jedes Mal, wenn Sie das auswählen Prefab-Routine Im Editor sollte ein neuer Ordner erstellt werden und in der Projektansicht sichtbar sein.
Um ein Prefab zu erstellen, müssen wir anrufen EditorUtility.CreateEmptyPrefab (). Die Funktion nimmt den Pfad des Prefab als Argument an.
[MenuItem ("Examples / Prefab Routine")] statisch void PrefabRoutine () AssetDatabase.CreateFolder ("Assets", "Prefab Folder"); Object prefab = EditorUtility.CreateEmptyPrefab ("Assets / Prefab Folder / obj.prefab"); Vergiss die Erweiterung nicht! Nachdem wir die Datei erstellt haben, müssen wir sie auch aufrufen AssetDatabase.Refresh (), so kann die einheit es sehen.
[MenuItem ("Examples / Prefab Routine")] statisch void PrefabRoutine () AssetDatabase.CreateFolder ("Assets", "Prefab Folder"); Object prefab = EditorUtility.CreateEmptyPrefab ("Assets / Prefab Folder / obj.prefab"); AssetDatabase.Refresh (); Wenn wir einen konstanten Pfad als Argument belassen, wird jedes Mal, wenn wir unsere Routine auswählen, ein neues leeres Fertighaus das alte ersetzen. Weisen wir jedem Prefab einen separaten Ordner zu, um dem entgegenzuwirken. Dazu müssen wir den zuletzt erstellten Ordner in einer Zeichenfolge speichern, um ihn später als Pfadargument verwenden zu können. Das Ordner erstellen Funktion gibt a zurück GUID, Dies ist im Grunde die ID der Datei (oder des Verzeichnisses). Es gibt eine Funktion, die den Pfad abruft, wenn wir diese ID übergeben. Es heißt GUIDToAssetPath; Lassen Sie uns damit den Pfad unseres Ordners abrufen.
[MenuItem ("Examples / Prefab Routine")] statisch void PrefabRoutine () string path = AssetDatabase.GUIDToAssetPath (AssetDatabase.CreateFolder ("Assets", "Prefab Folder")); Object prefab = EditorUtility.CreateEmptyPrefab ("Assets / Prefab Folder / obj.prefab"); AssetDatabase.Refresh (); Lass uns jetzt die Pfad Um die Prefabs zu leiten, erstellen wir den zuletzt erstellten Ordner.
[MenuItem ("Examples / Prefab Routine")] statisch void PrefabRoutine () string path = AssetDatabase.GUIDToAssetPath (AssetDatabase.CreateFolder ("Assets", "Prefab Folder")); Object prefab = EditorUtility.CreateEmptyPrefab (Pfad + "/obj.prefab"); AssetDatabase.Refresh (); Sie können jetzt testen, ob die erstellten leeren Prefabs jetzt in Ordnern verpackt sind.
Wenn Sie ein Fertighaus erstellen, möchten Sie es wahrscheinlich nicht leer lassen, weil es in diesem Fall ziemlich nutzlos ist. Lassen Sie uns unser Prefab festlegen, wenn während der Ausführung unserer Routine ein Spielobjekt ausgewählt wird. Wir werden das fertige Objekt zum ausgewählten Objekt machen. Um das aktuell ausgewählte Objekt zu erhalten, können wir das verwenden Auswahl Klasse, die darauf Bezug nimmt. Um das Prefab einzustellen, müssen wir anrufen ReplacePrefab ().
[MenuItem ("Examples / Prefab Routine")] statisch void PrefabRoutine () string path = AssetDatabase.GUIDToAssetPath (AssetDatabase.CreateFolder ("Assets", "Prefab Folder")); Object prefab = EditorUtility.CreateEmptyPrefab (Pfad + "/obj.prefab"); AssetDatabase.Refresh (); if (Selection.activeObject) EditorUtility.ReplacePrefab (Selection.activeGameObject, vorgefertigt); Wenn Sie die Routine jetzt mit einem beliebigen ausgewählten Spielobjekt ausführen, werden Sie feststellen, dass das erstellte Prefab automatisch festgelegt wird.
Das ist es, wir haben eine benutzerdefinierte Routine für die Fertigerzeugung erstellt, sie ist nicht sehr nützlich, aber Sie sollten in der Lage sein, dies jetzt zu tun, wenn dies für Ihr Projekt erforderlich ist.
Zum Schluss möchte ich das auch erwähnen AssetDatabase Außerdem können Sie Assets verschieben, in den Papierkorb verschieben oder durch Aufrufen löschen AssetDatabase.MoveAsset (), AssetDatabase.MoveAssetToTrash () und AssetDatabase.DeleteAsset () beziehungsweise. Die restliche Funktionalität finden Sie im AssetDatabase Skriptreferenzseite.
Gehen wir zu einem anderen Beispiel, diesmal erstellen wir eine Textur und ein Material programmgesteuert. Rufen wir diesen Menüpunkt auf Materielle Routine.
[MenuItem ("Examples / Prefab Routine")] statisch void PrefabRoutine () string path = AssetDatabase.GUIDToAssetPath (AssetDatabase.CreateFolder ("Assets", "Prefab Folder")); Object prefab = EditorUtility.CreateEmptyPrefab (Pfad + "/obj.prefab"); AssetDatabase.Refresh (); if (Selection.activeObject) EditorUtility.ReplacePrefab (Selection.activeGameObject, vorgefertigt); [MenuItem ("Beispiele / Materialroutine")] statisch void MaterialRoutine () Jetzt haben wir zwei Elemente zur Auswahl Beispiele Speisekarte.
Lass uns einen erstellen Textur2D und setze seine Größe auf (256, 256) für dieses Beispiel.
[MenuItem ("Examples / Material Routine")] statische Leere MaterialRoutine () Texture2D tex = new Texture2D (256, 256); Jetzt sollten wir nicht zulassen, dass all diese Pixel verloren gehen. Setzen wir also die Pixel der Textur nach einer Art von Formel. Dafür brauchen wir zwei zum Durchläuft jedes Pixel. Um die Farbe jedes Pixels einzustellen, müssen wir sie anrufen SetPixel () wobei die Position des Pixels auf einer Textur und seine Farbe als Argumente verwendet wird.
[MenuItem ("Examples / Material Routine")] statische Leere MaterialRoutine () Texture2D tex = new Texture2D (256, 256); für (int y = 0; y < 256; ++y) for (int x = 0; x < 256; ++x) tex.SetPixel(x, y, new Color()); Um die Farbe zuzuweisen, verwenden wir die Mathf.Sin () Funktion. Das Farbe Die Klasse kann mit drei Floats initialisiert werden, die den roten, grünen bzw. blauen Farbkomponenten entsprechen. Der maximal zulässige Wert ist 1 und min ist 0, so die Sünde() Funktion passt perfekt zu unseren Bedürfnissen.
für (int y = 0; y < 256; ++y) for (int x = 0; x < 256; ++x) tex.SetPixel(Mathf.Sin(x*y), Mathf.Sin(x*y), Mathf.Sin(x*y)));
Es ist egal, was wir dem unterwerfen Sünde() Funktion, aber um etwas interessanter zu bekommen, sollten wir einen Wert angeben, der sich für jedes Pixel ändert.
Jetzt erstellen wir ein Bild aus der soeben erstellten Textur. Da wir im Binärmodus in eine Datei schreiben, müssen wir dies tun mit System.IO, Fügen wir es also oben in unser Skript ein.
mit UnityEngine; using System.Collections; UnityEditor verwenden; using System.IO; öffentliche Klasse Beispiele: Editor
So speichern Sie unsere Textur als PNG Bild, das wir zuerst anrufen müssen EncodeToPNG () was ein Array von Bytes zurückgibt, das die PNG Datei besteht aus.
für (int y = 0; y < 256; ++y) for (int x = 0; x < 256; ++x) tex.SetPixel(x, y, new Color(Mathf.Sin(x*y), Mathf.Sin(x*y), Mathf.Sin(x*y))); byte[] pngData = tex.EncodeToPNG();
Jetzt haben wir unsere pngData Wir können es in eine Datei schreiben und eine erstellen PNG Bild auf diese Weise.
Byte [] pngData = tex.EncodeToPNG (); if (pngData! = null) File.WriteAllBytes ("Assets / texture.png", pngData); Da wir die Datei unter einem konstanten Pfad erstellen, werden wir jedes Mal ausgeführt MaterialRoutine (), Die Textur wird überschrieben.
Und da wir unser Bild haben, brauchen wir die erzeugte Textur nicht mehr, da sie ohnehin kein Bild referenziert. Lass es uns zerstören.
Byte [] pngData = tex.EncodeToPNG (); if (pngData! = null) File.WriteAllBytes ("Assets / texture.png", pngData); DestroyImmediate (tex); Außerdem müssen wir die Projektansicht und Dateiverweise von Unity aktualisieren lassen. um das zu tun, müssen wir anrufen AssetDatabase.Refresh ().
Byte [] pngData = tex.EncodeToPNG (); if (pngData! = null) File.WriteAllBytes ("Assets / texture.png", pngData); DestroyImmediate (tex); AssetDatabase.Refresh (); Lassen Sie uns testen, ob die Textur erstellt wird, wenn wir unsere Routine ausführen.
Wir haben ein Bild und können nun ein Material erstellen, das es als Textur verwendet. Lass uns einen erstellen Neues Material.
AssetDatabase.Refresh (); neues Material (Shader.Find ("Diffuse")); Das erstellte Material verwendet a Diffus Shader. Um dieses Material in der Datei zu speichern, können wir anrufen AssetDatabase.CreateAsset (). Diese Funktion verwendet ein Asset als erstes Argument und den Pfad als zweites Argument.
AssetDatabase.Refresh (); AssetDatabase.CreateAsset (neues Material (Shader.Find ("Diffuse")), "Assets / New Material.mat"); Wenn Sie jetzt unsere Routine ausführen, sehen Sie, dass das Material erstellt wurde.
Wie Sie sehen können, ist alles korrekt Neues Material und es nutzt Diffus Shader, aber es ist keine Textur zugewiesen.
Zuerst müssen wir einen Verweis auf das soeben erstellte Material erhalten. Wir können das erreichen, indem wir anrufen AssetDatabase.LoadAssetAtPath () welches das Asset lädt und seine Referenz zurückgibt.
AssetDatabase.CreateAsset (neues Material (Shader.Find ("Diffuse")), "Assets / New Material.mat"); Material Material = (Material) (AssetDatabase.LoadAssetAtPath ("Assets / New Material.mat", typeof (Material))); Nun weisen wir unsere generierte Textur als Haupttextur des Materials zu. Wir können die Texturreferenz der erzeugten Textur auf dieselbe Weise wie die Materialreferenz erhalten.
Material Material = (Material) (AssetDatabase.LoadAssetAtPath ("Assets / New Material.mat", typeof (Material))); material.mainTexture = (Texture2D) (AssetDatabase.LoadAssetAtPath ("Assets / texture.png", typeof (Texture2D))); Um die Ergebnisse zu sehen, führen Sie das aus Materielle Routine.
Wie Sie sehen, hat das Material jetzt die Textur zugewiesen.
Damit ist die Einführung beendet, um Ihre Assets mithilfe von Skripts zu verwalten. Wenn Sie Ihr Wissen zu diesem Thema erweitern möchten, besuchen Sie die Referenzseite für Unity-Editor-Klassen. Insbesondere die Referenz zu AssetDatabase-Skripts ist ein Blick wert. Wenn Sie auf einem niedrigen Niveau arbeiten müssen, sollten Sie auch die Dokumentation zu System.IO lesen, um weitere Informationen zu den Klassen und deren Verwendung zu erhalten. Vielen Dank für Ihre Zeit!
