Tipps zur Optimierung und Fehlerbehebung von Unity Shader-Varianten

Beim Schreiben von Shadern in Unity haben wir praktischerweise die Möglichkeit, mehrere Features, Durchläufe und Verzweigungslogiken in einer einzigen Quelldatei zu integrieren. Beim Build werden Shader-Quelldateien zu Shader-Programmen kompiliert, die eine oder mehrere Varianten enthalten. Eine Variante ist eine Version dieses Shaders, die einem einzelnen Satz von Bedingungen folgt, was (in den meisten Fällen) zu einem linearen Ausführungspfad ohne statische Verzweigungskonditionen führt.

Der Grund, warum wir Varianten verwenden, anstatt die Verzweigungspfade alle in einem Shader zu behalten, ist, dass GPUs hervorragend darin sind, Code zu parallelisieren, der vorhersehbar ist und immer den gleichen Pfad geht, was zu einem höheren Durchsatz führt. Wenn Bedingungen im kompilierten Shader-Programm vorhanden sind, muss die GPU Ressourcen für prädiktive Aufgaben aufwenden und auf den Abschluss der anderen Pfade warten usw., um Ineffizienzen einzuführen.

Dies führt zwar zu einer deutlich besseren GPU-Leistung als dynamisches Branching, hat aber auch einige Nachteile. Die Build-Zeiten werden mit zunehmender Anzahl von Varianten länger, manchmal sogar um mehrere Stunden pro Build. Das Booten des Spiels wird auch länger dauern, da es mehr Zeit mit dem Laden und Vorwärmen von Shadern verbringen muss. Schließlich können Sie feststellen, dass Shader eine erhebliche Laufzeitspeichernutzung aufweisen, wenn Varianten nicht richtig verwaltet werden, manchmal über 1 GB.

Die Anzahl der generierten Varianten hängt von einer Vielzahl von Faktoren ab, darunter Schlüsselwörter und definierte Eigenschaften, Qualitätseinstellungen, Grafikstufen, aktivierte Grafik-APIs, Nachbearbeitungseffekte, die aktive Rendering-Pipeline, Beleuchtungs- und Nebelmodi und ob XR aktiviert ist. Shader, die zu einer Vielzahl von Varianten führen, werden oft Uber-Shader genannt. Zur Laufzeit lädt Unity die Variante, die den erforderlichen Einstellungen und Schlüsselwörtern entspricht, wie wir später erläutern werden.

Dies ist besonders wirkungsvoll, wenn man bedenkt, dass wir oft Shader mit über 100 Keywords sehen, was zu einer unüberschaubaren Anzahl von resultierenden Varianten führt, die oft als Shadervariantenexplosion bezeichnet werden. Es ist nicht ungewöhnlich, Shader mit einem anfänglichen Variantenraum in Millionenhöhe zu sehen, bevor eine Filterung angewendet wird.

Um dies zu vermeiden, wird Unity versuchen, die Anzahl der Varianten, die anhand einiger Filterdurchläufe generiert werden, zu reduzieren. Wenn XR beispielsweise nicht aktiviert ist, werden Varianten, die dafür benötigt werden, normalerweise entfernt. Unity berücksichtigt dann, welche Funktionen Sie in Ihren Szenen tatsächlich verwenden, wie z. B. Beleuchtungsmodi, Nebel usw. Diese sind besonders schwierig zu erkennen, da Entwickler und Grafiker scheinbar sichere Änderungen einführen können, die tatsächlich zu einer signifikanten Zunahme von Shader-Varianten führen, ohne dass eine offensichtliche Möglichkeit besteht, sie zu erkennen, es sei denn, Sie haben einige Sicherungsmaßnahmen als Teil Ihrer Bereitstellungspipeline ergriffen.

Das ist zwar hilfreich, aber dieser Prozess ist nicht perfekt, und wir können viel tun, um so viele Varianten wie möglich zu entfernen, ohne die visuelle Qualität Ihres Spiels zu beeinträchtigen.

Hier möchte ich einige praktische Tipps für den Umgang mit Varianten geben, verstehen, woher sie kommen, und einige effektive Möglichkeiten, sie zu reduzieren. Ihre Projekt-Build-Zeit und der Speicher-Fußabdruck werden dadurch erheblich profitieren.

Weitere Informationen zum Stripping von Shadervarianten finden Sie unter Reducing Shader variants im Unity Manual.

Shader-Varianten werden unter anderem basierend auf allen möglichen Kombinationen von shader_feature- und multi_compile-Keywords in Ihrem Shader generiert. Schlüsselwörter, die als multi_compile markiert sind, sind immer in Ihrem Build enthalten, während die Schlüsselwörter, die als shader_feature markiert sind, ebenfalls enthalten sind, wenn sie von einem Material in Ihrem Projekt referenziert werden. Aus diesem Grund sollten Sie nach Möglichkeit Shader_feature verwenden.

Um zu sehen, welche Keywords in einem Shader definiert sind, können Sie ihn auswählen und den Inspector überprüfen.

Wie Sie sehen können, sind Keywords in Overridable und Not Overridable unterteilt. Lokale Schlüsselwörter (die in der eigentlichen Shader-Datei definierten) mit einem globalen Geltungsbereich können durch ein globales Shader-Schlüsselwort mit einem übereinstimmenden Namen überschrieben werden. Wenn sie stattdessen in einem lokalen Geltungsbereich definiert sind (unter Verwendung von multi_compile_local oder Shader_feature_local), können sie nicht überschrieben werden und werden im Abschnitt Nicht überschreibbar darunter angezeigt. Globale Shader-Keywords werden von der Unity Engine bereitgestellt und sind überschreibbar. Da sie jederzeit im Build-Prozess hinzugefügt werden können, werden möglicherweise nicht alle globalen Keywords in dieser Liste angezeigt.

Schlüsselwörter können in Gruppen definiert werden, die sich gegenseitig ausschließen und als Sets bezeichnet werden, indem sie in derselben Richtlinie definiert werden. Dadurch vermeiden Sie die Generierung von Varianten für Kombinationen von Schlüsselwörtern, die niemals gleichzeitig aktiviert werden (z. B. zwei verschiedene Arten von Beleuchtung oder Nebel).

#pragma shader_feature LIGHT_LOW_Q LIGHT_HIGH_Q

Um die Anzahl der Keywords pro Plattform zu reduzieren, können Sie Preprocessor-Makros verwenden, um sie nur für die relevante Plattform zu definieren, zum Beispiel:

#ifdef SHADER_API_METAL
   #pragma shader_feature IOS_FOG_FEATURE
#else
   #pragma shader_feature BASE_FOG_FEATURE
#endif

Beachten Sie, dass diese Ausdrücke mit Makros nicht von anderen Schlüsselwörtern oder Funktionen abhängen können, die sich nicht nur auf das Build-Ziel beziehen.

Keywords können auch auf einen bestimmten Durchlauf beschränkt werden, wodurch die Anzahl der möglichen Kombinationen reduziert wird. Dazu können Sie der Richtlinie eines der folgenden Suffixe hinzufügen:

• _vertex
• _fragment
• _hull
• _domain
• _geometry
• _raytracing

Zum Beispiel:

#pragma shader_feature_fragment FRAG_FEATURE_1 FRAG_FEATURE_2

Dies kann sich je nach verwendetem Renderer unterschiedlich verhalten. Auf OpenGL, OpenGL ES und Vulkan werden beispielsweise Suffixe ignoriert.

Sie können die Direktive #pragma skip_variants verwenden, um Schlüsselwörter zu definieren, die bei der Generierung von Varianten für diesen bestimmten Shader ausgeschlossen werden sollten. Beim Erstellen Ihres Players werden alle Shader-Varianten für diesen Shader, der eines dieser Schlüsselwörter enthält, übersprungen.

Sie können auch optional Schlüsselwörter mit der Direktive #pragma dynamic_branch definieren, wodurch Unity gezwungen wird, auf dynamisches Branching zu setzen und keine Varianten für diese Schlüsselwörter zu generieren. Dies reduziert zwar die Anzahl der resultierenden Varianten, kann jedoch je nach Shader und Spielinhalt zu einer schwächeren GPU-Leistung führen, daher empfiehlt es sich, bei der Verwendung ein entsprechendes Profil zu erstellen.

Weitere Informationen zu Shader-Keywords finden Sie unter Ändern der Shaderfunktion mithilfe von Keywords im Unity Manual.

Normalerweise werden Shader-Varianten erst kompiliert, wenn Sie das Spiel tatsächlich entwickeln. Mit dieser Option können Sie die resultierenden Shader-Varianten für eine bestimmte Build-Plattform oder GrafikAPI inspizieren. So können Sie im Voraus auf Fehler prüfen. Darüber hinaus können Sie den generierten Code für weitere Optimierungen in GPU-Shader-Leistungsanalysetools wie PVRShaderEditor einfügen.

Unten sehen Sie einen Eintrag, der besagt, wie viele Varianten enthalten sind, basierend auf den Materialien, die in der aktuell geöffneten Szene vorhanden sind, ohne dass skriptfähiges Stripping angewendet wird. Wenn Sie auf die Schaltfläche „Anzeigen“ klicken, wird eine temporäre Datei mit einigen zusätzlichen Debug-Informationen darüber angezeigt, welche Keywords auf verschiedenen Plattformen verwendet oder entfernt wurden, einschließlich der Anzahl der Vertex-Stage-Varianten.

Das Kontrollkästchen Nur Vorverarbeitung oben ermöglicht es Ihnen, zwischen kompiliertem Shader-Code und vorverarbeiteter Shader-Quelle für einfacheres und schnelleres Debugging zu wechseln.

Wenn Sie die integrierte Rendering-Pipeline verwenden und mit einem Oberflächen-Shader arbeiten, können Sie den generierten Code überprüfen, den Unity verwendet, um Ihre vereinfachte Shader-Quelle beim Erstellen zu ersetzen. Sie können dann optional Ihre Shader-Quelle durch den generierten Code ersetzen, wenn Sie die Ausgabe ändern möchten.

Weitere Informationen finden Sie unter Überprüfen der Anzahl von Shader-Varianten im Unity Handbuch.

Bei der Entwicklung des Spiels wird Unity den Variantenbereich für jeden Shader anhand aller möglichen Veränderungen seiner Funktionen, Engine-Einstellungen und anderer Faktoren bestimmen. Diese Kombinationen werden dann für mehrere Stripping-Durchläufe an die Vorprozessoren weitergegeben. Dies kann mit IPreprocessShaders-Callbacks erweitert werden, um eine benutzerdefinierte Logik zu erstellen, um weitere Varianten aus dem Build zu entfernen, wie im Folgenden behandelt.

Shader, die als Teil der Always-included Shaderliste (unter Projekteinstellungen > Grafik) enthalten sind, werden alle ihre Varianten in den Build einbezogen. Daher ist es am besten, dies nur zu verwenden, wenn es unbedingt erforderlich ist, da es leicht zu einer Vielzahl von Varianten führen kann.

Schließlich durchläuft die Build-Pipeline einen Prozess namens Deduplizierung, bei dem identische Varianten innerhalb desselben Durchgangs identifiziert und sichergestellt werden, dass sie auf denselben Bytecode zeigen. Dies führt zu einer verringerten Größe auf der Festplatte, aber identische Varianten haben nach wie vor negative Auswirkungen auf die Build-Zeit, die Ladezeit und die Laufzeitspeichernutzung, so dass es kein Ersatz für richtiges Varianten-Stripping ist.

Nach einem erfolgreichen Build können wir in die Editor.log-Datei schauen, um nützliche Informationen darüber zu sammeln, welche Shader-Varianten im Build enthalten waren. Suchen Sie dazu in der Protokolldatei nach „Compiling Shader“ und dem Namen Ihres Shaders. So sieht es beispielsweise aus:

Compiling shader "GameShaders/MyShader" pass "Pass 1" (vp)
	Full variant space:     	608
	After settings filtering:   608
	After built-in stripping:   528
	After scriptable stripping: 528
	Processed in 0.00 seconds
	starting compilation...
	finished in 0.02 seconds. Local cache hits 528 (0.16s CPU time), remote cache hits 0 (0.00s CPU time), compiled 0 variants (0.00s CPU time), skipped 0 variants

In bestimmten Fällen wird die Anzahl der Varianten nach dem Filterschritt für die Einstellungen erhöht, z. B. wenn XR für Ihr Projekt aktiviert ist.

Wenn Ihr Spiel mehrere Grafik-APIs unterstützt, finden Sie auch Informationen zu jedem unterstützten Renderer:

Serialized binary data for shader GameShaders/MyShader in 0.00s
	gles3 (total internal programs: 290, unique: 193)
	vulkan (total internal programs: 290, unique: 193)

Abschließend sehen Sie diese Kompressionsprotokolle, die Ihnen einen Hinweis auf die endgültige Größe des Shaders für eine bestimmte Graphics API auf der Festplatte geben:

Compressed shader 'GameShaders/MyShader' on vulkan from 1.35MB to 0.19MB

Wenn Sie die Universal Render Pipeline (URP) verwenden, können Sie auswählen, ob Protokolle nur aus SRP Shadern, aus allen Shadern generiert oder deaktiviert werden sollen. Wählen Sie dazu unter Projekteinstellungen > Grafik > URP Global Settings die Protokollebene aus.

Wenn Sie unten die Option Shader-Varianten exportieren auswählen, wird nach Ihrem Build außerdem eine JSON-Datei generiert, die einen Bericht über die Shader-Varianten-Kompilierungen enthält. Dies ist ab Unity 2022.2 verfügbar.

Um zu verstehen, welche Shader tatsächlich zur Laufzeit für die GPU kompiliert werden, können Sie unter Projekteinstellungen > Grafik die Option Log Shader Compilation aktivieren.

Dadurch wird Ihr Spiel in den Spielerprotokollen gedruckt, sobald ein Shader kompiliert wird, während Sie spielen. Es funktioniert nur für Entwicklungs-Builds und den Debug-Modus, wie im Tooltip beschrieben.

Das Format sieht so aus:

Compiled Shader: Folder/ShaderName, pass: PASS_NAME, stage: STAGE_NAME, keywords ACTIVE_KEYWORD_1 ACTIVE_KEYWORD_2

Beachten Sie, dass einige Plattformen wie Android kompilierte Shader zwischenspeichern werden. Aus diesem Grund müssen Sie das Spiel deinstallieren und erneut installieren, bevor Sie einen Testdurchlauf durchführen, um alle kompilierten Shader zu finden.

Schließlich können Sie das Memory-Profiler-Paket verwenden, um einen Schnappschuss Ihres Spiels während der Ausführung zu machen, und haben dann einen Überblick darüber, welche Shader aktuell im Speicher geladen werden und welche Größe sie haben. Die Sortierung nach Größe gibt normalerweise einen guten Überblick darüber, welche Shader die meisten Varianten enthalten und welche Optimierungen wert sind.

Als Teil der Stripping-Durchläufe entfernt Unity Shader-Varianten, die Grafikfunktionen betreffen, die Ihr Spiel nicht verwendet. Der Prozess ändert sich leicht, wenn Sie die integrierte Rendering-Pipeline oder URP verwenden.

Um diese zu definieren, gehen Sie zu Projekteinstellungen > Grafik. Von hier aus können Sie bei Verwendung der integrierten Rendering-Pipeline auswählen, welche Lightmap- und Nebelmodi Ihr Spiel unterstützt.

Durch die Einstellung auf Automatisch kann Unity basierend auf den Szenen, die in Ihrem Build enthalten sind, bestimmen, welche Varianten entfernt werden sollen.

Wenn Sie sich nicht sicher sind, welche Funktionen Sie verwenden, können Sie auch die Schaltfläche Import from Current Scene verwenden, um Unity herausfinden zu lassen, welche Funktionen Sie benötigen. Das ist natürlich nur hilfreich, wenn alle Szenen dieselben Einstellungen verwenden. Wählen Sie also unbedingt eine repräsentative Szene aus, wenn Sie diese Option verwenden.

Wenn Sie URP verwenden, werden einige dieser Optionen ausgeblendet. Stattdessen können Sie direkt in den Pipeline-Einstellungen festlegen, welche Funktionen für Ihr Spiel erforderlich sind.

Wenn Sie beispielsweise Terrain Holes deaktivieren, werden alle Terrain Holes Shader-Varianten entfernt, was ebenfalls die Build-Zeit reduziert.

URP bietet eine detailliertere Kontrolle darüber, welche Funktionen Sie in Ihr Spiel integrieren möchten, was möglicherweise zu optimierteren Builds mit weniger ungenutzten Varianten führt.

Hinweis: Dies ist nur bei Verwendung der integrierten Rendering-Pipeline relevant. Diese Einstellungen werden bei Verwendung einer skriptfähigen Rendering-Pipeline wie URP ignoriert.

Grafikstufen werden verwendet, um verschiedene Grafikeinstellungen basierend auf der Hardware anzuwenden, auf der Ihr Spiel ausgeführt wird (nicht zu verwechseln mit den Qualitätseinstellungen). Wenn das Spiel startet, bestimmt Unity Ihre Gerätegrafikstufe basierend auf Hardwarefunktionen, GrafikAPI und anderen Faktoren.

Sie können unter Projekteinstellungen > Grafik > Stufeneinstellungen festgelegt werden.

Auf dieser Grundlage fügt Unity allen Shadern diese drei Schlüsselwörter hinzu:

UNITY_HARDWARE_TIER1

UNITY_HARDWARE_TIER2

UNITY_HARDWARE_TIER3

Anschließend werden Shader-Varianten für jede der definierten Grafikstufen generiert. Wenn Sie keine Grafikstufen verwenden und die zugehörigen Varianten für diese vermeiden möchten, müssen Sie sicherstellen, dass alle Grafikstufen auf genau die gleichen Einstellungen eingestellt sind, damit Unity diese Varianten überspringt.

Wie bereits erwähnt, wird Unity versuchen, identische Varianten zu deduplizieren. Wenn also beispielsweise zwei der drei Stufen dieselben Einstellungen haben, führt dies zu einer Verkleinerung der Festplatte, obwohl alle Varianten weiterhin generiert werden. Sie können Unity optional dazu zwingen, Stufenvarianten für einen bestimmten Shader und eine Grafik-Renderer API zu generieren, indem Sie die Hardware_stufe_variants wie folgt verwenden:

// Direct3D 11/12
#pragma hardware_tier_variants d3d11 

Weitere Informationen finden Sie unter Grafikstufen in der integrierten Rendering-Pipeline im Unity Handbuch.

Unity kompiliert einen Satz Shader-Varianten für jede API, die in Ihrem Build enthalten ist. In manchen Fällen ist es also vorteilhaft, die APIs manuell auszuwählen und die nicht benötigten auszuschließen.

Gehen Sie dazu zu Projekteinstellungen > Player. Standardmäßig ist die Auto Graphics API ausgewählt und Unity enthält eine Reihe integrierter Grafik-APIs und wählt je nach Gerätefähigkeit eine zur Laufzeit aus. Auf Android versucht Unity beispielsweise zuerst Vulkan zu verwenden. Sollte das Gerät dies nicht unterstützen, greift die Engine auf GLES3.2, GLES3.1 oder GLES3.0 zurück (die Varianten sind jedoch in diesen GLES-Versionen identisch).

Deaktivieren Sie stattdessen die Auto Graphics API für die entsprechende Plattform und wählen Sie manuell die APIs aus, die Sie einbinden möchten. Unity wird dann dem ersten in der Liste Vorrang einräumen.

Der Nachteil ist, dass Sie möglicherweise die Anzahl der Geräte begrenzen, die Ihr Spiel unterstützen. Achten Sie also darauf, dass Sie wissen, was Sie tun, wenn Sie dies ändern, und testen Sie auf einer Vielzahl von Geräten.

Normalerweise versucht Unity während der Laufzeit, die Variante zu laden, die dem Satz von Schlüsselwörtern am nächsten liegt, wenn eine exakte Übereinstimmung nicht verfügbar ist oder aus dem Player-Build entfernt wurde. Das ist zwar praktisch, verbirgt aber auch mögliche Probleme bei der Einrichtung von Shader-Keywords.

In Unity 2022.3 können Sie unter Projekteinstellungen > Player Strict Shader Variant Matching auswählen, um sicherzustellen, dass Unity nur die exakte Übereinstimmung für die von Ihnen benötigte Kombination aus lokalen und globalen Keywords lädt.

Wenn nicht gefunden, wird der Fehler-Shader verwendet und ein Fehler in der Konsole mit dem Shader, dem Subshader-Index, dem tatsächlichen Durchlauf und den gewünschten Schlüsselwörtern ausgegeben. Das ist praktisch, wenn Sie fehlende Varianten aufspüren müssen, die Sie tatsächlich benötigen. Wie beim Stripping üblich, funktioniert dies nur im Player und hat keine Auswirkungen auf den Editor.

Während Sie das Spiel im Editor spielen, verfolgt Unity, welche Shader und Varianten aktuell in Ihrer Szene verwendet werden, und ermöglicht es Ihnen, dies in eine Sammlung zu exportieren. Navigieren Sie dazu zu Projekteinstellungen > Grafik. Unten sehen Sie einen Abschnitt zum Laden von Shadern, der anzeigt, wie viele Shader aktuell als aktiv eingestuft werden.

Achten Sie darauf, dass Sie vorher auf „Löschen“ klicken, um ein genaueres Sample zu erhalten, dann den Wiedergabemodus aufrufen und sich mit Ihrer Szene beschäftigen, um sicherzustellen, dass Sie auf alle Spielelemente stoßen, die bestimmte Shader erfordern. Dies erhöht die nachverfolgten Zähler. Drücken Sie dann die Schaltfläche „Speichern in Asset...“, um alle in einem Sammlungs-Asset zu speichern.

Weitere Informationen finden Sie unter Erstellen einer Shadervariantensammlung im Unity Handbuch.

Shader Variants Collections sind Assets, die eine Liste von Shadern und verwandten Varianten enthalten. Sie werden häufig verwendet, um vorzudefinieren, welche Varianten in Ihren Build aufgenommen werden sollen, und um Shader vorzuwärmen.

Ein Ansatz, der in einigen Projekten verwendet wird, ist, dies für jede Spielebene auszuführen, eine Sammlung für jedes von ihnen zu speichern und dann alle Varianten zu entfernen, die in keiner dieser Listen vorhanden sind, indem ein IPreprocessShaders-Skript verwendet wird (das im nächsten Abschnitt behandelt wird). Das ist zwar praktisch, aber meiner Erfahrung nach auch ziemlich fehleranfällig. Es ist schwer sicherzustellen, dass Sie alle erforderlichen Varianten in einem einzigen Spieldurchlauf finden, und einige der Funktionen werden möglicherweise nur auf dem Gerät und in bestimmten Fällen geladen, was zu einer Liste führt, die nicht unbedingt korrekt ist. Sobald sich Ihr Spiel ändert und neue Elemente zu den Leveln oder Materialien hinzugefügt werden, müssen die Sammlungen aktualisiert werden. Aus diesem Grund würde ich dies hauptsächlich für Debugging- und Untersuchungszwecke verwenden, anstatt es direkt in Ihre Build-Pipeline zu integrieren.

Weitere Informationen finden Sie unter Erstellen einer Shadervariantensammlung im Unity Handbuch.

Sobald ein Shader in Ihren Spiele-Build kompiliert werden soll, sendet Unity einen Rückruf. Dies geschieht sowohl bei Player- als auch bei Asset-Bundles-Builds. Diese können wir uns bequem mit IPreprocessShaders.OnProcessShader und IPreprocessComputeShaders.OnProcessComputeShader (für Compute-Shader) anhören und benutzerdefinierte Logik hinzufügen, um unnötige Varianten zu entfernen. Auf diese Weise können wir die Build-Zeit, die Build-Größe und die Gesamtzahl der Varianten, die in Ihren Build gelangen, erheblich reduzieren.

Erstellen Sie dazu ein Skript, das die IPreprocessShaders-Schnittstelle implementiert, und schreiben Sie dann Ihre Stripping-Logik in OnProcessShader. Hier ist zum Beispiel ein Skript, das alle Varianten, die das DEBUG-Shader-Schlüsselwort enthalten, in Versions-Builds entfernt:

public class StripDebugVariantsPreprocessor : IPreprocessShaders
{
   public int callbackOrder => 0;

   ShaderKeyword keywordToStrip;

   public StripDebugVariantsPreprocessor()
   {
      keywordToStrip = new ShaderKeyword("DEBUG");
   }


   public void OnProcessShader(Shader shader, ShaderSnippetData snippet, IList<ShaderCompilerData> data)
   {
      if (EditorUserBuildSettings.development)
      {
         return;
      }

      for (int i = data.Count - 1; i >= 0; i--)
      {
         if (data[i].shaderKeywordSet.IsEnabled(keywordToStrip))
         {
            data.RemoveAt(i);
         }
      }
   }
}

Mit der Callback-Reihenfolge können Sie festlegen, welches Vorverarbeitungsskript zuerst ausgeführt werden soll, sodass Sie mehrstufige Stripping-Durchläufe erstellen können. Skripts mit niedrigerer Priorität werden zuerst ausgeführt.

Besuchen Sie die Diskussion im Graphics-Shader-Forum, um mehr zu erfahren.

Weitere Informationen finden Sie in den folgenden Abschnitten des Unity Handbuchs:

• Schreiben benutzerdefinierter Shader
• Shader-Varianten reduzieren
• Shader-Varianten in URP reduzieren