in

C++ dans Unreal Engine : architecture, gestion mémoire et bonnes pratiques 

Illustration d'une station de développement de jeux vidéo

Le développement de jeux modernes exige une gestion stricte des ressources et du temps de calcul. Les moteurs temps réel doivent garantir une cadence stable sur des architectures très variées. Pour répondre à ces contraintes industrielles, le C++ occupe une place centrale dans Unreal Engine. Ce langage constitue ainsi le socle technique majeur de nombreux systèmes d’Epic Games.

Toutefois, l’environnement d’Epic Games diffère sensiblement de la programmation C++ traditionnelle. Le moteur encadre le langage par une chaîne de compilation dédiée et une réflexion opt-in. Il propose aussi une gestion mémoire hybride, pensée pour le temps réel. Cet article détaille ces mécanismes, de la compilation à la réplication réseau.

Architecture du C++ dans Unreal Engine et standard C++20

Depuis la version 5.3, les modules du moteur Unreal Engine sont compilés par défaut en C++20. Cette évolution donne accès aux concepts, aux lambdas génériques et à la comparaison à trois voies. Epic Games restreint toutefois l’usage direct de la bibliothèque standard pour préserver le contrôle mémoire et la portabilité. Le moteur privilégie donc ses propres abstractions pour les plateformes prises en charge.

Par ailleurs, le moteur évite l’usage direct de la bibliothèque standard C++ dans son code interne et dans les interfaces de gameplay. Ce choix favorise la cohérence des interfaces et un contrôle plus fin de l’allocation mémoire, notamment grâce à des allocateurs comme FMallocBinned2. Enfin, Epic évite généralement les exceptions au profit de mécanismes de diagnostic tels que check et ensure.

Cette éviction n’est toutefois pas absolue lors de l’intégration de bibliothèques tierces. La bibliothèque standard n’est en effet pas bannie de l’architecture d’un projet Unreal. Les développeurs peuvent employer des conteneurs std:: dans des couches d’adaptation isolées. Ces types standards ne devraient cependant pas être exposés dans les interfaces Unreal-facing du moteur.

Chaîne de compilation : Unreal Build Tool et Unreal Header Tool

La compilation d’un projet ne repose pas sur des solutions classiques, mais sur Unreal Build Tool (UBT). Développé en C#, cet outil orchestre la construction du code à partir de scripts de configuration dédiés. Ces fichiers, dotés des extensions .Build.cs et .Target.cs, structurent précisément l’architecture du jeu. Chaque module y déclare explicitement ses dépendances publiques et privées.

Établi depuis Unreal Engine 4.15, le modèle Include What You Use est pris en charge par UBT. Ce principe demande aux fichiers sources du moteur de n’inclure que les dépendances nécessaires. Ce découpage rigoureux réduit les dépendances transitives, même si des PCH restent utilisés et forcés par UBT. Il favorise par conséquent de meilleures compilations incrémentielles.

Avant d’invoquer MSVC ou Clang, UBT déclenche Unreal Header Tool (UHT), un composant du système de build d’Unreal. Cet outil analyse les en-têtes contenant les macros de réflexion du moteur. Il génère ensuite automatiquement des fichiers C++ tels que .generated.h et .gen.cpp. Le compilateur natif assemble enfin le code écrit et le code généré en bibliothèques finales.

Image illustrant un éditeur Unreal Engine sur PC

Système de réflexion et macros fondamentales

Epic Games désactive généralement le RTTI natif dans ses modules principaux, afin de limiter son empreinte mémoire. Le moteur déploie à la place son propre système de réflexion pour l’introspection à l’exécution. Cette couche inspecte dynamiquement la hiérarchie des classes, leurs propriétés et leurs méthodes. La fonction modèle Cast effectue des conversions dynamiques sûres pour les UObject.

Pour inscrire un élément dans ce système, le développeur balise son code via des macros dédiées à UHT. UCLASS() déclare les classes dérivées d’UObject, tandis que USTRUCT() enregistre les structures reflétées. UPROPERTY() expose les variables et UFUNCTION() ouvre les méthodes au système de réflexion. Enfin, GENERATED_BODY() insère au sein de la classe l’infrastructure requise.

La réflexion pilote des fonctions clés : le panneau Détails, la sérialisation et les Blueprints. Ce mécanisme n’est toutefois pas automatique et exige une annotation explicite dans le code. Sans macro UPROPERTY() ou UFUNCTION(), toute variable ou méthode reste donc purement native. Elle conserve un comportement natif, mais reste invisible pour l’éditeur, la sauvegarde et le ramasse-miettes.

Gestion de la mémoire : Garbage Collector et pointeurs intelligents

Toute classe dérivée d’UObject, incluant acteurs et composants, relève du ramasse-miettes d’Unreal. Contrairement aux idées reçues, appeler Destroy() ne libère pas instantanément la mémoire allouée. L’objet passe d’abord en attente de destruction et IsValid() peut encore renvoyer true. La libération physique survient lors d’un cycle ultérieur, configuré par les paramètres du moteur.

Pour protéger un UObject actif, sa référence doit être déclarée avec la macro UPROPERTY(). À sa collecte, le moteur réinitialise ces pointeurs à nullptr, évitant tout pointeur pendouillant. Depuis Unreal Engine 5, TObjectPtr est recommandé à la place des pointeurs bruts lorsque possible. Enfin, TWeakObjectPtr permet d’observer un objet sans bloquer sa suppression en mémoire.

Les classes C++ pures étrangères à UObject échappent totalement au ramasse-miettes du moteur. Pour gérer ces allocations, Unreal offre TUniquePtr pour l’exclusivité et TWeakPtr pour l’observation. De leur côté, TSharedPtr et TSharedRef gèrent le comptage partagé selon le mode de thread-safety choisi. Encapsuler un UObject dans un TSharedPtr reste toutefois incompatible avec le système du moteur.

Image illustrant un développeur en train de coder

Conteneurs haute performance et chaînes de caractères en C++ Unreal Engine

Unreal Engine privilégie TArray plutôt que les conteneurs standard dans son code et ses interfaces. L’appel à Reserve() préalloue une capacité afin de réduire les réallocations coûteuses. Pour des recherches rapides par clé, le moteur offre aussi les conteneurs hachés TMap et TSet. Ces conteneurs étant des types valeurs, les passer par référence constante évite une copie complète.

Le moteur distingue trois classes de texte selon des besoins techniques précis. Mutable et construite notamment via la macro TEXT(), FString gère les manipulations mais peut allouer à chaque copie. Immuable, FName offre des comparaisons rapides et insensibles à la casse pour nommer les os et matériaux. Enfin, FText pilote le texte visible en intégrant les tables de traduction et le formatage culturel.

L’association entre ces conteneurs et la réflexion exige une vigilance particulière. Déclarer un TArray de TObjectPtr avec UPROPERTY() protège chaque acteur face au ramasse-miettes. À l’inverse, omettre cette macro rend le tableau invisible au système de réflexion et donc au ramasse-miettes. Les acteurs référencés risquent alors d’être supprimés en arrière-plan, laissant des pointeurs non suivis invalides.

Conventions de nommage et préfixes stricts du moteur

La lisibilité du code dans Unreal Engine repose sur plusieurs préfixes fixés par le standard d’Epic Games. La lettre A désigne les classes dérivées d’AActor et U identifie les autres héritiers d’UObject. Le préfixe F s’applique quant à lui à la plupart des autres classes, dont les USTRUCT. Cette convention aide ainsi à identifier rapidement la nature générale de chaque type déclaré.

Trois lettres complètent ce cadre : E pour les énumérations, I pour les interfaces et T pour les modèles. Loin d’être esthétiques, les préfixes A, U, F, E et I guident l’analyse d’Unreal Header Tool pour les types concernés. Oublier ou inverser l’un d’eux sur un type décoré peut provoquer une erreur de compilation. En revanche, le T reste surtout conventionnel, car UHT ne traite pas tous les modèles génériques.

Le standard d’Epic impose aussi des règles typographiques strictes à tous les identifiants. Les noms de classes, de méthodes et de variables s’écrivent ainsi en PascalCase, à l’exception du préfixe b des booléens. Cette norme déconseille généralement l’usage du caractère souligné (_). Enfin, chaque variable booléenne doit débuter par la minuscule b, comme bIsGrounded ou bCanJump.

Anatomie complète d’une classe AActor de gameplay

Un fichier d’en-tête débute généralement par CoreMinimal.h pour charger les types de base courants du moteur. À l’inverse, l’inclusion .generated.h doit clore la liste pour que le code compile correctement. La classe intègre aussi une macro comme MONJEU_API pour exporter ses symboles entre modules. Enfin, UPROPERTY et UFUNCTION structurent ses membres.

Dans le fichier source, le constructeur sert principalement à fixer les valeurs par défaut des propriétés. Il permet aussi de créer les sous-objets par défaut via la fonction CreateDefaultSubobject. Il faut toutefois y éviter toute logique liée au monde de jeu. En effet, le moteur l’exécute lors de la création du Class Default Object.

L’initialisation liée à la partie prend donc place dans la méthode virtuelle BeginPlay(). Celle-ci s’exécute lorsque l’acteur entre dans un état jouable. Pour une mise à jour continue, la méthode Tick() est appelée à chaque image si le ticking est activé. Je conseille toutefois de désactiver bCanEverTick lorsque le ticking n’est pas nécessaire.

Arbitrage technique entre C++ Unreal Engine et Blueprints

Un projet Unreal performant combine C++ et Blueprints plutôt que d’imposer un choix exclusif. Le C++ convient particulièrement aux calculs lourds, aux données massives, à l’IA, à la sauvegarde et au réseau. À l’inverse, les Blueprints accélèrent l’assemblage visuel, la logique audio et les interfaces UMG. Ils excellent aussi pour créer les graphes d’animation et prototyper les mécaniques de jeu.

Contrairement aux idées reçues, les Blueprints ne sont pas systématiquement lents à l’exécution. Chaque nœud d’un graphe peut appeler une fonction déjà compilée en C++ natif. Le surcoût provient notamment de la machine virtuelle qui gère le passage entre ces nœuds. Négligeable sur un événement ponctuel, une boucle complexe à chaque image dégrade vite la fluidité.

Epic Games recommande ainsi une architecture hybride fondée sur l’héritage de classes. Le programmeur conçoit une base solide en C++ exposant les paramètres clés via UPROPERTY(). Les événements principaux sont ensuite ouverts aux scripts grâce à BlueprintImplementableEvent. Le concepteur crée enfin un Blueprint enfant pour régler l’équilibrage et associer les modèles 3D.

Optimisation, Live Coding et réplication réseau en C++ Unreal Engine

Sous Unreal Engine 5, Live Coding privilégie Hot Reload pour injecter du C++ à chaud via Ctrl + Alt + F11. Cet outil fonctionne idéalement pour modifier le corps d’une fonction au sein d’un fichier .cpp. À l’inverse, modifier la réflexion dans un .h via UPROPERTY ou une classe n’est pas pris en charge. Il faut alors lancer une compilation complète, parfois après avoir fermé l’éditeur.

Le réseau d’Unreal repose sur une architecture client-serveur autoritaire s’appuyant sur la réflexion. Le serveur détient l’état réel du jeu et synchronise les clients grâce aux propriétés marquées Replicated. Chaque variable concernée est enregistrée dans GetLifetimeReplicatedProps via DOREPLIFETIME. Pour les actions distantes, le moteur utilise des RPC déclarés avec Server, Client ou NetMulticast.

Optimiser du code C++ sans mesure préalable complexifie souvent inutilement l’architecture du projet. Epic fournit donc Unreal Insights, un profileur traçant les événements et plages d’exécution. La macro TRACE_CPUPROFILER_EVENT_SCOPE affiche ainsi le coût mesuré d’une portée de code. Cette rigueur isole les vrais goulots d’étranglement et met le C++ au service de la fluidité.

Restez à la pointe de l'information avec REALITE-VIRTUELLE.COM !

▶ Abonnez-vous à notre chaîne YouTube et Ajoutez-nous à vos favoris sur Google Actualités
Cliquez pour commenter

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *