Une fidélité supérieure et des fréquences d'images plus fluides avec Adaptive Performance

Nous avons récemment terminé la GDC 2019, où nous avons parlé des Adaptive Performance lors de notre discours d'ouverture. Nous sommes ravis de vous annoncer que la version Preview et l'échantillon mobile Megacity sont désormais disponibles afin que vous puissiez commencer à explorer cette fonctionnalité. Ce blog explique plus en détail les Adaptive Performance et comment les appliquer à vos propres projets.

Contrairement à un jeu sur PC ou sur console, exploiter toute la puissance du matériel mobile nécessite un équilibre délicat pour que les jeux soient beaux et fonctionnent sans problème. Maximiser les capacités d'un appareil peut rapidement compromettre les performances de votre jeu en surchargeant le matériel, ce qui entraîne une limitation, une faible autonomie de la batterie et des performances incohérentes. Pour les développeurs, ce problème devient encore plus problématique compte tenu de la large gamme d’appareils cibles bas de gamme et haut de gamme.

Aujourd’hui, les développeurs adoptent différentes tactiques pour résoudre ce problème. Les deux principales approches que nous avons vues sont les suivantes : essayer de s'assurer que les jeux fonctionnent de manière optimale sur tout le matériel cible, ce qui signifie sacrifier la fidélité graphique et la fréquence d'images, ou tenter d'anticiper le comportement du matériel, ce qui est vraiment difficile car il n'existe pas beaucoup d'options pour mesurer précisément les tendances du matériel.

Adaptive Performance vous offre un meilleur moyen de gérer les performances thermiques et de vos jeux sur un appareil en temps réel, vous permettant d'ajuster de manière proactive les paramètres de performances et de qualité de votre jeu à la volée et d'utiliser le matériel sans surcharger l'appareil. Le résultat est une fréquence d’images prévisible et une diminution de l’accumulation thermique, permettant des temps de jeu plus longs et une expérience de jeu beaucoup plus agréable tout en préservant la durée de vie de la batterie.

Pour les développeurs, cela signifie avoir une vision nouvelle et plus approfondie du matériel avec de nouveaux outils pour rendre vos jeux plus dynamiques et flexibles, offrant à vos joueurs les expériences les plus fluides et les plus performantes lorsqu'ils jouent sur des appareils mobiles. Il vous donne le contrôle sur les décisions que prend habituellement le système d'exploitation, comme le moment où il faut fonctionner à des vitesses d'horloge élevées ou ce qu'il faut ajuster pour éviter la limitation.

Nous avons donné plusieurs conférences sur cette fonctionnalité lors de la GDC 2019. Vous pouvez consulter le diaporama ici et regarder le Unity GDC Booth Talk - Megacity sur mobile : Comment nous l'avons optimisé avec Adaptive Performance ci-dessous.

Nous nous sommes associés à Samsung, le plus grand fabricant d'appareils mobiles Android au monde, pour nous aider à concrétiser cette solution. Construit sur la base du GameSDK de Samsung, Adaptive Performance sera d'abord disponible pour les appareils Samsung Galaxy tels que le Samsung Galaxy S10 et le Galaxy Fold, suivis par d'autres appareils Samsung Galaxy plus tard cette année.

Ces graphiques (présentés lors de notre discours d'ouverture sur Unity à la GDC 2019) illustrent comment Adaptive Performance contribue à fournir une fréquence d'images élevée et constante avec Megacity exécuté sur le nouveau Samsung Galaxy S10.

En rouge, vous pouvez voir la fréquence d'images dans Megacity avant d'ajouter Adaptive Performance; et en bleu, vous pouvez voir les résultats après avoir ajouté Adaptive Performance. Avec Adaptive Performance, la démo fonctionne à 30 ips pendant une durée beaucoup plus longue et est beaucoup plus stable.

Megacity est une ville futuriste et interactive comprenant des millions d'entités, démontrant comment Unity peut exécuter même les projets les plus complexes sur le matériel mobile de génération actuelle. Il présente les dernières avancées de notre pile technologique orientée données (DOTS), le nom de tous les projets sous notre bannière « Performance par défaut », y compris Entity Component System (ECS), Native Collections, C# Job System et le compilateur Burst . Megacity a été présenté pour la première fois à Unite Los Angeles 2018 et est sorti sur ordinateur lors de la GDC 2019.

Megacity est le bon projet pour démontrer un exemple d'implémentation d' Adaptive Performance, car il nous offre la flexibilité d'adapter le jeu de manière dynamique et proactive pour utiliser au mieux le matériel. Adaptive Performance a été conçu dans un souci d'évolutivité, ce qui fonctionne parfaitement avec les principes DOTS utilisés pour construire les fondations de Megacity.

La version mobile du projet comprend 4,5 millions de moteurs de rendu en maillage, 200 000 composants de construction, 100 000 sources audio et plus de 6 millions d'entités, ce qui en fait un candidat idéal pour démontrer les capacités d'Adaptive Performance.

Après avoir installé Adaptive Performance via le gestionnaire de packages Unity , Unity ajoute automatiquement le sous-système Samsung GameSDK à votre projet lorsque vous le créez sur un appareil. Pendant l'exécution, Unity crée et démarre un gestionnaire de Adaptive Performance sur les appareils pris en charge, qui vous fournit des informations sur l'état thermique de l'appareil mobile. Vous pouvez vous abonner à des événements ou interroger les informations d' Adaptive Performance Manager pendant l'exécution pour réagir en temps réel ; sinon, il signalera uniquement les statistiques à la console.

À titre d’exemple, vous pouvez utiliser l’ API fournie pour créer des applications qui réagissent aux tendances et événements thermiques sur l’appareil. Cela garantit des fréquences d'images constantes sur une période plus longue tout en évitant la limitation thermique, même avant le début de la limitation. Dans l'exemple d'implémentation d' Adaptive Performance dans Megacity, nous avons utilisé trois méthodes différentes pour lisser la fréquence d'images :

• En commençant avec des niveaux modérés de CPU et de GPU, et en les augmentant progressivement pour éliminer les goulots d’étranglement, nous avons pu maintenir une faible consommation d’énergie.
• Si nous voyions que l'appareil se rapprochait de la limitation, nous pouvions ajuster les paramètres de qualité pour réduire la charge thermique - et nous avons décidé de réduire les niveaux LOD .
• Nous avons également diminué la fréquence d'images cible une fois que nous étions proches de la limitation.
• Lorsque la fréquence d'images cible est atteinte et que la température est en baisse, nous augmentons les niveaux de LOD , augmentons la fréquence d'images cible et diminuons à nouveau les niveaux du CPU et du GPU.

Ces fonctionnalités permettent à votre jeu d’atteindre des performances plus fluides au fil du temps. En gardant un œil attentif sur les tendances thermiques d'un appareil, vous pouvez ajuster les paramètres de performances à la volée pour éviter toute limitation.

Téléchargez l'exemple de projet mobile Megacity icipour voir comment nous avons procédé. Pour des commentaires ou des questions sur Megacity, veuillez visiter ce fil de discussiondu forum.

Le cœur du package est l' Adaptive Performance Manager, Unity crée au démarrage, vous permettant d'accéder et de vous abonner facilement aux notifications d'événements thermiques et de performances. L'exemple ci-dessous montre comment accéder à Adaptive Performance Manager à l'aide de l'interface IAdaptivePerformance dans la fonction Démarrer de votre MonoBehaviour.

privé IAdaptivePerformance ap = null;

Annuler Démarrer()
{
ap = Holder.instance;
}

Unity envoie des événements thermiques chaque fois qu'il y a des changements dans l'état thermique de l'appareil. Les états importants sont ceux où la limitation est imminente et ceux où la limitation se produit. Dans l'exemple ci-dessous, vous vous abonnez à ThermalEvents pour réduire ou augmenter votre lodBias, ce qui contribue à réduire la charge du GPU.

en utilisant UnityEngine;
en utilisant UnityEngine.Mobile.AdaptivePerformance ;

classe publique AdaptiveLOD : MonoBehaviour
{
privé IAdaptivePerformance ap = null;

void Démarrer() {
si (Holder.instance == null)
retour;

ap = Holder.instance;

si (!ap.active)
retour;

QualitySettings.lodBias = 1;

ap.ThermalEvent += OnThermalEvent;
}

void OnThermalEvent(objet obj, ThermalEventArgs ev) {
commutateur (ev.warningLevel) {
Cas PerformanceWarningLevel.NoWarning :
QualitySettings.lodBias = 1;
casser;
Cas PerformanceWarningLevel.ThrottlingImminent :
Paramètres de qualité.lodBias = 0,75f ;
casser;
Cas PerformanceWarningLevel.Throttling :
Paramètres de qualité.lodBias = 0,5f;
casser;
}
}
}

Notez que si vous réduisez le lodBias en dessous d'une valeur de 1, cela aura un impact visuel dans de nombreux cas et un popping d'objets LOD peut se produire, mais c'est un moyen simple de réduire la charge graphique si cela n'est pas nécessaire pour l'expérience de jeu. Si vous souhaitez prendre des décisions encore plus détaillées pour affiner la manière dont les graphismes et le comportement de votre jeu sont gérés, les événements de goulot d'étranglement sont très utiles.

Niveaux de performances du CPU et du GPU

Le processeur et le processeur graphique d'un appareil mobile représentent une très grande partie de sa consommation d'énergie, en particulier lors de l'exécution d'un jeu. En règle générale, le système d’exploitation décide quelles vitesses d’horloge sont utilisées pour le processeur et le processeur graphique.

Les cœurs de processeur et les GPU sont moins efficaces lorsqu’ils fonctionnent à leur vitesse d’horloge maximale. L'exécution à des vitesses d'horloge élevées surchauffe facilement l'appareil mobile et le système d'exploitation limite la fréquence du processeur et du processeur graphique pour refroidir l'appareil.

Vous pouvez éviter cette situation en limitant les vitesses d'horloge maximales autorisées avec ces propriétés :

• IAdaptivePerformance.cpuLevel
• IAdaptivePerformance.gpuLevel

L'application peut configurer ces propriétés en fonction de ses connaissances spécifiques sur les exigences de performances actuelles et décider, en fonction du scénario, si les niveaux doivent être abaissés ou augmentés.

• L'application a-t-elle atteint la fréquence d'images cible dans les images précédentes ?
• L'application est-elle dans une scène de jeu ou dans un menu ?
• Est-ce qu'une scène lourde arrive ensuite ?
• Un événement à venir nécessite-t-il beaucoup de CPU ou de GPU ?
• Allez-vous afficher des publicités qui ne nécessitent pas de niveaux de CPU/GPU élevés ?

public void EnterMenu(){
si (!ap.active)
retour;

// Définir un niveau CPU et GPU bas dans le menu
ap.cpuLevel = 0;
ap.gpuLevel = 0;
// Définir un FPS cible bas
Application.targetFrameRate = 15;
}

public void ExitMenu(){
// Définissez un niveau de CPU et de GPU plus élevé lors du retour au jeu
ap.cpuLevel = ap.maxCpuPerformanceLevel;
ap.gpuLevel = ap.maxGpuPerformanceLevel;
}

Dans Adaptive Performance Manager, vous pouvez vous abonner pour recevoir des événements de goulot d'étranglement des performances qui vous permettent de savoir si vous êtes limité par le GPU, le CPU ou la « fréquence d'images ». La fréquence d'images limitée signifie que le jeu est limité par Application.targetFrameRate, auquel cas l'application doit envisager de réduire ses exigences de performances.

En arrière-plan, le pilote de temps d'image du GPU, qui surveille le temps matériel passé par le GPU sur la dernière image, s'exécute et gère les décisions de goulot d'étranglement, et peut être interrogé via le gestionnaire. Pour le moment, le temps CPU est calculé en additionnant les sous-systèmes internes d'Unity. Selon le jeu et le scénario, vous pouvez le faire réagir différemment lorsque le jeu est lié au CPU ou au GPU en fonction des changements d'état thermique.

void OnBottleneckChange(objet obj, PerformanceBottleneckChangeEventArgs ev) {
commutateur (ev.goulot d'étranglement) {
Cas PerformanceBottleneck.TargetFrameRate :
si (ap.cpuLevel > 0) {
ap.cpuLevel--;
}
si (ap.gpuLevel > 0) {
ap.gpuLevel--;
}
casser;
Cas PerformanceBottleneck.GPU :
si (ap.gpuLevel < ap.maxGpuPerformanceLevel) {
ap.gpuLevel++;
}
casser;
Cas PerformanceBottleneck.CPU :
si (ap.cpuLevel < ap.maxCpuPerformanceLevel) {
ap.cpuLevel++;
}
casser;
}
}

Il existe de nombreuses façons différentes d'optimiser les jeux, et les exemples ci-dessus et dans Megacity ne fournissent que quelques suggestions sur la manière de procéder ; en fin de compte, cela dépend beaucoup de ce qui fonctionne le mieux pour votre jeu. Pour plus d'informations, veuillez également consulter la documentationdu package.

Ce n'est que le début ! Nous allons continuer à investir dans les Adaptive Performance, en ajoutant davantage de fonctionnalités et en prenant en charge davantage d’appareils au fil du temps. Le package actuel inclut une API de bas niveau, mais nous travaillons déjà sur une API de haut niveau basée sur des composants compatible avec DOTS, ce qui devrait faciliter encore plus l'adaptation des performances dans vos projets Unity . Restez à l’écoute pour plus d’informations.

Une version préliminaire d' Adaptive Performance est désormais disponible pour Unity 2019.1 (bêta) via le gestionnaire de packages Unity . Vous pouvez y accéder ici. Pour des informations à jour sur Adaptive Performance, pour voir comment d'autres développeurs l'utilisent et pour poster des questions ou des commentaires, veuillez visiter le forum.