Personnaliser les profils d'appareils et l'évolutivité pour Android

L'Unreal Engine utilise les profils d'appareil et les paramètres d'évolutivité pour personnaliser les paramètres de rendu en fonction du matériel. Les paramètres d'évolutivité définissent les niveaux de qualité de fonctionnalités individuelles comme les ombres, la végétation et les détails des maillages. Ils rassemblent une matrice de différents paramètres en une seule valeur facilement ajustable. Les profils d'appareils mappent ensuite ces paramètres sur les appareils compatibles.

Android propose une large matrice de profils correspondant à des familles de GPU spécifiques. Dans ce guide, vous découvrirez les règles de correspondance des appareils, la façon de les modifier et la façon d'utiliser les paramètres d'évolutivité pour créer des profils répondant aux besoins spécifiques du jeu.

Configurations et ordre de priorité

Les configurations de l'Unreal Engine sont lues à partir du répertoire d'installation du moteur et du dossier du projet. Le dossier Engine/Config définit les paramètres de configuration de base du moteur. Après cela, ils se remplacent les uns les autres dans l'ordre suivant :

1. Engine/Config/Base*.ini

2. Projet/Config/Base*.ini

3. Engine/Config/Android/Android*.ini

4. Projet/Config/Android/Android*.ini

Par exemple, le fichier AndroidDeviceProfiles.ini dans Engine/Config/Android prévaut sur BaseDeviceProfiles.ini à la fois dans Engine/Config et Projet/Config. Le fichier AndroidDeviceProfiles.ini dans Projet/Config/Android prévaut sur tous les éléments ci-dessus.

Profils d'appareils Android

Les profils d'appareils Android standard sont les suivants : Android_Low, Android_Mid et Android_High. Le profil Android_High représente l'ensemble des fonctionnalités prises en charge par l'Unreal Engine sur les appareils Android haut de gamme, tandis que Android_Low représente l'ensemble minimal de fonctionnalités pour les appareils Android bas de gamme.

Nous classons également des profils d'appareil plus spécifiques en fonction des familles de GPU prises en charge par l'Unreal Engine, car les appareils mobiles équipés du même GPU présentent généralement des caractéristiques de performance similaires. Ces profils d'appareil spécifiques au GPU mappent généralement l'un des profils standard (comme Android_High) à des appareils spécifiques, mais ils doivent parfois fournir des ajustements pour les cas particuliers.

Par exemple, les profils d'appareil suivants sont destinés aux appareils Adreno 5xx de l'Unreal Engine 4.24 :

[Android_Adreno5xx DeviceProfile]
	DeviceType=Android
	BaseProfileName=Android_High
	+CVars=r.DisjointTimerQueries=1

	[Android_Adreno5xx_No_Vulkan DeviceProfile]
	DeviceType=Android
	BaseProfileName=Android_Adreno5xx;
	There are several issues (vulkan sub-passes, occlusion queries) on devices running Android 7 and earlier
	+CVars=r.Android.DisableVulkanSupport=1

Le profil appareil standard Android_Adreno5XX hérite de Android_High pour tous ses paramètres de base, avec un seul remplacement pour rDisjointTimerQuery. Le profil Android_Adreno5xx_No_Vulkan hérite alors du profil standard Android_Adreno5xx et fournit un autre remplacement qui désactive la prise en charge du moteur de rendu Vulkan en raison de problèmes rencontrés sur les anciens appareils Adreno5xx.

En fonction du contenu de votre jeu, il peut être nécessaire de remplacer les profils existants ou d'en fournir de nouveaux dans le fichier AndroidDeviceProfiles.ini du projet. Si nécessaire, vous pouvez enrichir ces profils spécifiques au GPU pour représenter des appareils plus spécifiques au sein de ces familles de GPU, ou réécrire complètement les profils définis précédemment.

Règles de correspondance des profils d'appareil

Au lancement d'une application Unreal Engine, elle charge des informations sur l'appareil qui l'exécute. L'application parcourt ensuite une liste de règles permettant d'identifier les appareils en fonction de ces paramètres. Celles-ci se trouvent dans le fichier **BaseDeviceProfiles.ini**, dans la section [/Script/AndroidDeviceProfileSelector.AndroidDeviceProfileMatchingRules]. Lorsque l'application trouve une règle correspondant aux informations de l'appareil détecté, elle cesse de parcourir la liste et utilise le profil d'appareil associé.

Le format d'une entrée dans cette liste est le suivant :

+MatchProfile=(Profile="Profile_Name", Match=( ( Rule 1 ), ( Rule 2 ), (...) )

Les règles en elles-mêmes sont des comparaisons de chaîne qui adoptent le format suivant :

SourceType=[source string], CompareType=[comparison type], MatchString=[string to compare the source string to]

En fonction de la valeur que vous fournissez à SourceType, il produit une chaîne source à laquelle le système compare ensuite le composant MatchString.

Les valeurs valides pour SourceType et les chaînes sources de sortie correspondantes sont les suivantes :

Les types de comparaison disponibles sont les suivants :

À titre d'exemple, voici une entrée pour les appareils Mali T8xx dans la version 4.24 :

+MatchProfile=(Profile="Android_Mali_T8xx_No_Vulkan",Match=((SourceType=SRC_GpuFamily,CompareType=CMP_Regex,MatchString="^Mali\\-T8"),(SourceType=SRC_AndroidVersion, CompareType=CMP_Regex,MatchString="([0-9]+).*"),(SourceType=SRC_PreviousRegexMatch,CompareType=CMP_Less,MatchString="8")))

Cette entrée MatchProfile comporte de trois règles :

1. Il doit y avoir une correspondance d'expression régulière pour la famille de GPU portant la chaîne "^Mali-T8".

2. La version Android doit comporter un ou plusieurs chiffres. Ces chiffres sont conservés en mémoire jusqu'à ce qu'une valeur non numérique soit trouvée.

3. La version Android obtenue via la deuxième règle doit être inférieure à 8.

Si tous ces critères sont remplis, le profil Android_Mali_T8xx_No_Vulkan sera utilisé.

Les règles de profils d’appareils sont d'abord répertoriées par fabricant, puis par ordre croissant des spécifications, des appareils bas de gamme aux appareils haut de gamme. Les profils Android standard sont répertoriés comme solutions de repli si aucune des règles ne convient et que l'appareil spécifique ne peut être identifié.

Activer Vulkan

Un paramètre spécial appelé VulkanAvailable est utilisé pour déterminer si un appareil peut utiliser le moteur de rendu Android Vulkan. Il vérifie d'abord si la prise en charge de Vulkan est activée dans le jeu, puis si l'appareil dispose de pilotes Vulkan. Si ces deux conditions sont remplies, on considère que VulkanAvailable a la valeur true.

Les appareils compatibles avec Vulkan disposent de profils avec ou sans Vulkan activé, afin de prendre en compte les projets qui n'utilisent pas Vulkan malgré sa disponibilité sur l'appareil cible. Tous les profils ont un paramètre appelé r.Android.DisableVulkanSupport, qui est défini sur 1 par défaut. Les profils d'appareils compatibles avec Vulkan remplacent la valeur de ce paramètre par 0.

Paramètres d'évolutivité

Les paramètres d'évolutivité de base d'Unreal Engine sont définis dans le fichier Engine/Config/BaseScalability.ini, qui se trouve dans le répertoire d'installation du moteur. Les paramètres d'évolutivité des appareils Android sont définis dans le fichier Engine/Config/Android/AndroidScalability.ini.

Comprendre les valeurs d'évolutivité

Les paramètres d'évolutivité regroupent de vastes ensembles de paramètres dans des catégories générales qui peuvent ensuite être définies avec des valeurs simples comprises entre 0 et 3. Par exemple, voici le mappage d'évolutivité pour le niveau 0 de ShadowQuality dans BaseScalability.ini :

[ShadowQuality@0]
	r.LightFunctionQuality=0
	r.ShadowQuality=0
	r.Shadow.CSM.MaxCascades=1
	r.Shadow.MaxResolution=512
	r.Shadow.MaxCSMResolution=512
	r.Shadow.RadiusThreshold=0.06
	r.Shadow.DistanceScale=0.6
	r.Shadow.CSM.TransitionScale=0
	r.Shadow.PreShadowResolutionFactor=0.5

Chacune des valeurs répertoriées correspond à des fonctionnalités très spécifiques et chacune a sa propre échelle. Par exemple, certaines fonctionnent en termes de résolution de pixel, d'autres en termes de facteur d'échelle qui multiplie une valeur par défaut, et d'autres sont plus arbitraires. Ces valeurs peuvent être complexes à définir pour chaque fonctionnalité et doivent être modifiées entre les versions, car le matériel est mis à jour fréquemment.

Par conséquent, nous utilisons ShadowQuality pour condenser un groupe de paramètres connexes sous une seule valeur accessible à l'utilisateur. L'entrée ci-dessus définit le comportement de toutes ces valeurs lorsque sg.ShadowQuality est défini sur 0 dans un fichier de configuration. Des entrées similaires existent pour ShadowQuality@1 à 3.

Les recommandations pour ces valeurs d'évolutivité par défaut sont les suivantes :

Remplacer des paramètres d'évolutivité

Pour remplacer les paramètres d'évolutivité, vous pouvez créer un fichier AndroidScalability.ini dans le répertoire Config de votre projet. Par exemple, si vous avez un projet appelé AndroidQuickStart, vous pourriez le placer dans AndroidQuickStart/Config/Android.

Les paramètres d'évolutivité créés dans ce fichier auront la précédence sur les paramètres définis dans le fichier Engine/Config/Android/AndroidScalability.ini.

Définir les valeurs d'évolutivité dans les profils d'appareil

Pour faire référence à une valeur d'évolutivité dans les profils d'appareil, utilisez le préfixe sg. suivi du nom de la valeur que vous souhaitez définir. Par exemple, si vous souhaitez définir ShadowQuality sur 1 dans un profil d'appareil, vous pouvez utiliser ce qui suit :

+CVars=sg.ShadowQuality = 1

Tous les paramètres répertoriés après cette valeur d'évolutivité prévalent sur la valeur d'origine. Toutefois, il est fortement recommandé de modifier les paramètres d'évolutivité dans les fichiers *Scalability.ini et d'observer les groupes d'évolutivité au lieu de modifier systématiquement les paramètres à petite échelle dans les profils d'appareil. Cela permet de s'assurer que le niveau de rendu de l'aperçu dans l'éditeur applique correctement les valeurs d'évolutivité sur mobile.

Modifier les paramètres d'évolutivité lors de l'exécution

Les paramètres d'évolutivité initiaux sélectionnés par un profil d'appareil sont simplement les paramètres par défaut, et l'évolutivité peut facilement être modifiée à l'exécution grâce à différentes méthodes.

Utiliser le menu Paramètres dans l'Unreal Editor

À des fins de test, vous pouvez modifier les paramètres d'évolutivité de votre jeu dans l'Unreal Editor en cliquant sur le menu déroulant Paramètres dans la barre d'outils, puis en atteignant les Paramètres d'évolutivité du moteur.

Toutes les modifications effectuées dans ce menu sont appliquées immédiatement.

Modifier les paramètres d'évolutivité avec des commandes de console

Vous pouvez également appeler n'importe quel paramètre d'évolutivité via une commande de console. Par exemple, si vous saisissez sg.FoliageQuality 2 dans la console et appuyez sur la touche Entrée, la valeur de toutes les Cvar sous FoliageQuality est modifiée en conséquence.

Les valeurs du menu Paramètres d'évolutivité du moteur refléteront ce changement.

Vous pouvez également obtenir la valeur actuelle d'un paramètre d'évolutivité en saisissant son nom dans une commande de console, sans valeur numérique. Par exemple, si vous saisissez sg.FoliageQuality et appuyez sur Entrée, la console affiche la valeur actuelle de FoliageQuality ainsi que le dernier endroit où elle a été définie.

Modifier les paramètres d'évolutivité dans Blueprint

Bien qu'il soit possible de modifier les paramètres d'évolutivité via des commandes de console dans Blueprint, ceux-ci sont également accessibles par des fonctions dédiées au sein des paramètres utilisateur du jeu, auxquels vous pouvez accéder via le nœud Get Game User Settings.

Vous pouvez combiner cette fonctionnalité avec UMG pour créer des menus dans lesquels vos utilisateurs peuvent modifier ces paramètres. Les utilisateurs peuvent ainsi personnaliser les graphismes et les performances d'un jeu à leur guise.

Modifier les paramètres d'évolutivité dans C++

En C++, les paramètres utilisateur du jeu sont accessibles avec la fonction statique UGameUserSettings::GetGameUserSettings. Vous pouvez ensuite utiliser ses fonctions dédiées get et set pour obtenir et définir le niveau de qualité des paramètres d'évolutivité.

#include "MyActor.h"
	#include "GameUserSettings.h"

	void AMyActor::SampleScalabilityFunctions()
	{
		//Getting a reference to the Game User Settings.
		UGameUserSettings* UserSettings = UGameUserSettings::GetGameUserSettings();

		//Getting the current Foliage Quality.
		Int32 FoliageQuality = UserSettings->GetFoliageQuality();