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 :
Engine/Config/Base*.iniProjet/Config/Base*.iniEngine/Config/Android/Android*.iniProjet/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=1Le 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 :
| Valeur de SourceType | Description | Exemple de sortie |
|---|---|---|
| Le numéro de modèle de l'appareil. | "Nexus 6" |
| Le fabricant de l'appareil. | "NVidia" |
| La famille de GPU du GPU de cet appareil. | "Adreno (TM) 320", "NVIDIA Tegra" |
| La version OpenGL exécutée par cet appareil. | OpenGL ES 3 |
| La version de système d'exploitation Android utilisée par cet appareil. | Une valeur numérique. |
| Vérifier si l'application a été empaquetée avec Vulkan activé et si l'appareil prend en charge la version de Vulkan requise dans les paramètres du projet. |
|
| La version de Vulkan utilisée par cet appareil, le cas échéant. | Une valeur numérique. |
| La valeur d'une correspondance d'expression régulière précédente au sein de la même entrée MatchProfile. | Toute information déjà générée par une correspondance d'expression régulière. |
Les types de comparaison disponibles sont les suivants :
| Type de comparaison | Description |
|---|---|
| Effectuer une comparaison qui utilise des opérateurs d'expression régulière dans MatchString. |
| Vérifier que les valeurs des deux chaînes sont exactement identiques. |
| Identique à |
| Vérifier que les valeurs des deux chaînes sont différentes. |
| Identique à |
| Vérifier si la valeur numérique de la chaîne source est inférieure à MatchString. |
| Identique à |
| Identique à |
| Identique à |
| Vérifier si la valeur numérique de la chaîne source est supérieure à MatchString. |
| Identique à |
| Identique à |
| Identique à |
À 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 :
Il doit y avoir une correspondance d'expression régulière pour la famille de GPU portant la chaîne "^Mali-T8".
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.
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é.
Si vous ajoutez des règles à cette liste, assurez-vous de les placer dans le bon ordre par rapport aux autres appareils de la même famille.
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.
L'activation de Vulkan n'est recommandée que pour les appareils qui fonctionnent sous Android 9 ou une version ultérieure, car les premiers appareils prenant en charge Vulkan présentaient plusieurs bogues dans leurs pilotes.
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 :
| Valeur d'évolutivité | Description |
|---|---|
0 | Basse qualité. Les paramètres les plus bas compatibles avec la gamme minimale d'appareils pris en charge par l'Unreal Engine. |
1 | Qualité moyenne. Des paramètres adaptés à une grande variété d'appareils de milieu de gamme sur lesquels l'Unreal Engine a été testé. |
2 | Haute qualité. Les paramètres qui conviennent à la plupart des appareils haut de gamme sur lesquels l'Unreal Engine a été testé. |
3 | Qualité Epic. Les valeurs les plus élevées possibles pour une fonctionnalité donnée dans la version actuelle de l'Unreal Engine. |
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 = 1Tous 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();