Erweiterte Material-Instanzen

Die Änderung der Materialeigenschaften eines Assets während des Gameplays ist nützlich, um dem Spieler visuelles Feedback, Gameplay-Informationen oder Immersion zu fördern. Zum Beispiel:

• Spieler-Skins können ihr Aussehen ändern, um verschiedene Statuseffekte anzuzeigen.

• Aufnehmbare Objekte können leuchten, um die Aufmerksamkeit von Spielern in der Nähe auf sich zu ziehen.

• Wenn der Boden bei Regen von trocken zu nass wechselt, kann die Immersion erhöht werden.

In diesem Tutorial wirst du Blueprints verwenden, um Materialeigenschaften in einer interaktiven Tech-Demo zur Laufzeit zu ändern. In dieser Demo erstellst du einen Wasserball, der den Boden durchnässt, während du ihn durch das Level schiebst.

Du experimentierst auch mit emissiv Materialien, einfachen Masken und statisch Schaltern, um Set-Gestaltung zu erstellen, die vom nass Boden reflektiert wird.

Erstelle ein spielfertiges Boden-Asset

Das erste Asset, das du für die Tech-Demo erstellen wirst, ist der Boden. In Raum 3 von Lvl_Adventure erstellst du ein spielfertiges Boden-Asset mit Oberfläche, um das Platzhalter-Boden-Mesh zu ersetzen.

Bevor du beginnst, lass uns kurz anhalten und deinen Ansatz betrachten. Im vorherigen Tutorial hast du gelernt, dass Kachelung-Texture eine kostengünstige Methode sind, um große Meshes wie Böden zu gestalten. Du hast ebenfalls gelernt, dass die UVs eines Meshs das Aussehen von Texturen beeinflussen.

Der Platzhalterboden in Raum 3 besteht aus drei Meshes, und jedes hat unterschiedliche UVs.

In der folgenden Demonstration siehst du, wie die Kacheltexturen aufgrund von UV-Inkonsistenzen zwischen den Meshes unterschiedliche Größen haben. Das stellt eine Herausforderung für die kohärente Bearbeitung der Bodenoberfläche dar.

Du löst diese Herausforderung, indem du triplanare Projektion verwendest. Die triplanare Projektion ist eine Technik zur Oberflächengestaltung, die UVs ignoriert und Texturen an der Welt ausrichtet. Das ist nützlich, wenn du UVs nicht korrigieren kannst oder mit Geometrie arbeitest, die sich nur schwer als UV-Map erstellen lässt.

Mit diesem Ansatz verwendest du Ausdrücke, um M_Surfaces an der Welt auszurichten. Da Instanzen Eigenschaften von Parent-Materialien übernehmen, wirdMI_Surfaces_Floor ebenfalls an der Welt ausgerichtet. Dann wendest du MI_Surfaces_Floor auf einen Blueprint an, der die Platzhalter-Meshes ersetzt.

Erstellen eines weltausgerichteten Materials

Um dein Parent-Material weltorientiert auszurichten, befolge diese Schritte:

1. Im Inhaltsbrowser navigiert zu Alle > Content > AdventureGame > Artist > Materialien und öffnet M_Surfaces.

2. Wähle alle Knoten im UV-Kachel-Kommentarbereich, der Streu-Map und der Normal-Map aus. Lösche sie.

   

3. Klicke mit der rechten Maustaste in das Diagramm und suche nach Texturobjekt. Erstelle zwei dieser Knoten.

   

4. Wähle das erste Texturobjekt. Lege im Details-Panel die Textur auf DefaultDiffuse fest.

5. Klicke mit der rechten Maustaste auf das Texturobjekt und wähle In Parameter konvertieren aus. Nenne den neuen Parameter Streuen.

6. Wähle das zweite Texturobjektaus. Lege im Details-Panel die Textur auf DefaultNormal fest.

7. Klicke mit der rechten Maustaste auf das Texturobjekt und wähle In Parameter konvertieren aus. Benenne den neuen Parameter Normal.

8. Ziehe vom Output des Streu-Knotens und füge einen World-Aligned-Texture-Knoten hinzu.

   

9. Verbinde den Output der XYZ-Textur mit dem A-Input des Multiplizieren-Knotens (im Kommentarbereich Farbton streuen).

10. Ziehe vom Output des Normal-Knotens und füge einen World Aligned Normal-Knoten hinzu.

11. Verbinde den Output XYZ Textur mit dem Input Normal des Materialstammknotens M_Surfaces.

12. Klicke mit der rechten Maustaste in das Diagramm und suche nach Skalierbarer Parameter. Benenne es Texture Scaling.

13. Setze den Standardwert auf 214.

14. Verbinde den Output von Texture Scaling mit den TextureSizeV3-Inputs auf beiden WorldAligned-Knoten.

15. Speichere dein Material.

Dein Materialdiagramm sollte nun so aussehen:

Als nächstes erstellst du einen Blueprint, der den Platzhalterboden ersetzt.

Erstelle einen Boden-Blueprint

Um den Blueprint zu erstellen, führe die folgenden Schritte aus:

1. Im Inhaltsbrowser, im Pfad Inhalt > AdventureGame > Artist klickst du mit der rechten Maustaste und wählst Neuer Ordner aus.

2. Benenne den Ordner Blueprints.

3. Klicke mit der rechten Maustaste in den Blueprints-Ordner, wähle Blueprint-Klasse und dann Actor als Parent-Klasse.

4. Benenne den Blueprint BP_Floor und doppelklicke darauf, um ihn im Blueprint-Editor zu öffnen.

5. Wähle im Inhaltsbrowser den Alle-Ordner aus, und suche nach SM_Cube.

   

6. Ziehe SM_Cube als Child von BP_Floor ins Komponenten-Panel des Blueprint-Editor.

   

7. Bennen den SM_Cube Boden.

8. Stelle im Details-Panel sicher, dass der Maßstab auf 1,0, 1,0, 1,0 liegt.

9. Stelle unter Materialien > Element 0 das Material auf MI_Surfaces_Floor.

   

10. Im Tab Komponenten wähle DefaultSceneRoot aus, klicke auf Hinzufügen und füge eine Box-Kollision hinzu.

11. Benenne die Box-Kollision Trigger.

    

12. Im Details-Panel, setze den Trigger- Maßstab auf 1.5, 1.5, 1.5.

13. Setze den Standort des Triggers auf 50, 50, 55.

14. Speichere und kompiliere deinen Blueprint.

Ziehe eine Instanz von BP_Floor in dein Level und bewege sie herum. Beachte, dass die Textur an der gleichen Stelle bleibt, wenn du das Mesh bewegst. Wenn du es skalierst, ändert sich das Mesh, aber die Textur nicht.

Als Nächstes ersetzt du das Platzhalter-Bodenmaterial in Raum 3 durch Instanzen von BP_Floor.

Ersetze die Placeholder-Meshes

Du kannst jetzt die Platzhalter-Meshs in Raum 3 durch BP_Floor in einer beliebigen Anordnung ersetzen. Wir haben einen Boden erstellt, der den Platzhaltern entspricht:

Wenn du die oben gezeigten Elemente verwenden möchtest, kannst du das Level folgendermaßen kopieren:

1. Stelle sicher, dass du M_Surfaces aktualisiert und BP_Floor gemäß dem obigen Tutorial erstellt hast.

2. Wähle im Outliner alles im Ordner Raum 3 aus und drücke die Entf-Taste.

3. Kopiert den folgenden Ausschnitt.

   Console Output

   Begin Map
      Begin Level
         Begin Actor Class=/Script/Engine.StaticMeshActor Name=StaticMeshActor_2 Archetype="/Script/Engine.StaticMeshActor'/Script/Engine.Default__StaticMeshActor'" ExportPath="/Script/Engine.StaticMeshActor'/Game/SFEFWFWEEEWEF.SFEFWFWEEEWEF:PersistentLevel.StaticMeshActor_2'"
            Begin Object Class=/Script/Engine.StaticMeshComponent Name="StaticMeshComponent0" Archetype="/Script/Engine.StaticMeshComponent'/Script/Engine.Default__StaticMeshActor:StaticMeshComponent0'" ExportPath="/Script/Engine.StaticMeshComponent'/Game/SFEFWFWEEEWEF.SFEFWFWEEEWEF:PersistentLevel.StaticMeshActor_2.StaticMeshComponent0'"
            End Object
            Begin Object Name="StaticMeshComponent0" ExportPath="/Script/Engine.StaticMeshComponent'/Game/SFEFWFWEEEWEF.SFEFWFWEEEWEF:PersistentLevel.StaticMeshActor_2.StaticMeshComponent0'"
               StaticMesh="/Script/Engine.StaticMesh'/Game/LevelPrototyping/Meshes/SM_Cylinder.SM_Cylinder'"
               StaticMeshImportVersion=1
               bUseDefaultCollision=False
               StaticMeshDerivedDataKey="STATICMESH_FD1BFC73B5510AD60DFC65F62C1E933E_228332BAE0224DD294E232B87D83948FQuadricMeshReduction_V2$2e1_6D3AF6A2$2d5FD0$2d469B$2dB0D8$2dB6D9979EE5D2_CONSTRAINED0_100100000000000000000000000100000000000080FFFFFFFFFFFFFFFFFFFFFFFF000000000000803F00000000000000803F0000803F00000000000000003D19FC1626C9B2485E57DB4B8EC731318B8215AE8D46FAD400000000010000000100000000000000010000000100000000000000000000000100000001000000400000000000000001000000000000000000F03F000000000000F03F000000000000F03F0000803F00000000050000004E6F6E65000C00000030000000803FFFFFFFFF0000803FFFFFFFFF0000000000000041000000000000A0420303030000000000000000_RT00_0"
   
   Expand code Copy full snippet(2319 lines long)

4. Drücke im Viewport Strg + V.

   

Als Nächstes erstellst du den Wasserball und verwendest dynamische Material-Instanzen , um den Boden von trocken zu nass zu machen.

Materialien durch Spielerinteraktion ändern

Der Wasserball wird ein physikaktiviertes Objekt sein, das eine Änderung der Eigenschaft des Bodens auslöst, wodurch er nass erscheint.

Einen Wasserball erstellen

Befolge diese Schritte, um den Wasserball zu erstellen und an die Oberfläche zu bringen:

1. Klicke mit der rechten Maustaste im Inhaltsbrowser im Ordner Blueprints, um eine neue Blueprint-Klasse zu erstellen.

2. Wähle Actor als Parent-Klasse aus.

3. Benenne den neuen Blueprint BP_WaterBall und öffne ihn im Blueprint-Editor.

4. Im Tab Komponenten klicke auf Hinzufügen und suche nach Kugel.

5. Im Details-Panel stellst du Materialien > Element 0 auf M_Water.

   M_Water ist in der Unreal Engine enthalten; du musst es nicht herunterladen oder erstellen. Solltest du das Asset nicht sehen, klicke in der Asset-Auswahl oder im Inhaltsbrowser auf die Schaltfläche Einstellungen und aktiviere Plugin-Inhalte.

   

6. Immer noch im Details-Panel, unter Physik, aktiviere Simulate Physics.

   

7. Speichere und kompiliere deinen Blueprint.

8. Ziehe eine Instanz von BP_WaterBall in dein Level.

Teste die Wasserkugel in deinem Level, indem du im Viewport mit der rechten Maustaste klickst und Ab hier spielen auswählst. Der Ball sollte am Boden springen, wenn du gegen ihn läufst.

Als nächstes verwendest du die Logik in BP_Floor, um eine dynamische Material-Instanz zu erstellen.

Erstellen Dynamic Material Instanz

Eine dynamische Material-Instanz ist eine Material-Instanz, die durch ein Script (etwa Blueprint) generiert wurde und ihre Eigenschaften zur Laufzeit ändern kann.

In diesem Abschnitt erstellst du eine Blueprint-Logik, die auf das dem Boden-Mesh zugewiesene Material (MI_Surfaces_Floor) verweist, daraus eine dynamische Material-Instanz generiert und die neue Instanz dem Boden zuweist. Dann modifiziert die dynamische Material-Instanz die Eigenschaften, die du im vorherigen Tutorial freigelegt hast – Rauheit und Farbton streuen –, um einen nassen Boden zu imitieren.  

Während der Laufzeit sorgt dieser Austausch dafür, dass es so aussieht, als würde der Boden mit einer dünnen Schicht Wasser bedeckt.

Um eine dynamische Material-Instanz zu erstellen, gehe folgendermaßen vor:

1. Im Inhaltsbrowser doppelklicke auf BP_Floor, um es im Blueprint-Editor zu öffnen.

2. Lösche im EventGraph alle Knoten außer Event BeginPlay.

3. Ziehe vom Tab Komponenten eine Instanz von Boden in das Event-Diagramm.

4. Aus dem Output von Boden ziehen und nach Material holen suchen.

   

5. Ziehe einen Create Dynamic Material Instance-Knoten vom Ergebniswert-Output von Material erhalten und füge ihn hinzu, dessen Ziel die Kismet-Materialbibliothek ist.

   

6. Verbinde den Output von Event BeginPlay mit dem Input-Exec-pin von Dynamische Material-Instanz erstellen.

   

7. Vom Ergebniswert der Dynamic Material Instance ziehe und wähle Beförderung zu Variable aus.

8. Im Details-Panel benenne diese Variable als Dynamische Materialreferenz um.

9. Ziehe eine weitere Instanz von Floor in den EventGraph.

10. Ziehe vom Output von Boden und suche nach Material einstellen.

11. Verbinde den weißen Exec-Outputs-Pin des Set-Knotens mit dem Exec-Inputs-Pin des Material festlegen-Knotens.

12. Verbinde den blauen Output des Einstellen-Knotens mit dem Materialeingang des Materialeinstell-Knotens.

    

13. Wähle alle Knoten aus und drücke dann C, um das Diagramm zu ordnen. Benenne die Box Dynamisches Material erstellen.

14. Speichern und Kompilieren.

Dein Event-Diagramm sollte jetzt so aussehen:

Ereignisse aufrufen

Um den nassen Look des Bodens auszulösen, benötigst du ein Event, das prüft, ob BP_Floor mit BP_WaterBall überlappt, sowie ein Event, das als Ergebnis das korrekte Aussehen aufruft.

Skizzieren wir nun die Logik:

• Wenn ein Actor BP_Floor überlappt:

  • Prüft, ob der andere Actor (gleich) BP_waterBall ist. Wenn dies (true) ist:

    • Rufe den Wet-Lookvon BP_Floor auf.

  • Andernfalls, wenn es nicht true (false) ist, dann:

    • Tu nichts.

Um diese Logik zu erstellen, führe die folgenden Schritte aus:

1. Rechtsklicke im vom BP_Floor besessenen EventGraph und suche nach Hinzufügen von benutzerdefinierten Events. Benenne den Nassen Look aufrufen.

2. Im Komponenten-Tab klicke mit der rechten Maustaste auf Trigger und erstelle Event hinzufügen > OnComponentBeginOverlap hinzufügen.

   

   

   OnComponentBeginOverlap sucht nach Kollisionen.

3.  Ziehe Klasse holen aus dem Output von Andere Actor in OnComponentBeginOverlap und erstelle es.

4. Aus dem Ergebniswert-Output ziehe und erstelle Gleich.

5. Klicke mit der rechten Maustaste auf das Eingabefeld Klasse auswählen und wähle Beförderung zu Variable aus.

6. Benenne die Variable WaterBall und kompiliere deinen Blueprint.

   

7. Im Details-Panel setzt du den Standardwert von WaterBall auf BP_WaterBall.

   

8. Aus dem Output des Equal-Knotens, ziehe und erstelle einen Verzweigung-Knoten.

9. Vom True-Output des Verzweigung-Knotens, ziehe und suche nach Nassen Look aufrufen.

10. Verbinde den Exec-Output von OnComponentBeginOverlap mit dem Exec-Input im Branc-Knoten.

Dein Event-Diagramm sollte jetzt so aussehen:

Materialeigenschaften steuern

Jetzt erstellst du die nass deiner Variante. Da der Boden steinartig und porös ist, sollte er sich bei der Aufnahme von Wasser verdunkeln (Farbton streuen). Da sich oben eine dünne Wasserschicht befindet, sollte die Oberfläche glänzend erscheinen (Rauheit).

Um eine Logik für den Wet-Look zu erstellen, führe die folgenden Schritte durch:

1. Ziehe die Variable Dynamic Mat Ref in den EventGraph und wähle Get aus der Liste.

   

2. Aus dem output-Pin, ziehe und erstelle Skalar-Parameterwert einstellen.

3. Aus demselben Output-Pin, ziehe und erstelle Vektorparameterwert einstellen.

   Erinnerst du dich noch an die Parameter, die du enthüllt hast in M_Surfaces? Die Rauheit ist ein Skalar (einzelner Wert), und der Farbton streuen ist ein Vektor (drei Werte: das RGB).

4. Auf dem Set Scalar Parameter Value-Knoten rechtsklicken auf Parameter Name und Zu Variable befördern auswählen. Benenne die Variable Rauheit.

5. Auf dem Set Vector Parameter Value-Knoten rechtsklicken auf Parameter Name und Beförderung zu Variable auswählen. Gib der Variable den Namen Farbton streuen.

6. Kompiliere den Blueprint und gib Werte für jeden Parameternamen ein:

   1. Wähle die Variable Rauheit aus und gib Rauheit als Standardwert ein.  

   2. Wähle die Farbton-streuen-Variable und gib Farbton streuen als Standardwert ein.

      

      Die Standardwerte müssen mit den entsprechenden Parametern in M_Surfaces übereinstimmen.

7. Verbinde den output Exec-Pin des Skalarparameterwert festlegen-Knotens mit dem input Exec des Vektorparameterwert festlegen-Knotens.

   

Zusätzlich zum Wechsel von Trocken zu Nass kannst du Logik verwenden, um zu steuern, wie schnell diese Veränderung erfolgt. Da das Sättigen einer Substanz Zeit braucht, werden die Materialeigenschaften nach und nach von einer zur anderen übergehen. Du kannst das mit einem Lineare-Interpolation-Knoten (lerp) machen.

Befolge diese Schritte, um eine lineare Interpolation zu erstellen:

1. Ziehe aus dem Value-Input des Scalar Parameter-Knoten und erstelle eine lineare Interpolation. Dies steuert die Rauheit.

   

2. Bei der linearen Interpolation stelle den A-Wert auf 1.0 ein. Das ist der Rauheitswert für den Trockenen Look. Belasse den B-Wert bei 0,0. Das ist der Wert des Nasser Look-Werts.

   Im vorherigen Tutorial hast du gelernt, dass eine Rauheit von 1 matt und von 0 glänzend ist. Du möchtest, dass dein Wasser glänzend aussieht.  

3. Ziehe eine lineare Interpolation (lineare Farbe) aus dem Value-Input des Set-Vector-Parameter-Value-Knotens. Damit steuerst du Farbton streuen.

   

4. Ziehe den A-Wert der neuen linearen Interpolation und wähle Beförderung zu Variable (lineare Farbe) aus. Benenne die Variable Ungesättigt.

   

5. Vom B-Pin des Lineare Interpolation-Knotens ziehe und wähle Auf Variable hochstufen aus. Benenne die Variable Gesättigt.

6. Kompiliere deinen Blueprint. Im Details-Panel den Standardwert von Unsaturated auf CDDAFFFF setzen.

   

7. Stelle im Details-Panel den Standardwert von Saturated auf einen dunkleren Wert ein, beispielsweise 656C7FFF.

Dein Event-Diagramm sollte jetzt so aussehen:

Du hast nun mit der Blueprint-Logik ein brandneues Aussehen für den Boden erstellt. Allerdings fehlt dir eine Engine, die diese Logik antreibt: eine Zeitleiste.

Optimiere deine Logik mit Zeitleisten

Ähnlich wie die Zeitleiste in Animationssoftware steuern Zeitleisten-Knoten Werte zwischen Keyframes über die Zeit. Du wirst diesen Knoten verwenden, um die Interpolation zwischen dem trockenen und nassen Look über einen festgelegten Zeitraum zu steuern.

Um eine Zeitleiste zu erstellen, gehe folgendermaßen vor:

1. Klicke mit der rechten Maustaste in das Event-Diagramm, suche und erstelle Zeitleiste hinzufügen.

   

2. Doppelklicke auf den Timeline-Knoten, um den Timeline_Template-Tab zu öffnen.

3. Klicke auf Track, und wähle Float-Track hinzufügen aus der Liste.

4. Gib der Spur den Namen Alpha. Dieser Spurname wird als Ausgabepin auf dem Zeitleistenknoten erscheinen.

5. Lege die Länge der Zeitleiste auf 3,0 Sekunden fest.

   

6. Klicke mit der rechten Maustaste in die Zeitleiste und wähle Schlüssel hinzufügen.

7. Während der Schlüssel ausgewählt und blau hervorgehoben ist, setze Zeit und Wert auf 0.0.

   

8. Erstelle einen zweiten Schlüssel und lege dessen Zeit und Wert auf 1,0 fest.

9. Klicke mit der rechten Maustaste auf den ersten Schlüssel und wähle Benutzer aus.

   

   Mit der Einstellung User kannst du die Animationseasing steuern. Wir entschieden uns, die Geschwindigkeit des gesättigten Effekts langsam zu erhöhen.

   

10. Speichern und Kompilieren.

Die Zeitleiste gibt nun einen Wert aus, der über einen Zeitraum von drei Sekunden von 0 bis 1 reicht. Jetzt kannst du die verbliebenen Knoten mit der Zeitleiste verbinden:

1. Zurück im EventGraph verbindest du den Call Wet Look-Output mit dem Spielen-Input auf der Zeitleiste.

2. Verbinde den Update-Output auf der Zeitleiste mit dem Exec-Input von Skalarparameterwert einstellen.

3. Verbinde den Alpha-Output der Zeitleite mit den Alpha-Inputs beider linearen Interpolationen.

   

4. Wähle die Knoten aus und drücke C, um einen Kommentar zu hinterlassen. Benenne die Box lineare Interpolation dynamische Materialien.

   

5. Speichern und Kompilieren.

Dein vollständiges Event-Diagramm sollte jetzt so aussehen:

Um deine Arbeit zu testen, klicke mit der rechten Maustaste in deinem Level und wähle Spiele von hier. Wenn du den Wasserball durch den Raum schiebst, sollte der Boden überflutet werden.

Die Reflexion der nassen Oberfläche ist bei Tageslicht etwas schwer zu erkennen. Um das Reflexionsvermögen des Bodens zu zeigen, wirst du das Level verdunkeln und Beleuchtung mit einem emissiven Material hinzufügen.

Emissive Materialien

Emissive Materialien sind eine kostengünstige Möglichkeit, Selbst-Beleuchtung zu erzeugen. Sie können verwendet werden, um ein Leuchten zu erzeugen, das in komplexere Materialien integriert ist, wie etwa LEDs an der Sci-Fi-Rüstung eines Charakters oder den Bremslichtern eines Autos.

Emissive Materialien können auch mit dem System für globale Beleuchtung und Reflexionen von Lumen interagieren, was bedeutet, dass sie mit der Umgebung interagieren.

Die Helligkeit eines emissiven Materials kann mit Float-Werten von 0 (kein Licht) bis 1 (emissives Licht) oder über 1 (emissives Licht, das Bloom erzeugt) gesteuert werden.

Emissive Materialien und Reflexionen sind in dunklen Levels deutlicher sichtbar. Um die gesamte Beleuchtung in deinem Level zu ändern, gehe folgendermaßen vor:

1. Wähle im Outliner Direktionales Licht aus.

2. Im Viewport drücke Strg + L, und bewege deine Maus, um die Position des direkten Lichts und die relative Tageszeit in deinem Level anzupassen.

   

Erstellen eines emissiven Materials

In diesem Tutorial baust du Neonschilder, die vom nassen Stein reflektiert werden, wenn sie im Level platziert werden. Dazu erstellst du ein flexibles Parent-Material, das folgende Parameter an seine Child-Instanzen weitergeben kann:

• Emissionsfarbe

• Emissive Helligkeit

• Texturmaske

Befolge diese Schritte, um ein emissives Material zu erstellen:

1. Im Inhaltsbrowser, im Pfad Alle > Inhalt > AdventureGame > Artist > Materialien, erstelle ein neues Material.

2. Benenne das Material M_EmissiveSign und doppelklicke darauf, um es im Material-Editor zu öffnen.

3. Im Materialdiagramm ziehst du den Emissivfarbeneingang vom Materialstammknoten ab und fügst du einen Multiplizieren-Knoten aus der Auswahlliste hinzu.

4. Ziehe den A-Input des Multiplizieren-Knotens ab und füge einen Constant3Vector hinzu.

   

5. Klicke mit der rechten Maustaste auf den Constant3Vector und wähle In Parameter konvertieren aus.

6. Bennene den Parameter Farbe.

7. Doppelklicke auf das Farbfeld und wähle eine Farbe für deine Emissivfarbe aus.

8. Ziehe den B-Input des Multiplizieren-Knotens ab und füge einen Konstante-Knoten aus der Auswahlliste hinzu.

   

9. Wandle die Konstante in einen Parameter um, benenne sie Helligkeit und lege ihren Wert auf 25 fest.

Dein Materialdiagramm sollte nun so aussehen:

Parameter mit Klammern begrenzen

Obwohl die Emissionshelligkeit keine obere Grenze hat, kannst du mithilfe einer Klammer benutzerdefinierte Grenzen für die minimale und maximale Helligkeit im Parent-Material festlegen. Mit Klammern kann die Anpassung von Werten mit einem Regler erleichtert werden, insbesondere bei kleinen Zahlen und empfindlichen Anpassungen.

Wie andere Parameter werden Klammern an Material-Instanzen propagiert.

Befolge diese Konstante, um die Helligkeit zu Klammer:

1. Wähle im Materialdiagramm den Parameter Helligkeit aus.

2. Stelle im Details-Panel den Regler Max auf 50 ein.

   

Als Nächstes versiehst du deine Beschilderung mit Inhalt mithilfe von Texturmasken.

Eine einfache Maske erstellen

Eine Texturmaske ist eine Graustufen- (Alpha-) oder ein einzelner Kanal einer Textur, die verwendet wird, um bestimmte Bereiche eines Materials sichtbar oder unsichtbar zu machen. Du kannst dir eine Alphamaske wie Schichten vorstellen; der weiße Bereich der Maske zeigt Informationen auf einer niedrigeren Ebene an, und der schwarze Bereich verbirgt sie.

In deinem emissiven Material verwendest du eine Alpha-Maske, um Bereiche mit emissivem Glühen freizulegen oder zu blockieren, um den Inhalt des Neonschilds zu erstellen.

Um eine Maske im Parent-Material M_Emissive zu erstellen, gehe folgendermaßen vor:

1. Wenn keine Knoten ausgewählt sind, navigiert zum Details-Panel. Neben Überblendmodus öffne das Dropdown-Menü und wähle Maskiert.

   

2. Im Event-Diagrammmit der rechten Maustaste klicken und eine Texturprobe erstellen.

3. Im Details-Panel, neben Texture, sucht nach T_UE_Logo_M.

   Diese Textur ist in der Unreal Engine enthalten. Du musst sie nicht herunterladen oder erstellen.

4. Verbinde den RGB-Output des Texture Sample mit dem Opacity Mask-Input des Materialstammknotens.

5. Klicke mit der rechten Maustaste auf den Textur-Sample und wähle In Parameter konvertieren aus. Benenne den Parameter LED-Zeichen.

Dein Materialdiagramm sollte nun so aussehen:

Du hast jetzt ein Material erstellt, das eine Leuchtreklame imitiert. Als Nächstes erhöhst du die Flexibilität deines Parent-Materials und die Anzahl einzigartiger Assets, die du erstellen kannst, indem du die Maske invertierst:

Ursprüngliche Maske.	Invertierte Maske.

Um das zu erreichen, kannst du einzigartige Material-Instanzen für invertierte und nicht-invertierte Masken erstellen. Stattdessen verwendest du einen statischen Schalter, um die Inversion in jeder Material-Instanz von M_EmissiveSign umzuschalten.

Parameter mit statischen Schaltern umschalten.

Im vorherigen Tutorial hast du die Material-Propagation-Hierarchie kennengelernt; Child-Instanzen erben Eigenschaften von Parent-Materialien.

Eine Instanz kann einen übernommenen Parameter personalisieren, aber nicht ganz ignorieren – es sei denn, du verwendest einen statischen Schalter. Statische Schalter, die im Parent-Material eingerichtet werden, geben Child-Instanzen die Fähigkeit, Parameter ein- oder auszuschalten.

Da deaktivierte Parameter nicht kompiliert werden, können statische Switches die Performance zur Laufzeit verbessern. Da jedoch jeder Boolean eine neue Shader-Permutation erstellt, kann dies die Kompilierzeit drastisch erhöhen (abhängig von der Komplexität des Materials). Der Wert von Schaltern hängt davon ab, wie du sie verwendest und welche Entwicklungsanforderungen dein Projekt hat.

Um einen statischen Schalter, der die Maskeninversion steuert, zu erstellen, führe die folgenden Schritte durch:

1. Im Materialdiagramm wähle den LED-Sign-Knoten aus und dupliziere ihn durch Drücken von Strg + D.

2. Benenne den neuen Knoten Bildschirm.

3. Ziehe aus dem RGB-Output von Screen und suche nach One Minus.

4. Klicke mit der rechten Maustaste in das Diagramm und suche nach Static Switch Parameter. Benenne den Schalter Flip Mask?

5. Verbinde den Output von One Minus mit dem False-Input des Schalters.

6. Verbinde den RGB-Output von LED-Schild mit dem True-Input des Schalters.

7. Verbinde den Output des Schalters mit dem Input der Durchsichtigkeitsmaske des Materialstammknotens.

8. Speichere dein Material.

Dein Materialdiagramm sollte nun so aussehen:

Jetzt könnt ihr Material-Instanzen aus M_EmissiveSign erstellen, die auf einzigartige Weise die Helligkeit, Farbe, Textur-Map oder Maskeninversio steuern.

Wende Instanzen von M_EmissiveSign auf neue oder bestehende Meshes in deinem Level an, um eine Szene deiner Wahl zu erstellen. Wenn du die Wasserkugel durch das Level rollst, werden deine Schilder mithilfe des standardmäßig aktivierten Lumen-Systems für globale Beleuchtung und Reflexionen vom nassen Boden reflektiert. Du erfährst mehr über Lumen und andere Reflektionssysteme im nächsten Tutorial.

Als Nächstes

Im nächsten Tutorial erfährst du mehr über Reflexionen in Post-Process-Volumes, Beleuchtungssysteme und wie du verschiedene kamerainterne Effekte auf dein Level anwenden kannst.

• 

  Nachbearbeitungsvolumen hinzufügen

  Erstelle Nachbearbeitungsvolumen, um das Erscheinungsbild und die Performance eines Levels zu steuern.