Gestion de l'utilisation du GPU pour les jeux PC et consoles

Comprenez les limites de votre matériel cible et comment profiler le GPU pour optimiser le rendu de vos graphismes. Essayez ces conseils et bonnes pratiques pour réduire la charge de travail du GPU.

Lors du profilage, il est utile de commencer par un benchmark pour vous indiquer les résultats de profilage que vous devez attendre de GPU spécifiques.

Consultez GFXBench pour une grande liste de références standard pour les GPU et les cartes graphiques. Le site Web offre un bon aperçu des GPU actuels disponibles et de la façon dont ils s'empilent les uns sur les autres.

Regardez les statistiques de rendu

Cliquez sur le bouton Statistiques en haut à droite de la fenêtre Game. Cette fenêtre vous montre des informations de rendu en temps réel sur votre application en mode lecture. Utilisez ces données pour optimiser les performances :

- FPS : Images par seconde

- CPU Main : Temps total nécessaire pour traiter une image (et mettre à jour l'éditeur pour Windows)

- Rendu du processeur : Temps total de rendu d'une image de la vue du jeu

- Lots : Groupes de requêtes à réunir

- Triangles et sommets : Géométrie de maillage

- Appels SetPass : Le nombre de fois où Unity doit changer de shader passe pour afficher les GameObjects à l'écran ; chaque passe peut introduire une surcharge supplémentaire du processeur.

Remarque : FPS dans l'Éditeur ne se traduit pas nécessairement par des performances de compilation. Nous vous recommandons de profiler votre compilation pour des résultats aussi précis que possible. Le temps d'image en millisecondes est un indicateur plus précis que lors de l'étalonnage. Apprenez-en plus dans l'ebook Guide ultime sur le profilage des jeux Unity (édition Unity 6).

Pour dessiner un GameObject, Unity lance un appel de tirage à l'API graphique (par exemple OpenGL, Vulkan ou Direct3D). Chaque requête est gourmande en ressources. Les changements d'état entre les requêtes, tels que le changement de matériau, peuvent entraîner une surcharge de performances du côté du processeur.

Le matériel PC et console peut pousser beaucoup de requêtes, mais le surcharge de chaque requête est toujours assez élevé pour justifier d'essayer de les réduire. Sur les appareils mobiles, l'optimisation des requêtes est vitale. Cela est possible grâce au traitement par lots des requêtes.

Le traitement par lots des requêtes minimise ces changements d'état et réduit le coût du processeur pour le rendu des objets. Unity peut combiner plusieurs objets en moins de lots en utilisant plusieurs techniques :

- SRP Batching: Si vous utilisez HDRP ou URP, activez le SRP Batcher dans votre ressource Pipeline sous Advanced. Lorsque vous utilisez des shaders compatibles, le SRP Batcher réduit la configuration du GPU entre les requêtes et rend les données matérielles persistantes dans la mémoire du GPU. Cela peut accélérer considérablement les temps de rendu de votre processeur. Utilisez moins de variantes de shader avec un minimum de mots-clés pour améliorer le traitement par lots SRP. Consultez cette documentation SRP pour voir comment votre projet peut tirer parti de ce flux de rendu.

- Instancing GPU : Si vous avez un grand nombre d'objets identiques (par exemple, des bâtiments, des arbres, de l'herbe, etc. avec le même maillage et le même matériau), utilisez l'instanciation GPU. Cette technique les traite par lots en utilisant du matériel graphique. Pour activer l'instanciation du GPU, sélectionnez votre matériau dans la fenêtre Project et, dans l'Inspector, cochez la case Activer l'instanciation.

- Traitement par lots statiques : Pour la géométrie non mouvante, Unity peut réduire les requêtes pour tous les maillages partageant le même matériau. Il est plus efficace que le traitement par lots dynamique, mais il utilise plus de mémoire.Marquez tous les maillages qui ne bougent jamais comme statiques de lots dans l'Inspector. Unity combine tous les maillages statiques en un grand maillage au moment de la compilation. L'utilitaire StaticBatching vous permet également de créer vous-même ces lots statiques lors de l'exécution (par exemple, après avoir généré un niveau procédural de pièces non mobiles).

- Traitement par lots dynamique : Pour les petits maillages, Unity peut regrouper et transformer les sommets sur le processeur, puis les dessiner tous en une seule fois. Remarque : Ne l'utilisez pas à moins d'avoir suffisamment de maillages low-poly (pas plus de 300 sommets chacun et 900 attributs de vertex au total). Sinon, l'activer fera perdre du temps au processeur à chercher de petits maillages à traiter par lots.

Vous pouvez maximiser le traitement par lots avec quelques règles simples :

- Utiliser le moins de textures possible dans une scène. Moins de textures nécessitent moins de matériaux uniques, ce qui les rend plus faciles à mélanger. En outre, utilisez des atlas de texture dans la mesure du possible.

- Faites toujours cuire des lightmaps à la plus grande taille possible de l'atlas. Moins de lightmaps nécessitent moins de changements d'état des matériaux, mais surveillez l'empreinte mémoire.

- Faites attention à ne pas invoquer de matériaux involontairement. Accéder à Renderer.material dans les scripts duplique le matériel et renvoie une référence à la nouvelle copie. Cela casse tout lot existant qui inclut déjà le matériau. Si vous souhaitez accéder à la matière de l'objet par lots, utilisez plutôt Renderer.sharedMaterial.

- Surveillez le nombre de lots statiques et dynamiques par rapport au nombre total de requêtes en utilisant le Profiler ou les statistiques de rendu lors des optimisations.

Veuillez consulter la documentation sur le traitement par lots pour en savoir plus.

Le Frame Debugger vous permet de figer la lecture sur une seule image et de montrer comment Unity construit une scène pour identifier les opportunités d'optimisation. Recherchez les GameObjects qui rendent inutilement et désactivez-les pour réduire les requêtes par image.

Note : Le Frame Debugger n'affiche pas les requêtes individuelles ou les changements d'état. Seuls les profileurs de GPU natifs vous fournissent des informations détaillées sur les requêtes et le timing. Cependant, le Frame Debugger peut toujours être très utile pour déboguer les problèmes de pipeline ou de traitement par lots.

Un avantage du débogueur de frames Unity est que vous pouvez relier un draw call à un GameObject spécifique dans la scène. Cela facilite l'investigation de certains problèmes qui ne sont peut-être pas possibles dans les débogueurs d'images externes.

Pour en savoir plus, lisez la documentation sur le débogueur d'images, puis consultez la section

Le taux de remplissage fait référence au nombre de pixels que le GPU peut rendre à l'écran chaque seconde.

Si votre jeu est limité par le taux de remplissage, cela signifie qu'il essaie de dessiner plus de pixels par image que le GPU ne peut en gérer.

Dessiner sur le même pixel plusieurs fois est appelé overdraw. Overdraw réduit le taux de remplissage et coûte une bande passante mémoire supplémentaire. Les causes les plus fréquentes d'overdraw sont :

- Géométrie opaque ou transparente s ' imbriquant

- Des shaders complexes, souvent avec plusieurs passes de rendu

- Particules non optimisées

- Superposition des éléments de l'IU

Bien que vous souhaitiez minimiser ses effets, il n'existe pas d'approche unique pour résoudre les problèmes d'overdraw. Commencez par expérimenter les facteurs ci-dessus pour réduire leur impact.

Comme pour les autres plateformes, l'optimisation sur console implique souvent de réduire les lots de requêtes. Il existe quelques techniques qui pourraient vous aider.

- À l'aide du gommage d'occlusion, supprimez les objets cachés derrière les objets de premier plan et réduisez l'overdraw. Attention : cela nécessite un traitement supplémentaire du processeur. Utilisez donc le Profiler pour vous assurer que le déplacement du GPU vers le processeur est bénéfique.

- L'instanciation du GPU peut également réduire vos lots si vous avez de nombreux objets qui partagent le même maillage et le même matériau. Limiter le nombre de modèles dans votre scène peut améliorer les performances. Si c'est fait avec art, vous pouvez créer une scène complexe sans la rendre répétitive.

- Le SRP Batcher peut réduire la configuration du GPU entre les DrawCalls en groupant les commandes Bind et Draw GPU. Pour bénéficier de ce traitement par lots SRP, utilisez autant de matériaux que nécessaire, mais limitez-les à un petit nombre de shaders compatibles (par exemple, shaders éclairés et non éclairés dans les pipelines de rendu universel et HDRP).

Le gommage d'occlusion désactive les GameObjects qui sont entièrement cachés (occlus) par d'autres GameObjects. Cela empêche le processeur et le GPU d'utiliser le temps pour rendre des objets qui ne seront jamais vus par la caméra.

Le gommage se fait par caméra. Elle peut avoir un impact considérable sur les performances, en particulier lorsque plusieurs caméras sont activées simultanément. Unity utilise deux types de gommage, le gommage tronconique et le gommage occlusion.

Le gommage des troncs est effectué automatiquement sur chaque caméra. Il empêche le rendu des GameObjects qui se trouvent en dehors du frustum de vue, ce qui permet d'optimiser les performances.

Vous pouvez définir des distances de gommage manuellement via Camera.layerCullDistances. Cela vous permet de gommer les petits GameObjects à une distance inférieure à celle du farClipPlane par défaut.

Organisez les GameObjects en calques. Utilisez le tableau layerCullDistances pour attribuer à chacune des 32 couches une valeur inférieure à farClipPlane (ou utilisez 0 pour utiliser par défaut farClipPlane).

Unity gomme d'abord par couche, en ne conservant les GameObjects que sur les couches utilisées par la Caméra. Par la suite, le gommage de tronc supprime tous les GameObjects en dehors du tronc de caméra. Le gommage des troncs est effectué sous la forme d'une série de tâches pour tirer parti des threads de travail disponibles.

Chaque test de gommage de couche est très rapide (essentiellement juste une opération de masque de bits). Cependant, ce coût peut toujours s'additionner avec un très grand nombre de GameObjects. Si cela devient un problème pour votre projet, vous devrez peut-être implémenter un système pour diviser votre monde en « secteurs » et désactiver les secteurs qui ne sont pas en tronc de caméra afin d'alléger une partie de la pression sur le système de gommage des couches/frustums de Unity.

Le gommage d'occlusion supprime les GameObjects de la vue Game si la caméra ne peut pas les voir. Utilisez cette fonctionnalité pour empêcher le rendu d'objets cachés derrière d'autres objets, car ceux-ci peuvent toujours rendre et coûter des ressources. Par exemple, le rendu d'une autre pièce n'est pas nécessaire si une porte est fermée et que la caméra ne peut pas voir dans la pièce.

Activer le gommage d'occlusion peut augmenter considérablement les performances, mais peut également nécessiter plus d'espace disque, de temps de processeur et de mémoire vive. Unity précalcule les données d'occlusion pendant la compilation, puis doit les charger du disque à la mémoire vive pendant le chargement d'une scène.

Alors que le gommage des troncs en dehors de la vue de la caméra est automatique, le gommage des occlusions est un processus précalculé. Marquez simplement vos objets comme Static.Occluders ou Occludees, puis précalculez dans la boîte de dialogue Window > Rendering > Occlusion Culling.

Consultez le tutoriel Working with Occlusion Culling pour en savoir plus.

Autoriser la résolution dynamique est un paramètre de caméra qui vous permet d'adapter dynamiquement des cibles de rendu individuelles pour réduire la charge de travail sur le GPU. Dans les cas où la fréquence d'image de l'application diminue, vous pouvez réduire progressivement la résolution pour conserver une fréquence d'image cohérente.

Unity déclenche cette mise à l'échelle si les données de performance suggèrent que la fréquence d'image est sur le point de diminuer à la suite de l'utilisation du GPU. Vous pouvez également déclencher cette mise à l'échelle manuellement avec le script. Ceci est utile si vous abordez une section de l'application qui nécessite beaucoup de GPU. Si on l'adapte progressivement, la résolution dynamique peut être presque inaperçue.

Consultez la page du manuel de résolution dynamique pour plus d'informations et une liste des plateformes prises en charge.

Parfois, vous aurez besoin de rendre votre jeu de plusieurs points de vue. Par exemple, il est courant dans un jeu FPS de dessiner séparément l'arme du joueur et l'environnement avec des champs de vision (FOV) différents. Cela empêche les objets du premier plan de se sentir trop déformés vus à travers le grand angle FOV de l'arrière-plan.

Vous pouvez utiliser Camera Stacking dans l'URP pour rendre plus d'une vue de caméra. Cependant, il y a encore beaucoup de gommage et de rendu effectué pour chaque caméra. Chaque caméra entraîne des surcharges, qu'elle effectue ou non un travail significatif. Utilisez uniquement les composants Camera requis pour le rendu. Sur les plateformes mobiles, chaque caméra active peut utiliser jusqu'à 1 ms de temps processeur, même en ne rendant rien.

Dans l'URP, au lieu d'utiliser plusieurs caméras, essayez une fonctionnalité Render Objects Renderer personnalisée. Sélectionnez Add Renderer Feature dans la ressource Renderer Data. Choisissez l'objet de rendu.

Lorsque vous écrasez chaque objet de rendu, vous pouvez :

- Associez-le à un événement et injectez-le dans un timing spécifique de la boucle de rendu

- Filtre par file d'attente de rendu (transparente ou opaque) et LayerMask

- Affecter les paramètres Depth et Stencil

- Modifier les paramètres de la caméra (champ de vision et décalage de position)

En HDRP, vous pouvez utiliser des passes personnalisées à effet similaire. La configuration d ' un pass personnalisé à l ' aide d ' un volume personnalisé est analogue à celle d ' un volume HDRP.

Un Pass personnalisé vous permet de :

- Modifiez l'apparence des matériaux de votre scène

- Modifier l'ordre dans lequel Unity rend les GameObjects

- Lire les tampons de caméra dans les shaders

L'utilisation des volumes de passes personnalisés peut vous aider à éviter d'utiliser des caméras supplémentaires et les surcharges supplémentaires qui y sont associées. Les passes personnalisées offrent une flexibilité supplémentaire dans la façon dont elles peuvent interagir avec les shaders. Vous pouvez également étendre la classe Custom Pass avec C#.

Lorsque les objets se déplacent au loin, le niveau de détail (LOD) peut les ajuster ou les changer pour utiliser des maillages de basse résolution avec des matériaux et des shaders plus simples. Cela améliore les performances du GPU.

Consultez le cours Working with LODs sur Unity Learn pour en savoir plus.

Profilez vos effets de post-traitement pour voir leur coût sur le GPU. Certains effets plein écran, comme Bloom et la profondeur de champ, peuvent coûter cher, mais expérimentez jusqu'à trouver un bon équilibre entre qualité visuelle et performance.

Le post-traitement a tendance à ne pas beaucoup fluctuer à l'exécution. Une fois que vous avez déterminé vos remplacements de volume, attribuez à vos effets de post une partie statique de votre budget d'image total.

La tessellation subdivise les formes en petites versions. Cela peut améliorer les détails grâce à une géométrie accrue. Bien qu'il existe des exemples où la tessellation est logique, comme pour les écorces d'arbre réalistes, en général, évitez la tessellation sur les consoles. Ils peuvent coûter cher sur le GPU.

Comme les shaders de tessellation, les shaders de géométrie et de sommet peuvent s'exécuter deux fois par image sur le GPU : une fois lors du pré-passage de profondeur, et une autre fois lors du passage d'ombre.

Si vous souhaitez générer ou modifier des données de sommet sur le GPU, un shader informatique est souvent un meilleur choix qu'un shader géométrique. Effectuer le travail dans un shader de calcul signifie que le shader de sommet qui rend la géométrie peut être relativement rapide et simple.

En savoir plus sur les concepts de base du shader.

Lorsque vous envoyez un appel de requête au GPU, ce travail se divise en plusieurs fronts d'onde que Unity distribue dans les SIMD disponibles au sein du GPU.

Chaque SIMD dispose d'un nombre maximum de fronts d'onde pouvant être exécutés en même temps. L'occupation du front d'onde fait référence au nombre de fronts d'onde actuellement utilisés par rapport au maximum. Cela mesure la façon dont vous utilisez le potentiel du GPU. Les outils d'analyse des performances spécifiques aux consoles montrent très en détail le taux d'occupation du front d'onde.

Dans l'exemple ci-dessous, les fronts d'onde des shaders de sommets apparaissent en vert. Les fronts d'onde des shaders de pixels apparaissent en bleu. Sur le graphique du bas, de nombreux fronts d'onde de shader de sommet apparaissent sans grande activité de shader de pixel. Cela montre une sous-utilisation du potentiel du GPU.

Si vous effectuez beaucoup de travail sur des shaders de vertex qui ne génèrent pas de pixels, cela peut indiquer une inefficacité. Bien qu'un faible taux d'occupation du front d'onde ne soit pas nécessairement mauvais, il s'agit d'un indicateur pour commencer à optimiser vos shaders et vérifier s'il y a d'autres goulots d'étranglement. Par exemple, si vous avez un décrochage dû à des opérations de mémoire ou de calcul, augmenter le taux d'occupation peut améliorer les performances. D'autre part, un trop grand nombre de fronts d'onde en vol peut entraîner un écrasement du cache et diminuer les performances.

Si vous avez des intervalles où vous sous-utilisez le GPU, Async Compute vous permet de déplacer le travail de shader de calcul utile en parallèle de votre file d'attente graphique. Cela permet de mieux utiliser ces ressources GPU.

Par exemple, lors de la génération de shadow map, le GPU effectue un rendu uniquement en profondeur. Très peu de travaux de shader de pixels se produisent à ce stade, et de nombreux fronts d'onde restent inoccupés.

Si vous pouvez synchroniser certains travaux de compute shader avec le rendu uniquement en profondeur, cela permet une meilleure utilisation globale du GPU. Les fronts d'onde inutilisés peuvent aider avec Screen Space Ambient Occlusion ou toute tâche qui complète le travail actuel.

Regardez cette session sur l'optimisation des performances des Unite

Le GPU Resident Drawer (disponible à la fois pour l'URP et le HDRP) est un système de rendu piloté par le GPU conçu pour optimiser le temps passé sur le processeur, offrant des avantages significatifs en termes de performances. Il prend en charge le rendu multiplateforme et est conçu pour fonctionner dès le départ avec des projets existants.

Le système peut être activé dans la ressource pipeline de rendu HDRP ou URP. Sélectionnez Instanced Drawing pour l'activer. vous pouvez également sélectionner si vous souhaitez l'activer en mode lecture uniquement ou en mode édition également.

Lorsque vous activez le GPU Resident Drawer, les jeux qui sont liés au processeur en raison d'un nombre élevé de requêtes peuvent améliorer leurs performances à mesure que la quantité de requêtes diminue. Les améliorations que vous verrez dépendent de l'échelle de vos scènes et de la quantité d'instanciation que vous utilisez. Plus vous rendrez d'objets instanceables, plus vous verrez d'avantages.

En sélectionnant l'option Instanced Drawing, vous pouvez recevoir un message dans l'IU vous avertissant que le paramètre «BatchRenderGroup Variants must be ‘Keep All’». Le réglage de cette option dans les paramètres graphiques complète la configuration du tiroir résident du GPU.

Pour en savoir plus, consultez ici notre fil de discussion.

Le gommage d'occlusion du GPU, disponible à la fois pour l'URP et HDRP, fonctionne en tandem avec le tiroir résident du GPU. Il améliore considérablement les performances en réduisant la quantité d'overdraw pour chaque image, ce qui signifie que le moteur de rendu ne gaspille pas de ressources en dessinant des éléments qui ne sont pas vus.

Pour activer le gommage d'occlusion du GPU, localisez la ressource pipeline de rendu et activez la case à cocher Occlusion du GPU.

Pour activer le gommage d'occlusion du GPU en mode Debug dans Unity 6, accédez à Window > Rendering > Occlusion Culling. Vous pouvez visualiser ici la façon dont les objets sont gobés en sélectionnant diverses options de visualisation.