Unreal-Rust expose le moteur de rendu d'Unreal à Rust via une interface de fonction étrangère en C,
le C++ aurait un gros défaut dans Unreal qui serait mieux géré avec Rust

Rust est un langage de programmation affectionné pour ses qualités en mémoire, notamment la sécurité mémoire. Alors que beaucoup se demande si le langage ne va pas ravir la vedette aux langages plus anciens tels C et C++, Maik Klein, Ingénieur logiciel chez Embark Studios et programmeur Rust semble donner plus de crédit à ce questionnement en annonçant Unreal-Rust qui permet d’explorer la possibilité d’écrire un jeu en Rust en utilisant Unreal comme moteur de rendu.

Rust est un langage de programmation compilé multiparadigme, conçu par Graydon Hore alors employé chez Mozilla Research, avec la contribution du créateur de JavaScript Brendan Eich. Utilisé par plusieurs grandes entreprises et par de nombreux développeurs dans le monde, Rust est devenu le langage de base pour certaines des fonctionnalités fondamentales du navigateur Firefox et de son moteur Gecko, ainsi que pour le moteur Servo de Mozilla.

Nom : Good.jpg
Affichages : 2208
Taille : 52,0 Ko

Avec Rust, il est possible de développer des pilotes de périphériques, des systèmes embarqués, des systèmes d'exploitation, des jeux, des applications web, et bien d'autres choses encore. Des centaines d'entreprises dans le monde entier utilisent Rust en production pour des solutions multiplateformes et économes en ressources. Des logiciels connus et appréciés, comme Firefox, Dropbox, et Cloudflare, utilisent ce langage. De la startup à la multinationale, du système embarqué au service web à haute disponibilité, Rust est une excellente solution.

Si certains programmeurs préfèrent utiliser les langages de programmation qui on fait des preuves tels C ou encore C++, ce n’est pas le cas de Maik Klein, programmeur Rust, qui veut bien developper un jeu en Rust en utilisant le moteur Unreal.

Rendu à sa version 5, Unreal Engine est un moteur de jeu vidéo propriétaire développé par Epic Games. Il permet d’effectuer des créations 3D en temps réel, de donner vie à des expériences étonnantes en temps réel.

« L'attente est terminée : nous sommes très heureux d'annoncer qu'Unreal Engine 5 est désormais disponible. Avec cette version, nous voulons permettre aux petites et grandes équipes de repousser les limites du possible, visuellement et interactivement. Unreal Engine 5 (UE5) vous permettra de réaliser des contenus et des expériences 3D en temps réel de nouvelle génération avec plus de liberté, de fidélité et de flexibilité que jamais auparavant », a déclaré l’équipe de développement.

Peut-on écrire un jeu en Rust en utilisant Unreal ?

Rust via C ffi

Si développer un jeu en Rust est possible, le faire en utilisant le moteur de rendu Unreal peut présenter quelques challenges. Alors on serait en droit de se demander s’il est possible d’écrire un jeu en Rust en utilisant Unreal ? Oui en utilisant le concept d’interface de fonction étrangère, c’est-à-dire exposé des fonctions C ou tout simplement appeler des routines ou utiliser des services écrits en C (Rust via C ffi). Ce qui serait toutefois très fastidieux selon Maik Klein.

« Après une semaine, j'ai exposé quelques fonctions qui me permettaient d'obtenir des entrées, de définir et de récupérer la position d'un acteur. Avec cela, je pouvais enfin déplacer un personnage dans Unreal. J'ai étudié comment Unreal gère les animations. Dans cet exemple, le personnage est déjà truqué et possède des animations. Ces animations sont pilotées par un AnimationBlueprint. Tout ce que j'avais à faire était d'indiquer la vélocité à laquelle le personnage court, et l'AnimationBlueprint s'occuperait du reste. »

Nom : 1-1B.png
Affichages : 1187
Taille : 333,7 Ko

Maik Klein réussis à faire marcher son personnage en exposant une fonction ffi GetRustVelocity, fonction qui lui permet de déplacer un personnage avec Rust dans Unreal et unreal-rust est né.

unreal-rust

Unreal-rust permet d'écrire des jeux avec Unreal Engine en Rust. C’est une intégration Rust pour Unreal. Rust se soucie de la propriété, de la mutabilité et des durées de vie. « Mapper les concepts d'Unreal à Rust 1 à 1 ne ferait que causer un mal de tête ». Au lieu de cela, unreal-rust sera écrit sur le AActor d'Unreal et exposera son API d'une manière conviviale pour Rust.

Le premier grand changement est qu'unreal-rust utilisera un Entity Component System (ECS). Pour unreal-rust, Maik Klein utilise bevy au lieu de développer son propre système. « Je ne suis qu'un seul développeur et je dois choisir mes batailles. Écrire et maintenir un ECS me distrairait du travail réel. Les gens de bevy ont fait un travail formidable pour rendre l'ECS convivial », déclare-t-il.

Toute la logique des applications dans Bevy utilise le paradigme Entity Component System. L'ECS est un modèle logiciel qui consiste à décomposer un programme en entités, composants et systèmes. Les entités sont des « objets » uniques auxquels sont attribués des groupes de composants, qui sont ensuite traités à l'aide de systèmes.

Par exemple, une entité peut avoir un composant Position et Vélocité, tandis qu'une autre entité peut avoir un composant Position et IU. Les systèmes sont des logiques qui s'exécutent sur un ensemble spécifique de types de composants. Vous pouvez avoir un système de mouvement qui s'exécute sur toutes les entités ayant un composant Position et Vélocité. Le modèle ECS encourage les conceptions propres et découplées en obligeant à décomposer les données et la logique de l’application en composants essentiels. Il contribue également à rendre le code plus rapide en optimisant les modèles d'accès à la mémoire et en facilitant le parallélisme.

A la lecture des écrits de Maik Klein, programmeur Rust, pour intégrer profondément Rust dans Unreal il est possible d’ajouter des composants Rust à AActor dans l'éditeur. Par exemple, il est possible d’ajouter un CharacterConfigComponent au PlayerActor, auquel il sera ensuite possible d’accéder depuis Rust. Cela permet de configurer le personnage depuis Unreal sans avoir besoin de toucher au code. De plus, il est possible d’accéder aux composants Rust depuis le Blueprint. Cela permet de piloter des blueprints d'animation ou de passer des données dans l’interface utilisateur.

Blueprint est le système de script visuel d'Unreal et il est fortement utilisé dans le moteur. Il permet de piloter les animations, les matériaux, les particules, le son, le gameplay. « Il est important que unreal-rust puisse être utilisé dans Blueprint aussi », indique Maik Klein. « J'ai ajouté un nouveau noeud appelé GetComponent(Rust), qui donne accès à tous les composants Rust. » Toutefois, Rust communique avec Unreal toujours par le biais de C FFI.

Pour rendre les composants visibles dans l'éditeur/blueprint, tout ce que reste à faire est d'ajouter le dérivé de composant, lui donner un UUID/GUID unique (que l’éditeur peut générer) et l'enregistrer avec register_components. Pour qu’il apparaisse dans l'éditeur, il faut simplement le marquer avec #[reflect(editor)].

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#[derive(Debug, Component)]
#[uuid = "16ca6de6-7a30-412d-8bef-4ee96e18a101"]
#[reflect(editor)]
pub struct CharacterConfigComponent {
    pub max_movement_speed: f32,
    pub gravity_dir: Vec3,
    pub gravity_strength: f32,
    pub max_walkable_slope: f32,
    pub step_size: f32,
    pub walk_offset: f32,
    pub jump_velocity: f32,
    pub max_gliding_downwards_speed: f32,
    pub gliding_gravity_scale: f32,
    pub ground_offset: f32,
}
 
...
 
impl Plugin for MovementPlugin {
    fn build(&self, module: &mut Module) {
        register_components! {
            CharacterConfigComponent,
            => module
        };
    }
}

Le composant devrait être immédiatement visible dans l'éditeur et on pourra l'ajouter à n'importe quel acteur de notre choix. Pour l'instant, malheureusement, il ne supporte que quelques types primitifs comme Vec3, Quat, f32, bool, et quelques actifs comme UClass et USound. Maik Klein dit avoir l'intention de l'étendre aux structures définies par l'utilisateur, aux hashmaps, aux tableaux, etc. et aussi d'ajouter des tiroirs personnalisés comme avoir un curseur pour un f32 au lieu d'une boîte de saisie.

Par la suite, il est possible d’ajouter n'importe quel composant à un acteur dans l'éditeur. Cela donne essentiellement un moyen d'avoir des prefabs. (Les préfabriqués sont un type spécial de composant qui permet de sauvegarder des GameObjects entièrement configurés dans le projet pour les réutiliser.) Il est possible de créer un PlayerActor, lui donner les composants de son choix, le configurer et lorsquil est placé dans un niveau bas, unreal-rust l'enregistrera automatiquement et ajoutera les composants à l'entité Rust réelle.

Expérimenter sans planter l'éditeur

À en croire Maik Klein, le C++ aurait un gros défaut dans Unreal. « Vous pouvez facilement faire planter l'éditeur, soit en déclenchant un assert, soit en accédant à un nullptr. Cela rend assez difficile l'expérimentation avec le moteur, surtout si vous êtes nouveau. » Dans Rust cependant, les crashes sont bien définis et peuvent être détectés. Cela signifie que si vous déballez une Option::None ou faites un accès hors limites, unreal-rust va simplement détecter la défaillance, quitter le mode de jeu et enregistrer l'erreur dans la console. Il ne plantera jamais l'éditeur.

La comparaison entre Rust et C++ reste un sujet d'actualité. Du point de vue technique, les deux langages partagent de nombreuses similitudes dans leur syntaxe. Cependant, Rust et C++ présentent des différences significatives. Pour certains analystes, le C++ possède des bases plus solides en ce qui concerne la communauté et les informations générales sur ses principes. En outre, par rapport au C++, Rust est un nouveau venu dans le monde de la programmation, et de nombreux développeurs hésitent à s'y intéresser. Toutefois, les grands projets de l'industrie ont commencé à l'adopter ces dernières années.

Pour Guido van Rossum, créateur de Python, Rust est un « excellent » langage de programmation qui mérite tout l'enthousiasme à son égard. « Cela semble être un langage génial – pour certaines choses. Rust améliore vraiment C++ dans un domaine particulier – il est beaucoup plus difficile de contourner les contrôles du compilateur. Et bien sûr, il corrige le problème de l'allocation de mémoire d'une manière presque parfaite. Si vous écriviez la même chose en C++, vous ne pourriez pas être aussi sûr, par rapport à Rust, que vous avez obtenu toute votre allocation de mémoire et votre gestion de la mémoire correctement. Rust est donc un langage intéressant », a-t-il déclaré.



Source : Maik Klein's blog

Et vous ?

Quel est votre avis sur le sujet ?

Pensez-vous comme Maik Klein que le C++ a un gros défaut dans Unreal et que Rust serait la solution ?

Voir aussi :

Unreal Engine 5 est disponible, elle améliore l'interface utilisateur et le flux de travail de l'éditeur, apporte un ensemble d'outils pour la modélisation de maillage, l'édition d'UV et le baking

Microsoft, Google, AWS, Huawei et Mozilla s'associent pour créer la Fondation Rust, une organisation à but non lucratif chargée de gérer le langage de programmation

Le créateur de Python, Guido van Rossum, dit ce qu'il pense de Rust, Go, Julia et TypeScript et relève des similitudes entre ces langages et Python