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

Um Vulkan erfolgreich in Ihrer Spiel-Engine zu implementieren, müssen Sie

  • Android-Geräte für Vulkan auswählen
  • Nachteile der Unterstützung älterer Android-Geräte
  • Vulkan zu deinem Android-Build-Ziel hinzufügen
  • Shader-Compiler zum Erstellen von SPIR-V für Vulkan auswählen
  • Verfügbare Vulkan API-Version zur Laufzeit ermitteln
  • Hier erfahren Sie, wie Sie Ihre Vulkan-Renderingvorgänge mit Vulkan-Profilen, Frame-Taktung und Vorrotation optimieren können.
  • Grafiktools für Fehlerbehebung und Leistungsanalyse auswählen

Mindestgerätespezifikationen für Vulkan auswählen

Vulkan ist auf Android-Geräten ab Android 7.0 (API-Level 24) verfügbar. Vulkan wird nicht von allen Android-Geräten mit Android 7.0 oder höher unterstützt. Lege fest, welche Vulkan-fähigen Android-Geräte dein Spiel unterstützt.

Empfehlungen

Verwenden Sie die folgenden Spezifikationen als Mindestanforderungen für die Vulkan-Unterstützung:

  • Auf dem Gerät läuft Android 10.0 (API-Level 29) oder höher
  • Gerät unterstützt Vulkan API-Version 1.1 oder höher
  • Hardwarefunktionen und -funktionen des Geräts sind mit dem Android Baseline-Profil 2022 kompatibel.

Unterstützung für ältere Geräte

Wenn Ihr Spiel für eine Vielzahl von Geräten mit unterschiedlichen Grafikleistungsstufen entwickelt wurde, müssen Sie möglicherweise Geräte unterstützen, die älter sind als die unter Mindestgerätespezifikationen für Vulkan auswählen empfohlenen. Bevor Sie den Support für ältere Geräte einrichten, sollten Sie prüfen, ob Vulkan für Ihr Spiel Vorteile bietet. Bei Spielen, die viele Zeichenaufrufe enthalten und OpenGL ES verwenden, ist mit einem erheblichen Treiberaufwand zu rechnen, da bei Spielen mit OpenGL ES hohe Kosten für Zeichenaufrufe anfallen. Bei diesen Spielen kann es sein, dass sie einen großen Teil ihrer Framezeit in den Grafiktreiber stecken und dann CPU-gebunden sind. Durch den Wechsel von OpenGL ES zu Vulkan können auch die CPU- und Energienutzung erheblich sinken. Dies ist insbesondere dann der Fall, wenn Ihr Spiel komplexe Szenen hat, die Instantität nicht effektiv zur Reduzierung von Zeichenaufrufen verwenden können. Wenn Sie ein Targeting auf ältere Geräte vornehmen, sollten Sie OpenGL ES-Rendering als Fallback verwenden, da auf einigen Geräten auf Ihrer Zielgeräteliste eventuell Vulkan-Implementierungen vorhanden sind, die Ihr Spiel nicht zuverlässig ausführen können.

Ältere Vulkan-fähige Geräte sollten nicht unterstützt werden, weil ihnen Leistung und Funktionen fehlen oder sie Stabilitätsprobleme haben.

Leistung und Funktionen

Ältere Vulkan-fähige Android-Geräte bieten möglicherweise nicht die Rendering-Leistung oder die Hardwareunterstützung für Funktionen, die zum Ausführen Ihres Spiels erforderlich sind. Das ist besonders wahrscheinlich, wenn Ihr Spiel High-Fidelity-Grafiken hat und Vulkan die einzige API ist, die Sie für Android verwenden. Viele ältere Geräte sind auf Version 1.0.3 der Vulkan API beschränkt und es fehlen häufig verwendete 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 Programmfehler enthalten, die die Stabilität deines Spiels beeinträchtigen können. Das Umgehen von Treiberfehlern kann viel Zeit für Tests und Entwicklung erfordern.

Vulkan zu Ihrem Projekt hinzufügen

So fügen Sie Vulkan Ihrem Projekt hinzu:

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

Vulkan API-Header einschließen

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 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 vom NDK verwenden, nutzen Sie die NDK-Version 25 oder höher. Diese enthält Headerdateien, die Vulkan Version 1.3 unterstützen. Das Vulkan SDK hat die aktuelle Version der Header.

Shader-Code in SPIR-V kompilieren

Die Vulkan API erwartet, dass Shader-Programme im binären SPIR-V-Format bereitgestellt werden. Diese Konvention unterscheidet sich von OpenGL ES, bei dem Sie Quellcode, der in der OpenGL Shading Language (GLSL) geschrieben wurde, als Textstrings senden. 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 zur Verwendung mit Vulkan zu kompilieren.

Mit dem Compiler shaderc können in GLSL geschriebene Shader-Programme in SPIR-V kompiliert werden. Wenn Ihr Spiel HLSL verwendet, unterstützt der DirectXShaderCompiler die SPIR-V-Ausgabe. Normalerweise kompilieren Sie Shader-Programme offline als Teil des Asset-Build-Prozesses für Ihr Spiel und fügen die SPIR-V-Module als Teil Ihrer Laufzeit-Assets hinzu.

Vulkan API zur Laufzeit aufrufen

Zum Aufrufen der Vulkan API muss Ihr Spiel Funktionsverweise auf Vulkan API-Aufrufe abrufen. Am einfachsten ist 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 für die Funktionsweiterleitung und die Einschränkungen, bei denen Vulkan API-Funktionszeiger automatisch aufgelöst werden, wird aufgehoben.

Wenn Sie eine Vulkan API-Funktion aufrufen, durchläuft die Steuerung eine Weiterleitungstabelle, die von einem Konstrukt namens Vulkan Loader verwaltet wird. Android verwendet seine eigene Vulkan-Ladeprogramm-Implementierung und nicht den LunarG-Ladeprogramm. Dieses Ladesystem ist Teil der Ebenenarchitektur der Vulkan API. Das Verknüpfen 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 bemerkbar sein, die viele Vulkan-Aufrufe ausführen.

Die Systembibliothek löst in der Regel nur Verweise auf Vulkan-Funktionen auf, die als Teil der Kern-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 die Verweise auf diese Vulkan-Funktionen manuell auflösen, bevor Sie sie verwenden können.

Um diese Probleme zu minimieren, lösen Sie dynamisch Zeiger auf alle Vulkan-Funktionen auf, die Sie zur Laufzeit verwenden möchten. Eine Möglichkeit, dies zu erreichen, ist die Verwendung einer Open-Source-Meta-Loader-Bibliothek wie volk. Das Beispielspiel AGDKTunnel integriert Volk zu diesem Zweck. Wenn Sie eine Meta-Loader-Bibliothek verwenden, dürfen in Ihren Build-Skripts keine Verknüpfungen mit der gemeinsam genutzten Bibliothek libvulkan.so erstellt werden.

Verfügbare Vulkan API-Version ermitteln

Android unterstützt die folgenden Vulkan API-Versionen:

  • 1.0.3
  • 1,1
  • 1.3

Die höchste auf einem Gerät verfügbare Vulkan API-Versionsnummer wird anhand der Android-Version und der Vulkan-Treiberunterstützung bestimmt.

Android-Version

Die Unterstützung der Vulkan API-Version ist abhängig von der jeweiligen Android-Mindestversion (API-Level):

  • 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 einer Android-Plattform für eine Vulkan API-Version ist keine Garantie dafür, dass die API-Version vom Vulkan-Treiber auf dem Gerät 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 ist als:

Hier ist ein Beispiel, wie Sie die höchste unterstützte Vulkan API-Version ermitteln können:

// 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 und Fähigkeiten sowie Mindestparameterlimits definiert werden, die ein Vulkan-Gerät unterstützen muss, um mit dem Profil kompatibel zu sein. Mit der Open-Source-Vulkan Profiles API-Bibliothek können Sie feststellen, ob ein Gerät mit einem bestimmten Vulkan-Profil wie dem Android Baseline-Profil von 2022 kompatibel ist. Sie können die JSON-Profildatei auch selbst parsen und die Gerätefunktionen mit den relevanten Vulkan APIs abfragen, um die Profilkompatibilität zu ermitteln.

Vulkan-Profile

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

Das Android Baseline Profile (ABP) ist der erste Versuch, Vulkan Profile zu erstellen. ABP2021 und ABP2022 sind rückwärtsgerichtete Profile, die mehr als 85% der zu dieser Zeit aktiven Geräte abdecken sollen. Ab jetzt gibt es keine neuen ABP mehr.

Vulkan-Profile für Android (VPA) ist das neue zukunftsgerichtete Profil, das die Anforderungen von Softwareentwicklern widerspiegelt und einheitliche Funktionen bietet, 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 veröffentlicht.

Frame-Taktung implementieren

Das richtige Frame-Taktung ist ein wesentlicher Bestandteil für ein qualitativ hochwertiges Gameplay. Das Android Game Development Kit enthält die Frame Pacing-Bibliothek, mit der Sie für Ihr Spiel eine optimale Frame-Taktung erreichen können. Weitere Informationen zur Implementierung finden Sie unter Android Frame Pacing in den Vulkan-Renderer integrieren.

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 auf Android handhabt Vulkan Abweichungen nicht. Informationen zur Funktionsweise der Ausrichtung und zur optimalen Methode für die Verarbeitung von Ausrichtungsunterschieden bei der Verwendung von Vulkan finden Sie unter Geräterotation mit Vulkan vordrehen.

Fehler beim Vulkan-Rendering beheben und Profil erstellen

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

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

Vulkan-Validierungsebenen

Vulkan-Validierungsebenen sind Laufzeitbibliotheken, die aktiviert werden können, um Ihre Aufrufe der Vulkan API zu prüfen und Warnungen oder Fehler zu einer falschen oder nicht optimalen Verwendung auszugeben. Diese Validierungsebenen sind standardmäßig nicht aktiv, da der Validierungsprozess den Laufzeitaufwand erhöht und die Leistung Ihres Spiels beeinträchtigt. Informationen zur Verwendung von Validierungsebenen in Ihrem Spiel finden Sie unter Fehlerbehebung mit der Validierungsschicht.

Bildaufnahme-Tools

Mit Frame Capture-Tools können Sie die Vulkan API-Aufrufe, die während eines Spiel-Frames ausgeführt wurden, aufzeichnen und wiederholen. Mit diesen Tools können Sie:

  • Informationen zu aktiven Grafikressourcen und entsprechende Visualisierungen ansehen
  • Sieh dir die Abfolge der API-Aufrufe deines Spiels und die API-Parameter an
  • Den Status der Grafikpipeline zum Zeitpunkt eines Zeichenaufrufs untersuchen
  • Ergebnisse des Renderings bis zu einem bestimmten Zeichenaufruf im Frame visualisieren

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

Sie können auch den Android GPU Inspector (AGI) verwenden, um Vulkan-Frames zu erfassen.

Tools zur Leistungsanalyse

Verwende Tools zur Leistungsanalyse, um Rendering-Probleme in deinem Spiel zu untersuchen, die zu suboptimalen Framerates führen. Einzelne GPU-Anbieter stellen Tools bereit, mit denen Sie ein Profil für Ihr Spiel erstellen und Leistungsdaten speziell für ihre GPU-Architektur bereitstellen können. Die Leistungsmerkmale und Engpässe Ihres Spiels können erheblich variieren, wenn Sie auf GPUs verschiedener Anbieter oder sogar mit verschiedenen GPU-Generationen desselben Anbieters rendern.

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 verwenden die Compatibility Test Suite (CTS), um sicherzustellen, dass ihre Geräte kompatibel sind. Developer-Powered CTS (CTS-D) sind Tests, die von Entwicklern von Android-Apps eingereicht werden, um sicherzustellen, dass zukünftige Android-Geräte ihren Anwendungsfällen gerecht werden und Anwendungen reibungslos und fehlerfrei ausführen können.

Wenn Sie in Ihrer Vulkan-App einen neuen Fehler auslösen, der ein bestimmtes Android-Gerät betrifft, können Sie einen neuen Testvorschlag einreichen, in dem Sie das Problem beschreiben und herausfinden, wie Sie es prüfen können. So wird sichergestellt, dass das Problem in einem zukünftigen Update für das Gerät behoben und auch bei anderen Geräten nicht auftritt.

In der CTS-Übermittlung finden Sie eine Schritt-für-Schritt-Anleitung zum Einreichen des Testvorschlags.