Native und proprietäre Engines

Erste Schritte mit Vulkan unter Android

Vulkan ist die primäre Low-Level-Grafik-API unter Android. Vulkan bietet optimale Leistung für Spiele, die eine eigene Game Engine und einen eigenen Renderer implementieren.

Damit Sie Vulkan erfolgreich in Ihre Game Engine implementieren können, müssen Sie Folgendes tun:

  • Festlegen, welche Android-Geräte mit Vulkan verwendet werden sollen
  • Die Kompromisse bei der Unterstützung älterer Android-Geräte verstehen
  • Vulkan zu Ihrem Android-Build-Ziel hinzufügen
  • Einen Shader-Compiler auswählen, um SPIR-V für Vulkan zu erstellen
  • Die verfügbare Vulkan API-Version zur Laufzeit ermitteln
  • Informationen zum Optimieren Ihrer Vulkan-Renderingvorgänge mit Vulkan-Profilen, Frame Pacing und Vorrotation
  • Grafiktools für das Debugging und die Leistungsanalyse auswählen

Mindestgerätespezifikationen für Vulkan auswählen

Vulkan ist unter Android 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 Android-Geräte mit Vulkan von Ihrem Spiel unterstützt werden.

Empfehlungen

Verwenden Sie die folgenden Spezifikationen 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 Vulkan API-Version 1.1 oder höher.
  • Das Gerät verfügt über Hardwarefunktionen und -features, die mit dem Android-Baseline-Profil von 2022 kompatibel sind.

Unterstützung älterer Geräte

Wenn Ihr Spiel für eine Vielzahl von Geräten mit unterschiedlichen Grafikfunktionen entwickelt wurde, müssen Sie möglicherweise Geräte unterstützen, die älter sind als die unter Mindestgerätespezifikationen für Vulkan 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 Zeichenaufrufen und OpenGL ES kann es zu einem erheblichen Treiber-Overhead kommen, da Zeichenaufrufe in OpenGL ES sehr kostspielig sind. Bei diesen Spielen kann es zu einer CPU-Begrenzung kommen, da ein Großteil der Framezeit im Grafiktreiber verbracht wird. Durch den Wechsel von OpenGL ES zu Vulkan kann die CPU- und Stromnutzung erheblich reduziert werden. Dies gilt insbesondere, wenn Ihr Spiel komplexe Szenen enthält, in denen Instancing nicht effektiv zur Reduzierung von Zeichenaufrufen verwendet werden kann. Wenn Sie ältere Geräte als Zielgruppe haben, sollten Sie die OpenGL ES-Renderingunterstützung als Fallback einbeziehen, da einige Geräte in Ihrer Zielliste möglicherweise Vulkan-Implementierungen haben, auf denen Ihr Spiel nicht zuverlässig ausgeführt werden kann.

Möglicherweise möchten Sie ältere Geräte mit Vulkan nicht unterstützen, weil sie nicht die erforderliche Leistung und die erforderlichen Funktionen bieten oder Stabilitätsprobleme haben.

Leistung und Funktionen

Ältere Android-Geräte mit Vulkan haben möglicherweise nicht die Renderingleistung oder die Hardwareunterstützung für die Funktionen, die zum Ausführen Ihres Spiels erforderlich sind. Dies ist besonders wahrscheinlich, wenn Ihr Spiel hochwertige Grafiken hat und Vulkan die einzige API ist, die Sie unter Android verwenden. Viele ältere Geräte sind auf Version 1.0.3 der Vulkan API beschränkt und es fehlen oft weit verbreitete Vulkan-Erweiterungen, die auf modernerer Hardware verfügbar sind.

Stabilität

Auf älteren Android-Geräten werden möglicherweise veraltete Vulkan-Treiber verwendet. Diese Treiberversionen können Fehler enthalten, die sich auf die Stabilität Ihres Spiels auswirken können. Das Umgehen von Treiberfehlern kann viel Test- und Entwicklungszeit in Anspruch nehmen.

Vulkan zu Ihrem Projekt hinzufügen

So fügen Sie Vulkan zu Ihrem Projekt hinzu:

  • Vulkan API-Header einbeziehen
  • Shader-Code in SPIR-V kompilieren
  • Vulkan API zur Laufzeit aufrufen

Vulkan API-Header einbeziehen

Ihr Spiel muss die Vulkan API-Headerdateien enthalten, um Code zu kompilieren, der Vulkan verwendet. Eine Kopie der Vulkan-Header finden Sie im Android NDK oder in den 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, die Headerdateien enthält, die Vulkan-Version 1.3 unterstützen. Das Vulkan SDK enthält die aktuelle Version der Header.

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, wo Sie Quellcode, der in der OpenGL Shading Language (GLSL) geschrieben wurde, als Text strings 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 für die Verwendung mit Vulkan zu kompilieren.

Mit dem shaderc-Compiler können Shader-Programme, die in GLSL geschrieben wurden, in SPIR-V kompiliert werden. 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-Build-Prozesses für Ihr Spiel und fügen die SPIR-V-Module als Teil Ihrer Laufzeit-Assets ein.

Vulkan API zur Laufzeit aufrufen

Um die Vulkan API aufzurufen, muss Ihr Spiel Funktionszeiger auf Vulkan API-Aufrufe abrufen. Die einfachste Möglichkeit hierfür ist, die gemeinsam genutzte Bibliothek libvulkan.so zu verknüpfen, die im Android NDK enthalten ist. Die Verknüpfung mit der Bibliothek hat zwei Nachteile: zusätzlichen Overhead bei der Funktionsverteilung und Einschränkungen bei den Vulkan API-Funktionszeigern, die automatisch aufgelöst werden.

Wenn Sie eine Vulkan API-Funktion aufrufen, wird die Steuerung über eine Dispatch-Tabelle weitergeleitet, die von einem Konstrukt namens Vulkan-Loader verwaltet wird. Android verwendet eine eigene Vulkan-Loader-Implementierung und nicht den LunarG -Loader. Dieses Loader-System ist Teil der Layer-Architektur der Vulkan API. Wenn Sie zur Build-Zeit eine Verknüpfung zur Systembibliothek herstellen, entsteht eine zusätzliche Dispatch-Ebene 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 Zeiger auf Vulkan-Funktionen auf, die als Teil der Core API betrachtet werden. Vulkan hat eine große Anzahl von Erweiterungen, die zusätzliche Vulkan-Funktionen definieren. Viele davon werden nicht automatisch von der Systembibliothek aufgelöst. Sie müssen Zeiger auf diese Vulkan-Funktionen manuell auflösen, bevor Sie sie verwenden können.

Um diese Probleme zu vermeiden, sollten Sie Zeiger auf alle Vulkan-Funktionen, die Sie zur Laufzeit verwenden möchten, dynamisch auflösen. Eine Möglichkeit hierfür ist die Verwendung einer Open-Source-Meta-Loader-Bibliothek wie volk. Im AGDKTunnel-Beispielspiel ist volk für diesen Zweck integriert. Wenn Sie eine Meta-Loader-Bibliothek verwenden, stellen Sie in Ihren Build-Skripts keine Verknüpfung zur gemeinsam genutzten Bibliothek libvulkan.so her.

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-Versionsnummer, 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

Vulkan-Treiberunterstützung

Die Android-Plattformunterstützung 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 bei der Initialisierung von Vulkan keine API-Version an, die höher ist als:

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 von erforderlichen Funktionen, Erweiterungen, Möglichkeiten und Mindestparameterlimits definieren, die ein Vulkan-Gerät unterstützen muss, um mit dem Profil kompatibel zu sein. Um zu ermitteln, ob ein Gerät mit einem bestimmten Vulkan-Profil kompatibel ist, z. B. mit dem Android-Baseline -Profil von 2022, verwenden Sie die Open-Source-Bibliothek Vulkan Profiles API. Sie können die JSON-Datei des Profils auch selbst parsen und Gerätefunktionen mit den entsprechenden Vulkan APIs abfragen, um die Profilkompatibilität zu ermitteln.

Vulkan-Profile

Android verwendet Vulkan-Profile , die definieren, welche Funktionen und Erweiterungen für die einzelnen Geräte mit Android verfügbar sind.

Das Android-Baseline-Profil (Android Baseline Profile, ABP) ist der erste Versuch, ein Vulkan-Profil zu erstellen. ABP2021 und ABP2022 sind Profile, die in die Vergangenheit gerichtet sind und > 85% der aktiven Geräte zu diesem Zeitpunkt abdecken sollen. Es wird keine neuen ABPs mehr geben.

Vulkan Profiles for Android (VPA) ist das neue zukunftsorientierte Profil, das die Anforderungen von Softwareentwicklern widerspiegeln und konsistente Funktionen fördern soll, sobald Hardwareentwickler sie bereitstellen können. VPA15_minimums ist das erste Profil für Android 15. Jedes Jahr wird ein neues VPA veröffentlicht, um die jeweilige Hauptversion von Android abzudecken.

Frame Pacing implementieren

Ein korrektes Frame Pacing ist ein wesentlicher Bestandteil einer hochwertigen Gameplay-Erfahrung. Das Android Game Development Kit enthält die Frame Pacing library, mit der Sie ein optimales Frame Pacing für Ihr Spiel erreichen können. Weitere Informationen zur Implementierung finden Sie unter Android Frame Pacing in Ihren Vulkan-Renderer einbinden.

Nicht auf implizite Synchronisierung und Frame Pacing verlassen

vkAcquireNextImageKHR und vkQueuePresentKHR werden verwendet, um die Swapchain zu verwalten. Verlassen Sie sich nicht auf ihr potenzielles Blockierungsverhalten für die allgemeine Anwendungs- oder GPU-Synchronisierung.

Das genaue Blockierungsverhalten dieser Funktionen kann sich erheblich unterscheiden zwischen:

  • Android-Geräten
  • GPU-Treibern
  • Zuständen der Präsentations-Engine (VkPresentModeKHR)

Der einzige Zweck von vkAcquireNextImageKHR ist es, ein verfügbares präsentierbares Bild abzurufen. Es kann blockieren oder nicht. Ebenso stellt vkQueuePresentKHR eine Anfrage zum Anzeigen eines Bildes in die Warteschlange und kann auch blockieren oder nicht.

Keine der beiden Funktionen bietet zuverlässige Garantien für die Synchronisierung unabhängiger CPU-Aufgaben oder GPU-Vorgänge.

Für eine robuste Synchronisierung sollten Sie immer explizite Vulkan-Primitive verwenden, z. B. Semaphoren für GPU-GPU-Abhängigkeiten (z. B. Render-to-Present), Fences für die GPU-CPU-Synchronisierung (z. B. um zu wissen, wann das Rendering auf der CPU abgeschlossen ist) und Pipeline-Barrieren oder Ereignisse für eine genauere GPU-Ausführung und Speicherabhängigkeiten. Durch die Verwendung der expliziten Synchronisierung wird ein vorhersehbares Verhalten gewährleistet und es werden subtile Fehler vermieden, die durch implementierungsspezifische Timing-Variationen entstehen, die im vielfältigen Hardware-Ökosystem von Android inhärent sind.

Vorrotation implementieren

Android-Geräte können in mehreren Ausrichtungen angezeigt werden. Die Geräteausrichtung kann sich von der Ausrichtung der Renderingoberfläche unterscheiden. Im Gegensatz zu OpenGL ES unter Android werden Abweichungen zwischen den beiden nicht von Vulkan verarbeitet. Informationen zur Funktionsweise des Ausrichtungsprozesses und zur optimalen Methode zum Umgang mit Ausrichtungs unterschieden bei der Verwendung von Vulkan finden Sie unter Geräteausrichtung mit der Vulkan Vorrotation verarbeiten.

Fehlerbehebung und Profilerstellung für das Vulkan-Rendering

Es stehen mehrere Tools zur Verfügung, mit denen Sie Renderingprobleme und Leistungsprobleme mit Vulkan-Renderingcode diagnostizieren können.

Weitere Informationen zu den Debugging- und Profilerstellungstools von Vulkan finden Sie im Abschnitt Tools und erweiterte Funktionen.

Vulkan-Validierungslayer

Vulkan-Validierungslayer sind Laufzeitbibliotheken, die aktiviert werden können, um Ihre Aufrufe der Vulkan API zu prüfen und Warnungen oder Fehler bei falscher oder nicht optimaler Verwendung auszugeben. Diese Validierungslayer sind standardmäßig nicht aktiv, da der Validierungsprozess Laufzeit-Overhead verursacht und sich auf die Leistung Ihres Spiels auswirkt. Informationen zur Verwendung von Validierungslayern mit Ihrem Spiel finden Sie unter Debugging mit Validierungslayern.

Tools zur Frame-Erfassung

Mit Tools zur Frame-Erfassung können Sie die Vulkan API-Aufrufe aufzeichnen und wiedergeben, die während eines Game-Frames ausgeführt werden. Mit diesen Tools können Sie Folgendes tun:

  • Informationen zu aktiven Grafikressourcen und Visualisierungen davon ansehen
  • Die Reihenfolge der API-Aufrufe Ihres Spiels und die API-Parameter ansehen
  • Den Zustand der Grafikpipeline zum Zeitpunkt eines Zeichenaufrufs untersuchen
  • Die Ergebnisse des Renderings bis zu einem bestimmten Zeichenaufruf im Frame visualisieren

Mit dem Open-Source-Tool RenderDoc können Sie Frames aus Spielen auf Android-Geräten erfassen. RenderDoc unterstützt die Frame-Erfassung von Vulkan und OpenGL ES.

Mit dem Android GPU Inspector (AGI) können auch Vulkan-Frames erfasst werden.

Tools zur Leistungsanalyse

Mit Tools zur Leistungsanalyse können Sie Renderingprobleme in Ihrem Spiel untersuchen, die zu suboptimalen Frameraten führen. Einzelne GPU-Anbieter bieten Tools, mit denen Sie Ihr Spiel profilieren und Leistungsdaten für ihre GPU-Architekturen erhalten können. Die Leistungsmerkmale und Engpässe Ihres Spiels können erheblich variieren, wenn es auf GPUs verschiedener Anbieter oder sogar auf verschiedenen GPU-Generationen desselben Anbieters gerendert wird.

Sie können auch den Android GPU Inspector 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 sicherzustellen, dass ihre Geräte kompatibel sind. Developer-Powered CTS (CTS-D) sind Tests, die von Android-App-Entwicklern eingereicht werden, um sicherzustellen, dass zukünftige Android-Geräte ihren Anwendungsfällen entsprechen 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 der gleiche Fehler nicht auf anderen Geräten auftritt.

Eine detaillierte Anleitung zum Einreichen des Testvorschlags finden Sie unter CTS-Einreichungsprozess.