Native und proprietäre Engines

Erste Schritte mit Vulkan auf Android

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

Damit Sie Vulkan in Ihrer Game Engine implementieren können, müssen folgende Voraussetzungen erfüllt sein:

• Android-Geräte für die Verwendung mit Vulkan identifizieren
• Vor- und Nachteile der Unterstützung älterer Android-Geräte
• Vulkan Ihrem Android-Buildziel hinzufügen
• Shader-Compiler zum Erstellen von SPIR-V für Vulkan auswählen
• 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 die Fehlerbehebung und Leistungsanalyse auswählen

Hinweis:Informationen zur Verwendung von Vulkan auf Android mit den Spiel-Engines Unity oder Unreal finden Sie hier:
• Vulkan in Unity
• Vulkan in Unreal

Mindestgerätespezifikationen für Vulkan auswählen

Vulkan ist auf Android-Geräten ab Android 7.0 (API-Level 24) verfügbar. Nicht alle Android-Geräte mit Android 7.0 oder höher unterstützen Vulkan. Sie müssen festlegen, welche Vulkan-kompatiblen Android-Geräte Ihr Spiel unterstützt.

Empfehlungen

Die folgenden Spezifikationen gelten als Mindestanforderungen für die Vulkan-Unterstützung:

• Auf dem Gerät wird Android 10.0 (API-Level 29) oder höher ausgeführt
• Gerät unterstützt Vulkan API-Version 1.1 oder höher
• Das Gerät hat Hardwarefunktionen, die mit dem Android-Baseline-Profil von 2022 kompatibel sind.

Unterstützung älterer Geräte

Wenn Ihr Spiel auf einer Vielzahl von Geräten mit unterschiedlichen Grafikfunktionen ausgeführt werden soll, müssen Sie möglicherweise Geräte unterstützen, die älter sind als die in Mindestspezifikationen für Geräte für Vulkan auswählen empfohlenen. 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 Draw-Aufrufen und OpenGL ES kann es aufgrund der hohen Kosten für Draw-Aufrufe in OpenGL ES zu einem erheblichen Treiberoverhead kommen. Diese Spiele können CPU-gebunden werden, da ein großer Teil der Frame-Time im Grafiktreiber verbracht wird. Durch den Wechsel von OpenGL ES zu Vulkan kann die CPU- und Stromnutzung der Spiele ebenfalls deutlich gesenkt werden. Dies gilt insbesondere für Spiele mit komplexen Szenen, in denen Instancing nicht effektiv zur Reduzierung von Draw-Aufrufen eingesetzt 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-kompatible Android-Geräte haben möglicherweise nicht die Renderingleistung oder die Hardwareunterstützung für die Funktionen, die zum Ausführen Ihres Spiels erforderlich sind. Das ist besonders wahrscheinlich, wenn Ihr Spiel eine High-Fidelity-Grafik hat und Vulkan die einzige API ist, auf die Sie bei Android abzielen. Viele ältere Geräte sind auf Version 1.0.3 der Vulkan API beschränkt und es fehlen ihnen häufig weit verbreitete Vulkan-Erweiterungen, die auf modernerer Hardware verfügbar sind.

Stabilität

Ältere Android-Geräte verwenden möglicherweise veraltete Vulkan-Treiber. Diese Treiberversionen können Fehler enthalten, die sich auf die Stabilität des Spiels auswirken. Die Behebung von Treiberfehlern kann viel Zeit für Tests und Entwicklung in Anspruch nehmen.

Vulkan Ihrem Projekt hinzufügen

So fügen Sie Ihrem Projekt Vulkan hinzu:

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

Vulkan API-Header einschließen

Ihr Spiel muss die Headerdateien der Vulkan API enthalten, um Code zu kompilieren, der Vulkan verwendet. Eine Kopie der Vulkan-Header finden Sie im Android NDK oder in Vulkan SDK-Releases. Jede NDK-Version enthält 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 Shaderprogramme im SPIR-V-Binärformat bereitgestellt werden. Diese Konvention unterscheidet sich von OpenGL ES, bei dem Quellcode in der OpenGL Shading Language (GLSL) als Textstrings eingereicht werden konnte. Mit einem Shader-Compiler können Sie Code, der in einer Shadersprache wie GLSL oder High-Level Shader Language (HLSL) geschrieben wurde, in SPIR-V-Module zur Verwendung mit Vulkan kompilieren.

Mit dem shaderc-Compiler können Sie Shaderprogramme, die in GLSL geschrieben wurden, in SPIR-V kompilieren. Wenn Ihr Spiel HLSL verwendet, unterstützt der DirectXShaderCompiler die SPIR-V-Ausgabe. Normalerweise kompilieren Sie Shaderprogramme im Rahmen des Asset-Build-Prozesses für Ihr Spiel offline und nehmen die SPIR-V-Module in Ihre Laufzeit-Assets auf.

Vulkan API zur Laufzeit aufrufen

Zum Aufrufen der Vulkan API muss Ihr Spiel Funktionszeigers auf Vulkan API-Aufrufe abrufen. Am einfachsten ist es, eine Verknüpfung mit der freigegebenen Bibliothek libvulkan.so herzustellen, die im Android NDK enthalten ist. Das Verknüpfen mit der Bibliothek hat zwei Nachteile: zusätzlichen Funktionsabruf-Overhead und Einschränkungen bei der automatischen Auflösung von Vulkan API-Funktionszeigern.

Wenn Sie eine Vulkan API-Funktion aufrufen, wird die Steuerung über eine Dispatch-Tabelle geleitet, die von einem Konstrukt namens Vulkan-Ladeprogramm verwaltet wird. Android verwendet seine eigene Vulkan-Ladeprogrammimplementierung und nicht den LunarG-Ladeprogramm. Dieses Ladesystem ist Teil der Schichtarchitektur 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 Overhead ist zwar gering, kann aber bei Spielen mit vielen Vulkan-Aufrufen spürbar sein.

Die Systembibliothek löst in der Regel nur Verweise auf Vulkan-Funktionen auf, die zur Kern-API gehören. Vulkan hat eine große Anzahl von Erweiterungen, die zusätzliche Vulkanfunktionen definieren, von denen viele nicht automatisch von der Systembibliothek aufgelöst werden. Sie müssen Verweise auf diese Vulkan-Funktionen manuell auflösen, bevor Sie sie verwenden können.

Um diese Probleme zu vermeiden, müssen Sie Verweise auf alle Vulkan-Funktionen, die Sie zur 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 volk zu diesem Zweck verwendet. Wenn Sie eine Metaloader-Bibliothek verwenden, erstellen Sie in Ihren Build-Skripts keine Verknüpfung zur 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 Vulkan API-Version, die auf einem bestimmten Gerät verfügbar ist, wird durch die Android-Version und die Vulkan-Treiberunterstützung bestimmt.

Android-Version

Die Plattformunterstützung für eine Vulkan API-Version hängt von einer Mindestversion von Android (API-Level) ab:

• 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

Unterstützung für Vulkan-Treiber

Die Unterstützung der Android-Plattform für eine Vulkan API-Version ist keine Garantie dafür, 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.

Fordere beim Initialisieren von Vulkan keine API-Version an, die höher als die folgenden ist:

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

Im Folgenden finden Sie ein Beispiel für die Ermittlung 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;
}

Vulkan-Profilkompatibilität ermitteln

Vulkan-Profile sind JSON-Dateien, die eine Reihe erforderlicher Funktionen, Erweiterungen, Funktionen und Mindestparametergrenzwerte definieren, 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 entsprechenden Vulkan APIs abfragen, um die Profilkompatibilität zu ermitteln.

Vulkan-Profile

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

Das Android-Baseline-Profil (ABP) ist der erste Versuch, ein Vulkan-Profil zu erstellen. ABP2021 und ABP2022 sind rückwärtsgerichtete Profile, die mehr als 85% der aktiven Geräte zu dieser Zeit abdecken sollen. Es werden keine neuen ABPs mehr erstellt.

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

Frame-Pacing 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 ein optimales Frame Pacing für Ihr Spiel erzielen können. Weitere Informationen zur Implementierung finden Sie unter Android-Frame-Pacing in Ihren Vulkan-Renderer einbinden.

Vorab-Rotation implementieren

Android-Geräte können in mehreren Ausrichtungen angezeigt werden. Die Geräteausrichtung kann von der Ausrichtung der Rendering-Oberfläche abweichen. Im Gegensatz zu OpenGL ES auf Android werden Abweichungen zwischen den beiden Versionen von Vulkan nicht verarbeitet. Informationen dazu, wie der Ausrichtungsprozess funktioniert und wie Sie bei der Verwendung von Vulkan am besten mit Ausrichtungsunterschieden umgehen, finden Sie unter Geräterotation mit Vulkan-Vorauswahl.

Fehlerbehebung und Profilerstellung für Vulkan-Rendering

Es gibt mehrere Tools, mit denen Sie Rendering- und Leistungsprobleme mit Vulkan-Rendering-Code diagnostizieren können.

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

Vulkan-Validierungsebenen

Vulkan-Bestätigungsschichten sind Laufzeitbibliotheken, die aktiviert werden können, um Ihre Aufrufe an die Vulkan API zu prüfen und Warnungen oder Fehler bei falscher oder nicht optimaler Verwendung zu melden. 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 Frame-Aufnahme

Mit Frame-Capture-Tools können Sie die Vulkan API-Aufrufe während eines Spielframes aufzeichnen und wiedergeben. Mit diesen Tools können Sie Folgendes tun:

• Informationen zu und Visualisierungen aktiver Grafikressourcen aufrufen
• Aufrufabfolge der API-Aufrufe Ihres Spiels und API-Parameter ansehen
• Status der Grafikpipeline zum Zeitpunkt eines Draw-Aufrufs untersuchen
• Ergebnisse des Renderings bis zu einem bestimmten Draw-Aufruf im Frame visualisieren

Mit dem Open-Source-Tool RenderDoc Frames aus Spielen erfassen, die auf Android-Geräten ausgeführt werden RenderDoc unterstützt die Frame-Aufzeichnung sowohl für Vulkan als auch für OpenGL ES.

Der Android GPU-Prüfer (AGI) kann auch zum Erfassen von Vulkan-Frames verwendet werden.

Tools zur Leistungsanalyse

Mithilfe von Leistungsanalysetools können Sie Renderingprobleme in Ihrem Spiel untersuchen, die zu suboptimalen Frameraten führen. Einzelne GPU-Anbieter stellen Tools zur Verfügung, mit denen Sie Ihr Spiel profilieren und leistungsspezifische Daten zu ihren GPU-Architekturen erhalten 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-Inspektor verwenden, um Leistungsdaten zu erfassen und zu analysieren. Im Gegensatz zu den Tools der Anbieter ist der Android GPU Inspector mit mehreren GPUs verschiedener Anbieter kompatibel. Der 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 verwenden die Compatibility Test Suite (CTS), um die Kompatibilität ihrer Geräte zu prüfen. Von Entwicklern erstellte CTS-D-Tests (Compatibility Test Suite for Developers) sind Tests, die von Android-App-Entwicklern eingereicht werden, um sicherzustellen, dass zukünftige Android-Geräte ihre Anwendungsfälle erfüllen und ihre Apps 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. So wird sichergestellt, dass das Problem in einem zukünftigen Update für das Gerät behoben wird und dass derselbe Fehler nicht auf anderen Geräten auftritt.

Eine detaillierte Anleitung zum Einreichen des Testvorschlags finden Sie hier.