Motores nativos y propios

Cómo empezar a usar Vulkan en Android

Vulkan es la principal API de gráficos de bajo nivel de Android. Vulkan proporciona un rendimiento óptimo para los juegos que implementan su propio motor y procesador.

Para implementar Vulkan, de forma correcta, en tu motor de juego, debes hacer lo siguiente:

  • Identificar qué dispositivos Android usar con Vulkan
  • Comprender las ventajas y desventajas de admitir dispositivos Android más antiguos
  • Agregar Vulkan a tu destino de compilación de Android
  • Seleccionar un compilador de sombreadores para crear SPIR-V para Vulkan
  • Determinar la versión disponible de la API de Vulkan durante el tiempo de ejecución
  • Aprender a optimizar tus operaciones de renderización de Vulkan con el ritmo de fotogramas, la rotación previa y los perfiles de Vulkan
  • Seleccionar herramientas gráficas para depurar y analizar el rendimiento
    Nota: Si deseas obtener información para usar Vulkan en Android con los motores de juegos Unity o Unreal, consulta lo siguiente:
  • Vulkan en Unity
  • Vulkan en Unreal

Cómo elegir especificaciones mínimas de dispositivos para Vulkan

Vulkan está disponible en Android a partir de Android 7.0 (nivel de API 24). No todos los dispositivos Android que ejecutan Android 7.0 o versiones posteriores son compatibles con Vulkan. Debes determinar qué dispositivos Android compatibles con Vulkan admite tu juego.

Recomendaciones

Usa las siguientes especificaciones como requisitos mínimos para la compatibilidad con Vulkan:

  • El dispositivo ejecuta Android 10.0 (nivel de API 29) o una versión posterior.
  • El dispositivo es compatible con la versión 1.1 o una posterior de la API de Vulkan.
  • El dispositivo tiene capacidades de hardware y funciones compatibles con el perfil de Baseline de Android de 2022.

Compatibilidad con dispositivos más antiguos

Si el juego está diseñado para ejecutarse en una amplia variedad de dispositivos con diferentes niveles de capacidades de gráficos, es posible que debas admitir dispositivos más antiguos que los recomendados en Cómo elegir especificaciones mínimas de dispositivos para Vulkan. Antes de compilar compatibilidad para dispositivos más antiguos, evalúa si Vulkan le proporciona beneficios a tu juego. Los juegos que tienen muchas llamadas de dibujo y que usan OpenGL ES pueden observar una sobrecarga significativa de los controladores debido al alto costo de realizar llamadas de dibujo en OpenGL ES. Estos juegos pueden vincularse a la CPU, ya que gastan grandes porciones de su latencia de fotogramas en el controlador gráfico. Los juegos también pueden observar reducciones significativas en el uso de CPU y energía si cambian de OpenGL ES a Vulkan. Esto se aplica, en particular, si tu juego tiene escenas complejas que no pueden usar la creación de instancias de manera efectiva para reducir las llamadas de dibujo. Cuando orientes tu juego a dispositivos más antiguos, incluye la compatibilidad con la renderización de OpenGL ES como resguardo, ya que algunos dispositivos de tu lista de dispositivos de destino podrían tener implementaciones de Vulkan que no puedan ejecutar tu juego de manera confiable.

Es posible que no quieras admitir dispositivos más antiguos compatibles con Vulkan porque carecen de rendimiento y funciones o tienen problemas de estabilidad.

Rendimiento y funciones

Es posible que los dispositivos Android más antiguos compatibles con Vulkan no tengan el rendimiento de renderización ni la compatibilidad de hardware con las funciones necesarias para ejecutar tu juego. Esto es muy probable si tu juego tiene gráficos de alta fidelidad y Vulkan es la única API a la que te orientas en Android. Muchos dispositivos más antiguos se limitan a la versión 1.0.3 de la API de Vulkan y, con frecuencia, les faltan extensiones de Vulkan muy usadas que están disponibles en hardware más moderno.

Estabilidad

Es posible que los dispositivos Android más antiguos usen controladores de Vulkan desactualizados. Estas versiones del controlador podrían incluir errores que pueden afectar la estabilidad del juego. Para solucionar los errores del controlador, es posible que se deba dedicar tiempo significativo de ingeniería y pruebas.

Cómo agregar Vulkan a tu proyecto

Para agregar Vulkan a tu proyecto, debes hacer lo siguiente:

  • Incluir encabezados de la API de Vulkan
  • Compila el código del sombreador en SPIR-V
  • Llamar a la API de Vulkan durante el tiempo de ejecución

Incluye encabezados de la API de Vulkan

Tu juego debe incluir los archivos de encabezado de la API de Vulkan para compilar código que use Vulkan. Puedes encontrar una copia de los encabezados de Vulkan en el NDK de Android o empaquetados en las versiones del SDK de Vulkan. Cualquier versión particular del NDK solo incluye encabezados de Vulkan disponibles en el momento de la versión del NDK. Si usas encabezados de Vulkan desde el NDK, usa la versión 25 del NDK o una posterior, que incluye archivos de encabezados compatibles con la versión 1.3 de Vulkan. El SDK de Vulkan tiene la versión más reciente de los encabezados.

Compila el código del sombreador en SPIR-V

La API de Vulkan espera que los programas sombreadores se proporcionen en el formato intermedio binario SPIR-V. Esta convención es diferente de OpenGL ES, en el que puedes enviar el código fuente escrito en OpenGL Shading Language (GLSL) como cadenas de texto. Usa un compilador de sombreadores para convertir el código escrito en un lenguaje de sombreadores, como GLSL o High-level Shader Language (HLSL), y compílalo en módulos SPIR-V para usar con Vulkan.

El compilador shaderc se puede usar para compilar programas sombreadores escritos en GLSL, en SPIR-V. Si tu juego usa HLSL, DirectXShaderCompiler admite una salida de SPIR-V. Por lo general, compilarás programas sombreadores sin conexión como parte del proceso de compilación de los recursos del juego y, además, incluirás los módulos SPIR-V en los recursos del tiempo de ejecución.

Llama a la API de Vulkan durante el tiempo de ejecución

Para llamar a la API de Vulkan, tu juego debe obtener punteros a la función para las llamadas a la API de Vulkan. La manera más directa de hacerlo es vincular la biblioteca compartida libvulkan.so, que se incluye en el NDK de Android. Vincular la biblioteca tiene dos deficiencias: la sobrecarga adicional del despacho de funciones y las limitaciones con las que los punteros a la función de la API de Vulkan se resuelven automáticamente.

Cuando llamas a una función de la API de Vulkan, el control pasa por una tabla de despacho que administra una construcción denominada el cargador de Vulkan. Android usa su propia implementación del cargador de Vulkan en lugar del cargador de LunarG. Este sistema del cargador forma parte de la arquitectura de capas de la API de Vulkan. Vincular la biblioteca del sistema en el tiempo de compilación genera un nivel de despacho adicional para una llamada determinada a la API. Si bien la sobrecarga es pequeña, puede ser notoria para los juegos que realizan grandes volúmenes de llamadas de Vulkan.

Por lo general, la biblioteca del sistema solo resuelve punteros a funciones de Vulkan que se consideran parte de la API principal. Vulkan tiene una gran cantidad de extensiones, que definen funciones adicionales de Vulkan, muchas de las cuales la biblioteca del sistema no resuelve automáticamente. Debes resolver, de forma manual, los punteros a estas funciones de Vulkan antes de usarlas.

Para mitigar estos problemas, resuelve, de forma dinámica, los punteros a todas las funciones de Vulkan que deseas usar en el tiempo de ejecución. Una forma de lograrlo es con una biblioteca de metacargador de código abierto, como volk. El juego de muestra AGDKTunnel integra volk con este fin. Si usas una biblioteca de metacargador, no vincules la biblioteca compartida libvulkan.so en tus secuencias de comandos de compilación.

Determina la versión disponible de la API de Vulkan

Android admite las siguientes versiones de la API de Vulkan:

  • 1.0.3
  • 1.1
  • 1.3

El número más alto de la versión de la API de Vulkan disponible en un dispositivo determinado se determina según la versión de Android y la compatibilidad con el controlador de Vulkan.

Versión de Android

La compatibilidad de la plataforma con una versión de la API de Vulkan depende de una versión mínima de Android (nivel de API):

  • 1.3: Android 13.0 (nivel de API 33) y versiones posteriores
  • 1.1: Android 10.0 (nivel de API 29) y versiones posteriores
  • 1.0.3: Android 7.0 (nivel de API 24) y versiones posteriores

Compatibilidad con controladores de Vulkan

La compatibilidad de la plataforma de Android con una versión de la API de Vulkan no garantiza que la versión de la API sea compatible con el controlador de Vulkan del dispositivo. Es posible que un dispositivo con Android 13 solo admita la versión 1.1 de la API de Vulkan.

Cuando inicialices Vulkan, no solicites una API posterior a cualquiera de las siguientes versiones:

  • La versión máxima de la API de Vulkan para la versión de Android que se ejecuta en el dispositivo
  • La versión de la API de Vulkan informada por vkEnumerateInstanceVersion
  • La versión de la API de Vulkan informada por la propiedad apiVersion de la estructura VkPhysicalDeviceProperties

A continuación, se muestra un ejemplo para determinar la versión posterior compatible de la API de Vulkan:

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

Determina la compatibilidad con perfiles de Vulkan

Los perfiles de Vulkan son archivos JSON que definen un conjunto de funciones, extensiones, capacidades y límites de parámetros mínimos obligatorios que un dispositivo Vulkan debe admitir para ser compatible con el perfil. Para determinar si un dispositivo es compatible con un perfil de Vulkan específico, como el perfil de Baseline de Android de 2022, usa la biblioteca de la API de Vulkan Profiles de código abierto. También puedes analizar el archivo JSON de perfil por tu cuenta y consultar las capacidades del dispositivo con las APIs relevantes de Vulkan para determinar la compatibilidad del perfil.

Perfiles de Vulkan

Android usa perfiles de Vulkan, que definen qué funciones y extensiones están disponibles para cada uno de los dispositivos que ejecutan Android.

El perfil de Baseline de Android (ABP) es el primer intento de compilar el perfil de Vulkan. ABP2021 y ABP2022 son perfiles retrospectivos que tienen como objetivo abarcar más del 85% de los dispositivos activos en ese momento. No habrá ABP nuevos en el futuro.

Los perfiles de Vulkan para Android (VPA) son el nuevo perfil orientado al futuro que tiene como objetivo reflejar las necesidades de los desarrolladores de software y ofrecer funciones coherentes en cuanto los desarrolladores de hardware puedan entregarlas. VPA15_minimums es el primer perfil para Android 15 y habrá un nuevo VPA cada año para cubrir cada versión principal de Android.

Implementa el ritmo de fotogramas

Un ritmo de fotogramas adecuado es fundamental para ofrecer una experiencia de juego de alta calidad. Android Game Development Kit incluye la biblioteca de Frame Pacing para ayudar a tu juego a lograr un ritmo de fotogramas óptimo. Para obtener más detalles sobre la implementación, consulta Integra Android Frame Pacing a tu procesador de Vulkan.

Implementa la rotación previa

Los dispositivos Android pueden mostrarse en varias orientaciones. La orientación del dispositivo puede ser diferente a la de la superficie de renderización. A diferencia de OpenGL ES en Android, Vulkan no controla las discrepancias entre ambas. Para comprender cómo funciona el proceso de orientación y cuál es el método óptimo para manejar las diferencias de orientación cuando se usa Vulkan, consulta Cómo controlar la orientación del dispositivo con la rotación previa de Vulkan.

Soluciona problemas y genera perfiles de renderización de Vulkan

Existen varias herramientas disponibles para ayudarte a diagnosticar problemas de renderización y de rendimiento con el código de renderización de Vulkan.

Para obtener más información sobre las herramientas de depuración y generación de perfiles de Vulkan, consulta la sección Herramientas y funciones avanzadas.

Capas de validación de Vulkan

Las capas de validación de Vulkan son bibliotecas de tiempo de ejecución que se pueden habilitar para inspeccionar tus llamadas a la API de Vulkan y mostrar advertencias o errores sobre usos incorrectos o no óptimos. Estas capas de validación no están activas de forma predeterminada, ya que el proceso de validación agrega sobrecarga del tiempo de ejecución y afecta el rendimiento del juego. Si deseas obtener información para usar las capas de validación con tu juego, consulta Depuración con la capa de validación.

Herramientas de captura de fotogramas

Usa herramientas de captura de fotogramas para grabar y volver a reproducir las llamadas a la API de Vulkan que se realizan durante un fotograma del juego. Estas herramientas te permiten hacer lo siguiente:

  • Consultar información sobre los recursos gráficos activos y ver visualizaciones de estos
  • Consultar la secuencia de llamadas a la API que realiza tu juego y ver los parámetros de la API
  • Explorar el estado de la canalización de los gráficos en el momento de una llamada de dibujo
  • Visualizar los resultados de la renderización hasta una llamada de dibujo específica en el fotograma

Usa la herramienta de código abierto RenderDoc para capturar fotogramas de los juegos que se ejecutan en Android. RenderDoc admite la captura de fotogramas de Vulkan y OpenGL ES.

También se puede usar el Inspector de GPU de Android (AGI) para capturar fotogramas de Vulkan.

Herramientas de análisis del rendimiento

Usa las herramientas de análisis de rendimiento para investigar los problemas de renderización de tu juego que causan velocidades de fotogramas deficientes. Los proveedores individuales de las GPUs proporcionan herramientas diseñadas para generar perfiles de tu juego y brindar datos de rendimiento específicos a las arquitecturas de sus GPUs. Las características de rendimiento y los cuellos de botella de tu juego pueden variar de forma considerable cuando se renderiza en GPUs de distintos proveedores o incluso en diferentes generaciones de GPUs del mismo proveedor.

También puedes usar el Inspector de GPU de Android para recopilar y analizar los datos de rendimiento. A diferencia de las herramientas de los proveedores, el Inspector de GPU de Android es compatible con varias GPUs de distintos proveedores. Sin embargo, el Inspector de GPU de Android no es compatible con dispositivos Android más antiguos, y es posible que tampoco sea compatible con todos los dispositivos nuevos.

Mejora las pruebas de Vulkan con CTS-D

Los fabricantes de dispositivos con Android usan el Conjunto de pruebas de compatibilidad (CTS) para ayudar a garantizar que sus dispositivos sean compatibles. Las pruebas de CTS con tecnología de desarrollador (CTS-D) son pruebas que envían los desarrolladores de aplicaciones para Android para asegurarse de que los dispositivos Android futuros satisfagan sus casos de uso y puedan ejecutar sus aplicaciones sin problemas y sin errores.

Si logras activar un nuevo error con tu aplicación de Vulkan que afecta a cualquier dispositivo específico con Android, puedes enviar una nueva propuesta de prueba en la que describas el problema y las formas de verificarlo. Esto garantiza que el problema se solucione en una actualización futura del dispositivo y que no ocurra el mismo error en ningún otro dispositivo.

Consulta el proceso de envío de CTS para obtener instrucciones paso a paso sobre cómo enviar la propuesta de prueba.