🏞️ CryEngine – Moteur AAA (C++, Schematyc) & Rendu Photoréaliste

CryEngine est le "troisième" grand moteur AAA, bien que moins populaire que les deux géants.

C'est le point fort historique de CryEngine (depuis Far Cry). Le moteur excelle dans la création de vastes environnements extérieurs (Open Worlds).

Terrain Editor

Un outil intégré (Terrain > Edit Terrain) pour :

• Sculpter (Sculpting) : Modifier la hauteur (Heightmap) du terrain (élever, creuser, lisser).
• Peindre (Painting) : Appliquer des Layers (Couches) de matériaux (ex: Herbe, Roche, Sable) qui se mélangent (blend) en fonction de la hauteur ou de la pente.

Outil de Végétation

Un outil (Vegetation Painter) qui permet de "peindre" des assets (ex: arbres, buissons, rochers) sur le terrain, en respectant des règles (ex: "ne pas peindre sur les rochers", "varier la taille/rotation").

Track View est l'outil de cinématique (non-linéaire) de CryEngine. C'est l'équivalent du Sequencer (Unreal) ou de la Timeline (Unity).

Fonctionnement

Il permet de créer des "Séquences" (.seq) qui animent des objets et des propriétés via une Timeline (chronologie).

Usage :

• Cutscenes (Cinématiques) : Animer des caméras, des personnages (déclencher des animations), des lumières.
• Événements Scriptés : (ex: "Faire trembler la caméra (Keyframe), jouer un son (Keyframe), puis faire s'effondrer un pont (Keyframe)").

CryEngine (depuis v5) utilise une architecture ECS (Entity Component System), très similaire à celle d'Unity.

Entity (Entité)

L'Entité (IEntity) est l'objet de base (le "conteneur") dans la scène. (Équivalent : GameObject (Unity) / AActor (Unreal)).

Par défaut, une Entité est "vide" et ne possède qu'un Transform (Position, Rotation, Scale).

Elle obtient ses fonctionnalités (visuel, physique, logique) par l'ajout de Components (3.2).

Le Component (Composant) est la "brique" de fonctionnalité qui est attachée à une Entité.

Philosophie : Composition. (Au lieu d'hériter de "Joueur" qui hérite de "Physique", on prend une Entité "Joueur" et on lui *attache* un RigidbodyComponent et un PlayerInputComponent).

Types de Composants (Cœur)

• MeshComponent (Rendu 3D)
• LightComponent (Lumière)
• CameraComponent (Caméra)
• RigidbodyComponent (Physique Lourd)
• CharacterControllerComponent (Physique Joueur)
• AudioSourceComponent (Son)
• IEntityComponent (Base) : (Voir 3.3) La classe C++ dont vos scripts héritent.
• Schematyc Component : (Voir 4.2) Le composant qui exécute un script visuel Schematyc.

C'est l'équivalent du MonoBehaviour d'Unity. C'est la classe C++ de base pour votre "logique" (script) de gameplay.

// Fichier: PlayerComponent.h
#pragma once
#include 

class CPlayerComponent final : public IEntityComponent
{
public:
    // ...
    
    // Cycle de vie : (Équiv. Awake/Start)
    virtual void Initialize() override;
    
    // Cycle de vie : (Équiv. Update/FixedUpdate)
    // (Reçoit tous les événements de l'entité)
    virtual void ProcessEvent(SEntityEvent& event) override;
    
    // Rétro-compatibilité (Helper)
    virtual uint64 GetEventMask() const override {
        // (S'abonner à l'événement UPDATE)
        return BIT64(ENTITY_EVENT_UPDATE);
    }

protected:
    float m_speed = 5.0f;
    Vec3 m_moveDirection;
};

// Fichier: PlayerComponent.cpp
#include "PlayerComponent.h"
#include  // (Pour l'Input)

void CPlayerComponent::Initialize()
{
    // (Initialiser les composants, ex: Rigidbody)
    // (Abonnement aux inputs...)
}

void CPlayerComponent::ProcessEvent(SEntityEvent& event)
{
    // (Si événement = Update)
    if (event.event == ENTITY_EVENT_UPDATE)
    {
        // (Récupérer 'delta')
        const float deltaTime = event.fParam[0];
        
        // (Logique de jeu...)
        // (ex: m_moveDirection = ...)
        
        // Déplacer l'Entité (le Transform)
        GetEntity()->Move(m_moveDirection * m_speed * deltaTime);
    }
}

L'API C++ de CryEngine est vaste. La communication avec les "systèmes" (moteurs) globaux du moteur se fait (généralement) via le pointeur global gEnv (Global Environment).

// 'gEnv' est un pointeur global (Singleton) vers 'SSystemGlobalEnvironment'

// (Exemple : Obtenir le moteur de Rendu)
if (gEnv->pRenderer) { ... }

// (Exemple : Logger dans la console de l'éditeur)
gEnv->pLog->Log("Hello World");

// (Exemple : Obtenir le système de Physique)
gEnv->pPhysicalWorld->...

// (Exemple : Obtenir le système d'Input)
gEnv->pInput->...

SEntityEvent (Événements)

La fonction ProcessEvent (voir 3.3) reçoit des événements. Les plus importants :

• ENTITY_EVENT_UPDATE : (Le "Update" / Tick) Appelé à chaque frame.
• ENTITY_EVENT_START_GAME : (Le "BeginPlay" / Start) Appelé quand le jeu démarre.
• ENTITY_EVENT_RESET : (Mode Éditeur vs Jeu).

Schematyc (introduit en ~5.4) est le système de scripting visuel (nodal) de CryEngine. C'est le remplacement moderne de "Flow Graph".C'est l'équivalent direct des Blueprints (Unreal) ou du Visual Scripting (Unity).

Fonctionnement

Il permet aux designers (non-programmeurs) de créer une logique de gameplay (ex: "Ouvrir une porte si le joueur a la clé") en connectant des nœuds (nodes) dans une interface graphique (l'Éditeur Schematyc).

Interopérabilité (C++ & Schematyc)

Le workflow idéal (similaire à Unreal) est :

1. (C++) Le Programmeur : Crée les systèmes de base (performance) en C++.
2. (C++) Le Programmeur : Expose ces fonctions et propriétés à Schematyc (via des macros C++).
3. (Schematyc) Le Designer : Utilise ces nœuds (C++) personnalisés dans le graphe visuel pour créer la logique de jeu.

Lumen (UE5) et SVOGI (CryEngine) sont les deux technologies concurrentes pour l'Illumination Globale (GI) dynamique.

SVOGI (Sparse Voxel Octree Global Illumination)

C'est la solution "maison" de CryEngine pour le GI temps réel. Elle permet les "rebonds" (bounces) de lumière dynamiques.

Le Problème (Avant)

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 (SVOGI)

SVOGI 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.

Historiquement (depuis Far Cry 1), CryEngine a toujours été le leader incontesté pour le rendu photoréaliste des environnements extérieurs.

Végétation

L'outil de Végétation (Vegetation Tool) permet de "peindre" des millions d'instances d'arbres, d'herbes, et de buissons.

Points Clés : Rendu (shaders) de "subsurface scattering" (lumière passant à travers les feuilles) et animation (vent) très performants.

Eau (Océans & Rivières)

CryEngine est réputé pour sa simulation d'eau :

• Caustiques (Caustics) : Simulation des réflexions/réfractions de la lumière sous l'eau.
• Vagues (Waves) : Simulation de vagues d'océan (physique).

Le Material Editor (Éditeur de Matériaux) est l'éditeur nodal (visuel) de CryEngine pour créer des Shaders (programmes GPU), similaire à celui d'Unreal.

Matériau (Material)

Un Matériau (.mtl) est un Asset qui définit l'apparence d'une surface.

PBR (Physically Based Rendering)

CryEngine utilise un workflow PBR (Rendu Basé sur la Physique) (standard "Metallic/Roughness"). 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)).

CryEngine utilise son propre moteur physique intégré : CryPhysics.

(Contrairement à Unity (PhysX/Box2D) ou UE5 (Chaos)).

Fonctionnalités

• Rigid Bodies : Simulation d'objets dynamiques (caisses, débris).
• Ragdolls : Simulation physique des personnages (morts).
• Joints : Contraintes (charnières, ressorts).
• Véhicules : Moteur physique de véhicules (voitures, tanks).
• Destruction (Legacy) : (Crysis) Permettait la destruction (basique), mais a été moins développé que le "Chaos" d'Unreal.

CryEngine inclut un moteur audio intégré (CrySound).

Cependant, pour les productions AAA, il est conçu pour s'intégrer (via "Middleware Abstraction Layer" - MALA) aux deux standards de l'industrie :

• Wwise (Audiokinetic) : (Le standard de l'industrie AAA).
• FMOD (Firelight Technologies) : (Très populaire chez les Indies/AA).

Cela permet aux "Sound Designers" de travailler dans l'outil (Wwise/FMOD) qu'ils maîtrisent, tandis que le moteur (CryEngine) se contente de déclencher les événements audio.

CryEngine (historiquement) utilise un format d'asset "compilé" (similaire à un moteur de jeu "old-school").

Formats d'Assets

• .CGF (Crytek Geometry Format) : Un Mesh (maillage) statique.
• .SKD (Skinned Mesh) : Un Mesh "skinné" (avec squelette/armature) pour l'animation.
• .CDA (Character Definition) : Fichier qui assemble un squelette, des meshs, et des animations.
• .MTL (Material) : Le fichier Matériau (Shader + Textures).

Asset Processor (Resource Compiler)

Contrairement à Unity (qui lit .fbx / .png directement), CryEngine (traditionnellement) nécessitait un "Resource Compiler" (RC).

Flux : L'artiste (3ds Max/Maya) exporte (ex: .fbx). Le "RC" (Asset Processor) (qui tourne en fond) détecte le .fbx et le compile en un .CGF optimisé (que le moteur peut lire).

CryEngine possède une Marketplace (similaire à l'Asset Store d'Unity ou au Marketplace d'Unreal) accessible via le Launcher.

Comparaison : L'écosystème de CryEngine est beaucoup plus petit que celui de ses concurrents.

• La quantité d'assets (3D, scripts, outils) disponibles est très inférieure.
• La communauté (forums, tutoriels) est également plus restreinte.

C'est l'un des inconvénients majeurs pour les développeurs indépendants (Indies) qui dépendent de l'Asset Store.

• Far Cry (2004) (Le premier, qui a révélé le moteur)
• Série Crysis (2007-2013) (La vitrine technologique)
• Ryse: Son of Rome (2013)
• Evolve (2015)
• Prey (2017)
• Hunt: Showdown (2019) (Le succès récent de Crytek)
• Star Citizen (Utilisait un fork de CryEngine, avant de migrer vers Lumberyard/O3DE)

Amazon Lumberyard (Fork)

En 2015, Amazon a acheté une licence (très coûteuse) d'une ancienne version de CryEngine (CryEngine 3.8) et l'a "forkée" (dérivée) pour créer son propre moteur : Amazon Lumberyard.

Lumberyard était gratuit et profondément intégré à AWS (Twitch, GameLift...). (Ex: Star Citizen a migré de CryEngine vers Lumberyard).

O3DE (Open 3D Engine)

En 2021, Amazon a abandonné Lumberyard et a donné le code source à la Linux Foundation.

Ce fork (de Lumberyard, qui était un fork de CryEngine) a été renommé O3DE (Open 3D Engine) et est maintenant un moteur AAA 100% open-source (Apache 2.0) concurrent d'Unreal et Godot.