Unreal Engine Mobile Optimization: MetaHumans und PCG auf 60 FPS bringen

The Mobile Barrier: Next-Gen Visuals auf Mobile bringen

Dein schönes PC-Projekt läuft mit makellosen 120 FPS auf deiner Developer Workstation, doch im Moment des Tests des Mobile-Packages bricht die Framerate in den einstelligen Bereich ein, das Target-Smartphone läuft heiß und die GPU crashed aufgrund eines Skinning-Buffer-Overflows. High-End-Features wie MetaHumans, Procedural Content Generation (PCG) und Substrate-Materialien sehen auf PC und Konsolen atemberaubend aus, sind aber berüchtigt dafür, mobile Geräte in die Knie zu zwingen. Mobile GPUs und CPUs arbeiten in extrem eingeschränkten Thermal- und Power-Envelopes, bei denen die Speicherbandbreite eine kostbare Ressource ist. Diese Next-Gen-Features für das Mobile Deployment anzupassen, ist nicht bloß eine Frage des Setzens eines Hakens in den Einstellungen; es erfordert ein tiefes, systematisches Verständnis von Bone-Skinning-Limits, Groom-Strukturen, Procedural Baking Workflows und komplexem Material Shading.

Die Herausforderung bei GPU Skinning und Bone Limits

Der GPU Skinning Bottleneck auf Mobile

Skinned Skeletal Meshes werden in Chunks aus Vertices und Bones aufgeteilt, bevor sie an die GPU gesendet werden. Jeder Chunk wird in einem einzelnen Draw Call verarbeitet, und mobile GPUs haben ein striktes Hardware-Limit für die Anzahl der Bone-Matrizen, die sie gleichzeitig skinnen können. Diese Einschränkung wird durch die Anzahl der Uniform Vectors definiert, die dem Vertex Shader zur Verfügung stehen. Ein standardmäßiges MetaHuman-Charakterskelett enthält über 600 Bones, was mobile Limits problemlos überschreitet und zu Rendering-Fehlern, Vertex-Tearing oder vollständigen GPU-Hangs führt.

Um diesen Hardware-Constraint zu umgehen, musst du die Engine zwingen, die Skeletal-Mesh-Chunks so zu partitionieren, dass kein einzelner Draw Call mehr als eine bestimmte Anzahl von Bones referenziert. Dies wird durch das Anpassen der Skinning-Kompatibilitätseinstellungen erreicht. Wenn du diese Konfiguration nicht vornimmst, schlägt das Skinning deiner Charaktermodelle auf Android- und iOS-Geräten fehl, was zu statischen oder stark verzerrten Meshes führt.

Konfigurieren der DefaultEngine.ini

Um die Bone-Skinning-Limits zu lösen, musst du die Konfigurationsdatei DefaultEngine.ini deines Projekts anpassen. Du findest diese Datei im Ordner Config im Root-Verzeichnis deines Projekts. Füge im Abschnitt [ConsoleVariables] die folgende Zeile hinzu:

[ConsoleVariables]
Compat.MAX_GPUSKIN_BONES=75

Diese Console Variable weist den Shader-Compiler an, die maximale Anzahl von Bones pro Skinning-Chunk auf 75 zu begrenzen. Dies ist ein striktes Hardware-Limit für ältere oder Mid-Range Mobile-GPUs. Bedenke, dass ein niedrigerer Wert den Skeletal-Mesh-Compiler dazu zwingt, das Mesh in eine größere Anzahl von Chunks aufzuteilen. Dies löst zwar die Rendering-Kompatibilität, aber mehr Chunks bedeuten mehr Draw Calls, wodurch sich der Performance-Bottleneck auf den CPU-Render-Thread verlagern kann.

Reduzieren der Bone-Anzahl und Component Stripping

Für Hintergrundcharaktere oder Non-Player Characters (NPCs), die keine vollständige Gesichtsanimation benötigen, solltest du das Skelett abspecken. Wenn du beispielsweise Finger, Zehen und Bones für den Gesichtsausdruck entfernst, kann die Gesamtanzahl der Bones eines Charakters von über 600 auf unter 75 reduziert werden. Dadurch kann das Charakter-Mesh als einzelner Chunk ohne Draw-Call-Inflation gerendert werden.

Wenn du auch Dedicated Server für dein Multiplayer-Spiel deployst, sind clientseitige Optimierungen nur die halbe Miete. Du musst auch die serverseitige Performance optimieren, indem du Rendering Assets komplett strippst. Lies unseren Step-by-Step-Guide über wie du das Asset-Stripping für Unreal Engine Dedicated Server meisterst, um den Speicher-Overhead des Servers zu reduzieren und die CPU-Performance zu optimieren.

MetaHuman-Haare optimieren: Groom Strands vs. Hair Cards

Die Kosten von Strand Rendering

Epics Groom-Strand-Rendering-Technologie zeichnet einzelne Haarkurven dynamisch. Obwohl dies auf High-End-Desktop-GPUs hochgradig detailliertes Haar erzeugt, ist es unglaublich teuer. Strand Rendering beruht auf Compute Shader Passes für Depth-Sorting und Shadow-Map-Generierung, was erhebliche Pixel-Fill-Rate und Speicherbandbreite verbraucht.

Auf Mobile-Geräten ist Strand Rendering entweder gar nicht unterstützt oder läuft zu inakzeptablen Kosten – oft verbraucht es über 15 ms GPU-Zeit für das Haar eines einzigen Charakters. Mobilen GPUs fehlt die rohe Speicherbandbreite, die erforderlich ist, um Hunderte von Tausenden einzelner Haarkurven pro Frame zu sortieren und zu shaden.

Implementierung von Hair Cards

Die Lösung besteht darin, strand-basierte Grooms gegen Hair Cards auszutauschen. Hair Cards stellen Haar mithilfe flacher, vereinfachter Polygon-Meshes dar, auf die vorgerenderte Haartexturen gemappt sind. Dieser Ansatz ist hervorragend mit dem Mobile Forward Render Path kompatibel.

Um Hair Cards zu implementieren, öffne den MetaHuman Creator und stelle sicher, dass du die Card-basierten Groom-LODs für deinen Charakter generierst. Das Ersetzen von Strand-basiertem Haar durch Card-basierte Grooms reduziert die Rendering-Zeit für das Haar eines einzelnen Charakters von rund 18,2 ms auf 0,9 ms auf einem modernen Mobile-Chip wie dem Apple A15 oder Snapdragon 8 Gen 1. Diese enorme Ersparnis ermöglicht es dir, das Rendering-Budget für Gameplay-Elemente oder Umgebungsdetails freizugeben.

Deaktivieren von Post-Process Anim Blueprints

MetaHumans verwenden Post-Process Animation Blueprints, um sekundäre Bone-Bewegungen, korrigierende Muskelformen und Gelenkdynamiken zu berechnen. Während dies auf dem PC für realistische Hautbewegungen sorgt, führt es jede Frame komplexe Skelettberechnungen auf der CPU aus. Auf Mobile kann dieser CPU-Overhead leicht den Game Thread bottlenecken.

Du kannst das Post-Process Animation Blueprint auf Mobile-Geräten deaktivieren, um CPU-Zyklen zurückzugewinnen. Dies geschieht durch Setzen von bDisablePostProcessAnims = true auf den Skeletal Mesh Components. Das Deaktivieren dieser Post-Prozesse spart bis zu 4,5 ms CPU-Frametime auf Standard-Mobile-Hardware.

PCG für Mobile-Umgebungen optimieren

Der Overhead von Runtime-PCG-Ausführung

Das Procedural Content Generation (PCG) Framework ermöglicht es dir, deine Umgebungen dynamisch zu bevölkern, indem Static Meshes, Foliage und Actors basierend auf Regeln und Volumes verteilt werden. Die Ausführung von PCG Graphs zur Laufzeit auf Mobile-CPUs verursacht jedoch schwere Performance-Ruckler (Hitches). Eine typische Runtime-Generierung des Graphs kann den Game Thread während des Level-Loadings oder Player-Spawnings für 1,5 bis 3 Sekunden einfrieren.

In einem Multiplayer-Spiel ist ein solcher Hitch gefährlich; er kann zu Packet Loss führen und eine Desynchronisation des Client-Server-States auslösen. Um eine hohe Performance aufrechtzuerhalten, musst du deine PCG Graphs im Editor pre-baken. Dies konvertiert die prozeduralen Instanzen vor dem Packagen deines Spiels in statische Geometrie.

Step-by-Step PCG Baking Workflow

1. Wähle das PCG Volume: Wähle im Viewport des Unreal Editors das PCG Volume aus, das deine Umgebungselemente enthält.
2. Generieren und inspizieren: Klicke im Details Panel des Volumes auf Generate, um die prozedurale Platzierung deiner Assets in der Vorschau anzuzeigen.
3. Export to Actor: Suche die Option Export to Actor im PCG-Utilities-Menü.
4. Instanced Meshes auswählen: Wähle Hierarchical Instanced Static Mesh (HISM) als Zielformat. Diese Gruppe von Instanzen ist hochgradig für mobile GPUs optimiert, da sie alle identischen Meshes in einem einzigen GPU Draw Call zeichnet.
5. Den Graph leeren: Setze nach dem Exportieren den Generation Trigger des PCG Volumes auf Editor Only oder leere das Volume. Dies verhindert, dass die Runtime Engine versucht, den Graph neu zu erstellen.

Dynamisches HISM Culling und Streaming

Sobald du deine PCG-Instanzen in HISMs gebacken hast, musst du deren Culling Distances konfigurieren. HISMs unterstützen Per-Instance Culling, was bedeutet, dass Instanzen ab einer bestimmten Entfernung zur Kamera nicht mehr gezeichnet werden. Setze die Start Cull Distance und End Cull Distance im Details Panel deiner HISM Components. Für Mobile wird eine Cull Distance von 5000 bis 8000 Units empfohlen, um die Gesamtzahl der sichtbaren Polygone im Rahmen des Budgets der mobilen GPU zu halten.

Production C++ Optimization Script

Um diese Optimierungen zur Laufzeit zu automatisieren, kannst du eine benutzerdefinierte Helper-Klasse schreiben. Der folgende C++-Code demonstriert, wie du die Zielplattform prüfst, programmatisch niedrige LODs erzwingst, Post-Process Animation Blueprints deaktivierst und Groom Components zur Verwendung von Card-basiertem Rendering zwingst, wenn ein MetaHuman auf einem Mobile-Gerät gespawnt wird. Du kannst dies in einer Klasse wie UMetaHumanMobileOptimizer implementieren:

#pragma once

#include "CoreMinimal.h"
#include "Kismet/BlueprintFunctionLibrary.h"
#include "Components/SkeletalMeshComponent.h"
#include "GroomComponent.h"
#include "MetaHumanMobileOptimizer.generated.h"

UCLASS()
class MYPROJECT_API UMetaHumanMobileOptimizer : public UBlueprintFunctionLibrary

{
    GENERATED_BODY()

public:
    UFUNCTION(BlueprintCallable, Category = "Optimization")
    static void OptimizeMetaHumanForMobile(AActor* MetaHumanActor)
    {
        if (!MetaHumanActor)
        {
            return;
        }

        // Apply optimizations exclusively on Android and iOS platforms
        #if PLATFORM_ANDROID || PLATFORM_IOS
        TArray<USkeletalMeshComponent*> SkeletalComponents;
        MetaHumanActor->GetComponents<USkeletalMeshComponent>(SkeletalComponents);

        for (USkeletalMeshComponent* MeshComp : SkeletalComponents)
        { 
            if (MeshComp)
            {
                // Force a low LOD (LOD 3 or 4) to bypass dense meshes
                MeshComp->SetMinLOD(3);
                MeshComp->SetForcedLOD(3);

                // Disable expensive post-process animation blueprints
                MeshComp->bDisablePostProcessAnims = true;

                // Adjust animation tick rate to only calculate when visible
                MeshComp->VisibilityBasedAnimTickOption = EVisibilityBasedAnimTickOption::OnlyTickPoseWhenRendered;

                // Strip physics asset to avoid CPU collision overhead on cosmetic joints
                MeshComp->SetPhysicsAsset(nullptr);
            }
        }

        TArray<UGroomComponent*> GroomComponents;
        MetaHumanActor->GetComponents<UGroomComponent>(GroomComponents);

        for (UGroomComponent* GroomComp : GroomComponents)
        {
            if (GroomComp)
            {
                // Force the groom to use card rendering instead of strands
                GroomComp->SetUseCards(true);
            }
        }
        #endif
    }
};

Diese Helper-Funktion kann über das BeginPlay-Event deines Charakters oder direkt nach dem Spawnen eines MetaHuman-Actors aufgerufen werden. Durch die Verwendung von bedingten Kompilierungs-Makros (PLATFORM_ANDROID || PLATFORM_IOS) entfernt der Compiler diese Overrides aus PC- und Konsolen-Builds, wodurch du die plattformübergreifende visuelle Qualität automatisch beibehältst.

Substrate-Materialien für Mobile-GPUs anpassen

Was ist Substrate?

Substrate ersetzt das traditionelle Unreal Engine Shading Model durch ein modulares, mehrschichtiges Material Framework. Substrate ermöglicht es Entwicklern, mehrere Shading Slabs zu stapeln (z. B. das Platzieren eines glänzenden Clear-Coat-Layers direkt über einem rauen Metal-Layer). Während Substrate hervorragend für High-End Cinematic Assets geeignet ist, stellt es für Mobile Renderer eine ernsthafte Performance-Hürde dar.

Mobile GPUs verlassen sich stark auf Tiled Rendering-Architekturen, bei denen der Speicherbus zwischen dem GPU-Core und dem On-Chip Framebuffer ein großer Bottleneck ist. Komplexe Substrate-Materialien erhöhen die Anzahl der pro Pixel in den Framebuffer geschriebenen Bytes (Bytes per Pixel, BPP), was zu Thermal Throttling und Framerate-Einbrüchen führt.

Steuerung der Materialkomplexität über Quality Level Switches

Um Substrate-Materialien auf Mobile performant zu halten, solltest du die Nodes Material Quality Level Switch und Feature Level Switch im Material Editor verwenden. Diese Nodes ermöglichen es dir, den Material Graph basierend auf der Zielplattform zu vereinfachen.

Vereinfache den Graph für Mobile-Plattformen, indem du mehrschichtige Substrate-Blends umgehst. Greife stattdessen auf eine einzelne Slab zurück, die den visuellen Stil deines Assets annähert. Indem du deine Material-Nodes durch einen Quality Switch leitest, kannst du die Schreibbandbreite von 32 Bytes pro Pixel auf standardmäßige 8 Bytes pro Pixel reduzieren, was zu einem kühler laufenden Gerät und stabilen Framerates führt.

5 praxiserprobte Best Practices für Mobile Optimization

1. Alle PCG Graphs in HISMs pre-baken: Führe PCG Graphs zur Laufzeit nicht auf dem Client aus. Bake Graphs während der Editor-Entwicklung in Hierarchical Instanced Static Meshes (HISMs) vor und konfiguriere angemessene Start/End-Cull-Distances.
2. Bone-Anzahl global begrenzen: Füge Compat.MAX_GPUSKIN_BONES=75 zur Datei DefaultEngine.ini deines Projekts hinzu, um sicherzustellen, dass Skeletal Meshes auf mobilen GPUs korrekt gerendert werden, ohne Buffer-Overflows auszulösen.
3. Ausschließlich Card-basierte Grooms nutzen: Deaktiviere Strand-basierte Grooms für Mobile-Profile. Card-basiertes Hair Rendering reduziert die GPU-Frametimes von 18 ms auf unter 1 ms pro Charakter.
4. Material Quality Switches nutzen: Implementiere die Node Material Quality Level Switch in deinen Substrate-Materialien, um komplexe Shading-Layer auf Mobile-Plattformen zu einer einzigen Slab zu vereinfachen und so die GPU-Bandbreite zu entlasten.
5. Post-Process Animation Blueprints deaktivieren: Setze bDisablePostProcessAnims = true auf den Skeletal-Komponenten deiner Charaktere auf Mobile, um wertvolle CPU-Zyklen im Game Thread zurückzugewinnen.

Die Multiplayer- und Backend-Gleichung

Jenseits des Renderings: Mobile Network Optimization

Bei der Entwicklung von plattformübergreifenden Multiplayer-Spielen sind clientseitige Optimierungen nur ein Teil der Gleichung. Mobile Geräte sind häufig Netzwerkschwankungen ausgesetzt und wechseln ständig zwischen Mobilfunkdaten (5G/4G) und WLAN. Diese Schwankungen führen zu Packet Loss, Jitter und hohen Latenzspitzen.

Wenn dein Netzwerksynchronisationscode nicht robust ist, können diese Latenzspitzen den Multiplayer-Sync-Bug der Unreal Engine auslösen, bei dem die Actor-Replikation asynchron wird und den World State beschädigt. Das Verwalten von Multiplayer-States unter mobilen Netzwerkbedingungen ist ein komplexes Problem, das widerstandsfähige Netzwerktreiber, Delta-Kompression und Server-Authoritative Reconciliation erfordert.

Infrastruktur auslagern mit horizOn

Ein robustes Multiplayer-Backend selbst aufzubauen und zu warten, erfordert einen massiven Engineering-Aufwand. Du müsstest Load Balancer bereitstellen, globale Datenbankreplikation verwalten, Matchmaking-Logik implementieren und Mobile Billing handhaben. Diese Infrastrukturarbeit kann Monate an Entwicklungszeit in Anspruch nehmen und erfordert kontinuierliche Wartung.

Mit horizOn sind diese Backend-Dienste bereits vorkonfiguriert. horizOn bietet Game-Entwicklern Session-Matchmaking, latenzarme Statessynchronisation, Datenbankpersistenz und plattformübergreifende Authentifizierung direkt out of the box. So kannst du dich voll auf die Optimierung deiner Clients und den Feinschliff deines Game-Loops konzentrieren, anstatt Server-Cluster und Datenbank-Skalierbarkeit zu verwalten.

Fazit und nächste Schritte

Die Optimierung von Next-Gen-Features wie MetaHumans und PCG für Mobile erfordert eine strikte Kontrolle von Rendering-Budgets, Skeletal-Mesh-Kompilierung und Material-Shading-Komplexität. Durch das Pre-Baken deiner prozeduralen Assets, das Begrenzen von Bone-Limits und die Nutzung von Card-basiertem Hair Rendering kannst du visuell beeindruckende, plattformübergreifende Erlebnisse auf Mobilgeräten bereitstellen.

Bereit, dein Multiplayer-Backend zu skalieren? Teste horizOn kostenlos oder wirf einen Blick in die API docs, um zu sehen, wie du deine Infrastruktur vereinfachen und deine Spieler auf PC, Konsole und Mobile synchron halten kannst.

---

Quelle: Tutorial: Optimizing Next Gen Features for Mobile Game Development