Moteurs natifs et propriétaires

Premiers pas avec Vulkan sur Android

Vulkan est la principale API graphique de bas niveau sur Android. Vulkan offre des performances optimales pour les jeux qui implémentent leur propre moteur de jeu et de rendu.

Pour implémenter Vulkan dans votre moteur de jeu, vous devez :

  • Identifier les appareils Android à utiliser avec Vulkan
  • Comprendre les inconvénients de la prise en charge d'anciens appareils Android
  • Ajouter Vulkan à votre cible de compilation Android
  • Choisir un compilateur de nuanceurs pour créer le format SPIR-V pour Vulkan
  • Déterminer la version d'API Vulkan disponible au moment de l'exécution
  • Apprendre à optimiser vos opérations de rendu Vulkan avec des profils Vulkan, le frame pacing et la prérotation
  • Sélectionner des outils graphiques pour le débogage et l'analyse des performances
    Remarque : Pour en savoir plus sur l'utilisation de Vulkan sur Android avec les moteurs de jeu Unity ou Unreal, consultez les pages suivantes :
  • Vulkan sur Unity
  • Vulkan sur Unreal

Choisir les spécifications minimales de l'appareil pour Vulkan

Vulkan est disponible sur Android à partir d'Android 7.0 (niveau d'API 24). Tous les appareils Android équipés d'Android 7.0 ou d'une version ultérieure ne sont pas compatibles avec Vulkan. Vous devez déterminer les appareils Android compatibles avec Vulkan que votre jeu prend en charge.

Recommandations

Utilisez les spécifications suivantes comme configuration minimale requise pour la prise en charge de Vulkan :

  • L'appareil est équipé d'Android 10.0 (niveau d'API 29) ou d'une version ultérieure.
  • L'appareil est compatible avec l'API Vulkan 1.1 et versions ultérieures.
  • L'appareil dispose de capacités matérielles et de fonctionnalités compatibles avec le profil de référence Android 2022.

Compatibilité avec les appareils plus anciens

Si votre jeu est conçu pour s'exécuter sur une large gamme d'appareils avec différents niveaux de capacités graphiques, vous devrez peut-être prendre en charge des appareils plus anciens que ceux recommandés dans la partie Choisir les spécifications minimales de l'appareil pour Vulkan. Avant de mettre en place la prise en charge des appareils plus anciens, évaluez les avantages de Vulkan pour votre jeu. Les jeux qui comportent de nombreux appels de dessin et qui utilisent OpenGL ES peuvent entraîner une surcharge importante du pilote puisque les appels de dessin ont un coût élevé dans OpenGL ES. Ces jeux peuvent être dépendants du processeur lorsqu'ils accordent une grande partie de leur temps de rendu au pilote graphique. En passant d'OpenGL ES à Vulkan, il est également possible de constater une réduction significative de l'utilisation du processeur et de la consommation d'énergie dans les jeux. Cela est particulièrement vrai si votre jeu comporte des scènes complexes qui ne peuvent pas utiliser efficacement les instances pour réduire les appels de dessin. Lorsque vous ciblez des appareils plus anciens, incluez la prise en charge du rendu OpenGL ES en guise de solution de secours, car certains appareils de votre liste d'appareils cibles peuvent disposer d'implémentations Vulkan qui ne peuvent pas exécuter votre jeu de manière fiable.

Vous ne souhaitez peut-être pas prendre en charge d'anciens appareils compatibles avec Vulkan si leurs performances et fonctionnalités ne conviennent pas ou s'ils présentent des problèmes de stabilité.

Performances et fonctionnalités

Les appareils Android plus anciens compatibles avec Vulkan peuvent ne pas offrir les performances de rendu ou la compatibilité matérielle pour les fonctionnalités nécessaires à l'exécution de votre jeu. C'est notamment probable si votre jeu dispose de graphismes haute fidélité et que Vulkan est la seule API que vous ciblez sur Android. De nombreux appareils plus anciens sont limités à la version 1.0.3 de l'API Vulkan et ne profitent pas des extensions Vulkan largement utilisées et disponibles sur les matériels plus modernes.

Stabilité

Les anciens appareils Android peuvent utiliser des pilotes Vulkan obsolètes. Ces versions de pilote peuvent comporter des bugs susceptibles d'affecter la stabilité de votre jeu. Le contournement des bugs au niveau des pilotes peut nécessiter un temps important de test et d'ingénierie.

Ajouter Vulkan à votre projet

Pour ajouter Vulkan à votre projet, procédez comme suit :

  • Incluez les en-têtes d'API Vulkan.
  • Compiler le code du nuanceur au format SPIR-V
  • Appelez l'API Vulkan au moment de l'exécution.

Inclure les en-têtes d'API Vulkan

Votre jeu doit inclure les fichiers d'en-tête de l'API Vulkan pour compiler le code qui utilise Vulkan. Vous trouverez une copie des en-têtes Vulkan dans le NDK Android ou dans les versions du SDK Vulkan sous forme de package. Chaque version de NDK n'inclut que les en-têtes Vulkan disponibles au moment de la publication de cette version. Si vous utilisez des en-têtes Vulkan obtenus d'un NDK, utilisez la version 25 et les versions ultérieures, car elles incluent des fichiers d'en-tête compatibles avec la version 1.3 de Vulkan. Le SDK Vulkan dispose de la version la plus récente des en-têtes.

Compiler le code du nuanceur au format SPIR-V

L'API Vulkan s'attend à ce que les programmes de nuanceurs soient fournis au format intermédiaire binaire SPIR-V. Cette convention est différente d'OpenGL ES, pour laquelle vous pouvez envoyer du code source écrit en GLSL (OpenGL Shading Language) sous forme de chaînes de texte. Utilisez un compilateur de nuanceurs pour prendre le code écrit dans un langage de nuanceur, comme le GLSL ou le HLSL (High-level Shader Language) et le compiler en modules SPIR-V à utiliser avec Vulkan.

Le compilateur shaderc permet de compiler des programmes de nuanceurs écrits en GLSL au format SPIR-V. Si votre jeu utilise le HLSL, DirectXShaderCompiler permet une sortie au format SPIR-V. En règle générale, vous procédez à la compilation hors ligne des programmes de nuanceurs dans le cadre de processus de création d'éléments. Vous incluez ensuite les modules SPIR-V dans vos éléments d'exécution.

Appeler l'API Vulkan au moment de l'exécution

Pour appeler l'API Vulkan, votre jeu doit obtenir des pointeurs de fonction vers les appels d'API Vulkan. Pour ce faire, le moyen le plus simple consiste à l'associer à la bibliothèque partagée libvulkan.so, qui est incluse dans le NDK Android. L'association à la bibliothèque présente deux inconvénients : une surcharge de distribution des fonctions supplémentaire et des limites sur lesquelles les pointeurs de fonction de l'API Vulkan sont automatiquement résolus.

Lorsque vous appelez une fonction de l'API Vulkan, le contrôle passe par une table de distribution gérée par une construction appelée "chargeur Vulkan". Android utilise sa propre implémentation du chargeur Vulkan, et non le chargeur LunarG. Ce système de chargeur fait partie de l'architecture de couche de l'API Vulkan. Si vous associez la bibliothèque système au moment de la compilation, un niveau de distribution supplémentaire est ajouté pour un appel d'API donné. Bien que la surcharge soit faible, elle peut être visible pour les jeux qui effectuent des volumes élevés d'appels Vulkan.

La bibliothèque système ne résout généralement que les pointeurs vers les fonctions Vulkan qui sont considérées comme faisant partie de l'API principale. Vulkan comporte un grand nombre d'extensions qui définissent des fonctions Vulkan supplémentaires, dont la plupart ne sont pas automatiquement résolues par la bibliothèque système. Vous devez résoudre manuellement les pointeurs vers ces fonctions Vulkan avant de les utiliser.

Pour atténuer ces problèmes, résolvez de manière dynamique les pointeurs vers toutes les fonctions Vulkan que vous prévoyez d'utiliser au moment de l'exécution. Pour ce faire, vous pouvez utiliser une bibliothèque de méta-chargeurs Open Source telle que volk. L'exemple de jeu AGDKTunnel intègre volk à cette fin. Si vous utilisez une bibliothèque de méta-chargeurs, n'associez pas vos scripts de compilation à la bibliothèque partagée libvulkan.so.

Déterminer la version disponible de l'API Vulkan

Android est compatible avec les versions suivantes de l'API Vulkan :

  • 1.0.3
  • 1.1
  • 1.3

Le numéro de version de l'API Vulkan le plus élevé disponible sur un appareil donné est déterminé par la version d'Android et la compatibilité du pilote Vulkan.

Version d'Android

La compatibilité d'une plate-forme avec une version d'API Vulkan dépend d'une version minimale d'Android (niveau d'API) :

  • 1.3 – Android 13.0 (niveau d'API 33) ou version ultérieure
  • 1.1 – Android 10.0 (niveau d'API 29) ou version ultérieure
  • 1.0.3 – Android 7.0 (niveau d'API 24) ou version ultérieure

Prise en charge des pilotes Vulkan

La compatibilité d'une version d'API Vulkan avec la plate-forme Android ne garantit pas que celle-ci est compatible avec le pilote Vulkan de l'appareil. Un appareil exécutant Android 13 peut ne prendre en charge que la version 1.1 de l'API Vulkan.

Lors de l'initialisation de Vulkan, ne demandez pas de version d'API supérieure à :

  • La version maximale de l'API Vulkan pour la version d'Android exécutée sur l'appareil ;
  • La version de l'API Vulkan signalée par vkEnumerateInstanceVersion ;
  • La version de l'API Vulkan indiquée par la propriété apiVersion de la structure VkPhysicalDeviceProperties.

Voici un exemple permettant de déterminer la version d'API Vulkan la plus élevée compatible :

// Minimum Android API levels for Vulkan 1.3/1.1 version support
static constexpr int kMinimum_vk13_api_level = 33;
static constexpr int kMinimum_vk11_api_level = 29;

uint32_t GetHighestSupportedVulkanVersion(VkPhysicalDevice physical_device) {
  uint32_t instance_api_version = 0;
  vkEnumerateInstanceVersion(&instance_api_version);

  VkPhysicalDeviceProperties device_properties;
  vkGetPhysicalDeviceProperties(physical_device, &device_properties);

  // Instance and device versions don't have to match, use the lowest version
  // number for API support if they don't.
  const uint32_t driver_api_version =
      (instance_api_version < device_properties.apiVersion) ?
      instance_api_version : device_properties.apiVersion;

  const int device_api_level = android_get_device_api_level();
  if (device_api_level >= kMinimum_vk13_api_level &&
      driver_api_version >= VK_API_VERSION_1_3) {
    return VK_API_VERSION_1_3;
  } else if (device_api_level >= kMinimum_vk11_api_level &&
             driver_api_version >= VK_API_VERSION_1_1) {
    return VK_API_VERSION_1_1;
  }
  return VK_API_VERSION_1_0;
}

Déterminer la compatibilité du profil Vulkan

Les profils Vulkan sont des fichiers JSON qui définissent un ensemble de fonctionnalités, d'extensions, de capacités et de limites minimales de paramètres qu'un appareil Vulkan doit prendre en charge pour être compatible avec le profil. Pour déterminer si un appareil est compatible avec un profil Vulkan spécifique, tel que le profil de référence Android 2022, utilisez la bibliothèque d'API Vulkan Profiles Open Source. Vous pouvez également analyser le fichier JSON de profil et interroger les capacités de l'appareil à l'aide des API Vulkan appropriées pour déterminer la compatibilité du profil.

Profils Vulkan

Android utilise des profils Vulkan qui définissent les fonctionnalités et les extensions disponibles pour chacun des appareils exécutant Android.

Le profil de référence Android (ABP) est la première tentative de création d'un profil Vulkan. ABP2021 et ABP2022 sont des profils rétrospectifs visant à couvrir plus de 85% des appareils actifs à ce moment-là. Aucun nouvel ABP ne sera créé à l'avenir.

Les profils Vulkan pour Android (VPA) sont de nouveaux profils tournés vers l'avenir qui visent à refléter les besoins des développeurs logiciels et à générer des fonctionnalités cohérentes dès que les développeurs matériels peuvent les fournir. VPA15_minimums est le premier profil pour Android 15. Un nouveau VPA sera publié chaque année pour couvrir chaque version majeure d'Android.

Implémenter le frame pacing

Un frame pacing approprié est essentiel pour offrir une expérience de jeu de haute qualité. Android Game Development Kit comprend la bibliothèque Frame Pacing pour vous aider à optimiser le frame pacing dans votre jeu. Pour en savoir plus sur l'implémentation, consultez l'article Intégrer Android Frame Pacing dans votre moteur de rendu Vulkan.

Implémenter la prérotation

Les appareils Android peuvent proposer un affichage sous plusieurs orientations. L'orientation de l'appareil peut être différente de l'orientation de la surface de rendu. Contrairement à OpenGL ES sur Android, Vulkan ne gère pas les différences entre les deux. Pour comprendre le fonctionnement du processus d'orientation et la méthode optimale de gestion des différences d'orientation lors de l'utilisation de Vulkan, consultez l'article Gérer l'orientation de l'appareil avec la prérotation Vulkan.

Résoudre les problèmes et profiler le rendu Vulkan

Plusieurs outils sont disponibles pour vous aider à diagnostiquer les problèmes de rendu et de performances avec le code de rendu Vulkan.

Pour en savoir plus sur les outils de débogage et de profilage de Vulkan, consultez la section Outils et fonctionnalités avancées.

Couches de validation Vulkan

Les couches de validation Vulkan sont des bibliothèques d'exécution qui peuvent être activées pour inspecter vos appels à l'API Vulkan et générer des avertissements ou des erreurs concernant une utilisation incorrecte ou non optimale. Ces couches de validation ne sont pas actives par défaut, car le processus de validation augmente la charge d'exécution et affecte les performances de votre jeu. Pour en savoir plus sur l'utilisation des couches de validation avec votre jeu, consultez Déboguer avec une couche de validation.

Outils de capture de frame

Utilisez des outils de capture de frames pour enregistrer et répéter les appels d'API Vulkan effectués pendant un frame de jeu. Grâce à ces outils, vous pouvez :

  • Afficher les informations et les visualisations des ressources graphiques actives ;
  • Voir la séquence des appels d'API effectués par votre jeu et voir les paramètres d'API ;
  • Explorer l'état du pipeline graphique au moment d'un appel de dessin ;
  • Visualiser les résultats du rendu jusqu'à un appel de dessin spécifique dans l'image.

Utilisez l'outil Open Source RenderDoc pour capturer des images de jeux exécutés sur Android. RenderDoc est compatible avec la capture de frames de Vulkan et d'OpenGL ES.

Vous pouvez également utiliser Android GPU Inspector (AGI) pour capturer des frames Vulkan.

Outils d'analyse des performances

Utilisez des outils d'analyse des performances pour identifier les problèmes de rendu dans votre jeu qui affectent les fréquences d'images. Chaque fournisseur de GPU propose des outils conçus pour profiler votre jeu et fournir des données de performances spécifiques à leurs architectures GPU. Les caractéristiques de performances et les goulots d'étranglement de votre jeu peuvent varier considérablement lors du rendu sur des GPU de différents fournisseurs, ou même sur différentes générations de GPU du même fournisseur.

Vous pouvez également utiliser Android GPU Inspector pour collecter et analyser les données sur les performances. Contrairement aux outils des fournisseurs, Android GPU Inspector est compatible avec plusieurs GPU de différents fournisseurs. Toutefois, Android GPU Inspector n'est pas compatible avec les appareils Android plus anciens et peut ne pas être compatible avec tous les nouveaux appareils.

Améliorer les tests Vulkan avec CTS-D

Les fabricants d'appareils Android utilisent la suite de tests de compatibilité (CTS) pour s'assurer que leurs appareils sont compatibles. Le CTS (CTS-D) optimisé par le développeur est un test envoyé par les développeurs d'applications Android pour s'assurer que les futurs appareils Android répondent à leurs cas d'utilisation et qu'ils peuvent exécuter leurs applications de manière fluide et sans bugs.

Si vous parvenez à déclencher un nouveau bug avec votre application Vulkan qui affecte un appareil Android spécifique, vous pouvez envoyer une nouvelle proposition de test, en décrivant votre problème et les moyens de le vérifier. Cela garantit que le problème sera résolu dans une prochaine mise à jour de l'appareil et que le même bug ne se produira pas sur d'autres appareils.

Consultez le processus d'envoi à CTS pour obtenir des instructions détaillées sur l'envoi de la proposition de test.