Aggiungere funzioni di pacing dei frame

Usa le seguenti funzioni per usare il pacing dei frame Android con un motore di rendering basato sull'API Vulkan.

Identifica le estensioni necessarie per la creazione

Per raccogliere il set di estensioni necessarie per creare un'istanza di Pacing dei frame Android 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);

A questo punto, puoi avviare il pacing del frame Android chiamando il numero vkCreateDevice(). Nel secondo argomento, uno struct di tipo VkDeviceCreateInfo*, il membro enabledExtensionCount deve essere impostato sul numero di estensioni richieste.

Identifica famiglia di code

Per presentare la coda di visualizzazione corretta, il pacing dei frame Android deve sapere quale famiglia di code viene utilizzata da Vulkan. Per determinare la famiglia corretta, completa i passaggi mostrati nello snippet di codice:

// 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 frequenza fotogrammi per la swapchain

Per inizializzare il pacing dei frame Android per un determinato dispositivo fisico e la swapchain, completa i passaggi mostrati nel seguente snippet di codice:

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

Questo determina la durata dello scambio in nanosecondi. Esistono macro helper definite in swappy_common.h per le durate di scambio più comuni (ad esempio, SWAPPY_SWAP_60FPS).

Successivamente, devi specificare 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 A NativeWindow

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

Modalità automatiche

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

• void SwappyVk_setAutoSwapInterval(bool enabled);
• void SwappyVk_setMaxAutoSwapIntervalNS(uint64_t max_swap_ns);
• void SwappyVk_setAutoPipelineMode(bool enabled);

Presentare un frame

Per presentare un frame del tuo gioco al pacing del frame Android, chiama SwappyVk_queuePresent(). Questa funzione chiama vkQueuePresentKHR() per conto del tuo gioco.

Distruggi 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);