🚀 Unreal Engine 5 – Moteur AAA (Lumen, Nanite) & C++/Blueprints

Qu'est-ce que Unreal Engine (UE) ?

Unreal Engine (par Epic Games) est un moteur de jeu (Game Engine) 3D temps réel, leader de l'industrie, conçu pour le développement haut de gamme ("AAA").

Il est réputé pour ses capacités graphiques (rendu) de pointe. Il est écrit en C++ et propose une double approche de scripting : C++ (performance) et Blueprints (visuel).

Usage (Plus que le jeu)

Bien que (à l'origine) conçu pour les jeux (Unreal Tournament, Fortnite), UE5 est maintenant un moteur "Temps Réel" dominant pour :

• Cinéma & VFX : Production virtuelle (ex: "The Mandalorian"), prévisualisation.
• Architecture : Visualisation (ArchViz) photoréaliste.
• Automobile : Design et simulateurs.

Il y a deux façons principales d'installer UE5.

L'interface (GUI) de l'Éditeur Unreal est très similaire à celle d'Unity.

C'est la hiérarchie de base d'Unreal (similaire à Unity : Scene, GameObject, Component).

Unreal utilise à la fois l'Héritage (via C++) et la Composition (via Components). C'est une différence majeure avec Unity (qui est 100% Composition).

AActor
 └ APawn (Peut être "possédé" par un Controller)
   └ ACharacter (Un Pawn "humanoïde")
     ├─ (Possède un 'Capsule Component')
     ├─ (Possède un 'Skeletal Mesh Component')
     └─ (Possède un 'Character Movement Component')

C'est l'architecture (conceptuelle) d'Unreal pour la logique de jeu. C'est la partie la plus complexe à maîtriser pour les débutants.

Le Scripting Visuel (Nodal)

Blueprints (BP) est le système de scripting visuel (Nodal) d'Unreal. Il permet de créer une logique de jeu (fonctions, variables) sans écrire de code C++.

C'est un système "basé sur les nœuds" (Nodes) : on connecte des "boîtes" (Fonctions) avec des "fils" (Flux d'exécution).

(Équivalent C# de Unity: 'OnTriggerEnter')

[Event 'OnActorBeginOverlap']──(Exec)──►[Cast To 'BP_Player']──(Exec)──►[Apply Damage]
 (Actor) ───────────────────────────────► (Object)              (Target) ◄─ (Self)
                                         (As BP_Player) ───────────────► (Damaged Actor)

Avantages

• Accessibilité : Permet aux non-programmeurs (Game Designers, Artistes) de créer de la logique.
• Prototypage Rapide : Extrêmement rapide pour tester une idée (itération).
• Intégration : Parfaitement intégré à l'éditeur.

Un "Actor Blueprint" (3.2) contient deux graphes (espaces de code) principaux :

Le C++ est le langage "natif" d'Unreal Engine. Il est utilisé pour la performance et pour créer des systèmes de base (ex: la "fondation" d'un Personnage) qui seront ensuite étendus/utilisés par les Blueprints.

Unreal Header Tool (UHT) - La "Magie"

UE utilise un C++ "modifié" (via un pré-processeur, l'UHT) qui gère la Réflexion (Reflection) et le Garbage Collection (GC).

Pour que le C++ soit "visible" par l'Éditeur Unreal (et par les Blueprints), vous devez utiliser des Macros :

// MyCharacter.h (Fichier Header)
#pragma once
#include "GameFramework/Character.h"
#include "MyCharacter.generated.h" // (Généré par UHT)

// 1. UCLASS() (Rend la classe visible par UE)
UCLASS(Blueprintable) // (Permet d'en hériter en Blueprint)
class AMyCharacter : public ACharacter
{
    GENERATED_BODY() // (Magie UHT)

public:
    AMyCharacter();

protected:
    // 2. UPROPERTY() (Rend la variable visible/éditable)
    // (Visible dans l'Inspecteur ET en Blueprint)
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Stats")
    float Health;

    // 3. UFUNCTION() (Rend la fonction visible/appelable)
    // (Peut être appelée depuis un Event Graph Blueprint)
    UFUNCTION(BlueprintCallable, Category="Stats")
    void TakeDamage(float Amount);

    // (Événement natif, implémentable en BP)
    UFUNCTION(BlueprintImplementableEvent)
    void OnDeath();
};

Historiquement, la compilation C++ (surtout pour un moteur de jeu) était un processus très lent (Hot Reload).

Live Coding (UE5)

Live Coding (UE 4.22+) est le système de compilation "moderne". Il permet de modifier le code C++ pendant que l'Éditeur (ou le jeu) tourne.

Workflow (Live Coding)

1. Lancer le jeu (Play in Editor).
2. Ouvrir Visual Studio / VS Code / Rider.
3. Modifier une fonction C++ (ex: changer la vitesse du joueur).
4. Appuyer sur Ctrl+Alt+F11 (Compiler).
5. Live Coding compile les deltas (changements) (très rapide).
6. Il "patch" (applique) le nouveau code (DLL) à chaud dans le processus du jeu.
7. Vous voyez le changement (nouvelle vitesse) instantanément, sans redémarrer le jeu.

Limite : Le Live Coding ne fonctionne (généralement) pas si vous modifiez les en-têtes (.h) (ex: ajouter un UPROPERTY). Cela nécessite un redémarrage complet de l'Éditeur.

La force d'Unreal est l'hybridation des deux. La question n'est pas "l'un *ou* l'autre", mais "quand utiliser l'un *et* l'autre".

Le Workflow Hybride (Recommandé)

1. (C++) Le Programmeur crée les systèmes de base (fondations) en C++.
   • (Ex: AMyCharacter.cpp).
   • (Crée les UPROPERTY (ex: float Health) et les UFUNCTION (ex: TakeDamage())).
2. (BP) Le Designer crée un Blueprint (Enfant) qui hérite de la classe C++ (ex: BP_Joueur hérite de AMyCharacter).
3. (BP) Le Designer (dans l'Éditeur) :
   • (Inspecteur) : Règle les variables (UPROPERTY) (ex: Health = 150).
   • (Event Graph) : Assemble la logique (ex: Event OnOverlap -> (Appelle C++) TakeDamage(10)).
   • (Event Graph) : Implémente les événements (ex: Event OnDeath -> (Logique BP) Spawn Explosion VFX).

Lumen est le système d'Illumination Globale (Global Illumination - GI) et de Réflexions dynamique (temps réel) de UE5.

Le Problème (Avant Lumen)

Avant UE5 (et dans Unity/autres), l'éclairage "indirect" (les rebonds de lumière, ex: la lumière du soleil qui rebondit sur un mur rouge et colore le plafond en rouge) était pré-calculé ("baked").

Ce "baking" (ex: "Lightmass" dans UE4) prenait des heures (voire des jours) de calcul et était statique (si vous déplaciez une lumière ou un mur, il fallait tout re-calculer).

La Solution (Lumen)

Lumen calcule l'éclairage indirect et les réflexions en temps réel (dynamique). Si vous déplacez le soleil, l'éclairage de la scène est mis à jour instantanément.

Résultat : Itération artistique ultra-rapide, mondes dynamiques (ex: cycle jour/nuit, lampes torches).

Modes (Software vs Hardware)

• Software Ray Tracing : (Défaut) Rapide, fonctionne sur (presque) tout.
• Hardware Ray Tracing : (Meilleure qualité) Utilise les cœurs RT des cartes (NVIDIA RTX, PS5, Xbox Series X).

Nanite est le système de géométrie virtualisée (micropolygones) de UE5.

Le Problème (Avant Nanite)

Un modèle 3D "ciné-qualité" (ex: une statue) peut avoir 10 millions de polygones. (Budget de polygones/frame : 1-5M polys).

Solution (Legacy) : L'artiste 3D devait manuellement créer des LODs (Level of Detail) :

• LOD 0 (proche) = 50k polys
• LOD 1 (moyen) = 5k polys
• LOD 2 (loin) = 500 polys

Un travail long et coûteux.

La Solution (Nanite)

Avec Nanite, vous importez directement le modèle ciné-qualité (10 millions de polygones) dans le moteur.

Nanite analyse le modèle et génère automatiquement une représentation (micropolygone) qu'il peut "streamer" (diffuser) à la volée. Il ne dessine que les polygones (Clusters) qui sont visibles et de la taille d'un pixel.

Résultat : Niveaux de détail géométrique infinis, plus de "pop-in" de LOD, et un gain de temps de production artistique massif.

Problème : Comment créer un monde ouvert (Open World) (ex: 100km x 100km) ? On ne peut pas charger tous les assets (terrains, arbres, bâtiments) en mémoire en même temps (RAM/VRAM).

Solution (Legacy - UE4) : World Composition. L'artiste découpait manuellement le monde en "Levels" (sous-niveaux) et gérait leur chargement (streaming) manuellement.

Solution (UE5) : World Partition

World Partition (le système par défaut pour les "Open Worlds" UE5) automatise ce processus.

1. L'artiste travaille sur 1 seul "Persistent Level" (Niveau Persistent).
2. Il place ses assets (ex: une forêt, un village).
3. En arrière-plan, UE5 assigne automatiquement ces assets à une grille (Grid) (cellules).
4. Au Runtime : UE5 ne charge (stream) que les cellules (grilles) qui sont proches du joueur.

Résultat : Mondes ouverts massifs avec streaming automatique. (Fonctionne avec "Data Layers" (ex: charger/décharger la version "détruite" d'un bâtiment)).

Chaos est le moteur physique (développé en interne par Epic) de UE5. Il remplace l'ancien moteur (NVIDIA PhysX) utilisé dans UE4.

Fonctionnalités Clés

• Destruction (Chaos Destruction) : (Le point fort) Système de fracture procédurale (Geometry Collections) pour créer des destructions cinématiques (murs, piliers) en temps réel.
• Tissus (Cloth) : Simulation de vêtements, drapeaux...
• Fluides (Niagara) : Intégration avec Niagara pour les fluides (SPH).
• Champs (Fields) : Permet aux artistes (via Blueprints) de "cibler" la destruction (ex: "Fracturer uniquement à ce point d'impact").

Niagara est le système de VFX (Effets Visuels) (particules) de UE5. Il remplace l'ancien système "Cascade" (UE4).

Philosophie (Programmable)

Cascade était une "boîte noire". Niagara est un système nodal (similaire aux Blueprints/Materials) qui donne un contrôle total aux artistes (VFX Artists).

Architecture Niagara

• Emitter (Émetteur) : Un "gabarit" (Template) qui définit un effet (ex: "Fumée").
  • (Contient des "Modules" : Spawn Rate, Velocity, Color...).
• System (Système) : Un "conteneur" qui combine plusieurs Émetteurs (ex: 1 Émetteur "Feu" + 1 Émetteur "Fumée" + 1 Émetteur "Étincelles" = 1 Système "Explosion").

Permet des effets extrêmement complexes (ex: interaction avec les fluides Chaos, audio...).

Le Material Editor est l'éditeur nodal (visuel) d'Unreal pour créer des Shaders (programmes GPU).

Matériau (Material) vs Instance

• Material (.uasset) : (Le "Parent") C'est le shader. C'est là que l'artiste crée la "logique" (les nœuds) (ex: "Prendre une Texture A, une Texture B, les multiplier, et les brancher sur 'Base Color'"). C'est compilé.
• Material Instance (.uasset) : (L'"Enfant") Une "copie" (Instance) du Matériau parent. N'expose que des Paramètres (ex: "Couleur", "Texture"). Très léger, non-compilé.

PBR (Physically Based Rendering)

Unreal utilise un workflow PBR (Rendu Basé sur la Physique). Le nœud "Matériau" final expose des entrées physiques :

• Base Color : La couleur/texture (Albedo).
• Metallic : (0=Non-métal, 1=Métal).
• Roughness (Rugosité) : (0=Miroir parfait, 1=Mat/Diffus).
• Normal : (La "fausse" texture de relief (Normal Map)).

Sequencer est l'outil de cinématique (non-linéaire) d'Unreal (remplace l'ancien "Matinee").

C'est un "Adobe Premiere" ou "After Effects" intégré à l'éditeur.

Usage

Permet de créer des "Séquences" (.uasset) qui animent n'importe quoi dans la scène via une Timeline (chronologie) :

• Caméras : (Mouvement, Focus (Focale)).
• Actors : (Mouvement, Propriétés (ex: couleur de lumière)).
• Animations : (Déclencher des animations de personnages).
• Audio : (Déclencher des musiques, sons).

C'est l'outil utilisé pour les cinématiques de jeu ("Cutscenes") et la production virtuelle (VFX).

Quixel (acquis par Epic Games) est une bibliothèque massive d'Assets (Ressources) photoréalistes, basés sur des scans 3D (Photogrammétrie) du monde réel.

Quixel Megascans

La bibliothèque (des milliers d'assets "AAA") :

• Surfaces : (Sol, Rocher, Bois, Métal...).
• Assets 3D : (Plantes, Rochers, Débris, Bâtiments...).
• Decals : (Tags, Flaques d'eau, Fissures...).

Intégration : Les "Megascans" sont gratuits pour tous les utilisateurs d'Unreal Engine.

Quixel Bridge

Bridge est l'outil (intégré à l'Éditeur UE5) qui permet de naviguer dans la bibliothèque Megascans et d'importer (Drag & Drop) les assets (Modèle 3D + Materials PBR) directement dans le projet.

C'est un accélérateur majeur pour la création de mondes réalistes (surtout avec Nanite).