Aggiungere funzioni di pacing dei frame

Utilizza le seguenti funzioni per utilizzare Android Frame Pacing con un motore di rendering basato sull'API Vulkan.

Identificare le estensioni richieste per la creazione

Per raccogliere il set di estensioni necessarie per creare un'istanza di Android Frame Pacing quando utilizzi Vulkan, completa i passaggi mostrati nel seguente snippet di codice:

VkPhysicalDevice physicalDevice;
uint32_t availableExtensionCount;
VkExtensionProperties* pAvailableExtensions;
uint32_t requiredExtensionCount;
char** pRequiredExtensions;

// Determine the number of extensions available for this device.
vkEnumerateDeviceExtensionProperties(physicalDevice, layerName, &availableExtensionCount,
    pAvailableExtensions);

// Determine the number of required extensions.
SwappyVk_determineDeviceExtensions(physicalDevice, availableExtensionCount,
    pAvailableExtensions, &requiredExtensionCount, nullptr);

// Determine the required extensions.
pRequiredExtensions = (char**)malloc(requiredExtensionCount * sizeof(char*));
pRequiredExtensionsData = (char*)malloc(requiredExtensionCount * (VK_MAX_EXTENSION_NAME_SIZE + 1));
for (uint32_t i = 0; i < requiredExtensionCount; i++) {
    pRequiredExtensions[i] = &pRequiredExtensionsData[i * (VK_MAX_EXTENSION_NAME_SIZE + 1)];
}
SwappyVk_determineDeviceExtensions(physicalDevice, availableExtensionCount,
    pAvailableExtensions, &requiredExtensionCount, pRequiredExtensions);

Puoi quindi avviare Android Frame Pacing chiamando vkCreateDevice(). Il secondo argomento, una struct di tipo VkDeviceCreateInfo*, deve avere il membro enabledExtensionCount impostato sul numero di estensioni richieste.

Identificare la famiglia di code

Per presentare la coda di visualizzazione corretta, Android Frame Pacing deve sapere quale famiglia di code utilizza Vulkan. Per determinare la famiglia corretta, completa i passaggi mostrati nello snippet di codice seguente:

// Reusing local variables from previous snippets:
// VkPhysicalDevice physicalDevice;

const VkDeviceCreateInfo createInfo;
const VkAllocationCallbacks allocator;
VkDevice device;
uint32_t queueFamilyIndex;
uint32_t queueIndex;
VkQueue deviceQueue;

// Values of "device" and "deviceQueue" set in the 1st and 2nd function
// calls, respectively.
vkCreateDevice(physicalDevice, &createInfo, &allocator, &device);
vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, &deviceQueue);
SwappyVk_setQueueFamilyIndex(device, deviceQueue, queueFamilyIndex);

Definisci il frame rate per la swapchain

Per inizializzare Android Frame Pacing per una determinata swapchain e un determinato dispositivo fisico, completa i passaggi mostrati nello snippet di codice seguente:

// Reusing local variables from previous snippets:
// VkPhysicalDevice physicalDevice;
// VkDevice device;

// Assume that the JNI environment is available in:
// JNIEnv *env;
// jobject jactivity;

// Assume that swapchain is already known.
VkSwapchainKHR swapchain;
uint64_t refreshDuration; // in nanoseconds

// Determine duration between vertical-blanking periods.
// Example: 60 FPS sets "refreshDuration" to 16,666,666.
SwappyVk_initAndGetRefreshCycleDuration(env, jactivity, physicalDevice,
        device, swapchain, &refreshDuration);

Determina la durata dello swap in nanosecondi. Esistono macro helper definite in swappy_common.h per le durate comuni di swap (ad esempio, SWAPPY_SWAP_60FPS).

Successivamente, devi fornire la durata dello scambio in nanosecondi.

// Declare the periods in nanoseconds that should elapse before refreshing one
// image with the next image. There are helper macros defined in swappy_common.h
// for common swap durations.
// This example shows what to do when you want to render your game at 30 FPS.

SwappyVk_setSwapIntervalNS(device, swapchain, SWAPPY_SWAP_30FPS);

Impostazione di ANativeWindow

Swappy ha bisogno dell'handle di ANativeWindow per eseguire un'operazione specifica di ANativeWindow, ad esempio chiamare ANativeWindow_setFrameRate(). Chiama SwappyVk_setWindow() quando la superficie di visualizzazione di Android è cambiata e hai un nuovo handle ANativeWindow (vedi l'esempio di cubo).

Modalità automatiche

Android Frame Pacing regola la durata dello scambio e la modalità pipeline in base alla durata media dei frame precedenti. Puoi controllare questo comportamento con le seguenti funzioni:

Presentare un frame

Per presentare un frame del gioco ad Android Frame Pacing, chiama SwappyVk_queuePresent(). Questa funzione chiama vkQueuePresentKHR() per conto del tuo gioco.

Distrugge la swapchain

Per eliminare i dati SwappyVk associati a una determinata swapchain, completa i passaggi mostrati nel seguente snippet di codice:

// Reusing local variables from previous snippets:
// VkDevice device;
// VkSwapchainKHR swapchain;
// const VkAllocationCallbacks allocator;

SwappyVk_destroySwapchain(device, swapchain);
vkDestroySwapchainKHR(device, swapchain, &allocator);
Indietro
Aggiornare le impostazioni della build
Avanti
Verificare il miglioramento del pacing del frame