Unity: PBR-Texturen für URP und HDRP richtig einbauen

Warum die Render Pipeline über das Kanal-Layout entscheidet

Ein PBR-Material besteht in Unity nie aus einer festen Anzahl Texturen. Es besteht aus dem, was der jeweilige Shader an Eingängen anbietet, und jede Render Pipeline bringt einen eigenen Standard-Shader mit. Built-in Render Pipeline, Universal Render Pipeline (URP) und High Definition Render Pipeline (HDRP) laufen nebeneinander her, sind aber nicht austauschbar. Ein Material, das in URP gebaut wurde, funktioniert nicht automatisch in HDRP, und umgekehrt genauso wenig.

Für neue Projekte rät Unity zu URP oder HDRP; die Built-in Pipeline gilt als Altlast und wird in offiziellen Dokumenten kaum noch mit eigenen Packing-Regeln beschrieben. Deshalb konzentriert sich diese Anleitung auf URP und HDRP – die beiden Pipelines, in denen unsere Texturpakete (Cracked Concrete 01, Oak Planks 01, Rusty Corrugated Metal 01, Cobblestone 01, Corrugated Metal 01) sauber ankommen, wenn man weiß, wo welcher Wert hingehört.

Die kurze Antwort: Unity liest bei gepackten Texturen feste Kanäle aus dem Shader-Code, nicht aus dem Dateinamen. Steckt Metallic im falschen Kanal, wird eine Betonwand im schlimmsten Fall komplett spiegelnd. Der Rest dieser Anleitung zeigt, wie du unsere Dateien – _diff, _nor_gl, _rough, _ao, _disp, _arm – für URP und für HDRP richtig anschließt.

Schritt 1: Textur-Import-Einstellungen prüfen

Bevor eine Textur in einem Material landet, entscheidet der Import-Inspector, wie Unity die Pixel interpretiert. Für unsere sechs Karten gilt:

Diffuse-Texturen enthalten Farbinformation und brauchen sRGB, damit Unity die Gammakorrektur richtig anwendet. Roughness, AO, Displacement und die gepackte ARM-Datei sind dagegen reine Messwerte – lineare Daten, keine Farbe. Bleibt sRGB dort aktiv, verschiebt Unity die Werte, und die Materialwirkung stimmt nicht mehr mit dem gemessenen Original überein.

Für _nor_gl wählst du im Dropdown Texture Type den Eintrag Normal Map. Unity erkennt daraufhin selbst, dass es sich um Richtungsdaten handelt, und verwaltet Farbraum und Kompression passend. Ein manuelles Invertieren ist nicht nötig, unsere Dateien liegen bereits in der von Unity erwarteten Normal-Map-Form vor.

KI-generiert

Schritt 2: URP Lit Shader einrichten

Der Standard-Shader in URP heißt Lit. Er nimmt laut Unity-Dokumentation Base Map, Metallic Map, Smoothness und Normal Map als eigene Eingänge entgegen, kann Metallic, Occlusion und Smoothness aber auch aus einer einzigen gepackten Textur lesen. Das Kanal-Layout dafür ist fest vorgegeben:

Wichtig: Diese Textur wird sowohl in das Feld Metallic Map als auch in Occlusion Map gezogen. Unity liest dann automatisch die passenden Kanäle aus derselben Datei – zwei Slots, eine Textur.

Unser _arm-Format legt AO in Rot, Roughness in Grün und Metallic in Blau ab, also in einer anderen Reihenfolge. Wer die ARM-Datei ungeprüft in die Metallic-Slots von URP zieht, bekommt falsche Ergebnisse: Aus AO wird Metallic, aus Roughness wird Occlusion. Wie du daraus in wenigen Zeilen eine URP-taugliche Textur baust, steht in Schritt 4.

Base Map bekommt _diff, Normal Map bekommt _nor_gl. Beide Zuweisungen laufen unabhängig vom Kanal-Packing und funktionieren ohne Umweg.

Schritt 3: HDRP Lit Shader und die Mask Map

HDRP nutzt ebenfalls einen Lit-Shader, packt Metallic, AO, ein Detail-Masken-Bit und Smoothness aber grundsätzlich in eine einzige Mask Map – ein separates Metallic-Feld gibt es hier nicht. Laut der offiziellen HDRP-Dokumentation ist das Layout:

Auch hier gilt: Beim Import der Mask Map sRGB (Color Texture) deaktivieren, sonst verschiebt HDRP die linearen Werte. Ohne eigene Detail Map spielt der Blau-Kanal keine Rolle für das Ergebnis, wir setzen ihn im Skript unten trotzdem sauber auf 0, statt ihn einfach leer zu lassen.

KI-generiert

Fällt dir auf, wie ähnlich sich URP-Packing und HDRP-Mask-Map sind? Rot und Alpha stimmen überein, nur Grün und Blau vertauschen ihre Rolle leicht. Genau das macht Schritt 4 so kurz.

Schritt 4: Smoothness berechnen und Kanäle neu packen

Zwei Dinge fehlen noch, um aus unseren Dateien eine für Unity brauchbare Textur zu machen: Roughness muss in Smoothness umgerechnet werden (Smoothness = 1 − Roughness), und die Kanäle müssen in der Reihenfolge landen, die URP beziehungsweise HDRP erwarten. Ein kurzes Python-Skript mit Pillow erledigt beides in einem Rutsch:

from PIL import Image

# FS-Modworks-ARM: R = AO, G = Roughness, B = Metallic
arm = Image.open("FSMW_cracked_concrete_01_arm_4k.jpg").convert("RGB")
rough = Image.open("FSMW_cracked_concrete_01_rough_4k.jpg").convert("L")

ao, _, metallic = arm.split()
smoothness = rough.point(lambda p: 255 - p)      # Smoothness = 1 - Roughness
detail_mask = Image.new("L", ao.size, 0)         # keine Detail Map -> 0

# R Metallic, G AO/Occlusion, B Detail-Maske, A Smoothness
# passt so fuer die HDRP Mask Map UND fuer das URP-Kanal-Packing
# (in URP bleibt Blau schlicht ungenutzt)
packed = Image.merge("RGBA", (metallic, ao, detail_mask, smoothness))
packed.save("cracked_concrete_01_packed_4k.png")

Die erzeugte PNG-Datei kommt in URP in die Felder Metallic Map und Occlusion Map (beide gleichzeitig), in HDRP in Mask Map. In beiden Fällen: sRGB beim Import ausschalten, Texture Type bleibt Default.

Schritt 5: Tiling passend zum Kachelmaß setzen

Unsere Texturen sind kachelbar, aber nicht beliebig groß – jede hat ein festes Kachelmaß, auf das sie in Substance, Blender oder direkt am Modell gebaut wurde:

Im Material-Inspector findest du unter der Textur-Zuweisung die Felder Tiling (X/Y) und Offset. Der Tiling-Wert multipliziert die UV-Koordinaten des Meshs; er ist kein absoluter Meterwert, sondern ein Verhältnis zur UV-Größe des Objekts. Als Faustregel: Tiling = Kantenlänge der Fläche in Metern ÷ Kachelmaß der Textur, vorausgesetzt die UVs des Meshs sind 1:1 zur realen Objektgröße gelegt. Eine 4 Meter breite Wand mit Cracked Concrete 01 bekommt bei sauberen UVs also Tiling X = 4.

Schritt 6: FBX und glTF importieren

Unsere 3D-Modell-Pakete liegen in mehreren Formaten vor. FBX-Dateien liest Unity nativ, ohne dass du irgendetwas installieren musst – Datei in den Assets-Ordner legen, Unity baut daraus automatisch ein Prefab samt Materialien. Details zu unseren Formaten stehen in der Anleitung zu 3D-Dateiformaten.

Für .gltf und .glb ist das anders: Unity bringt dafür kein eigenes Importmodul mit. Laut Unity-Dokumentation übernimmt das Paket glTFast (com.unity.cloud.gltfast) diese Aufgabe. Installation über Window → Package Manager, dort das Paket suchen und hinzufügen. Danach kannst du .gltf- und .glb-Dateien wie jede andere Szene in den Assets-Ordner kopieren; glTFast baut daraus native Unity-Prefabs. Denk daran, die zugehörige .bin-Datei und den textures-Ordner mit zu kopieren, sonst fehlen Verweise.

KI-generiert

Willst du dieselbe Textur zusätzlich im LS25 einsetzen, ist Unity dafür der falsche Weg – dort übernimmt das GIANTS Texture Tool die Konvertierung nach DDS, mit eigenem Kanal-Layout für die Spekular-Karte.

Ein Blick auf verwandte Engines lohnt sich, wenn ein Projekt mehrgleisig läuft: Die Anleitung zu Unreal Engine zeigt, wie dort aus unserer ARM-Datei direkt eine ORM-Textur wird, und die ORM/ARM-Anleitung erklärt den Unterschied zwischen den Packing-Standards im Detail. Wie Normal Maps grundsätzlich funktionieren und woran man eine falsch orientierte erkennt, steht in der Normal-Map-Anleitung.

Häufige Fehler