godot-performance

Détectez et résolvez les problèmes de performance dans Godot 4.7 : profileurs et moniteurs, budgets de trame, MultiMesh et API serveur pour des milliers d'objets, WorkerThreadPool et groupes de threads, goulots d'étranglement GDScript/C#, appels de dessin, lumières, LOD, coût physique, chargement et fuites mémoire. À utiliser quand le jeu saccade, que les FPS sont bas, que le chargement est lent ou que la mémoire augmente.

Qu'est-ce que godot-performance ?

Cette compétence permet aux développeurs Godot 4.7 d'identifier et de corriger les problèmes de performance de manière méthodique. Elle fournit un guide complet pour utiliser les outils de profilage intégrés (Profiler, Visual Profiler, Moniteurs, ObjectDB snapshots) ainsi que des profileurs natifs comme Tracy, Perfetto ou Apple Instruments. Elle détaille les stratégies d'optimisation CPU (désactivation des traitements inutiles, mise en cache des nœuds, utilisation de MultiMesh et des API serveur pour gérer des milliers d'entités sans nœuds individuels), GPU (réduction des appels de dessin, gestion des lumières et ombres, LOD et occlusion culling), et mémoire (chargement paresseux, compression VRAM, libération des ressources). Des conseils spécifiques sont donnés pour le multithreading (WorkerThreadPool, groupes de threads), les différences entre GDScript et C#, ainsi que des budgets de performance par plateforme (mobile, web, desktop/console).

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/EL4CTEO/godot-skills/tree/main/skills/godot-performance

Installed? Explore more Développement et programmation skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Performance (4.7)

Mesurez d'abord. N'optimisez jamais à l'aveugle. Un budget de 16,6 ms par trame (60 FPS) ou 8,3 ms (120 FPS) couvre le script, la physique, le rendu sur le CPU et le GPU.

Outils

  • Débogueur de l'éditeur : Profileur (fonctions de script ; démarrez-le, jouez, puis triez par temps propre), Profileur visuel (CPU vs GPU par passe de rendu), Moniteurs (FPS, temps de processus/physique, objets, nœuds, nœuds orphelins, appels de dessin, mémoire vidéo), Profileur réseau et instantanés ObjectDB (4.6+ : différenciez deux instantanés pour trouver les fuites).
  • Code : Performance.get_monitor(Performance.TIME_PROCESS), RENDER_TOTAL_DRAW_CALLS_IN_FRAME, OBJECT_NODE_COUNT, OBJECT_ORPHAN_NODE_COUNT. Ajoutez les vôtres avec Performance.add_custom_monitor(&"game/enemies", callable).
  • Profileurs natifs (4.6+) : Tracy, Perfetto (Android par défaut) et Apple Instruments peuvent voir les trames GDScript, C# et GDExtension. Utilisez-les pour les pics de temps de trame.
  • CLI : --profiling, --gpu-profile, --print-fps, --benchmark. Utilisez --fixed-fps 60 --quit-after N pour des exécutions reproductibles.
  • Fuites : les nœuds orphelins sont des nœuds retirés de l'arbre mais jamais libérés. Node.print_orphan_nodes(), get_orphan_node_ids() (4.5+).

CPU : faire moins de travail

  • Désactivez les traitements inutiles : set_process(false)/set_physics_process(false) quand inactif. VisibleOnScreenEnabler2D/3D met en pause les acteurs hors écran. Les minuteries sont meilleures que le sondage par trame.
  • Le code par trame est le goulot d'étranglement. Mettez en cache les nœuds dans @onready/_Ready. Utilisez les littéraux StringName (&"jump") pour les actions, groupes et noms de méthodes. N'appelez pas get_tree().get_nodes_in_group() à chaque trame. Utilisez du GDScript typé (les opcodes typés sont plus rapides).
  • Les signaux et call_group sont bon marché pour les événements, mais ne les émettez pas par entité par trame pour des milliers d'entités.
  • Des milliers de choses : arrêtez d'utiliser un nœud par chose.
    • Visuels : MultiMeshInstance3D/2D (un appel de dessin ; écrivez multimesh.buffer en masse), ou particules GPU.
    • Logique : tableaux simples et structures dans un script gestionnaire unique (orienté données), pas un script par entité.
    • Physique : corps et zones PhysicsServer2D/3D sans nœuds, ou un lot de raycasts par trame.
    • Rendu sans nœuds : instances RenderingServer et éléments de canevas.
  • Physique : gardez physics_ticks_per_second à 60 sauf si le jeu en a besoin de plus. Utilisez des formes primitives simples et évitez ConcavePolygonShape3D sur les corps en mouvement. Les couches et masques réduisent les vérifications de paires. Laissez les corps dormir (can_sleep).

Threads

  • WorkerThreadPool.add_task(callable) / add_group_task(callable, count) (parallèle pour), puis wait_for_task_completion(id). C'est mieux que Thread brut pour la plupart des tâches.
  • Règle de l'arbre de scène : les nœuds dans l'arbre ne peuvent être touchés que depuis le thread principal, sauf s'ils sont dans un groupe de threads (process_thread_group = PROCESS_THREAD_GROUP_SUB_THREAD, qui traite ce sous-arbre en parallèle et utilise call_deferred_thread_group pour les appels inter-groupes). Depuis les threads de travail, renvoyez les résultats avec call_deferred / Callable.call_deferred(). Vérifiez avec Thread.is_main_thread() (4.7).
  • Données partagées : protégez-les avec Mutex, ou donnez à chaque travailleur sa propre tranche et fusionnez sur le thread principal.
  • Chargement en arrière-plan : ResourceLoader.load_threaded_request(path, "", true) utilise des sous-threads pour les dépendances.

GPU et rendu

  • Appels de dessin : fusionnez les maillages statiques et partagez les matériaux, car chaque matériau unique sur une surface de maillage ajoute des appels. Utilisez MultiMesh pour les répétitions et les atlas de textures en 2D.
  • Les lumières et les ombres sont les habituels consommateurs de GPU. Utilisez peu de lumières omnidirectionnelles et projecteurs avec ombres, gardez directional_shadow_max_distance petit, et cuisez l'éclairage statique (LightmapGI).
  • Sur-dessin : grosses particules transparentes et alpha plein écran. Utilisez alpha scissor ou hash pour le feuillage et des quads de particules plus petits.
  • Détail adaptatif : LOD (mesh_lod_threshold), visibility_range_*, occlusion culling, et mise à l'échelle de résolution (FSR, MetalFX) sur les GPU faibles. Choisissez le bon moteur de rendu : Mobile ou Compatibility pour les appareils bas de gamme (voir godot-3d-rendering).
  • Saccades de shader : cuiseur de shader (option d'exportation), moins de variantes de matériaux.

Chargement et mémoire

  • preload charge au chargement du script et bloque. Utilisez-le uniquement pour les petites choses dont vous avez toujours besoin. load est paresseux. Le chargement par threads convient aux niveaux.
  • ResourceLoader met en cache les ressources. Réutilisez-les, et ne faites pas duplicate() de ressources partagées sauf si vous avez besoin d'un état par instance.
  • Textures : importation compressée VRAM (par défaut pour la 3D ; activez pour les grandes textures 2D). Mipmaps pour la 3D. Limitez la taille maximale par plateforme. Audio : flux Ogg pour les longues pistes.
  • Libérez ce que vous créez : queue_free() et pools pour les balles. Surveillez que le nombre d'orphelins reste stable.

GDScript vs C#

  • GDScript est suffisant pour le gameplay. Déplacez les boucles mathématiques serrées (pathfinding, génération procédurale, simulations) vers C# ou GDExtension, et regroupez les appels API.
  • C# : évitez les allocations par trame (LINQ, closures, formatage de chaînes, new Godot.Collections.Array). Chaque appel API Godot traverse une limite d'interopérabilité, donc regroupez-les. Les tableaux packagés sont copiés lorsqu'ils traversent cette limite.

Budgets par plateforme (règle empirique)

Mobile : < 100–150 appels de dessin, 1 lumière avec ombre, moteur de rendu Mobile ou Compatibility, cible 30–60 FPS. Web : moteur de rendu Compatibility, mono-thread sauf si l'exportation utilise des threads (nécessite des en-têtes cross-origin isolation), et gardez les téléchargements petits. Bureau ou console : Forward+, profilez sur le matériel minimum spécifié.

HUD de performance + moniteurs personnalisés, foule MultiMesh, tâche de groupe parallèle, balles côté serveur (compilées par les tests) : references/patterns.md

Individual skills in this repo

This repo contains 4 individual skills — each has its own dedicated page.

Skills associés