Beschleunigen Sie die Arbeitsabläufe Ihrer Programmierer

Wir haben vor kurzem zwei Blogbeiträge veröffentlicht, Fünf Wege, Ihre Arbeitsabläufe im Editor zu beschleunigen und Beschleunigen Sie Ihre Künstler-Workflows, beide basierend auf unserem E-Book für professionelle Entwickler, 70+ Tipps zur Steigerung der Produktivität mit Unity 2020 LTS. In diesem dritten und letzten Blog-Beitrag der Serie konzentrieren wir uns auf Arbeitsabläufe und die Funktionen, die Programmierern helfen, mehr in kürzerer Zeit zu erledigen. Beginnen wir damit, wie Sie beim Playtesting Zeit bei der Kompilierung sparen können.

Wenn Sie in den Play-Modus wechseln, wird Ihr Projekt wie bei einem Build ausgeführt. Alle Änderungen, die Sie im Editor während des Wiedergabemodus vornehmen, werden zurückgesetzt, wenn Sie den Wiedergabemodus verlassen.

Jedes Mal, wenn Sie im Editor den Wiedergabemodus aufrufen, führt Unity zwei wichtige Aktionen aus:

• Domain Reload: Unity sichert, entlädt und erstellt den Skriptstatus neu.
• Szene neu laden: Unity löscht die Szene und lädt sie erneut.

Diese beiden Aktionen nehmen immer mehr Zeit in Anspruch, je komplexer Ihre Skripts und Szenen werden.

Wenn Sie nicht vorhaben, weitere Skriptänderungen vorzunehmen, nutzen Sie die Einstellungen für den Wiedergabemodus (Bearbeiten > Projekteinstellungen > Editor), um etwas Kompilierzeit zu sparen. Unity bietet Ihnen die Möglichkeit, entweder den Domain Reload, den Scene Reload oder beide zu deaktivieren. Dies kann das Aufrufen und Beenden des Spielmodus beschleunigen.

Denken Sie nur daran, dass Sie Domain Reload wieder aktivieren müssen, wenn Sie weitere Skriptänderungen vornehmen möchten. Ebenso sollten Sie, wenn Sie die Szenenhierarchie ändern, das erneute Laden von Szenen wieder aktivieren. Andernfalls kann es zu unerwartetem Verhalten kommen.

Eine Assembly ist eine C#-Codebibliothek, eine Sammlung von Typen und Ressourcen, die so aufgebaut sind, dass sie zusammenarbeiten und eine logische Einheit von Funktionen bilden. Standardmäßig kompiliert Unity fast alle Ihre Spielskripte in die vordefinierte Assembly Assembly-CSharp.dll. Das funktioniert gut für kleine Projekte, hat aber auch einige Nachteile:

• Jedes Mal, wenn Sie ein Skript ändern, kompiliert Unity alle anderen Skripte neu.
• Ein Skript kann auf Typen zugreifen, die in jedem anderen Skript definiert sind.
• Alle Skripte sind für alle Plattformen kompiliert.

Die Organisation Ihrer Skripte in benutzerdefinierten Assemblies fördert die Modularität und Wiederverwendbarkeit. Es verhindert, dass sie automatisch zu den Standard-Assemblies hinzugefügt werden, und schränkt ein, auf welche Skripte sie zugreifen können.

Sie können Ihren Code in mehrere Assemblies aufteilen, wie im obigen Diagramm dargestellt. Hier können sich Änderungen am Code in Main nicht auf den Code in Stuff auswirken. Und da Library nicht von anderen Assemblies abhängt, können Sie den Code von Library problemlos in fast jedem anderen Projekt wiederverwenden.

Assemblies in .NET enthält allgemeine Informationen über Assemblies in C#. Weitere Informationen zur Definition Ihrer eigenen Assemblies in Unity finden Sie unter Assembly-Definitionen in der Unity-Dokumentation.

Haben Sie sich schon einmal dabei ertappt, dass Sie bei der Erstellung eines neuen Skripts immer wieder dieselben Änderungen vornehmen? Fügen Sie instinktiv einen Namespace hinzu oder löschen Sie die Funktion "Ereignis aktualisieren"? Sparen Sie sich ein paar Tastenanschläge und schaffen Sie Konsistenz im gesamten Team, indem Sie die Skriptvorlage an dem von Ihnen bevorzugten Ausgangspunkt einrichten.

Jedes Mal, wenn Sie ein neues Skript oder einen neuen Shader erstellen, verwendet Unity eine Vorlage, die in

%EDITOR_PATH%\Data\Resources\ScriptTemplates:

• Fenster: C:\Program Files\Unity\Editor\Data\Resources\ScriptTemplates
• Mac: /Applications/Hub/Editor/[Version]/Unity/Unity.app/Contents/Resources/ScriptTemplates

Die Standardvorlage für MonoBehaviour ist diese:

81-C# Script-NewBehaviourScript.cs.txt

Außerdem gibt es Vorlagen für Shader, andere Verhaltensskripte und Assembly-Definitionen.

Für projektspezifische Skriptvorlagen erstellen Sie einen Ordner Assets/ScriptTemplates und kopieren dann die Skriptvorlagen in diesen Ordner, um die Standardeinstellungen zu überschreiben.

Sie können die Standard-Skriptvorlagen auch direkt für alle Projekte ändern, aber stellen Sie sicher, dass Sie die Originale sichern, bevor Sie Änderungen vornehmen.

Die ursprüngliche 81-C# Script-NewBehaviourScript.cs.txt Datei sieht wie folgt aus:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

#ROOTNAMESPACEBEGIN#
public class #SCRIPTNAME# : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        #NOTRIM#
    }

    // Update is called once per frame
    void Update()
    {
        #NOTRIM#
    }
}
#ROOTNAMESPACEEND#

Es ist hilfreich, diese beiden Schlüsselwörter im Hinterkopf zu behalten:

• #SCRIPTNAME# gibt den eingegebenen Dateinamen oder den Standard-Dateinamen an (zum Beispiel NewBehaviourScript).
• #NOTRIM# sorgt dafür, dass die Klammern eine Zeile mit Leerzeichen enthalten.

Starten Sie den Unity-Editor neu, und Ihre Änderungen sollten jedes Mal erscheinen, wenn Sie ein benutzerdefiniertes MonoBehaviour erstellen.

Sie können auch die anderen Vorlagen auf ähnliche Weise ändern. Denken Sie daran, eine Kopie Ihres Originals und der Änderungen außerhalb des Unity-Projekts aufzubewahren.

Unity verfügt über eine Vielzahl von Attributen, die über einer Klasse, Eigenschaft oder Funktion platziert werden können, um ein spezielles Verhalten anzuzeigen. C# enthält Attributnamen innerhalb eckiger Klammern.

Hier sind einige gängige Attribute, die Sie Ihren Skripten hinzufügen können:

Dies ist nur eine kleine Auswahl der zahlreichen Attribute, mit denen Sie arbeiten können. Möchten SieIhre Variablen umbenennen, ohne ihre Werte zu verlieren? Oder eine Logik ohne ein leeres GameObject aufzurufen? In der Scripting API finden Sie eine vollständige Liste der Attribute, um zu sehen, was alles möglich ist.

Sie können sogar Ihr eigenes PropertyAttribute erstellen, um benutzerdefinierte Attribute für Ihre Skriptvariablen zu definieren

Eine der mächtigsten Funktionen von Unity ist der erweiterbare Editor. Verwenden Sie das UI-Toolkit Paket oder das IMGUI Modus, um Editor-Benutzeroberflächen zu erstellen, wie z.B. benutzerdefinierte Fenster und Inspektoren.

UI Toolkit hat einen ähnlichen Arbeitsablauf wie die normale Webentwicklung. Verwenden Sie die von HTML und XML inspirierte Auszeichnungssprache UXML, um Benutzeroberflächen und wiederverwendbare Benutzeroberflächenvorlagen zu definieren. Wenden Sie dann Unity Style Sheets (USS) an, um den visuellen Stil und das Verhalten Ihrer Unity UI zu ändern.

Alternativ können Sie auch den Sofortmodus verwenden, IMGUI, wie oben erwähnt. Leiten Sie zunächst von der Basisklasse Editor ab und verwenden Sie dann das Attribut CustomEditor .

Beide Lösungen können einen eigenen Inspektor erstellen.

Ein benutzerdefinierter Editor ändert, wie das MyPlayer-Skript im Inspektor angezeigt wird:

Unter Erstellen von Benutzeroberflächen (UI) erfahren Sie mehr darüber, wie Sie benutzerdefinierte Editor-Skripte mit dem UI Toolkit oder IMGUI implementieren können. Eine kurze Einführung in das UI Toolkit erhalten Sie im Tutorial Erste Schritte mit dem Editor-Skripting.

Das Addressable Asset System vereinfacht die Verwaltung der Assets, aus denen Ihr Spiel besteht. Jedes Asset, einschließlich Szenen, Prefabs, Text-Assets usw., kann als "adressierbar" markiert und mit einem eindeutigen Namen versehen werden. Sie können diesen Alias von überall aus aufrufen.

Diese zusätzliche Abstraktionsebene zwischen dem Spiel und seinen Assets kann bestimmte Aufgaben vereinfachen, z. B. die Erstellung eines separaten Pakets mit herunterladbaren Inhalten. Dieses System erleichtert auch das Auffinden dieser Asset Packs, unabhängig davon, ob sie lokal oder remote sind.

Installieren Sie zunächst das Addressables-Paket über den Paketmanager und fügen Sie dem Projekt einige Grundeinstellungen hinzu. Jedes Asset oder Prefab im Projekt sollte die Möglichkeit haben, "adressierbar" gemacht zu werden. Aktivieren Sie die Option unter dem Namen eines Assets im Inspektor, um ihm eine eindeutige Standardadresse zuzuweisen.

Sobald Sie sie markiert haben, erscheinen die entsprechenden Assets im Fenster > Asset Management > Addressables > Gruppen.

Der Einfachheit halber können Sie entweder jede Adresse in den einzelnen Adressfeldern der Assets umbenennen oder sie alle auf einmal vereinfachen.

Bündeln Sie diese Assets, um sie auf einem anderen Server zu hosten, oder verteilen Sie sie lokal in Ihrem Projekt. Wo auch immer sich die Assets befinden, das System kann sie anhand der Zeichenfolge Addressables Name lokalisieren.

Sie können Ihre Addressable Assets jetzt über die Addressables API nutzen.

Es sei darauf hingewiesen, dass Sie ohne Addressables die folgenden Schritte ausführen müssten, um eine Prefab in Ihrer Szene zu instanziieren:

public GameObject prefabToCreate;

public void CreatePrefab() 
{
    GameObject.Instantiate(prefabToCreate);
}
view rawgistfile1.txt hosted with ❤ by GitHub

Der Nachteil dabei ist, dass jede referenzierte Prefab (wie prefabToCreate) in den Speicher geladen wird, auch wenn die Szene sie nicht benötigt.

Wenn Sie Addressables verwenden, tun Sie stattdessen Folgendes:

public string prefabByAddress;
… 
public void CreatePrefabWithAddress() 
{
    Addressables.Instantiate(prefabByAddress, instantiationParameters, bool);
}

Dadurch wird das Asset über seine Adresszeichenfolge geladen, was bedeutet, dass die Voreinstellung erst dann in den Speicher geladen wird, wenn sie benötigt wird (wenn wir Adressables.Instantiate innerhalb von CreatedPrefabWithAddress aufrufen). Außerdem können Sie Addressables für die Zählung von Referenzen auf hoher Ebene verwenden, um Bundles und die dazugehörigen Assets automatisch zu entladen, wenn sie nicht mehr verwendet werden.

Geschichten aus den Schützengräben der Optimierung: Speicherplatz sparen mit Addressables zeigt ein Beispiel dafür, wie Sie Ihre Addressables Gruppen so organisieren können, dass sie mehr Speicherplatz benötigen. In der Zwischenzeit haben die Addressables: Einführung in die Konzepte bietet einen schnellen Überblick darüber, wie das Addressable Asset System in Ihrem Projekt funktionieren kann.

Wenn Sie ein Live-Spiel betreiben, sollten Sie vielleicht die Cloud Content Delivery (CCD) Lösung von Unity mit Addressables in Betracht ziehen. Das Addressables-System speichert und katalogisiert Spiel-Assets, so dass sie automatisch gefunden und aufgerufen werden können. CCD gibt diese Assets dann direkt an Ihre Spieler weiter, völlig unabhängig von Ihrem Code. Dies reduziert die Größe Ihres Builds und macht es überflüssig, dass Ihre Spieler bei jeder Aktualisierung neue Spielversionen herunterladen und installieren müssen. Wenn Sie mehr erfahren möchten, lesen Sie diesen Blog über die Integration von Addressables und Cloud Content Delivery.

Mit der Funktion für plattformabhängige Kompilierung können Sie Ihre Skripte so partitionieren, dass der Code für eine bestimmte Plattform kompiliert und ausgeführt wird.

In diesem Beispiel werden die vorhandenen #define-Direktiven der Plattform mit der #if-Compilerdirektive verwendet:

using UnityEngine;
using System.Collections;

public class PlatformDefines : MonoBehaviour 
{
  void Start () 
  {
    #if UNITY_EDITOR
      Debug.Log("Unity Editor");
    #endif

    #if UNITY_IOS
      Debug.Log("Iphone");
    #endif

    #if UNITY_STANDALONE_OSX
      Debug.Log("Stand Alone OSX");
    #endif

    #if UNITY_STANDALONE_WIN
      Debug.Log("Stand Alone Windows");
    #endif

  }          
}

Verwenden Sie die #define DEVELOPMENT_BUILD, um festzustellen, ob Ihr Skript in einem Player ausgeführt wird, der mit der Option Development Build erstellt wurde.

Sie können selektiv für bestimmte Unity-Versionen und/oder Skript-Backends kompilieren und sogar Ihre eigenen benutzerdefinierten #define-Direktiven beim Testen im Editor angeben. Öffnen Sie das Panel Andere Einstellungen, das Teil der Player-Einstellungen ist, und navigieren Sie zu Skripting Symbole definieren.

Weitere Informationen zu den Präprozessor-Direktiven von Unity finden Sie unter Plattformabhängige Kompilierung.

Ein ScriptableObject ist ein Datencontainer, der große Datenmengen getrennt von Klasseninstanzen speichert. ScriptableObjects vermeiden das Kopieren von Werten, was den Speicherbedarf Ihres Projekts reduzieren kann. Sehen Sie sich das vollständige E-Book an, um einige Beispiele für die Verwendung von ScriptableObjects zu sehen. Andernfalls lesen Sie die ScriptableObject-Dokumentation für weitere Details zur Verwendung von ScriptableObjects in Ihrer Anwendung.

Suchen Sie noch mehr? Schauen Sie sich Bessere Daten mit ScriptableObjects in Unity an, um eine kurze Einführung zu erhalten und zu sehen, wie sie bei der Verwaltung von Szenen in Achieve better Scene workflow with ScriptableObjects helfen können.

Tipp für die Optimierung

Wir empfehlen binäre Serialisierungsformate wie MessagePack oder Protocol Buffers für gespeicherte Daten und keine textbasierten Formate wie JSON oder XML. In Projektbesprechungen wurde festgestellt, dass diese binären Serialisierungsformate die mit letzteren verbundenen Speicher- und Leistungsprobleme verringern.

Unity bietet Unterstützung für die folgenden integrierten Entwicklungsumgebungen(IDEs):

• Visual Studio: Standard-IDE unter Windows und macOS
• Visual Studio Code: Windows, macOS, Linux
• JetBrains Rider: Windows, macOS, Linux

IDE-Integrationen für alle drei dieser Umgebungen erscheinen als Pakete im Paketmanager.

Wenn Sie Unity auf Windows und macOS installieren, wird Visual Studio standardmäßig installiert. Wenn Sie eine andere IDE verwenden möchten, suchen Sie einfach nach dem Editor in Unity > Einstellungen > Externe Tools > Externer Skript-Editor.

Rider baut auf ReSharper auf und enthält die meisten seiner Funktionen. Es unterstützt das C#-Debugging auf der .NET 4.6 Skripting-Runtime in Unity (C# 8.0). Weitere Informationen finden Sie in der Dokumentation von JetBrains zu Rider für Unity.

VS Code ist ein kostenloser, schlanker Code-Editor mit Unterstützung für Debugging, Aufgabenausführung und Versionskontrolle. Beachten Sie, dass Unity bei der Verwendung von VS Code Mono (macOS und Linux), Visual Studio Code C# und Visual Studio Code Debugger for Unity (nicht offiziell unterstützt) erfordert.

Jede IDE hat ihre eigenen Vorzüge. Unter Unterstützung für integrierte Entwicklungsumgebungen (IDE) finden Sie weitere Informationen zur Auswahl der richtigen IDE für Ihre Bedürfnisse.

Werfen Sie einen Blick in das E-Book, um eine Liste von Shortcuts zu erhalten, die für Ihr Projekt von Nutzen sein können, und sehen Sie sich die Tipps und Tricks zu Visual Studio an , um Ihre Produktivität zu steigern und den Workflow mit Visual Studio weiter zu verbessern.

Sind Sie daran interessiert, JetBrains Rider kennenzulernen? Lesen Sie Fast C# Scripting in Unity mit JetBrains Rider oder diese Tipps zur Verwendung von JetBrains Rider als Code-Editor.

Mit dem Unity Debugger können Sie Ihren C#-Code debuggen, während sich die Unity-Entität im Spielmodus befindet. Sie können im Code-Editor Haltepunkte setzen, um den Zustand Ihres Skriptcodes und seiner aktuellen Variablen zur Laufzeit zu überprüfen.

Unten rechts in der Statusleiste des Unity-Editors können Sie den Code-Optimierungsmodus auf Debuggen setzen. Sie können diesen Modus auch beim Start unter Bearbeiten > Voreinstellungen > Allgemein > Code-Optimierung beim Start ändern.

Setzen Sie im Code-Editor einen Haltepunkt an der Stelle, an der der Debugger die Ausführung unterbrechen soll. Klicken Sie einfach auf den linken Randbereich, in dem Sie einen Haltepunkt umschalten möchten (oder klicken Sie dort mit der rechten Maustaste, um das Kontextmenü für andere Optionen anzuzeigen). Neben der Zeilennummer der markierten Zeile erscheint ein roter Kreis (siehe Abbildung unten).

Wählen Sie in Ihrem Code-Editor Attach to Unity und führen Sie das Projekt im Unity-Editor aus.

Im Wiedergabemodus wird die Anwendung am Haltepunkt angehalten, so dass Sie Zeit haben, die Variablen zu überprüfen und ein unbeabsichtigtes Verhalten zu untersuchen.

Wie oben gezeigt, können Sie die Variablen beim Debuggen untersuchen, indem Sie beobachten, wie sich die Liste während der Ausführung Schritt für Schritt aufbaut.

Verwenden Sie die Steuerelemente Ausführung fortsetzen, Step Over, Step Into und Step Out, um im Kontrollfluss zu navigieren.

Drücken Sie Stop, um das Debugging zu beenden und die Ausführung im Editor fortzusetzen.

Sie können Skriptcode auch in einem Unity Player debuggen. Vergewissern Sie sich einfach, dass sowohl Development Build als auch Script Debugging unter Datei > Build-Einstellungen aktiviert sind, bevor Sie den Player erstellen. Aktivieren Sie Warten auf Managed Debugger, um auf den Debugger zu warten, bevor der Player Skriptcode ausführt. Um den Code-Editor mit dem Unity Player zu verbinden, wählen Sie die IP-Adresse (oder den Rechnernamen) und den Port Ihres Players. Fahren Sie dann ganz normal in Visual Studio mit der Option An Unity anhängen fort.

Unity bietet eine Debug-Klasse, mit der Sie die Informationen im Editor visualisieren können, während dieser läuft. Lernen Sie, wie Sie Meldungen oder Warnungen im Konsolenfenster ausgeben, Visualisierungslinien in den Ansichten Szene und Spiel zeichnen und den Wiedergabemodus im Editor aus einem Skript heraus anhalten. Hier sind noch ein paar Tipps, die Ihnen den Einstieg erleichtern:

1. Unterbrechen Sie die Ausführung mit Debug.Pause. Dies ist nützlich, um bestimmte Werte im Inspektor zu überprüfen, wenn es schwierig ist, die Anwendung manuell anzuhalten.

2. Sie sollten vertraut sein mit Debug.Log, Debug.LogWarningund Debug.LogError zum Drucken von Konsolenmeldungen. Ebenfalls praktisch ist Debug.Assertdie eine Bedingung durchsetzt und bei einem Fehlschlag einen Fehler protokolliert. Beachten Sie jedoch, dass dies nur funktioniert, wenn das Symbol UNITY_ASSERTIONS definiert ist. Protokollieren Sie Meldungen, Warnungen und Fehler in der Konsole.

3. Bei Verwendung von Debug.Logverwenden, können Sie ein Objekt als Kontext übergeben. Wenn Sie auf die Nachricht in der Konsole klicken, markiert Unity das GameObjects im Hierarchiefenster.

4. Verwenden Sie Rich Text zum Markieren Ihrer Debug.Log Anweisungen. Dies kann Ihnen helfen, die Fehlerberichte in der Konsole zu verbessern.

5. Unity entfernt nicht automatisch die Option Debug Protokollierungs-APIs aus Nicht-Entwicklungs-Builds. Verpacken Sie Ihre Debug Log-Aufrufe in benutzerdefinierte Methoden und schmücken Sie sie mit dem Attribut [Conditional]. Um die Debug-Protokolle auf einmal zu kompilieren, entfernen Sie das entsprechende Scripting Define Symbol aus den Player-Einstellungen. Dies ist identisch mit der Einbettung in #if... #endif Präprozessorblöcke. Weitere Einzelheiten finden Sie in dieser Anleitung Allgemeine Optimierungen.

6. Fehlersuche in der Physik? Debug.DrawLine und Debug.DrawRay können Ihnen helfen, Raycasting zu visualisieren.

1. Wenn Sie möchten, dass der Code nur ausgeführt wird, während Development Build aktiviert ist, prüfen Sie, ob Debug.isDebugBuild true zurückgibt.

2. Verwenden Sie Anwendung.SetStackTraceLogTypeoder die entsprechenden Kontrollkästchen in den Player-Einstellungen, um zu entscheiden, welche Art von Protokollmeldungen Stack Traces enthalten sollen. Stack Traces können nützlich sein, aber sie sind langsam und erzeugen Müll.

Der Konsolenprotokolleintrag zeigt standardmäßig zwei Zeilen an. Um die Lesbarkeit zu verbessern, können Sie sie auf nur eine Zeile reduzieren. Sehen Sie unten, wie.

Alternativ können Sie auch mehr Zeilen für längere Einträge verwenden.

Wenn Unity kompiliert, kann das Symbol in der unteren rechten Ecke schwer zu sehen sein. Verwenden Sie dieses benutzerdefinierte Editor-Skript, um EditorApplication.isCompiling aufzurufen. Dadurch wird ein schwebendes Fenster erstellt, um den Compiler-Status besser sichtbar zu machen.

Starten Sie das MenuItem, um das Fenster zu initialisieren. Sie können sogar das Erscheinungsbild mit einem neuen GUIStyle nach Ihren Wünschen anpassen.

using UnityEditor;
using UnityEngine;

public class CustomCompileWindow : EditorWindow
{
    [MenuItem("Examples/CustomCompileWindow")]
    static void Init()
    {
        EditorWindow window = GetWindowWithRect(typeof(CustomCompileWindow), new Rect(0, 0, 200, 200));
        window.Show();
    }
   void OnGUI()
    {
        EditorGUILayout.LabelField("Compiling:", EditorApplication.isCompiling ? "Yes" : "No");
       this.Repaint();
    }
}

Unity verfügt über Integrationen mit zwei Versionskontrollsystemen (VCS): Perforce und Plastic SCM. Um die Perforce- oder Plastic SCM-Server für Ihr Unity-Projekt festzulegen, gehen Sie zu Projekteinstellungen > Editor. Konfigurieren Sie den Server (und Ihre Benutzeranmeldedaten für Perforce) unter Version Control.

Teams auf Unity können Plastic SCM Cloud Edition kostenlos nutzen, für bis zu 5 GB Speicherplatz und maximal drei Benutzer. Wenn Sie Plastic SCM für Unity verwenden, können Sie Ihre Änderungen mit denen Ihrer Teamkollegen synchronisieren und Ihren Projektverlauf einsehen, ohne Unity zu verlassen. Lesen Sie hier über einige aktuelle Aktualisierungen von Plastic SCM.

Sie können auch ein externes System wie Git verwenden, einschließlich Git LFS (Large File Support) für eine effizientere Versionskontrolle größerer Assets, wie Grafiken und Soundressourcen. Um die Arbeit mit dem GitHub-Hostingdienst noch bequemer zu gestalten, installieren Sie das GitHub for Unity Plug-in. Mit dieser Open-Source-Erweiterung können Sie Ihren Projektverlauf einsehen, in Zweigen experimentieren, Ihre Änderungen festschreiben und Ihren Code auf GitHub veröffentlichen - alles innerhalb von Unity.

Unity verwaltet eine .gitignore-Datei. So können Sie entscheiden, was in das Git-Repository aufgenommen werden soll und was nicht, und diese Regeln dann durchsetzen.

Unity Teams ist eine weitere Option zur Rationalisierung Ihrer Arbeitsabläufe, denn damit können Sie Ihr gesamtes Projekt in der Cloud speichern. Das bedeutet, dass sie gesichert und überall zugänglich sind, was das Speichern, Freigeben und Synchronisieren Ihrer Unity-Projekte für jedermann sehr viel einfacher macht.

Lesen Sie die ersten beiden Blogbeiträge dieser Serie, 5 Wege zur Beschleunigung Ihrer Arbeitsabläufe im Editor und Beschleunigen Sie die Arbeitsabläufe Ihrer Künstler. Sie können auch den kostenlosen Leitfaden70+ Tipps zur Steigerung der Produktivität mit Unity 2020 LTS herunterladen, der alle Tipps in einem praktischen E-Book zusammenfasst.

Wie immer bitten wir Sie, uns in den Kommentaren weitere Themen oder Funktionen mitzuteilen, über die Sie gerne mehr erfahren möchten, und Sie können Ihre eigenen Produktivitätstipps mit der Community teilen.