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, die eine eigene Game-Engine und einen eigenen Renderer implementieren.

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
• Informationen zum Optimieren von Vulkan-Rendering-Vorgängen mit Vulkan-Profilen, Frame-Pacing und Vorrotation
• 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
• Das Gerät unterstützt die 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 Sie die Unterstützung für ältere Geräte einrichten, sollten Sie prüfen, ob Vulkan Vorteile für Ihr Spiel bietet. Bei Spielen mit vielen Draw-Aufrufen und OpenGL ES kann es aufgrund der hohen Kosten für Draw-Aufrufe in OpenGL ES zu erheblichem 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. Wenn Sie Ihre App auf ältere Geräte ausrichten, sollten Sie OpenGL ES-Rendering als Fallback hinzufügen. Einige Geräte in Ihrer Liste der Zielgeräte haben möglicherweise Vulkan-Implementierungen, auf denen Ihr Spiel nicht zuverlässig ausgeführt werden kann.

Möglicherweise möchten Sie ältere Vulkan-kompatible Geräte nicht unterstützen, da sie nicht leistungsfähig genug sind, nicht über die gewünschten Funktionen verfügen oder Stabilitätsprobleme haben.

Leistung und Funktionen

Ältere Vulkan-kompatible Android-Geräte haben möglicherweise nicht die Renderingleistung oder die Hardwareunterstützung für 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. Das Beheben 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 Sie Vulkan-Header aus dem NDK verwenden, verwenden Sie NDK-Version 25 oder höher. Diese Version enthält Headerdateien, die Vulkan-Version 1.3 unterstützen. Das Vulkan SDK enthält die aktuellste Version der Header.

Shadercode 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 Overhead bei der Funktionsausführung 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 zur Buildzeit führt zu einer zusätzlichen Dispatchebene 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 besteht darin, eine Open-Source-Meta-Ladebibliothek wie volk zu verwenden. Im Beispielspiel AGDKTunnel wird volk zu diesem Zweck verwendet. Wenn Sie eine Meta-Ladebibliothek verwenden, erstellen Sie in Ihren Build-Scripts keine Verknüpfung mit der libvulkan.so-gemeinsam genutzten Bibliothek.

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. Mit der Open-Source-Bibliothek Vulkan Profiles API können Sie prüfen, ob ein Gerät mit einem bestimmten Vulkan-Profil kompatibel ist, z. B. mit dem Android-Baseline-Profil von 2022. 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 festlegen, welche Funktionen und Erweiterungen für jedes der Geräte mit Android 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 neues VPA geben, das jede größere Android-Version abdeckt.

Frame-Pacing implementieren

Eine korrekte Framerate ist ein wichtiger Bestandteil für ein hochwertiges Gameplay. 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 zur Funktionsweise des Ausrichtungsprozesses und zur optimalen Methode zum Umgang mit Ausrichtungsunterschieden bei der Verwendung von Vulkan 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 Debugging- und Profiler-Tools 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 standardmäßig nicht aktiv, da der Validierungsprozess den Laufzeit-Overhead erhöht und sich auf die Leistung Ihres Spiels auswirkt. Informationen zur Verwendung von Validierungsschichten in Ihrem Spiel finden Sie unter Fehlerbehebung mit Validierungsschicht.

Tools für die 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-Aufnahme 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 sich beim Rendern auf GPUs verschiedener Anbieter oder sogar auf verschiedenen GPU-Generationen desselben Anbieters erheblich unterscheiden.

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-Anwendungsentwicklern eingereicht werden, um sicherzustellen, dass zukünftige Android-Geräte ihre Anwendungsfälle erfüllen und ihre Anwendungen reibungslos und ohne Fehler ausführen können.

Wenn Sie mit Ihrer Vulkan-Anwendung einen neuen Fehler auslösen, der sich auf ein bestimmtes Android-Gerät auswirkt, können Sie einen neuen Testvorschlag einreichen, in dem Sie das Problem und Möglichkeiten zur Überprüfung beschreiben. 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.