Optimisation du rendu pour mobile

Cette page fournit des recommandations et les bonnes pratiques pour optimiser les performances sur mobile tout en bénéficiant d'un maximum de fidélité visuelle grâce aux fonctionnalités HDR mobile. Les éléments suivants sont conservés :

• Informations sur les facteurs qui contribuent à votre budget de performances sur les appareils mobile

• Bonnes pratiques pour empaqueter des projets avec les fonctionnalités HDR mobile activées

• Une démonstration pas-à-pas des outils disponibles pour mesurer les goulots d'étranglement en matière de performances dans vos applications Unreal Engine

Connaître son budget de performance

L'appareil cible de votre application dispose d'une quantité limitée de ressources, tant pour la gestion des objets en mémoire que pour leur traitement. Lorsque vous développez votre application, vous devez décider comment allouer ces ressources. Vous devez vous familiariser avec les capacités de votre appareil en termes de vitesse, de threads et de bande passante pour vos CPU et GPU, ainsi qu'avec la mémoire, la mémoire graphique et l'espace disque disponible de l'appareil.

Vous devez également effectuer un test des performances de votre appareil pour comprendre comment il fonctionne et identifier les goulots d'étranglement en termes de performances. Vous pouvez effectuer le test de performance d'un appareil en exécutant une application gourmande ou une démonstration technique, puis en observant ses statistiques de performance.

Commandes de console pour afficher les statistiques de performance

Vous pouvez vérifier les statistiques de performance à l'aide d'une série de commandes de console. Pour ouvrir la console du développeur sur un appareil mobile, touchez l'écran avec quatre doigts à la fois. Cela ouvrira un clavier à l'écran ainsi qu'une invite permettant de saisir des commandes de console.

Dans la console, vous pouvez saisir des commandes pour afficher des informations de débogage à l'écran. Le tableau suivant répertorie les commandes permettant d'obtenir des informations sur les performances :

Facteurs de performance courants

Maintenant que vous savez où consulter les données de performance sur votre appareil, cette section vous présentera les facteurs qui influencent le plus souvent les performances des moteurs de rendu mobile d'Unreal Engine. En comprenant quels éléments ont un impact sur votre application et de quelle manière, vous pourrez identifier et résoudre rapidement les problèmes à l'aide des outils de diagnostic d'Unreal Engine.

Textures de normales ou Maillages à nombre élevé de vertex

Les moteurs de rendu mobile d'Unreal Engine sont efficaces pour le rendu d'un grand nombre de vertex, tandis que les textures de normales de haute qualité peuvent poser des problèmes de profondeur de bit et coûter plus cher en performances qu'un modèle à nombre élevé de polygones.

Avec du matériel moins performant, les textures de normales peuvent grandement améliorer la qualité des reflets et de l'éclairage sur la surface d'un modèle. Cependant, les formes subtiles, comme les panneaux de carrosserie d'une voiture, peuvent dépasser les deltas de 8 bits normalement utilisés pour ces textures, ce qui entraîne un effet de bandes visibles dans le rendu final.

Vous pouvez utiliser des textures de normales en 16 bits pour compenser cela, mais le coût en pixels des normales en 16 bits dépasse le coût en vertex d'un maillage de densité plus élevée. Les normales en 16 bits ne sont pas compressées dans le moteur. Elles sont donc huit fois plus grandes qu'une texture de normales ordinaire.

Dans l'exemple ci-dessous, nous utilisons des panneaux de carrosserie à haute densité sans textures de normales. Lors du ciblage de la Galaxy Tab S6, l'ensemble de nos panneaux de carrosserie totalise environ 500 000 vertex.

Bonnes pratiques pour les textures de normales haute résolution

Le précalcul de vertex haute résolution dans une texture de normales pour un modèle à faible nombre de polygones peut se révéler être un processus complexe. De nombreux facteurs peuvent réduire la qualité d'une texture de normales dans le moteur. Il existe de nombreux ensembles d'outils de précalcul des textures de normales, mais nous recommandons xNormal. Le processus utilisé pour xNormal est à peu près le suivant :

1. Précalculer la texture de normales dans xNormal au format TIFF 8k avec un anticrénelage 4x.

2. Importer le fichier TIFF dans Photoshop, puis réduire sa résolution à une texture 1k.

3. Appliquer un flou gaussien d'une valeur de 0,35 px.

4. Convertir l'image de 16 bits à 8 bits.

5. Exporter l'image au format TGA 24 bits.

6. Importer la texture de normales finale dans l'Unreal.

Pour s'assurer que les normales de surface utilisées dans le processus de précalcul sont les mêmes que celles présentes dans le moteur, vous devez exporter les normales optimisées depuis l'Unreal. Importez le modèle de précalcul dans l'Unreal, choisissez de créer ses propres normales, puis exportez le modèle de précalcul depuis l'Unreal pour le précalculer dans xNormal. Il s'agit d'une étape importante dans la création de textures de normales de haute qualité, car xNormal doit connaître les normales de surface du maillage pour appliquer les décalages à partir du modèle haute résolution.

Enfin, il existe deux options pour réduire les artefacts lors du rendu des maillages statiques :

• Use Full Precision UVs

• Use High Precision Tangent Basis

Ces deux options sont disponibles dans l'éditeur de maillage statique, dans le panneau Détails, sous les LOD.

Appels de rendu

Les appels à générer sont des recherches de ressources, qui se produisent à chaque image. Le nombre d'appels à générer utilisés par votre application dépend du nombre de maillages uniques dans votre scène, ainsi que du nombre d'identifiants de matériau uniques utilisés pour chaque maillage. Actuellement, un nombre élevé d'appels à générer constitue la principale cause de faibles performances graphiques. Vous devez réduire ce nombre autant que possible.

À titre d'exemple, un modèle de voiture très optimisé peut ne comporter que cinq ou six maillages distincts, chacun d'entre eux n'ayant qu'un seul matériau.

Dans une scène optimisée, il est conseillé de viser environ 700 appels à générer sur une Galaxy Tab S6, et moins de 500 sur des appareils moins puissants. Dans les projets HMI, qui ont tendance à utiliser des matériaux très spécifiques ou complexes, un objectif de 100 appels à générer sur un Galaxy Tab S6 est raisonnable, tandis qu'il est préférable de rester en dessous de 50.

Vous pouvez afficher le nombre d'appels à générer avec la commande de console Stat RHI.

Réduire le nombre de maillages

La façon la plus simple de réduire le nombre d'appels à générer est de réduire le nombre de maillages uniques dans votre monde. Pour ce faire, il est possible de combiner autant d'objets que possible dans un seul maillage à l'aide de la trousse à outils de création de contenu numérique (CCN), tels que Maya, 3DSMax ou Blender, avant de les importer dans l'Unreal.

Réduire le nombre d'identifiants de matériaux

Il existe plusieurs options permettant de réduire le nombre de matériaux uniques sur un maillage.

La méthode la plus simple consiste à utiliser un programme tel que Substance Painter, qui intègre plusieurs matériaux dans une même texture. Elle permet de tirer parti d'un très grand nombre de types de matériaux à partir d'un matériau Unreal très simple, que vous pouvez ensuite utiliser comme base pour des instances de matériau avec des entrées de textures simples. Elle permet également de réduire le nombre d'instructions de matériau, ce qui améliore davantage les performances.

La deuxième méthode utilise le masquage pour une approche plus procédurale. Les matériaux peuvent indiquer certaines caractéristiques d'une surface, comme sa couleur, sa rugosité ou son aspect métallique. Au lieu d'utiliser un matériau distinct pour chaque partie d'un maillage, vous pouvez utiliser des masques pour séparer les parties des UV d'un maillage et appliquer des paramètres différents à chaque section. Vous pouvez créer un masque de base à l'aide d'une texture en noir et blanc, mais il est plus efficace d'utiliser la colorisation des vertex.

Rendu final

Colorisation des vertex

Dans l'exemple ci-dessous, la colorisation des vertex est utilisée pour définir différents types de matériaux, et le matériau définit les paramètres qui peuvent influencer l'aspect de ces éléments individuellement. Le masquage par colorisation des vertex est plus efficace et crée une séparation plus nette, car il ne repose pas sur la résolution de la texture.

Materials

Lacomplexité des matériaux peut augmenter le coût en pixels d'un rendu. Plus il y a d'instructions pour chaque pixel, plus le moteur de rendu mettra de temps à calculer sa valeur finale. Les matériaux opaques sont les moins coûteux, mais ils peuvent grandement varier en fonction du modèle d'ombrage ou du code de shader de base.

Le nombre d'instructions d'un matériau est indiqué dans la fenêtre Stats de l'éditeur de matériau.

Le nombre d'instructions augmente également en fonction du nombre de fonctions mathématiques présentes dans un matériau. Plus il y a de nœuds, plus le matériau sera coûteux à rendre. Certaines opérations spécifiques sont également plus coûteuses. Essayez de limiter le nombre d'instructions lorsque vous créez des matériaux plus complexes.

Les matériaux translucides et transparents font partie des types de matériaux les plus coûteux. Les couches individuelles de translucidité ont un coût élevé par pixel. En outre, lorsque plusieurs couches de transparence sont empilées et rendues, leur coût est bien plus élevé. C'est ce qu'on appelle suraffichage.

Les phares et les feux arrière des véhicules sont un exemple de zones problématiques en matière de transparence. Dans de nombreux cas, nous utilisons des textures peintes à la main pour réduire la complexité des matériaux. Les formes complexes et la profondeur peuvent être bien illustrées, même avec une texture plane.

Optimiser la résolution des textures

Les textures haute résolution nécessitent beaucoup d'espace, à la fois pour le stockage sur un appareil et dans la mémoire de texture d'un appareil, et les textures plus grandes nécessitent davantage de pixels à afficher et à traiter. Bien qu'elles puissent améliorer la fidélité visuelle, l'augmentation de leur taille offre des bénéfices décroissants en fonction de la résolution de l'écran de l'appareil et de l'angle de vue de la texture. Il est important d'utiliser la plus petite texture possible pour obtenir le niveau de fidélité visuelle désiré.

Pour déterminer vos besoins en texture, vous devez d'abord finaliser l'emplacement de la caméra et le champ de vision à partir duquel vous allez visualiser votre modèle. Cela permettra de déterminer l'espace écran de tous les maillages et matériaux.

Une fois que l'emplacement de la caméra est déterminé, vous pouvez utiliser une texture de débogage spéciale pour déterminer la résolution de texture à utiliser pour les différents matériaux. Cette texture utilise le comportement des mipmaps pour déterminer la résolution nécessaire pour différents composants, en appliquant des couleurs différentes à chaque mipmap. Il est ainsi plus facile d'identifier le MIP utilisé par le matériau et la résolution de texture à utiliser.

Reliez la texture incluse dans le canal émissif d'un matériau non éclairé, puis appliquez ce matériau à votre maillage. Lorsque vous visualisez le maillage à partir de la distance de caméra appropriée, le code couleur indique le niveau de mip utilisé par le moteur pour le rendu. Le plus haut niveau observé devrait être de taille de texture native de vos textures d'occlusion ambiante.

Taille du paquet et temps de démarrage

Lors de l'empaquetage d'une application et de ses ressources, il existe un compromis entre la taille du paquet sur le disque et les performances au démarrage de l'exécution.

Lorsque la compression ZLib est activée, la taille du paquet de votre application est réduite. Cependant, le chargement de l'application peut être plus coûteux en temps de CPU, ce qui peut ralentir la vitesse de démarrage. Pour un temps de démarrage optimal, vous pouvez désactiver la compression.

Paramètres de chargement dynamique recommandés

Les paramètres de chargement dynamique suivants sont recommandés dans le fichier DefaultEngine.ini. Ces derniers fournissent du temps supplémentaire au début d'une application pour le chargement asynchrone des ressources, ce qui peut améliorer le temps de démarrage.

[/Script/Engine.StreamingSettings]
	s.PriorityAsyncLoadingExtraTime=275.0
	s.LevelStreamingActorsUpdateTimeLimit=250.0
	s.PriorityLevelStreamingActorsUpdateExtraTime=250.0

Paramètres d'empaquetage recommandés

Les paramètres d'empaquetage suivants sont recommandés dans le fichier DefaultEngine.ini. Ces paramètres réduisent la quantité de compression utilisée lors de l'empaquetage des ressources, car les fichiers .pak non compressés se chargent bien plus vite que les fichiers compressés avec ZLib au démarrage.

[/Script/UnrealEd.ProjectPackagingSettings]
	bCompressed=False
	BuildConfiguration=PPBC_Development
	bShareMaterialShaderCode=True
	bSharedMaterialNativeLibraries=True
	bSkipEditorContent=True

Analyse de la taille des paquets sur le disque

L'Unreal Engine propose plusieurs outils utiles permettant d'analyser l'empreinte mémoire des ressources.

Carte des tailles

La carte des tailles lit et compare la consommation de mémoire relative des ressources dans l'éditeur. Pour l'utiliser, vous devez activer le plug-in AssetManagerEditor. Après cela, vous pouvez y accéder en faisant un clic droit sur un dossier dans le navigateur de contenu et en sélectionnant Carte des tailles dans le menu contextuel.

La carte des tailles affiche une fenêtre avec des icônes représentant la quantité de mémoire que les dossiers et les fichiers consomment. Plus l'icône est grande, plus le fichier occupe d'espace.

Pour plus d'informations sur l'utilisation de la carte des tailles, consultez la rubrique Préparation et segmentation.

Statistiques

L'outil Statistiques offre des informations plus détaillées sur l'utilisation des ressources dans un niveau. Il se trouve dans le menu déroulant Fenêtre.

La fenêtre Statistiques ventile le nombre de ressources dans vos fichiers de niveau et peut afficher l'ensemble des niveaux ou seulement certains d'entre eux. Statistiques primitives répertorie les informations sur le nombre de triangles, la consommation de mémoire et le nombre d'éléments.

Cette liste inclut également des informations sur l'utilisation des textures et l'éclairage des maillages statiques. Le mode de liste de la fenêtre Statistiques met en évidence les ressources les plus gourmandes en mémoire. Les données de Statistiques du préparateur sont également très utiles, car elles répertorient toutes les ressources qui ont été préparées lors du dernier processus d'empaquetage.

Rapports sur la mémoire

Alors que les outils Statistiques et Carte des tailles affichent l'empreinte mémoire de vos fichiers dans l'Unreal Editor, la commande de console Memreport -full peut être utilisée à partir d'une installation de votre application lancée sur l'appareil cible. Cette option offre une vue détaillée et précise de la taille de vos fichiers telle qu'elle sera appliquée avec les paramètres de compression de votre appareil.

Une fois l'application compilée en configuration Développement et installée sur l'appareil, il est possible d'ouvrir la fenêtre de console et d'y saisir la commande. Cet instantané de la mémoire est enregistré dans le répertoire du projet, sur l'appareil. Ce répertoire est généralement le suivant : Game/[VotreApplication]/[VotreApplication]/Saved/Profiling/Memreports/, mais cela peut varier.

Le fichier .memreport est un fichier texte qui peut être lu dans la plupart des éditeurs de texte. Au début du texte figure des informations sur la mémoire allouée et la taille des pools, tandis que la majeure partie présente un historique des niveaux chargés, des statistiques RHI, des cibles de rendu, des informations sur la scène, et bien plus encore. Toutes ces informations sont utiles, car il s'agit des données qui ont passé le processus de préparation et d'empaquetage.

Si vous recherchez l'expression Liste de toutes les textures, vous trouverez une liste de toutes les textures dans votre application, avec des informations détaillées sur le type de texture, le groupe de textures, la taille des textures et leur empreinte mémoire. La liste est triée par taille de mémoire, les plus grandes textures étant présentées en premier. C'est une bonne méthode pour repérer les textures qui consomment le plus de mémoire.

Analyser le temps de démarrage

Les facteurs qui affectent le temps de démarrage sont les suivants :

• Le temps nécessaire pour charger et décompresser les ressources initiales

• La taille globale de votre application

• Tous les plug-ins à activer dans l'installation de l'utilisateur

• La quantité de données de chaîne à analyser

• Toute allocation ou fragmentation de mémoire sur l'appareil de l'utilisateur.

Plusieurs outils sont disponibles pour analyser le temps de démarrage de votre application, mais Unreal Insights est le plus recommandé, car il permet de profiler les données de performances à distance à partir d'un appareil cible. Pour obtenir des informations complètes sur cette trousse à outils, consultez la section Unreal Insights.

Pour un exemple d'utilisation d'Unreal Insights dans une application Android, consultez la rubrique Unreal Insights sur les appareils Android.