Unity : bases, architecture et développement en C#

Qu’est-ce qu’Unity ?

Unity est un environnement de développement de jeux et d’applications en temps réel créé par Unity Technologies en 2005. Le moteur prend en charge 27 plateformes, notamment iOS, Android, Windows, macOS, PlayStation, Xbox, Nintendo Switch et WebGL. Selon le rapport Unity Gaming Report (2024), plus de 3 milliards de jeux mobiles ont été lancés mensuellement sur Unity en 2023.

La principale caractéristique d’Unity est son architecture orientée composants. Chaque objet dans la scène est un conteneur vide (GameObject) auquel sont ajoutés des composants définissant son comportement : rendu, physique, son, animation et logique personnalisée. Cela distingue Unity des moteurs hiérarchiques comme Unreal Engine, où le comportement est défini par héritage de classes.

Selon Statista (2025), Unity détient 48 % du marché des moteurs de jeu pour mobiles, devançant Unreal Engine (15 %) et les solutions propriétaires (37 %). Les studios indépendants choisissent le moteur pour sa faible barrière à l’entrée et les grands éditeurs pour la flexibilité de son pipeline de compilation pour différentes plateformes.

Architecture d’Unity : scènes, objets et composants

L’architecture d’Unity repose sur quatre concepts fondamentaux : les scènes, les GameObjects, les composants et les prefabs. Comprendre cette hiérarchie est nécessaire pour travailler efficacement avec le moteur.

Scènes et GameObjects

Une scène (Scene) est un conteneur qui renferme tous les objets d’un niveau de jeu ou d’un état d’application. Chaque scène possède son propre ensemble de GameObjects, sources lumineuses, caméras et sources audio. La transition entre les scènes s’effectue via SceneManager.LoadScene().

Un GameObject est l’élément de base d’Unity. Il n’a pas de représentation visuelle ni de comportement par défaut — c’est un nœud vide dans la hiérarchie de la scène. Tout le comportement et l’apparence sont ajoutés via des composants. Par exemple, pour rendre un GameObject visible, on ajoute MeshRenderer ; pour qu’il obéisse à la physique, on ajoute Rigidbody.

Composants MonoBehaviour

MonoBehaviour est la classe de base pour tous les scripts personnalisés dans Unity. Elle fournit un cycle de vie : Awake (appelé au chargement de l’objet), Start (avant la première image), Update (chaque image), FixedUpdate (chaque pas physique) et OnDestroy (à la destruction).

Chaque composant peut interagir avec d’autres composants sur le même GameObject via GetComponent<T>(). Cela permet de créer des systèmes modulaires : par exemple, un composant Health peut être indépendant d’un composant Movement, mais les deux peuvent réagir aux événements via UnityEvent.

Prefabs

Un prefab (Prefab) est un modèle de GameObject enregistré dans le projet en tant qu’asset. Les modifications apportées au prefab sont automatiquement appliquées à toutes ses instances dans les scènes. C’est le mécanisme central de réutilisation dans Unity, qui accélère les itérations et réduit les erreurs.

Les prefabs prennent en charge l’imbrication (Nested Prefabs) : un prefab peut contenir d’autres prefabs, formant une hiérarchie. Par exemple, un prefab de voiture peut contenir des prefabs de roue, de moteur et de carrosserie, chacun avec ses propres composants et paramètres.

Exemples de code C# dans Unity

Examinons un composant de mouvement de personnage de base en C#. Ce script déplace un objet vers l’avant par rapport à sa rotation actuelle et traite les entrées utilisateur.

using UnityEngine;

public class PlayerMovement : MonoBehaviour
{
    public float speed = 5f;

    void Update()
    {
        float move = Input.GetAxis("Vertical");
        Vector3 direction = transform.forward * move;
        CharacterController controller = GetComponent<CharacterController>();
        controller.SimpleMove(direction * speed);
    }
}

La méthode Update() est appelée chaque image. Input.GetAxis lit l’entrée verticale, SimpleMove applique le mouvement avec la physique. CharacterController est un composant intégré d’Unity qui gère les collisions sans avoir à écrire de physique de collision.

Exemple de script pour gérer les collisions et appliquer des dégâts :

using UnityEngine;

public class DamageHandler : MonoBehaviour
{
    public int health = 100;

    void OnCollisionEnter(Collision collision)
    {
        if (collision.gameObject.CompareTag("Enemy"))
        {
            health -= 10;
            if (health <= 0)
            {
                Destroy(gameObject);
            }
        }
    }
}

La méthode OnCollisionEnter est appelée par le moteur physique lorsqu’un GameObject entre en collision avec un autre objet. La comparaison d’étiquette (CompareTag) détermine avec quoi la collision a eu lieu. Cette approche permet de réutiliser le composant DamageHandler pour le joueur, les ennemis et les objets destructibles sans modifier le code.

Développement de jeux mobiles avec Unity

Unity fournit des outils spécialisés pour optimiser les jeux sur les appareils mobiles aux ressources limitées. Les domaines d’optimisation clés incluent la gestion de la mémoire, la réduction des draw calls et l’adaptation aux différentes résolutions d’écran.

Optimisation des performances

Pour les plateformes mobiles, Unity propose des Asset Bundles, un système de packaging de contenu qui charge les ressources à la demande, réduisant ainsi la taille initiale de l’application. C’est particulièrement important pour les jeux avec de nombreux niveaux ou personnages où le chargement de tous les assets à la fois est impossible en raison des limites des magasins d’applications.

Le Profileur Unity (Profiler) permet d’analyser l’utilisation du CPU, du GPU et de la mémoire sur un périphérique réel via ADB (Android) ou USB (iOS). Selon la Documentation Unity (2025), l’optimisation des draw calls à 100–300 sur les appareils mobiles offre 60 FPS stables sur les appareils de gamme moyenne.

Entrée tactile et interface utilisateur

Pour les jeux mobiles, Unity utilise le système Input System, qui abstrait les commandes tactiles, l’accéléromètre et le gyroscope sous une API unifiée. Les joysticks virtuels, les balayages et les tapotements sont configurés via les Input Action Assets sans avoir à écrire de code de gestion tactile.

Le système d’interface utilisateur d’Unity (uGUI) prend en charge Canvas Scaler pour l’adaptation automatique de l’interface aux différents rapports d’aspect de l’écran. Le composant Canvas Scaler en mode Scale With Screen Size garantit que les boutons ne sortent pas de l’écran sur les tablettes et les smartphones.

Compilation pour iOS et Android

La compilation des jeux mobiles dans Unity s’effectue via la fenêtre Build Settings. Android nécessite Android SDK et NDK ; Unity génère un projet Gradle qui compile en APK ou AAB. iOS nécessite Xcode : Unity crée un projet Xcode avec un wrapper Objective-C/Swift qui est finalement compilé via Apple.

IL2CPP est une option de compilation qui traduit le code C# en C++ puis en code ARM natif. Selon Unity Benchmark (2024), IL2CPP augmente les performances de 15à 25 % sur iOS et Android par rapport à Mono, mais augmente le temps de compilation et la taille du binaire.

Comparaison d’Unity avec d’autres moteurs

Unity est comparé à Unreal Engine et Godot comme les principales alternatives sur le marché des moteurs de jeu. Le choix dépend du type de projet, des compétences de l’équipe et des plateformes cibles.

Pour les jeux mobiles, Unity reste la norme de l’industrie grâce à son système de rendu flexible (URP — Universal Render Pipeline), qui optimise les graphismes pour les GPU mobiles à puissance limitée. L’URP réduit automatiquement le nombre de passes de rendu et regroupe les shaders pour diminuer la charge du GPU.

Unreal Engine 5 offre la meilleure qualité graphique (Nanite pour la géométrie, Lumen pour l’éclairage) mais nécessite un matériel plus puissant et une plus grande expérience de l’équipe. Godot attire par son code open source et sa petite taille, mais dispose de moins d’assets prêts à l’emploi et d’un marché de spécialistes plus restreint.

Unity pour les applications non ludiques

Unity est activement utilisé en dehors du développement de jeux — dans l’architecture, l’automobile, le commerce de détail et l’éducation. La visualisation en temps réel (RT3D) permet de créer des présentations 3D interactives, des simulateurs et des configurateurs de produits.

Dans l’industrie automobile, Unity est utilisé pour créer des jumeaux numériques de voitures et des systèmes HMI (Human-Machine Interface). Mercedes-Benz et BMW utilisent Unity pour prototyper les tableaux de bord et les systèmes multimédia avant la construction d’un prototype physique.

Dans le commerce de détail, Unity est appliqué aux configurateurs de produits : IKEA (placement virtuel de meubles), Nike (personnalisation de chaussures) et Audi (configurateur de voitures) — tous ces projets sont construits sur Unity. L’utilisateur peut changer les couleurs, les matériaux et les équipements en temps réel et voir le résultat en 3D.

Pour les projets non ludiques, Unity fournit des outils spécialisés : AR Foundation (pour ARKit et ARCore), Pixyz Plugin (pour l’importation de modèles CAO) et Unity Reflect (pour la synchronisation avec les modèles BIM de Revit). L’entreprise développe activement la direction Unity Industry, qui comprend des services cloud pour les clients entreprises.