🔧 Custom Engine – Architecture, Motifs & Trade-offs

Un Moteur Personnalisé (Custom Engine) est un moteur de jeu (ou de rendu) développé en interne (in-house) par un studio, par opposition à l'achat (ou la location) d'une licence pour un moteur "sur étagère" (Off-the-shelf) comme Unity ou Unreal.

Le "cœur" (le main()) de tout moteur de jeu est une boucle while(true) infinie, appelée la Game Loop.

while (game_is_running)
{
    // (L'ordre est important)
    // 1. Lire les Entrées (Input)
    process_input();
    
    // 2. Mettre à jour la Logique
    update_game_logic();
    
    // 3. Rendu (Dessiner)
    render_graphics();
}
// Problème : 'update_game_logic()' (ex: Mouvement)
// s'exécute à la vitesse du Rendu.
// PC Rapide (500 FPS) -> Jeu 8x plus rapide
// PC Lent (60 FPS) -> Jeu normal

double last_time = get_time();

while (game_is_running)
{
    // 1. Calculer le DeltaTime
    double current_time = get_time();
    double delta_time = current_time - last_time; // (ex: 0.016s pour 60FPS)
    last_time = current_time;

    process_input();
    
    // 2. Passer le DeltaTime à la logique
    update_game_logic(delta_time);
    
    render_graphics();
}

// (Dans update_game_logic)
// vitesse_constante = 10 (mètres/sec)
position += vitesse_constante * delta_time;
// (PC Rapide) : 10 * 0.002s = 0.02m (x 500 = 10m/s)
// (PC Lent)   : 10 * 0.016s = 0.16m (x 60  = ~10m/s)

// (Logique 'FixedUpdate' (Unity)
//  ou '_physics_process' (Godot))

const double PHYSICS_TICK = 1.0 / 60.0; // 60 FPS
double accumulator = 0.0;

while (game_is_running)
{
    double delta_time = ...;
    accumulator += delta_time;
    
    process_input();
    
    // 1. Boucle Physique (Fixed)
    // (S'exécute 0, 1, or N fois par frame)
    while (accumulator >= PHYSICS_TICK)
    {
        update_physics_logic(PHYSICS_TICK);
        accumulator -= PHYSICS_TICK;
    }
    
    // 2. Boucle Logique (Variable)
    update_game_logic(delta_time);
    
    // 3. Rendu
    render_graphics();
}

Un moteur est un ensemble de sous-systèmes (Managers) qui doivent communiquer.

// (Accès facile)
g_Renderer->Draw(...);
g_Audio->PlaySound(...);

Philosophie : L'Héritage (Inheritance) (Programmation Orientée Objet - POO). C'est le modèle "classique", utilisé par Unreal Engine.

Le Modèle "Actor"

L'objet de base est l'Actor (AActor). Un Actor est "lourd" (il sait gérer le réseau, le "tick", la physique...).

Les fonctionnalités sont créées en héritant (extends) et en spécialisant.

Exemple (Hiérarchie de Classes)

class Actor (Objet de base)
  │
  └─ class Pawn (Peut être "possédé" par un Controller)
     │
     └─ class Character (Un Pawn "humanoïde")
        │ (Possède un Mesh, un Mouvement...)
        │
        └─ class MyPlayerCharacter (Mon C++ pour le Joueur)
           │
           └─ class BP_Player (Blueprint qui hérite de C++)

• Avantage : Très puissant, logique "verticale" claire.
• Inconvénient : Rigide. (Que faire si un objet doit hériter de Voiture ET de Arme ? (Héritage multiple impossible)).

Philosophie : La Composition (Composition over Inheritance). C'est le modèle utilisé par Unity et (plus récemment) CryEngine/O3DE.

Le Modèle "Composant"

L'objet de base est l'Entité (GameObject / Entity). C'est une "coquille" vide, un simple ID avec un Transform.

L'Entité "devient" un joueur en lui attachant (composant) des briques de fonctionnalités (Components).

Exemple (Composition)

Entité: "Joueur"
  ├ Component: Transform
  ├ Component: Mesh (Visuel)
  ├ Component: Rigidbody (Physique)
  ├ Component: Health (Script)
  └ Component: PlayerInput (Script)

Entité: "Tourelle"
  ├ Component: Transform
  ├ Component: Mesh
  ├ Component: Health (Script) (Réutilisation !)
  └ Component: AI_Turret (Script)

• Avantage : Extrêmement flexible et réutilisable. (Permet un "Héritage multiple" via composition).
• Inconvénient : Peut devenir complexe (communication inter-composants : "GetComponent").

Le DOD (Data-Oriented Design) est une philosophie de performance (utilisée par DOTS/ECS d'Unity) qui se concentre sur l'efficacité du Cache CPU (L1/L2).

Le Problème (POO/ECS Classique)

Un ECS classique (Composition) stocke les données de manière "Array of Structures" (AoS) :

[Joueur 1 (Pos, Vit, PV)] [Joueur 2 (Pos, Vit, PV)] ...

Si le "MouvementSystem" (logique) veut juste mettre à jour 1000 Positions, il doit "sauter" en mémoire (RAM) par-dessus les (inutiles) "Vit" et "PV", causant des "Cache Misses" (très lents).

La Solution (DOD - SoA)

Le DOD (ou ECS "pur") stocke les données en "Structure of Arrays" (SoA).

(Array 'Positions') : [Pos 1] [Pos 2] [Pos 3] ...
(Array 'Vitesses') : [Vit 1] [Vit 2] [Vit 3] ...
(Array 'PVs')      : [PV 1] [PV 2] [PV 3] ...

Flux (MouvementSystem) :

1. Le "MouvementSystem" (Logique) demande les "Arrays" (Positions, Vitesses).
2. Il boucle (FOR) sur ces deux arrays (contigus en mémoire).
3. Résultat : Zéro "Cache Miss". C'est extrêmement rapide (idéal pour le C# Job System (Unity) ou le parallélisme).

Studio : Rockstar Games.

Jeux : GTA IV, GTA V, Red Dead Redemption (1 & 2), Max Payne 3.

Objectif (Pourquoi "Build" ?)

RAGE a été développé (basé sur l'ancien moteur "Angel") spécifiquement pour une tâche : gérer des Mondes Ouverts (Open World) massifs, denses, et dynamiques, avec un streaming (chargement) "seamless" (sans couture) à haute vitesse (véhicules).

Systèmes Clés

• Streaming (Monde Ouvert) : Le point fort. Gère le "streaming" (chargement/déchargement) de la géométrie, des textures, et de la logique (IA) dans un rayon (ex: 2km) autour du joueur (véhicule).
• Moteur Physique : (A utilisé "Euphoria" (acheté) pour l'IA procédurale (Ragdolls dynamiques) et "Bullet" (open source) pour la physique générale).
• Scripting : Utilise massivement C++ (cœur) et un langage de script propriétaire (C-like).

Studio : DICE (pour Electronic Arts - EA).

Jeux : Série Battlefield, Mirror's Edge, Dragon Age: Inquisition, FIFA (depuis 2017).

Objectif (Pourquoi "Build" ?)

Conçu pour les FPS (First-Person Shooters) à grande échelle.

Systèmes Clés

• Destruction : (Le point fort) Célèbre pour son système de "Destruction" (Micro-destruction (murs) et Macro-destruction ("Levolution")).
• Audio (HDR Audio) : (Point fort) Un moteur audio très avancé pour gérer le "chaos" (centaines d'effets sonores) d'un champ de bataille.
• Rendu : (PBR) Très performant pour les grandes cartes (64-128 joueurs).

Le "Problème" Frostbite : EA a (dans les années 2010) forcé tous ses studios (BioWare (RPG), Visceral (Horreur)) à abandonner leurs moteurs (ex: Eclipse) et à utiliser Frostbite (un moteur de FPS). Cela a causé des difficultés de développement (ex: Dragon Age, Mass Effect: Andromeda) car l'outil n'était pas conçu pour les RPGs (sauvegardes, inventaires...).

Studio : Guerilla Games (Sony Interactive Entertainment).

Jeux : Horizon Zero Dawn, Horizon Forbidden West, Death Stranding (Kojima Productions).

Objectif (Pourquoi "Build" ?)

Un moteur "AAA" moderne conçu pour la PlayStation (PS4/PS5), optimisé pour les mondes ouverts (Open World) avec une très haute fidélité graphique (Rendu/Assets).

Systèmes Clés

• Rendu : (Point fort) Rendu PBR (physique) de très haute qualité (notamment les matériaux "durs" et la végétation).
• Outils (Monde) : Outils de génération procédurale pour les mondes ouverts.
• Partage : (Unique) Moteur interne de Sony, mais "partagé" (donné) à d'autres studios "amis" (ex: Kojima Productions pour Death Stranding).