Optimieren Sie die Leistung Ihres Mobilspiels: Tipps zu Profiling, Speicher und Code-Architektur von den besten Ingenieuren von Unity

Unser Unity Studio Produktionsteam kennt den Quellcode in- und auswendig und unterstützt eine Vielzahl von Unity-Kunden, damit sie das Beste aus der Engine herausholen können. In ihrer Arbeit tauchen sie tief in die Projekte der Creator ein, um Punkte zu identifizieren, an denen die Leistung für mehr Geschwindigkeit, Stabilität und Effizienz optimiert werden könnte. Wir haben uns mit diesem Team, das aus den erfahrensten Software-Ingenieuren von Unity besteht, zusammengesetzt und sie gebeten, ihr Fachwissen zur Optimierung von Mobilspielen zu teilen.

Als unsere Ingenieure begannen, ihre Erkenntnisse zur Optimierung von Mobilspielen zu teilen, wurde uns ziemlich schnell klar, dass es viel zu viele großartige Informationen für den einzelnen Blogbeitrag gab, den wir geplant hatten. Stattdessen haben wir beschlossen, ihr Wissen in ein umfassendes E-Book (das Sie hier herunterladen können) sowie in eine Reihe von Blogbeiträgen zu verwandeln, die einige dieser 75+ umsetzbaren Tipps hervorheben.

Wir beginnen den ersten Beitrag in dieser Reihe, indem wir uns darauf konzentrieren, wie Sie die Leistung Ihres Spiels mit Profiling, Speicher und Code-Architektur verbessern können. In den nächsten Wochen werden wir mit zwei weiteren Beiträgen nachlegen: der erste behandelt UI-Physik, gefolgt von einem weiteren über Audio und Assets, Projektkonfiguration und Grafik.

Möchten Sie die gesamte Serie jetzt ansehen? Laden Sie das vollständige E-Book kostenlos herunter.

Lass uns eintauchen!

Was wäre ein besserer Ausgangspunkt als Profiling und der Prozess des Sammelns und Handelns von Leistungsdaten für Mobilgeräte? Hier beginnt die Optimierung der mobilen Leistung wirklich.

Profilieren Sie früh, oft und auf dem Zielgerät

Der Unity Profiler liefert wichtige Leistungsinformationen über Ihre Anwendung, aber er kann Ihnen nicht helfen, wenn Sie ihn nicht verwenden. Profilieren Sie Ihr Projekt früh in der Entwicklung, nicht nur, wenn Sie kurz vor der Veröffentlichung stehen. Untersuchen Sie Störungen oder Spitzen, sobald sie auftreten. Während Sie eine „Leistungsunterschrift“ für Ihr Projekt entwickeln, werden Sie in der Lage sein, neue Probleme leichter zu erkennen.

Während das Profiling im Editor Ihnen eine Vorstellung von der relativen Leistung verschiedener Systeme in Ihrem Spiel geben kann, bietet das Profiling auf jedem Gerät die Möglichkeit, genauere Einblicke zu gewinnen. Profilieren Sie einen Entwicklungsbuild auf Zielgeräten, wann immer es möglich ist. Denken Sie daran, sowohl für die leistungsstärksten als auch für die schwächsten Geräte, die Sie unterstützen möchten, zu profilieren und zu optimieren.

Neben dem Unity Profiler können Sie native Tools von iOS und Android für weitere Leistungstests auf ihren jeweiligen Engines nutzen:

• Verwenden Sie auf iOS Xcode und Instruments.
• Verwenden Sie auf Android Android Studio und Android Profiler.

Bestimmte Hardware kann von zusätzlichen Profiling-Tools profitieren (z. B. Arm Mobile Studio, Intel VTune und Snapdragon Profiler). Siehe Profiling-Anwendungen, die mit Unity erstellt wurden für weitere Informationen.

Konzentrieren Sie sich darauf, die richtigen Bereiche zu optimieren

Raten Sie nicht oder ziehen Sie keine Schlussfolgerungen darüber, was die Leistung Ihres Spiels verlangsamt. Verwenden Sie den Unity Profiler und plattformspezifische Tools, um die genaue Quelle eines Verzugs zu lokalisieren.

Natürlich wird nicht jede hier beschriebene Optimierung auf Ihre Anwendung zutreffen. Etwas, das in einem Projekt gut funktioniert, lässt sich möglicherweise nicht auf Ihres übertragen. Identifizieren Sie echte Engpässe und konzentrieren Sie Ihre Bemühungen auf das, was Ihrer Arbeit zugutekommt.

Verstehen Sie, wie der Unity Profiler funktioniert

Der Unity Profiler kann Ihnen helfen, die Ursachen von Verzögerungen oder Einfrierungen zur Laufzeit zu erkennen und besser zu verstehen, was in einem bestimmten Frame oder zu einem bestimmten Zeitpunkt passiert. Aktivieren Sie standardmäßig die CPU- und Speicherspuren. Sie können zusätzliche Profiler-Module wie Renderer, Audio und Physik überwachen, je nach Bedarf für Ihr Spiel (z. B. physiklastiges oder musikbasiertes Gameplay).

Bauen Sie die Anwendung auf Ihr Gerät, indem Sie Entwicklungsbuild und Autoconnect Profiler aktivieren oder manuell verbinden, um die Startzeit der App zu beschleunigen.

Wählen Sie das Plattformziel zum Profilieren aus. Die Aufzeichnen-Schaltfläche verfolgt mehrere Sekunden der Wiedergabe Ihrer Anwendung (standardmäßig 300 Frames). Gehen Sie zu Unity > Einstellungen > Analyse > Profiler > Frame-Anzahl, um dies auf bis zu 2000 zu erhöhen, wenn Sie längere Aufnahmen benötigen. Obwohl dies bedeutet, dass der Unity-Editor mehr CPU-Arbeit leisten und mehr Speicher beanspruchen muss, kann es je nach Ihrem spezifischen Szenario nützlich sein.

Dies ist ein instrumentierungsbasierter Profiler, der die Codezeiten explizit in Profilmarkern umschließt (wie die Start- oder Update-Methoden von MonoBehaviour oder spezifische API-Aufrufe). Außerdem kann Unity beim Verwenden der Tiefenprofilierung-Einstellung den Anfang und das Ende jedes Funktionsaufrufs in Ihrem Skriptcode profilieren, um Ihnen genau zu sagen, welcher Teil Ihrer Anwendung eine Verlangsamung verursacht.

Beim Profilieren Ihres Spiels empfehlen wir, sowohl Spitzen als auch die Kosten eines durchschnittlichen Frames in Ihrem Spiel abzudecken. Das Verständnis und die Optimierung teurer Operationen, die in jedem Frame auftreten, kann für Anwendungen, die unter der Zielbildrate laufen, nützlicher sein. Wenn Sie nach Spitzen suchen, erkunden Sie zuerst teure Operationen (z. B. Physik, KI, Animation) und die Speicherbereinigung.

Klicken Sie im Fenster, um einen bestimmten Frame zu analysieren. Verwenden Sie anschließend entweder die Timeline- oder Hierarchie-Ansicht für Folgendes:

• Timeline zeigt die visuelle Aufschlüsselung der Zeit für einen bestimmten Frame. Dies ermöglicht es Ihnen, zu visualisieren, wie die Aktivitäten zueinander und über verschiedene Threads hinweg in Beziehung stehen. Verwenden Sie diese Option, um festzustellen, ob Sie CPU- oder GPU-gebunden sind.
• Hierarchie zeigt die Hierarchie der Profilmarker, die zusammengefasst sind. Dies ermöglicht es Ihnen, die Proben basierend auf den Zeitkosten in Millisekunden (Zeit ms und Selbst ms) zu sortieren. Sie können auch die Anzahl der Aufrufe zu einer Funktion und den verwalteten Heap-Speicher (GC Alloc) im Frame zählen.

Lesen Sie eine vollständige Übersicht über den Unity Profiler hier. Diejenigen, die neu im Profiling sind, können sich auch diese Einführung in das Unity Profiling ansehen.

Bevor Sie etwas in Ihrem Projekt optimieren, speichern Sie die Profiler .datafile. Implementieren Sie Ihre Änderungen und vergleichen Sie die gespeicherte .data vor und nach der Modifikation. Verlassen Sie sich auf diesen Zyklus zur Leistungsverbesserung: profilieren, optimieren und vergleichen. Dann, wiederholen Sie den Vorgang.

Verwenden Sie den Profilanalysator

Dieses Tool ermöglicht es Ihnen, mehrere Frames von Profiler-Daten zu aggregieren und dann interessante Frames zu lokalisieren. Möchten Sie sehen, was mit dem Profiler passiert, nachdem Sie eine Änderung an Ihrem Projekt vorgenommen haben? Die Vergleichen Ansicht ermöglicht es Ihnen, zwei Datensätze zu laden und zu unterscheiden, damit Sie Änderungen testen und deren Ergebnis verbessern können. Der Profilanalysator ist über den Unity Package Manager verfügbar.

Arbeiten Sie mit einem spezifischen Zeitbudget pro Frame

Jeder Frame hat ein Zeitbudget basierend auf Ihren Zielbildern pro Sekunde (fps). Idealerweise ermöglicht eine Anwendung, die mit 30 fps läuft, etwa 33,33 ms pro Frame (1000 ms / 30 fps). Ebenso lässt ein Ziel von 60 fps 16,66 ms pro Frame.

Geräte können dieses Budget für kurze Zeiträume überschreiten (z. B. für Zwischensequenzen oder Ladezeiten), jedoch nicht für längere Zeit.

Berücksichtigen Sie die Temperatur des Geräts

Für mobile Geräte empfehlen wir jedoch nicht, diese maximale Zeit konstant zu nutzen, da das Gerät überhitzen kann und das Betriebssystem die CPU und GPU drosseln kann. Wir empfehlen, nur etwa 65 % der verfügbaren Zeit zu nutzen, um eine Abkühlung zwischen den Frames zu ermöglichen. Ein typisches Frame-Budget beträgt ungefähr 22 ms pro Frame bei 30 fps und 11 ms pro Frame bei 60 fps.

Die meisten mobilen Geräte haben keine aktive Kühlung wie ihre Desktop-Pendants. Physikalische Wärmelevels können die Leistung direkt beeinflussen.

Wenn das Gerät heiß läuft, könnte der Profiler eine schlechte Leistung wahrnehmen und melden, auch wenn dies langfristig kein Grund zur Besorgnis ist. Um Überhitzung beim Profiling zu bekämpfen, profilieren Sie in kurzen Intervallen. Dies kühlt das Gerät und simuliert reale Bedingungen. Unsere allgemeine Empfehlung ist, das Gerät 10-15 Minuten lang kühl zu halten, bevor Sie erneut profilieren.

Bestimmen Sie, ob Sie GPU-gebunden oder CPU-gebunden sind

Der Profiler kann Ihnen sagen, ob Ihre CPU länger als Ihr zugewiesenes Frame-Budget benötigt oder ob der Übeltäter Ihre GPU ist. Dies geschieht durch das Ausgeben von Markern, die mit Gfx beginnen, wie folgt:

• Wenn Sie den Gfx.WaitForCommandsMarker sehen, bedeutet das, dass der Render-Thread bereit ist, Sie aber möglicherweise auf einen Engpass im Haupt-Thread warten.
• Wenn Sie häufig auf Gfx.WaitForPresentstoßen, bedeutet das, dass der Haupt-Thread bereit war, aber auf die GPU warten musste, um das Frame anzuzeigen.

Unity verwendet automatisches Speichermanagement für Ihren benutzergenerierten Code und Skripte. Kleine Datenmengen, wie lokal typisierte Variablen, werden auf dem Stack zugewiesen. Größere Datenmengen und langfristige Speicherung werden im verwalteten Heap zugewiesen.

Der Garbage Collector identifiziert und deallokiert regelmäßig ungenutzten Heap-Speicher. Während dies automatisch abläuft, kann der Prozess, alle Objekte im Heap zu untersuchen, dazu führen, dass das Spiel ruckelt oder langsam läuft.

Die Optimierung Ihrer Speichernutzung bedeutet, sich bewusst zu sein, wann Sie Heap-Speicher zuweisen und freigeben, und wie Sie die Auswirkungen der Speicherbereinigung minimieren. Siehe Verstehen des verwalteten Heaps für weitere Informationen.

Verwenden Sie den Memory Profiler

Dieses separate Add-On (verfügbar als experimentelles oder Vorschau-Paket im Paket-Manager) kann einen Snapshot Ihres verwalteten Heap-Speichers erstellen, um Ihnen zu helfen, Probleme wie Fragmentierung und Speicherlecks zu identifizieren.

Klicken Sie im Baumkartenansicht, um eine Variable dem nativen Objekt zuzuordnen, das den Speicher hält. Hier können Sie häufige Probleme mit dem Speicherverbrauch identifizieren, wie übermäßig große Texturen oder doppelte Assets.

Erfahren Sie, wie Sie den Memory Profiler in Unity für eine verbesserte Speichernutzung nutzen können. Sie können auch unsere offizielle Dokumentation zum Memory Profiler einsehen.

Reduzieren Sie die Auswirkungen der Speicherbereinigung (GC)

Unity verwendet den Boehm-Demers-Weiser-Garbage-Collector, der das Ausführen Ihres Programm-Codes stoppt und die normale Ausführung erst wieder aufnimmt, wenn seine Arbeit abgeschlossen ist.

Seien Sie sich bestimmter unnötiger Heap-Zuweisungen bewusst, die GC-Spitzen verursachen könnten:

• Strings: In C# sind Strings Referenztypen, keine Werttypen. Reduzieren Sie unnötige String-Erstellungen oder -Manipulationen. Vermeiden Sie das Parsen von stringbasierten Datendateien wie JSON und XML; speichern Sie Daten stattdessen in ScriptableObjects oder Formaten wie MessagePack oder Protobuf. Verwenden Sie die StringBuilder-Klasse, wenn Sie zur Laufzeit Strings erstellen müssen.
• Unity-Funktionsaufrufe: Einige Funktionen erstellen Heap-Zuweisungen. Cache-Referenzen auf Arrays, anstatt sie mitten in einer Schleife zuzuweisen. Nutzen Sie auch bestimmte Funktionen, die die Erzeugung von Müll vermeiden. Verwenden Sie beispielsweise GameObject.CompareTag anstelle des manuellen Vergleichs eines Strings mit GameObject.tag (da die Rückgabe eines neuen Strings Müll erzeugt).
• Boxing: Vermeiden Sie es, eine werttypisierte Variable anstelle einer referenztypisierten Variable zu übergeben. Dies erstellt ein temporäres Objekt, und der potenzielle Müll, der damit einhergeht, konvertiert den Werttyp implizit in einen Typobjekt (z. B. int i = 123; object o = i). Versuchen Sie stattdessen, konkrete Überschreibungen mit dem Werttyp bereitzustellen, den Sie übergeben möchten. Generics können auch für diese Überschreibungen verwendet werden.
• Koroutinen: Obwohl yield keinen Müll erzeugt, erzeugt das Erstellen eines neuen WaitForSeconds-Objekts Müll. Cache und wiederverwenden Sie das WaitForSeconds-Objekt, anstatt es in der yield-Zeile zu erstellen.
• LINQ und reguläre Ausdrücke: Beide erzeugen Müll durch das Boxen im Hintergrund. Vermeiden Sie LINQ und reguläre Ausdrücke, wenn die Leistung ein Problem darstellt. Schreiben Sie for-Schleifen und verwenden Sie Listen als Alternative zur Erstellung neuer Arrays.

Zeit Müllsammlung, wenn möglich

Wenn Sie sicher sind, dass ein Müllsammlungsstopp einen bestimmten Punkt in Ihrem Spiel nicht beeinträchtigt, können Sie die Müllsammlung mit System.GC.Collect auslösen.

Siehe Verstehen der automatischen Speicherverwaltung für Beispiele, wie Sie dies zu Ihrem Vorteil nutzen können.

Verwenden Sie den inkrementellen Müllsammler, um die GC-Arbeitslast zu verteilen

Anstatt eine einzige, lange Unterbrechung während der Ausführung Ihres Programms zu erzeugen, verwendet die inkrementelle Speicherbereinigung mehrere, viel kürzere Unterbrechungen, die die Arbeitslast über viele Frames verteilen. Wenn die Speicherbereinigung die Leistung beeinträchtigt, versuchen Sie, diese Option zu aktivieren, um zu sehen, ob sie das Problem mit den GC-Spitzen reduzieren kann. Verwenden Sie den Profilanalysator, um seinen Nutzen für Ihre Anwendung zu überprüfen.

Der Unity PlayerLoop enthält Funktionen zur Interaktion mit dem Kern der Spiel-Engine. Diese Struktur umfasst eine Reihe von Systemen, die die Initialisierung und die Aktualisierungen pro Frame verwalten. Alle Ihre Skripte sind auf diesen PlayerLoop angewiesen, um das Gameplay zu erstellen.

Beim Profilieren sehen Sie den Benutzercode Ihres Projekts unter dem PlayerLoop (mit Editor-Komponenten unter dem EditorLoop).

Lernen Sie den PlayerLoop und den Lebenszyklus eines Skripts kennen.

Sie können Ihre Skripte mit den folgenden Tipps und Tricks optimieren.

Verstehen Sie den Unity PlayerLoop

Stellen Sie sicher, dass Sie die Ausführungsreihenfolge der Frame-Schleife von Unity verstehen. Jedes Unity-Skript führt mehrere Ereignisfunktionen in einer vordefinierten Reihenfolge aus. Sie sollten den Unterschied zwischen Awake, Start, Update und anderen Funktionen, die den Lebenszyklus eines Skripts erstellen, verstehen.

Verweisen Sie auf das Flussdiagramm des Skriptlebenszyklus für die spezifische Reihenfolge der Ausführung von Ereignisfunktionen.

Minimiere Code, der in jedem Frame ausgeführt wird

Überlege, ob der Code in jedem Frame ausgeführt werden muss. Bewege unnötige Logik aus Update, LateUpdate und FixedUpdate heraus. Diese Ereignisfunktionen sind bequeme Orte, um Code zu platzieren, der in jedem Frame aktualisiert werden muss, während jegliche Logik, die nicht mit dieser Frequenz aktualisiert werden muss, extrahiert wird. Wann immer möglich, führe Logik nur aus, wenn sich etwas ändert.

Wenn du do Update verwenden musst, ziehe in Betracht, den Code alle n Frames auszuführen. Dies ist eine Möglichkeit, Zeit-Slicing anzuwenden, eine gängige Technik zur Verteilung einer schweren Arbeitslast über mehrere Frames. In diesem Beispiel führen wir die ExampleExpensiveFunction einmal alle drei Frames aus:

private int interval = 3;

void Update()
{
    if (Time.frameCount % interval == 0)
    {
        ExampleExpensiveFunction();
    }
}

Vermeide schwere Logik in Start/Awake

Wenn deine erste Szene geladen wird, werden diese Funktionen für jedes Objekt aufgerufen:

• Awake
• OnEnable
• Start

Vermeide teure Logik in diesen Funktionen, bis deine Anwendung ihren ersten Frame rendert. Andernfalls könntest du längere Ladezeiten als nötig erleben.

Siehe die Reihenfolge der Ausführung für Ereignisfunktionen für Details zum Laden der ersten Szene.

Vermeide leere Unity-Ereignisse

Selbst leere MonoBehaviours benötigen Ressourcen, daher solltest du leere Update oder LateUpdate Methoden entfernen.

Verwende Präprozessor-Direktiven, wenn du diese Methoden zum Testen verwendest:

#if UNITY_EDITOR
void Update()
{
}
#endif

Hier kannst du das Update im Editor zum Testen ohne unnötige Überlastung in deinen Build verwenden.

Debug-Log-Anweisungen entfernen

Log-Anweisungen (insbesondere in Update, LateUpdate oder FixedUpdate) können die Leistung beeinträchtigen. Deaktivieren Sie Ihre Log-Anweisungen, bevor Sie einen Build erstellen.

Um dies einfacher zu machen, sollten Sie ein Bedingtes Attribut zusammen mit einer Vorverarbeitungsanweisung erstellen. Erstellen Sie beispielsweise eine benutzerdefinierte Klasse wie diese:

public static class Logging
{
    [System.Diagnostics.Conditional("ENABLE_LOG")]
    static public void Log(object message)
    {
        UnityEngine.Debug.Log(message);
    }
}

Generieren Sie Ihre Protokollnachricht mit Ihrer benutzerdefinierten Klasse. Wenn Sie die ENABLE_LOG-Vorverarbeitungsanweisung in den Player-Einstellungen deaktivieren, verschwinden alle Ihre Log-Anweisungen auf einen Schlag.

Verwenden Sie Hash-Werte anstelle von String-Parametern

Unity verwendet intern keine String-Namen, um Animator-, Material- und Shader-Eigenschaften anzusprechen. Zur Geschwindigkeit werden alle Eigenschaftsnamen in Eigenschafts-IDs gehasht, und diese IDs werden tatsächlich verwendet, um auf die Eigenschaften zuzugreifen.

Wenn Sie eine Set- oder Get-Methode für einen Animator, ein Material oder einen Shader verwenden, nutzen Sie die Methode mit ganzzahligen Werten anstelle der Methoden mit String-Werten. Die String-Methoden führen einfach eine String-Hashing durch und leiten dann die gehashte ID an die Methoden mit ganzzahligen Werten weiter.

Verwenden Sie Animator.StringToHash für Animator-Eigenschaftsnamen und Shader.PropertyToID für Material- und Shader-Eigenschaftsnamen.

Wählen Sie die richtige Datenstruktur

Ihre Wahl der Datenstruktur beeinflusst die Effizienz, da Sie Tausende von Malen pro Frame iterieren. Sind Sie sich nicht sicher, ob Sie eine Liste, ein Array oder ein Wörterbuch für Ihre Sammlung verwenden sollen? Befolgen Sie den MSDN-Leitfaden zu Datenstrukturen in C# als allgemeine Anleitung zur Auswahl der richtigen Struktur.

Vermeiden Sie das Hinzufügen von Komponenten zur Laufzeit

Das Aufrufen von AddComponent zur Laufzeit hat einige Kosten. Unity muss bei der Hinzufügung von Komponenten zur Laufzeit auf doppelte oder andere erforderliche Komponenten prüfen.

Das Instanziieren eines Prefabs mit den bereits eingerichteten gewünschten Komponenten ist im Allgemeinen leistungsfähiger.

GameObjects und Komponenten cachen

GameObject.Find, GameObject.GetComponent und Camera.main (in Versionen vor 2020.2) können teuer sein, daher ist es am besten, sie in Update-Methoden zu vermeiden. Stattdessen rufen Sie sie in Start auf und cachen die Ergebnisse.

Hier ist ein Beispiel, das die ineffiziente Nutzung eines wiederholten GetComponent-Aufrufs demonstriert:

void Update()
{
    Renderer myRenderer = GetComponent<Renderer>();
    ExampleFunction(myRenderer);
}

Stattdessen rufen Sie GetComponent nur einmal auf, da das Ergebnis der Funktion zwischengespeichert wird. Das zwischengespeicherte Ergebnis kann in Update ohne weitere Aufrufe von GetComponent wiederverwendet werden.

private Renderer myRenderer;

void Start()
{
    myRenderer = GetComponent<Renderer>();
}

void Update()
{
    ExampleFunction(myRenderer);
}

Verwenden Sie Objektpools

Instantiate und Destroy können Müll und Spitzen bei der Müllsammlung (GC) erzeugen und sind im Allgemeinen ein langsamer Prozess. Anstatt regelmäßig GameObjects zu instanziieren und zu zerstören (z. B. Kugeln aus einer Waffe zu schießen), verwenden Sie Pools von vorab zugewiesenen Objekten, die wiederverwendet und recycelt werden können.

Erstellen Sie die wiederverwendbaren Instanzen an einem Punkt im Spiel (z. B. während eines Menüs), wenn ein CPU-Spike weniger auffällig ist. Verfolgen Sie diesen "Pool" von Objekten mit einer Sammlung. Während des Spiels aktivieren Sie einfach die nächste verfügbare Instanz, wenn nötig, deaktivieren Sie Objekte anstelle von Zerstörung und geben Sie sie an den Pool zurück.

Dies reduziert die Anzahl der verwalteten Zuweisungen in Ihrem Projekt und kann Probleme mit der Müllsammlung verhindern.

Erfahren Sie, wie Sie ein einfaches Object Pooling-System in Unity hier erstellen.

Verwenden Sie ScriptableObjects

Speichern Sie unveränderliche Werte oder Einstellungen in einem ScriptableObject anstelle eines MonoBehaviour. Das ScriptableObject ist ein Asset, das im Projekt lebt und das Sie nur einmal einrichten müssen. Es kann nicht direkt an ein GameObject angehängt werden.

Erstellen Sie Felder im ScriptableObject, um Ihre Werte oder Einstellungen zu speichern, und verweisen Sie dann auf das ScriptableObject in Ihren MonoBehaviours.

Die Verwendung dieser Felder aus dem ScriptableObject kann unnötige Datenverdopplung verhindern, jedes Mal, wenn Sie ein Objekt mit diesem MonoBehaviour instanziieren.

Sehen Sie sich dieses Einführung in ScriptableObjects Tutorial an, um zu sehen, wie ScriptableObjects Ihrem Projekt helfen können. Sie finden auch relevante Dokumentation hier.

Im nächsten Blogbeitrag werden wir einen genaueren Blick auf Grafik- und GPU-Optimierung werfen. Wenn Sie jedoch jetzt auf die gesamte Liste von Tipps und Tricks des Teams zugreifen möchten, ist unser vollständiges E-Book hier verfügbar.

Laden Sie unser E-Book herunter

Wenn Sie mehr über integrierte Supportdienste erfahren möchten und Ihrem Team direkten Zugang zu Ingenieuren, Expertenrat und Best-Practice-Leitfäden für Ihre Projekte geben möchten, dann schauen Sie sich die Erfolgpläne von Unity hier an.

Wir möchten Ihnen helfen, Ihre Unity-Anwendungen so leistungsfähig wie möglich zu machen. Wenn es also Optimierungsthemen gibt, über die Sie mehr erfahren möchten, lassen Sie es uns bitte in den Kommentaren wissen.