Passer au contenu

Psittacus

Optimisation des performances de jeu Flutter pour atteindre 60 FPS stables

Thème: Guides

Performances de jeu dans Flutter: maintenir 60 FPS sur mobile milieu de gamme

Comment maintenir 60 FPS stables dans un jeu Flutter sur mobile milieu de gamme: profilage DevTools, boucle de jeu Ticker, RepaintBoundary et atlas de sprites.

Écrit par Maksymilian JackowskiDéveloppeur principal de jeux

Publié le 16 min

Sur cette page

Un jeu mobile fonctionnant avec une grande fluidité sur un smartphone de développement haut de gamme peut masquer de sérieux défauts d’architecture. La réalité s’impose dès que ce même code est déployé sur un appareil milieu de gamme classique: les animations sautent des images au moindre effet de particules ou à chaque changement d’écran. Conserver une cadence d’affichage stable dans Flutter réclame une compréhension claire de la répartition des tâches entre les threads du moteur, de l’impact des reconstructions de widgets sur le pipeline de rendu et des méthodes de mesure fiables.

Chez Psittacus Studio, nous concevons des jeux de réflexion mobiles en pur Flutter. Notre premier projet, Polydocu, est une aventure centrée sur des grilles de sudoku. Même une grille 9x9 en apparence statique, enrichie de cases animées, d’indices interactifs, de compteurs et de transitions, peut épuiser le budget par image sur un processeur modeste si elle est conçue comme un simple formulaire d’application de gestion. Ce guide récapitule notre retour d’expérience pratique sur le profilage et l’optimisation pour tenir 60 FPS sur du matériel standard.

Le budget d’image: 16,6 millisecondes en pratique

Viser 60 images par seconde laisse exactement 16,6 millisecondes par image pour accomplir tous les calculs et restituer les pixels. Sur les écrans récents à 120 Hz, cette fenêtre se réduit à 8,3 millisecondes. Lorsque l’application dépasse ce délai, le contrôleur d’affichage réaffiche l’image précédente, ce que le joueur perçoit immédiatement sous la forme d’un à-coup désagréable (phénomène qualifié de jank).

Flutter structure la production des images autour de deux threads principaux:

  • Le thread UI. Il exécute le code Dart de l’application: gestion des gestes tactiles, calculs de la logique du jeu, construction des widgets, résolution de la disposition à l’écran et génération de l’arbre de calques (layer tree).
  • Le thread raster. Il réceptionne l’arbre de calques produit par le thread UI et convertit les ordres de tracé en instructions GPU exploitables via le moteur de rendu Skia ou Impeller.

D’après la documentation officielle sur les performances de Flutter, la lenteur du thread raster découle presque systématiquement d’instructions de dessin trop lourdes initiées côté Dart. La première étape de toute optimisation consiste donc à identifier quel thread sature son budget. Déplacer des calculs mathématiques dans un isolate distinct n’apportera aucun gain si le processeur graphique étouffe sous des effets de flou répétés.

+------------------------------------------------------------+
| Total Frame Window: 16.6 ms (at 60 Hz)                     |
+------------------------------+-----------------------------+
| UI Thread: Dart execution,   | Raster Thread: GPU commands |
| layout, widget construction  | and pixel rasterization     |
+------------------------------+-----------------------------+

Les deux threads travaillent de façon séquentielle pour chaque image. Si le thread UI utilise 11 ms pour la logique et les widgets et que le thread raster demande 9 ms pour la pixellisation, l’image nécessitera 20 ms et ratera l’échéance d’affichage, bien qu’aucun des deux threads n’ait individuellement excédé 16,6 ms.

Mettre en place un profilage rigoureux avec DevTools

Évaluer les performances d’un jeu en mode debug produit des diagnostics trompeurs. Le mode debug exécute des assertions régulières, intègre le mécanisme de Hot Reload et tourne avec une compilation JIT qui sacrifie sciemment la vitesse au profit du confort d’écriture du code.

Les mesures de référence doivent impérativement être relevées en mode profile sur un téléphone physique:

# Debug mode: unoptimized, useful only during feature implementation
flutter run

# Profile mode: compiled AOT, DevTools services enabled
flutter run --profile

Pour un contrôle visuel immédiat directement sur l’écran du mobile, Flutter intègre un calque de suivi des performances:

MaterialApp(
  showPerformanceOverlay: true,
  checkerboardRasterCacheImages: true,
  home: const GameScreen(),
)

Le graphique supérieur affiche l’activité du thread raster, tandis que le graphique inférieur suit le thread UI. Les barres virant au rouge signalent les images ayant dépassé le seuil de 16,6 ms.

Pour analyser les causes profondes, l’onglet Performance de Flutter DevTools met à disposition trois instruments essentiels:

  1. La chronologie graphique (Timeline Flame Chart). Elle décompose chaque image en étapes précises, affichant la durée exacte de construction des widgets, de calcul du layout et des opérations sur le canvas.
  2. Les statistiques raster (Raster Stats). Elles mesurent le temps de rendu de chaque calque sur le GPU, permettant de repérer immédiatement un arrière-plan trop lourd.
  3. Les bascules de calques (Layer Toggles). Elles permettent de désactiver à la volée les calques de découpe (clip), d’opacité ou d’ombre afin d’isoler les étapes de composition coûteuses.

Pour repérer les reconstructions inutiles de widgets depuis la console, activez le paramètre dédié dans votre fonction main:

void main() {
  debugPrintRebuildDirtyWidgets = true;
  runApp(const GameApp());
}

Une fois cette option enclenchée, le terminal affiche chaque widget marqué comme dirty, simplifiant grandement le nettoyage des chaînes de reconstruction superflues.

Chronologie Flutter DevTools détaillant les threads UI et raster

Dissocier la boucle de jeu de l’arbre de widgets

L’erreur la plus répandue dans le développement de jeux sur Flutter consiste à rythmer l’animation en appelant setState dans un minuteur périodique:

// Problematic pattern: triggers full widget tree rebuilds every frame
Timer.periodic(const Duration(milliseconds: 16), (_) {
  setState(() {
    character.updatePosition();
  });
});

Exécuter setState 60 fois par seconde force le framework à comparer les éléments dans tout l’arbre de widgets, à recalculer les boîtes d’agencement et à allouer de nouvelles instances. Sur une puce mobile de milieu de gamme, cette approche sature très vite le thread UI.

La bonne architecture sépare intégralement l’état du jeu de la hiérarchie visuelle. On utilise un Ticker pour mettre à jour les modèles de données et un CustomPainter pour restituer les changements directement sur un Canvas:

class GameRunnerState extends State<GameRunner>
    with SingleTickerProviderStateMixin {
  late final Ticker _ticker;
  Duration _previousTime = Duration.zero;
  final GameState _gameState = GameState();
  final ValueNotifier<int> _renderTrigger = ValueNotifier<int>(0);

  @override
  void initState() {
    super.initState();
    _ticker = createTicker(_onTick)..start();
  }

  void _onTick(Duration currentTime) {
    if (_previousTime == Duration.zero) {
      _previousTime = currentTime;
      return;
    }
    final double dt = (currentTime - _previousTime).inMicroseconds / 1000000.0;
    _previousTime = currentTime;

    _gameState.update(dt);
    _renderTrigger.value++;
  }

  @override
  void dispose() {
    _ticker.dispose();
    _renderTrigger.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return CustomPaint(
      painter: BoardPainter(_gameState, _renderTrigger),
      size: Size.infinite,
    );
  }
}

Le CustomPainter correspondant écoute le signal de rafraîchissement et redessine l’écran sans impacter l’arbre de widgets:

class BoardPainter extends CustomPainter {
  BoardPainter(this.state, Listenable repaint) : super(repaint: repaint);

  final GameState state;

  @override
  void paint(Canvas canvas, Size size) {
    // Avoid object allocations inside the hot paint path
    for (final entity in state.entities) {
      entity.render(canvas);
    }
  }

  @override
  bool shouldRepaint(covariant BoardPainter oldDelegate) => false;
}

Comme shouldRepaint renvoie false, le redessin n’est déclenché que par le signal émis par l’objet Listenable. L’arbre de widgets reste totalement passif pendant le déroulement de la partie.

Pour les productions exigeant des mécaniques d’action continue avec gestion physique, une alternative réputée dans l’écosystème est le moteur Flame. Les composants de Flame possèdent leurs propres routines update(double dt) et render(Canvas canvas), isolant nativement la simulation du moteur de layout de Flutter. En revanche, pour des jeux de réflexion ou de plateau comme le sudoku, un recours direct à CustomPainter offre un contrôle absolu sans dépendance superflue.

Exploiter RepaintBoundary avec discernement

Le widget RepaintBoundary isole son sous-arbre dans un calque d’affichage indépendant. Le moteur pixellise ce contenu dans un tampon hors écran et le garde en mémoire cache, ce qui permet de réutiliser l’image résultante lors des images suivantes sans réexécuter les instructions de tracé.

Toutefois, chaque calque consomme de la mémoire vive et ajoute une étape de composition sur le GPU. Placer des frontières sans justification mesurée détériore fréquemment les performances globales.

RepaintBoundary se montre particulièrement bénéfique dans deux configurations:

  1. Un décor statique sous des éléments continuellement animés. Le plateau est tracé une seule fois, et le GPU vient superposer les éléments mobiles sur le tampon existant sans repeindre le fond.
  2. Un élément compact animé fréquemment au sein d’une interface statique. Le composant en mouvement se redessine dans son propre tampon sans forcer le rafraîchissement des conteneurs parents.
Stack(
  children: [
    // Static background: rasterized once and cached
    const RepaintBoundary(
      child: StaticBoardBackground(),
    ),
    // Dynamic overlay: repainted every frame without dirtying the background
    RepaintBoundary(
      child: AnimatedParticleSystem(),
    ),
  ],
)

Il faut éviter d’entourer individuellement les cases d’une grille dense ou des composants qui changent d’apparence à chaque instant. Lorsqu’un élément évolue sans arrêt, le moteur détruit et recrée le tampon à chaque image, gaspillant du temps raster. La rentabilité de chaque frontière doit toujours être validée dans l’onglet Raster Stats de DevTools.

Éviter les appels prohibitifs à saveLayer

Certains assemblages de widgets forcent le moteur à invoquer la méthode saveLayer. Ce procédé alloue un tampon intermédiaire hors écran, y dessine les enfants, applique l’opacité ou le filtre désiré, puis fusionne le résultat avec le tampon principal de l’écran. Sur les puces graphiques des téléphones d’entrée ou de milieu de gamme, dont la bande passante mémoire est restreinte, la multiplication des saveLayer engendre des ralentissements immédiats.

Un cas classique se produit lors de l’animation d’un widget Opacity standard:

// Costly: allocates an offscreen buffer on every animation tick
Opacity(
  opacity: animationValue,
  child: const HeavyBoard(),
)

// Efficient: animates opacity via layer compositing without saveLayer
FadeTransition(
  opacity: animationController,
  child: const HeavyBoard(),
)

FadeTransition modifie la transparence directement au niveau des propriétés du compositeur graphique, évitant ainsi la création d’un tampon intermédiaire.

En outre, associer saveLayer à des filtres de couleur ou d’image peut neutraliser le cache de pixellisation de Flutter, comme l’explique le ticket 51975 du dépôt Flutter. Quand le moteur ne parvient pas à délimiter précisément le rectangle de découpe du contenu filtré, il désactive le cache des éléments voisins et contraint le processeur graphique à tout redessiner.

Pour cette raison, les flous dynamiques créés avec BackdropFilter doivent être réservés aux menus de pause ou aux fenêtres modales. Maintenir un flou dynamique en arrière-plan d’une partie active à 60 FPS sature immédiatement les processeurs graphiques milieu de gamme.

Optimisation du décodage d’images et atlas de sprites

La manipulation des textures est une source fréquente de saccades dans les jeux 2D. Les difficultés surviennent à deux moments clés: lors du décodage des fichiers et en cas de dispersion excessive des textures.

Décodage ciblé selon la résolution

Par défaut, Flutter décompresse les images dans leur résolution d’origine. Charger une texture de 2048x2048 pixels pour un emplacement de 250x250 pixels gaspille la mémoire RAM et monopolise inutilement le thread UI avec des opérations de redimensionnement.

Précisez systématiquement les dimensions voulues via les propriétés cacheWidth ou cacheHeight:

Image.asset(
  'assets/board_background.png',
  fit: BoxFit.cover,
  cacheWidth: (displayWidth * MediaQuery.of(context).devicePixelRatio).round(),
)

Selon la documentation de la classe ImageCache, la limite par défaut du cache d’images est de 100 Mo ou 1000 fichiers. Dépasser cette enveloppe entraîne l’éviction d’images et impose de les redécoder entièrement dès qu’elles réapparaissent.

À un niveau plus bas, la méthode instantiateImageCodec configurée avec targetWidth permet de confier le redimensionnement directement au moteur C++ avant l’allocation mémoire.

Regroupement dans des atlas de sprites

Restituer une multitude d’images isolées oblige le processeur graphique à changer constamment de texture en mémoire, ce qui multiplie les appels de tracé (draw calls). Rassembler les images et les cases dans un atlas de sprites unique permet au moteur de traiter des dizaines d’éléments en une seule commande GPU.

Flutter permet ce traitement groupé via Canvas.drawAtlas. Avec Flame, le mixin HasAutoBatchedChildren fusionne automatiquement les éléments utilisant la même texture:

class ParticleGroup extends PositionComponent with HasAutoBatchedChildren {
  // Child components referencing the same sprite atlas
  // render in a unified draw pass without texture swaps
}

Pour les décors constitués de nombreuses cases fixes, il est judicieux de restituer l’intégralité du damier dans un tampon d’image unique au chargement du niveau, plutôt que de redessiner des centaines de petites pièces à chaque frame.

Atlas de sprites regroupant les tuiles du jeu en une texture pour réduire les draw calls

Moteurs de rendu: comparaison entre Impeller et Skia

Flutter exploite aujourd’hui Impeller sur iOS ainsi que sur les déclinaisons récentes d’Android, Skia restant en fonction sur les configurations plus anciennes. L’atout déterminant d’Impeller réside dans l’élimination des micro-blocages liés à la compilation des shaders à l’exécution (shader jank), l’ensemble des programmes graphiques étant précompilé lors de la phase de packaging de l’application.

Au cours des phases d’optimisation, il convient de tester le comportement du jeu avec les deux moteurs:

# Force Impeller backend
flutter run --profile --enable-impeller

# Run with Skia backend for comparative baseline
flutter run --profile --no-enable-impeller

Examiner la durée des images sur les deux moteurs permet de vérifier sans ambiguïté si une perte de fluidité émane de particularités matérielles ou d’un défaut dans l’architecture du jeu. Des méthodes de test comparables sont présentées dans le guide de dépannage des performances sur freeCodeCamp.

Pour approfondir la synchronisation avec le rafraîchissement d’écran, Andrea Bizzotto analyse les mécanismes Timer et Ticker, mettant en évidence la gestion du cadencement lors de variations de charge processeur.

Mesures rigoureuses sur appareil physique

Faire reposer les tests de fluidité uniquement sur un ordinateur de bureau ou un simulateur donne une perception trompeuse. Les processeurs de stations de travail masquent avec aisance des défauts d’optimisation qui figeraient immédiatement un appareil mobile.

Les recommandations pour bâtir un protocole d’essai probant:

  • Un appareil de référence fixe. Prenez pour modèle d’essai principal un smartphone Android milieu de gamme âgé de deux ou trois ans.
  • Le contrôle thermique. Sous forte chaleur, les puces mobiles réduisent automatiquement leur fréquence d’horloge (thermal throttling). Ne lancez pas de tests immédiatement après la recharge ou à la suite d’une longue compilation.
  • Le niveau de batterie. En dessous de 20% d’autonomie, les systèmes d’exploitation brident les performances pour économiser l’énergie. Effectuez toujours les mesures au-delà de 50% de charge.
  • Des scénarios reproductibles. Les séquences d’essai doivent être pilotées de manière automatisée pour garantir des conditions rigoureusement identiques entre chaque version de code.

Le nombre moyen d’images par seconde (Average FPS) est un indicateur peu fiable. Un titre affichant 58 FPS de moyenne peut très bien figer pendant 150 ms toutes les quelques secondes, ce qui gâche totalement le plaisir de jeu. Les critères d’évaluation décisifs reposent sur les 95e et 99e centiles (p95 et p99).

Cette classe utilitaire enregistre la durée des images lors des sessions de profilage:

class FrameDurationTracker {
  final List<double> _history = List<double>.filled(120, 0.0);
  int _cursor = 0;

  void recordFrame(double durationMs) {
    _history[_cursor % _history.length] = durationMs;
    _cursor++;
  }

  double calculateP95() {
    final List<double> samples = List<double>.from(_history)..sort();
    final int index = (samples.length * 0.95).floor();
    return samples[index];
  }

  bool isTargetMet() => calculateP95() <= 16.6;
}

Le suivi continu des centiles permet de colmater les dérives du budget d’image bien avant la mise en production.

Profilage des temps de rendu des trames sur un smartphone milieu de gamme

Liste de contrôle pour le développement quotidien

Les réflexes majeurs à adopter pour garantir la fluidité d’un jeu Flutter:

  1. Mesurez systématiquement les durées d’exécution en mode --profile sur un smartphone milieu de gamme réel.
  2. Découplez la simulation de l’arbre de widgets en utilisant conjointement Ticker et CustomPainter.
  3. Bannissez les instanciations d’objets dans les méthodes update et paint. Réutilisez les instances de Paint.
  4. Positionnez RepaintBoundary avec parcimonie: seulement autour de fonds statiques ou d’éléments animés isolés.
  5. Remplacez le widget animé Opacity par FadeTransition pour supprimer les invocations superflues de saveLayer.
  6. Calibrez la décompression des images selon leur taille réelle d’affichage avec cacheWidth et cacheHeight.
  7. Fusionnez les sprites associés dans des atlas de textures afin de réduire les appels de dessin GPU.
  8. Évaluez la régularité du rendu sur la base des centiles p95 et p99 plutôt que sur une simple moyenne arithmétique.

FAQ: Foire aux questions

Flutter convient-il à des jeux 2D commerciaux?

Pour les jeux 2D occasionnels, les jeux de réflexion, de cartes ou de société, Flutter garantit d’excellentes performances, un cycle d’itération très rapide et une parfaite cohérence visuelle entre iOS et Android. Pour des réalisations 3D volumineuses ou des simulations physiques intenses, des moteurs spécialisés comme Godot ou Unity restent plus adaptés.

Pourquoi le jeu saccade-t-il lors du premier affichage d’un élément?

Ces à-coups initiaux s’expliquent généralement par le chargement différé des assets, la pixellisation des polices ou la compilation de shaders sous Skia. Les ressources visuelles et sonores doivent être préchargées dès l’écran d’accueil. Sur les mobiles animés par Impeller, les saccades liées à la compilation des shaders en cours de partie sont définitivement résolues.

RepaintBoundary est-il utile dans les listes défilantes?

Dans des composants tels que ListView, Flutter applique automatiquement RepaintBoundary autour de chaque élément afin que le défilement ne force pas le recalcul des éléments voisins. Il est déconseillé d’ajouter manuellement d’autres frontières imbriquées pour ne pas surcharger le compositeur graphique.

Faut-il déporter le décodage d’images dans un isolate indépendant?

En règle générale, non. Le pipeline interne de Flutter confie déjà la décompression d’images à des threads C++ natifs en arrière-plan. Transmettre des tableaux d’octets entre isolates en Dart impose des copies de mémoire dont le coût dépasse fréquemment le bénéfice attendu. Mieux vaut réserver les isolates à des calculs algorithmiques lourds, comme la génération de cartes ou la recherche de chemin.

Comment adapter la boucle de jeu aux écrans 90 Hz et 120 Hz?

Tous les déplacements dans l’univers de jeu doivent être multipliés par le delta time (dt) plutôt que de reposer sur un pas de temps fixe. Si les capacités matérielles ne permettent pas de tenir sereinement 8,3 ms par image, bloquer la cadence à 60 FPS garantit un défilement parfaitement régulier.

Comment identifier le widget qui provoque des reconstructions répétitives?

En mode debug, activez le drapeau debugPrintRebuildDirtyWidgets = true. La console affichera la liste des widgets demandant à être réactualisés à chaque image. Vous pourrez alors déplacer la gestion de l’état en dehors de l’arbre de widgets.

Sources et lectures complémentaires


Explorez nos réflexions sur la conception de jeux: découvrez nos choix de design dans notre aventure de sudoku Polydocu, comprenez d’où viennent les idées de jeu et consultez notre approche sur l’accessibilité des jeux mobiles.


Rédigé par Maksymilian Jackowski chez Psittacus Studio, créateurs de Polydocu, une aventure mobile autour du sudoku.

Polydocu - une aventure de sudoku

Neuf chiffres, une expédition dans la jungle, Poly le perroquet et aucun artifice payant. Rejoignez la liste d'attente et nous vous préviendrons dès le lancement.

Rejoindre la liste d'attente

Un seul e-mail à la sortie, aucun spam.

Trois autres notes du même carnet, choisies par thème et non par un algorithme.

Tous les articles