Unreal Engine : qu'est-ce que c'est, architecture et le langage C++

Qu'est-ce que Unreal Engine ?

Unreal Engine est un moteur de jeu développé par Epic Games, publié pour la première fois en 1998 avec le jeu Unreal. Depuis sa création, le moteur a connu cinq itérations majeures, et la version actuelle, Unreal Engine 5, publiée en 2022, est une plateforme entièrement repensée pour le développement de jeux, les simulations, la production cinématographique et la visualisation architecturale.

Contrairement à d'autres moteurs, Unreal Engine propose des solutions prêtes à l'emploi pour le Real-Time Ray Tracing et la géométrie virtuelle Nanite. Ces technologies permettent de créer des scènes avec des millions de polygones sans perte de performances. Les développeurs ont accès au code source complet du moteur en C++, ce qui leur permet de modifier tout aspect en fonction des besoins de leur projet spécifique.

L'écosystème comprend le Marketplace avec des milliers d'actifs, de plugins et d'effets sonores prêts à l'emploi. Les développeurs peuvent publier des projets sur 28 plateformes, notamment PlayStation 5, Xbox Series X, Nintendo Switch, iOS, Android et PC. Selon Epic Games (2026), l'écosystème compte plus de 12 millions de développeurs inscrits.

Histoire du développement d'Unreal Engine

La première version d'Unreal Engine (1998) a introduit l'architecture de rendu par portails, qui rendait efficacement les scènes complexes. Unreal Engine 2 (2002) a ajouté la prise en charge des consoles de sixième génération et un système de particules. Unreal Engine 3 (2006) est devenu le moteur dominant de l'ère Xbox 360 et PS3 grâce au moteur physique PhysX et au système de matériaux basé sur les shaders.

Unreal Engine 4 (2014) a réécrit le rendu pour le PBR (Physically Based Rendering) et a introduit Blueprints — un système de programmation visuelle. Cette version a rendu le développement de jeux accessible aux studios indépendants grâce à un modèle de redevances de 5% sur les revenus. Selon Epic Games (2019), plus de 50% des projets sur UE4 ont été créés par des développeurs indépendants.

Unreal Engine 5 (2022) a introduit Nanite et Lumen — des technologies qui ont éliminé le besoin de modèles LOD et d'éclairage pré-cuit. Selon Digital Foundry (2026), Nanite peut rendre des scènes avec 10 milliards de polygones en temps réel sur les consoles de la génération actuelle.

Architecture d'Unreal Engine : modules clés

L'architecture d'Unreal Engine est construite sur un principe modulaire, où chaque sous-système peut être remplacé ou désactivé. Le Core Engine gère le cycle de vie du jeu, la mémoire et les threads. Le Rendu gère les graphiques, le Gameplay Framework gère la logique du jeu et l'Éditeur gère les outils de développement.

Core Engine et système de modules

La couche de base comprend FPlatformMisc pour l'abstraction de plateforme, FMemory pour la gestion de la mémoire et FTaskGraph pour le multithreading. Chaque module est représenté par une classe UModule qui s'enregistre dans le système de chargement. Les modules sont compilés sous forme de DLL séparées sous Windows ou de DYLIB sous macOS, ce qui permet de les mettre à jour sans recompiler l'ensemble du moteur.

Le Registre d'actifs (Asset Registry) indexe toutes les ressources du projet et fournit une recherche rapide par tags et métadonnées. Chaque actif possède un identifiant global unique (FGuid) et peut référencer d'autres actifs via des mécanismes de référence Soft et Hard. Le système d'empaquetage regroupe les actifs dans des archives Pak optimisées pour la compilation finale du jeu.

Le module Réseau (Networking) offre un support multijoueur avec réplication via la prédiction côté client. Selon Epic Games (2025), l'architecture de réplication d'Unreal Engine prend en charge jusqu'à 100 joueurs simultanés sur un serveur dédié avec une latence inférieure à 50 ms.

Pipeline de rendu

Le pipeline de rendu prend en charge le rendu Forward et Deferred. Deferred Shading est utilisé pour la plupart des projets : il traite jusqu'à 256 sources de lumière par scène. Le rendu Forward est utilisé pour les plateformes mobiles et la VR, où la faible latence est essentielle. Les matériaux sont décrits via un graphe de nœuds et compilés en shaders HLSL.

Le post-traitement comprend Temporal Super Resolution (TSR) — l'algorithme d'upscaling propriétaire d'Unreal Engine qui offre une qualité 4K à partir d'un rendu 1080p. Selon Digital Foundry (2026), le TSR surpasse l'AMD FSR 2.0 de 15–20% en qualité à niveau de performance égal. La prise en charge supplémentaire inclut NVIDIA DLSS 3, AMD FSR 3.0 et Intel XeSS.

Gameplay Framework

Gameplay Framework est une hiérarchie de classes qui définit la structure du déroulement du jeu. Les classes de base incluent UGameInstance (session de jeu), UWorld (monde), APlayerController (contrôle du joueur) et APawn (personnage). Chaque classe possède un cycle de vie prédéfini avec des appels BeginPlay, Tick et EndPlay.

Le système de composants (UActorComponent) permet de construire des fonctionnalités à partir de blocs réutilisables. Le composant UCharacterMovementComponent gère le mouvement du personnage avec la gravité, les collisions et la réplication réseau. Remplacer un composant par un composant personnalisé permet de modifier le comportement sans hériter d'APawn.

Le Système de capacités (GameplayAbilities) fournit un framework pour les mécaniques RPG : sorts, buffs et effets avec réplication réseau automatique. Selon Epic Games (2025), le Système de capacités est utilisé dans 70% des projets RPG sur Unreal Engine.

Programmation dans Unreal Engine : C++ et Blueprints

C++ est le langage principal d'Unreal Engine : tout le moteur est écrit en C++17, et les développeurs peuvent modifier tout aspect de celui-ci. Le code utilise son propre système de réflexion (Unreal Reflection System) avec les marqueurs UPROPERTY et UFUNCTION pour l'intégration avec l'éditeur. Les classes héritent de UObject et prennent en charge la sérialisation, la réplication et l'édition via l'inspecteur.

Classe Actor en C++

Chaque objet dans le monde du jeu hérite de la classe AActor. Voici un exemple d'une classe de base qui déplace un objet le long de l'axe X :

// MovingActor.h
class AMovingActor : public AActor
{
    GENERATED_BODY()
    
public:
    AMovingActor();
    
    virtual void Tick(float DeltaTime) override;
    
    UPROPERTY(EditAnywhere, Category = "Movement")
    float Speed;
    
private:
    FVector StartLocation;
};

La propriété Speed avec le marqueur UPROPERTY(EditAnywhere) apparaît dans l'éditeur Unreal et est automatiquement sérialisée lors de la sauvegarde du niveau. La méthode Tick est appelée à chaque image avec un paramètre DeltaTime, garantissant l'indépendance par rapport à la fréquence d'images. C'est le modèle de base pour créer des objets interactifs dans le monde du jeu.

Blueprints — Programmation visuelle

Blueprints est un système de script visuel basé sur un graphe de nœuds. Chaque nœud représente un appel de fonction, une opération ou un événement. Les Blueprints sont compilés en code C++ natif lors de la compilation, offrant des performances proches du C++ pur. Les développeurs peuvent mélanger C++ et Blueprints en appelant des fonctions depuis le graphe visuel.

Voici un exemple de création d'un matériau dynamique en C++, qui est ensuite utilisé dans Blueprints :

// Création d'un matériau animé
UMaterialInstanceDynamic* DynMaterial =
    UMaterialInstanceDynamic::Create(BaseMaterial, this);
 
DynMaterial->SetScalarParameterValue(
    FName("GlowIntensity"), FMath::Sin(RunTime) * 0.5f + 0.5f
);

Ce code crée une instance de matériau dynamique et met à jour le paramètre GlowIntensity le long d'une onde sinusoïdale. Cette approche permet de créer des surfaces animées — des sources lumineuses pulsantes aux textures d'eau en mouvement — sans écrire de code shader. Les matériaux avec paramètres dynamiques sont automatiquement synchronisés avec l'éditeur.

Chargement asynchrone d'actifs

Unreal Engine utilise son propre pool de threads pour les tâches en arrière-plan. ASyncTask et FThreadSafeQueue assurent un transfert sécurisé des données entre les threads. Pour les opérations longues, le système FStreamableManager avec chargement asynchrone d'actifs et priorisation est utilisé.

// Chargement asynchrone de texture
TSoftObjectPtr<UTexture2D> TextureRef;
FStreamableManager &Streamable =
    UAssetManager::GetStreamableManager();
 
Streamable.RequestAsyncLoad(
    TextureRef.ToSoftObjectPath(),
    [this]() {
        UTexture2D* Tex = TextureRef.Get();
        ApplyTexture(Tex);
    }
);

La fonction lambda s'exécute dans le thread principal après la fin du chargement, éliminant les conditions de concurrence. Le système FStreamableManager prend en charge la priorisation des chargements et l'annulation des opérations via des descripteurs, ce qui est essentiel pour les projets open-world avec chargement de niveaux en streaming.

Outils de l'éditeur Unreal Engine

Unreal Editor est un environnement de développement intégré avec un ensemble complet d'outils pour créer des jeux sans écrire de code. L'éditeur comprend l'éditeur de niveaux pour le placement d'objets, l'éditeur de matériaux pour les shaders, l'éditeur d'animation pour l'animation squelettique et Sequencer pour les scènes cinématographiques. Toutes les modifications sont affichées en temps réel dans la fenêtre de la vue.

Éditeur de niveaux et paysages

L'éditeur de niveaux permet de placer des Actors sur la scène à l'aide de transformations. L'outil Landscape crée un terrain avec des pinceaux pour élever, abaisser et lisser. Les couches de texture sont prises en charge pour le mélange automatique de matériaux en fonction de la hauteur et de l'angle de la surface.

Le système Foliage remplit les niveaux de végétation grâce à un placement procédural. Chaque instance d'herbe, d'arbre ou de roche est tournée et mise à l'échelle de manière aléatoire pour un aspect naturel. Selon Epic Games (2025), le système procédural Foliage prend en charge jusqu'à 1 million d'instances par niveau sans perte de performances.

Sequencer et Control Rig

Sequencer est un éditeur non linéaire pour créer des cinématiques et des bandes-annonces dans le jeu, fonctionnant sur un principe de pistes. Chaque piste contrôle un paramètre : position de la caméra, animation du personnage, son ou effets. L'enregistrement se fait directement dans la fenêtre de la vue en temps réel.

Control Rig permet d'animer des squelettes directement dans l'éditeur sans exportation depuis Maya ou Blender. Les animateurs créent des animations procédurales via un graphe visuel de nœuds. Selon Epic Games (2026), Control Rig est utilisé dans 60% des projets cinématographiques sur Unreal Engine et prend en charge la cinématique inverse.

Niagara VFX

Niagara est un système VFX de nouvelle génération qui a remplacé Cascade. Il prend en charge les particules GPU, les événements de collision et la génération procédurale. Chaque effet est composé d'émetteurs, de modules et de paramètres combinés dans un graphe. Niagara permet de créer des systèmes météorologiques, des effets magiques et des explosions avec des millions de particules.

Le système Niagara utilise des interfaces de données pour interagir avec la physique et le paysage. Les particules peuvent répondre aux collisions avec la géométrie Nanite et capturer les flux d'air de l'éclairage Lumen. Selon Epic Games (2025), les performances de Niagara sur GPU sont 5–10 fois supérieures à celles de Cascade sur CPU.

Technologies de rendu d'Unreal Engine

Unreal Engine 5 a introduit deux technologies fondamentales : Nanite pour la géométrie et Lumen pour l'éclairage. Elles ont éliminé les compromis traditionnels entre qualité et performances. Nanite permet d'utiliser des actifs sources de qualité cinématographique sans optimisation manuelle des LOD.

Géométrie virtuelle Nanite

Nanite est un système de géométrie virtuelle qui rend des milliards de polygones en temps réel via une rastérisation logicielle et un LOD basé sur des clusters. Contrairement aux approches traditionnelles, Nanite rejette les pixels invisibles au niveau micro, ne rendant que les détails visibles avec une précision sous-pixellique.

Selon Epic Games (2025), Nanite offre une multiplication par 10 à 100 du détail géométrique par rapport à UE4 à performances égales. La technologie prend en charge l'importation directe de modèles ZBrush et les optimise automatiquement pour le rendu en temps réel. La limitation est l'absence de prise en charge des masques transparents et des décalcomanies.

Lumen Global Illumination

Lumen est un système d'éclairage global dynamique qui répond aux changements de sources lumineuses en temps réel. Il utilise le ray tracing dans les Signed Distance Fields pour calculer l'éclairage indirect. Lumen prend en charge les réflexions, la lumière diffuse et l'interaction des couleurs entre les objets.

Les performances de Lumen permettent son utilisation sur les consoles de la génération actuelle à 30–60 FPS. Selon Digital Foundry (2026), Lumen offre une qualité d'éclairage comparable au rendu hors ligne Mental Ray. Sur les PC équipés de RTX 4070 et supérieures, le ray tracing accéléré par matériel est disponible pour une qualité améliorée.

Temporal Super Resolution

Temporal Super Resolution (TSR) est l'algorithme d'upscaling propriétaire d'Unreal Engine qui utilise les informations des images précédentes pour reconstruire la haute résolution. Le TSR fonctionne sur tout GPU prenant en charge Shader Model 5, sans cœurs Tensor NVIDIA dédiés.

De plus, Unreal Engine 5 prend en charge NVIDIA DLSS 3, AMD FSR 3.0 et Intel XeSS. Selon Epic Games (2026), la combinaison du TSR avec l'upscaling basé sur le ML offre un gain de performances allant jusqu'à 2,5x tout en maintenant une qualité proche du 4K natif. Toutes les technologies sont intégrées via un système de rendu unifié.