Native und proprietäre Engines

Erste Schritte mit Vulkan auf Android

Vulkan ist die primäre Low-Level-Grafik-API unter Android. Vulkan bietet optimale Leistung für Spiele, in denen eine eigene Spiel-Engine und ein eigener Renderer implementiert sind.

Damit du Vulkan in deine Spiel-Engine implementieren kannst, musst du

• Herausfinden, welche Android-Geräte mit Vulkan verwendet werden sollen
• Vor- und Nachteile der Unterstützung älterer Android-Geräte
• Vulkan dem Android-Build-Ziel hinzufügen
• Wähle einen Shader-Compiler aus, um SPIR-V für Vulkan zu erstellen
• Verfügbare Vulkan API-Version zur Laufzeit ermitteln
• Hier erfährst du, wie du deine Vulkan-Renderingvorgänge mit Vulkan-Profilen, Frame-Taktung und Pre-Rotation optimieren kannst.
• Grafiktools für Fehlerbehebung und Leistungsanalyse auswählen

Hinweis:Informationen zur Verwendung von Vulkan unter Android mit der Unity- oder Unreal-Spiel-Engine findest du hier:
• Vulkan auf Unity
• Vulkan auf Unreal

Mindestgerätespezifikationen für Vulkan auswählen

Vulkan ist ab Android 7.0 (API-Level 24) auf Android-Geräten verfügbar. Nicht alle Android-Geräte mit Android 7.0 oder höher unterstützen Vulkan. Du musst herausfinden, welche Vulkan-fähigen Android-Geräte dein Spiel unterstützt.

Empfehlungen

Beachten Sie für den Vulkan-Support die folgenden Mindestanforderungen:

• Gerät verwendet Android 10.0 (API-Level 29) oder höher
• Gerät unterstützt Vulkan API-Version 1.1 oder höher
• Das Gerät hat Hardwarefunktionen und ‐funktionen, die mit dem Android Baseline-Profil aus dem Jahr 2022 kompatibel sind.

Support für ältere Geräte

Wenn dein Spiel für eine Vielzahl von Geräten mit unterschiedlichen Grafikfunktionen entwickelt wurde, musst du möglicherweise Geräte unterstützen, die älter sind als die im Artikel Mindestgerätespezifikationen für Vulkan auswählen empfohlenen Geräte. Bevor du Unterstützung für ältere Geräte erstellst, solltest du prüfen, ob Vulkan für dein Spiel Vorteile bietet. Bei Spielen mit vielen Zeichenaufrufen und OpenGL ES kann aufgrund der hohen Kosten für Zeichenaufrufe in OpenGL ES ein erheblicher Treiberaufwand anfallen. Diese Spiele können CPU-gebunden werden, indem ein großer Teil ihrer Frame Time im Grafiktreiber ausgegeben wird. Durch den Wechsel von OpenGL ES zu Vulkan können die Spiele außerdem deutlich weniger CPU und Strom verbrauchen. Dies gilt insbesondere, wenn Ihr Spiel komplexe Szenen hat, bei denen die Instanzerstellung nicht effektiv zur Reduzierung von Zeichenaufrufen verwendet werden kann. Füge beim Targeting auf ältere Geräte die OpenGL ES-Rendering-Unterstützung als Fallback hinzu, da einige Geräte in deiner Zielgeräteliste Vulkan-Implementierungen haben, die dein Spiel nicht zuverlässig ausführen können.

Möglicherweise möchten Sie keine älteren Vulkan-fähigen Geräte unterstützen, weil ihnen Leistung und Funktionen mangelt oder weil es Stabilitätsprobleme gibt.

Leistung und Funktionen

Ältere Vulkan-fähige Android-Geräte bieten möglicherweise nicht die Rendering-Leistung oder Hardwaresupport für Funktionen, die zum Ausführen des Spiels erforderlich sind. Das ist besonders wahrscheinlich, wenn Ihr Spiel High-Fidelity-Grafik hat und Vulkan die einzige API ist, die Sie auf Android ausrichten. Viele ältere Geräte sind auf Version 1.0.3 der Vulkan API beschränkt und es fehlen häufig genutzte Vulkan-Erweiterungen, die auf modernerer Hardware verfügbar sind.

Stabilität

Möglicherweise verwenden ältere Android-Geräte veraltete Vulkan-Treiber. Diese Treiberversionen können Programmfehler enthalten, die die Stabilität Ihres Spiels beeinträchtigen können. Das Umgehen von Treiberfehlern kann einen erheblichen Aufwand für Tests und Entwicklung erfordern.

Vulkan Ihrem Projekt hinzufügen

So fügen Sie Ihrem Projekt Vulkan hinzu:

• Vulkan API-Header einschließen
• Shader-Code in SPIR-V kompilieren
• Vulkan API zur Laufzeit aufrufen

Vulkan API-Header einschließen

Dein Spiel muss die Header-Dateien der Vulkan API enthalten, um Code zu kompilieren, der Vulkan verwendet. Eine Kopie der Vulkan-Header finden Sie im Android-NDK oder im Paket mit den Vulkan SDK-Releases. Jede NDK-Version umfasst nur Vulkan-Header, die zum Zeitpunkt der NDK-Veröffentlichung verfügbar waren. Wenn du Vulkan-Header aus dem NDK verwendest, benötigst du NDK-Version 25 oder höher. Diese Datei enthält Headerdateien, die Vulkan-Version 1.3 unterstützen. Im Vulkan SDK ist die aktuelle Version der Header verfügbar.

Shader-Code in SPIR-V kompilieren

Die Vulkan API erwartet, dass Shader-Programme im binären SPIR-V-Zwischenformat bereitgestellt werden. Diese Konvention unterscheidet sich von OpenGL ES, bei dem Sie in der OpenGL Shading Language (GLSL) geschriebenen Quellcode als Textstrings einreichen können. Verwenden Sie einen Shader-Compiler, um Code, der in einer Shader-Sprache wie GLSL oder der High-Level Shader Language (HLSL) geschrieben wurde, in SPIR-V-Module zu kompilieren, um sie mit Vulkan zu verwenden.

Mit dem Compiler shaderc können Shader-Programme kompiliert werden, die in GLSL in SPIR-V geschrieben wurden. Wenn Ihr Spiel HLSL verwendet, unterstützt der DirectXShaderCompiler die SPIR-V-Ausgabe. In der Regel kompilieren Sie Shader-Programme offline im Rahmen des Asset-Erstellungsprozesses für Ihr Spiel und binden die SPIR-V-Module in Ihre Laufzeit-Assets ein.

Vulkan API zur Laufzeit aufrufen

Wenn Sie die Vulkan API aufrufen möchten, benötigt Ihr Spiel Funktionszeiger für Vulkan API-Aufrufe. Am einfachsten geht das über eine Verknüpfung mit der gemeinsam genutzten Bibliothek libvulkan.so, die im Android-NDK enthalten ist. Die Verknüpfung mit der Bibliothek hat zwei Nachteile: der zusätzliche Aufwand bei der Funktionsweiterleitung und die Einschränkungen, bei denen die Funktionszeiger der Vulkan API automatisch behoben werden.

Wenn Sie eine Vulkan API-Funktion aufrufen, läuft die Steuerung durch eine Weiterleitungstabelle, die von einem Konstrukt namens Vulkan Loader verwaltet wird. Android verwendet eine eigene Vulkan Loader-Implementierung anstelle des LunarG-Ladeprogramms. Dieses Ladesystem ist Teil der Ebenenarchitektur der Vulkan API. Die Verknüpfung mit der Systembibliothek zum Build-Zeitpunkt führt zu einer zusätzlichen Weiterleitungsebene für einen bestimmten API-Aufruf. Der Aufwand ist zwar gering, kann aber bei Spielen mit einer hohen Anzahl von Vulkan-Aufrufen erkennbar sein.

Die Systembibliothek löst im Allgemeinen nur Verweise auf Vulkan-Funktionen auf, die als Teil der Kern-API gelten. Vulkan bietet eine Vielzahl von Erweiterungen, mit denen zusätzliche Vulkan-Funktionen definiert werden. Viele davon werden von der Systembibliothek nicht automatisch aufgelöst. Du musst die Verweise auf diese Vulkan-Funktionen manuell auflösen, bevor du sie verwenden kannst.

Um diese Probleme zu beheben, müssen Sie Verweise auf alle Vulkan-Funktionen, die Sie während der Laufzeit verwenden möchten, dynamisch auflösen. Eine Möglichkeit dazu ist die Verwendung einer Open-Source-Metaloader-Bibliothek wie volk. Im Beispielspiel AGDKTunnel wird zu diesem Zweck volk integriert. Wenn Sie eine Metaloader-Bibliothek verwenden, erstellen Sie in Ihren Build-Skripts keine Verknüpfung mit der gemeinsam genutzten Bibliothek libvulkan.so.

Verfügbare Vulkan API-Version ermitteln

Android unterstützt die folgenden Vulkan API-Versionen:

• 1.0.3
• 1,1
• 1.3

Die höchste verfügbare Vulkan API-Versionsnummer auf einem bestimmten Gerät wird durch die Android-Version und die Vulkan-Treiberunterstützung ermittelt.

Android-Version

Die Plattformunterstützung für eine Vulkan API-Version ist von der folgenden Android-Mindestversion (API-Level) abhängig:

• 1.3 – Android 13.0 (API-Level 33) und höher
• 1.1 – Android 10.0 (API-Level 29) und höher
• 1.0.3 – Android 7.0 (API-Level 24) und höher

Vulkan-Treiberunterstützung

Die Unterstützung der Android-Plattform für eine Vulkan API-Version garantiert nicht, dass die API-Version vom Vulkan-Treiber des Geräts unterstützt wird. Ein Gerät mit Android 13 unterstützt möglicherweise nur Version 1.1 der Vulkan API.

Fordern Sie beim Initialisieren von Vulkan keine API-Version an, die höher als:

• Die maximale Vulkan API-Version für die auf dem Gerät ausgeführte Android-Version
• Die von vkEnumerateInstanceVersion gemeldete Vulkan API-Version
• Die Vulkan API-Version, die über das Attribut apiVersion der Struktur VkPhysicalDeviceProperties gemeldet wird

Hier ein Beispiel zum Ermitteln der höchsten unterstützten Vulkan API-Version:

// 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;
}

Kompatibilität des Vulkan-Profils ermitteln

Vulkan-Profile sind JSON-Dateien, in denen eine Reihe von erforderlichen Funktionen, Erweiterungen, Funktionen und minimalen Parameterlimits definiert werden, die ein Vulkan-Gerät unterstützen muss, um mit dem Profil kompatibel zu sein. Wenn Sie feststellen möchten, ob ein Gerät mit einem bestimmten Vulkan-Profil kompatibel ist, z. B. dem Android Baseline-Profil von 2022, verwenden Sie die Open-Source-Bibliothek der Vulkan Profiles API. Sie können die JSON-Profildatei auch selbst parsen und die Gerätefunktionen mithilfe der relevanten Vulkan APIs abfragen, um die Kompatibilität des Profils zu ermitteln.

Vulkan-Profile

Android verwendet Vulkan-Profile, die definiert, welche Funktionen und Erweiterungen für jedes Android-Gerät verfügbar sind.

Android Baseline Profile (ABP) ist der erste Versuch, ein Vulkan-Profil zu erstellen. ABP2021 und ABP2022 sind rückwärtsgerichtete Profile, die mehr als 85% der zu diesem Zeitpunkt aktiven Geräte abdecken sollen. Es wird künftig keine neuen Abo-Optionen mehr geben.

Vulkan-Profile für Android (VPA) ist das neue, zukunftsorientierte Profil, das die Anforderungen von Softwareentwicklern reflektieren und einheitliche Funktionen bieten soll, sobald Hardwareentwickler sie bereitstellen können. VPA15_minimums ist das erste Profil für Android 15 und es wird jedes Jahr ein neues VPA für jede größere Android-Version geben.

Frame-Taktung implementieren

Die richtige Frame-Taktung ist für ein qualitativ hochwertiges Spielerlebnis unerlässlich. Das Android Game Development Kit enthält die Frame Pacing-Bibliothek, mit der Sie in Ihrem Spiel eine optimale Frame-Taktung erzielen können. Weitere Informationen zur Implementierung finden Sie unter Android Frame Pacing in den Vulkan-Renderer einbinden.

Vorrotation implementieren

Android-Geräte können in mehreren Ausrichtungen angezeigt werden. Die Geräteausrichtung kann von der Ausrichtung der Renderingfläche abweichen. Im Gegensatz zu OpenGL ES unter Android verarbeitet Vulkan keine Diskrepanzen zwischen den beiden. Weitere Informationen zur Funktionsweise des Ausrichtungsprozesses und zur optimalen Methode für den Umgang mit Ausrichtungsunterschieden in Vulkan finden Sie unter Geräterotation mit Vulkan-Vorrotation durchführen.

Fehlerbehebung und Profil für das Vulkan-Rendering

Es stehen verschiedene Tools zur Verfügung, mit denen du Rendering- und Leistungsprobleme mit Vulkan-Rendering-Code diagnostizieren kannst.

Weitere Informationen zu den Tools zur Fehlerbehebung und Profilerstellung von Vulkan finden Sie im Abschnitt Tools und erweiterte Funktionen.

Vulkan-Validierungsebenen

Vulkan-Validierungsebenen sind Laufzeitbibliotheken, die aktiviert werden können, um Ihre Aufrufe an die Vulkan API zu überprüfen und Warnungen oder Fehler zu einer falschen oder nicht optimalen Verwendung bereitzustellen. Diese Validierungsebenen sind nicht standardmäßig aktiv, da der Validierungsprozess den Laufzeit-Overhead erhöht und sich auf die Leistung Ihres Spiels auswirkt. Informationen zur Verwendung von Validierungsebenen mit Ihrem Spiel finden Sie unter Fehlerbehebung mit Validierungsschicht.

Tools zur Bilderfassung

Mit Frame Capture-Tools kannst du die Vulkan API-Aufrufe, die während eines Spiel-Frames getätigt wurden, aufzeichnen und wiedergeben. Mit diesen Tools können Sie:

• Informationen zu aktiven Grafikressourcen und Visualisierungen ansehen
• Abfolge der von Ihrem Spiel ausgeführten API-Aufrufe und API-Parameter ansehen
• Status der Grafikpipeline während eines Zeichenaufrufs untersuchen
• Die Ergebnisse des Renderings bis zu einem bestimmten Zeichenaufruf im Frame visualisieren

Verwenden Sie das Open-Source-Tool RenderDoc, um Frames aus Spielen zu erfassen, die unter Android ausgeführt werden. RenderDoc unterstützt die Frame-Erfassung sowohl von Vulkan als auch von OpenGL ES.

Du kannst auch den Android GPU Inspector (AGI) verwenden, um Vulkan-Frames zu erfassen.

Tools zur Leistungsanalyse

Verwenden Sie Tools zur Leistungsanalyse, um Renderingprobleme in Ihrem Spiel zu untersuchen, die zu suboptimalen Framerates führen. Einzelne GPU-Anbieter stellen Tools zur Verfügung, mit denen Sie ein Profil für Ihr Spiel erstellen und für ihre GPU-Architekturen spezifische Leistungsdaten bereitstellen können. Die Leistungsmerkmale und Engpässe Ihres Spiels können beim Rendern auf GPUs verschiedener Anbieter oder sogar auf verschiedenen GPU-Generationen desselben Anbieters erheblich variieren.

Sie können auch den Android GPU Inspector verwenden, um Leistungsdaten zu erfassen und zu analysieren. Im Gegensatz zu den Anbietertools ist Android GPU Inspector mit mehreren GPUs verschiedener Anbieter kompatibel. Android GPU Inspector unterstützt jedoch keine älteren Android-Geräte und ist möglicherweise nicht mit allen neuen Geräten kompatibel.

Vulkan-Tests mit CTS-D verbessern

Hersteller von Android-Geräten prüfen mithilfe der Compatibility Test Suite (CTS), ob ihre Geräte kompatibel sind. Developer-Powered CTS (CTS-D) sind Tests von Android-Anwendungsentwicklern, um sicherzustellen, dass zukünftige Android-Geräte ihren Anwendungsfällen entsprechen und ihre Anwendungen reibungslos und ohne Fehler ausführen können.

Wenn du es schaffst, in deiner Vulkan-App einen neuen Fehler auszulösen, der ein bestimmtes Android-Gerät betrifft, kannst du einen neuen Testvorschlag einreichen, in dem du das Problem beschreibst und wie du es prüfen kannst. Dadurch wird sichergestellt, dass das Problem in einem zukünftigen Update für das Gerät behoben wird. Außerdem wird sichergestellt, dass derselbe Fehler nicht auf anderen Geräten auftritt.

Sieh dir den CTS-Übermittlungsprozess an, um eine Schritt-für-Schritt-Anleitung zum Einreichen des Testangebots zu erhalten.