Aggiungere funzioni di pacing dei frame

Usa le seguenti funzioni per utilizzare il pacing del frame Android con un motore di rendering basate sull'API Vulkan.

Identifica le estensioni richieste per la creazione

Raccogliere il set di estensioni necessarie per creare un'istanza di Android Frame Quando utilizzi Vulkan, il pacing è necessario, completa i passaggi mostrati nel seguente codice snippet:

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 il pacing del frame Android chiamando vkCreateDevice(). Il 2° uno struct di tipo VkDeviceCreateInfo*, deve avere il suo enabledExtensionCount membro impostato sul numero di estensioni richieste.

Identifica famiglia di code

Per presentare la coda di visualizzazione corretta, il pacing del frame Android deve sapere quale la famiglia di code utilizzate da Vulkan. Per determinare la famiglia corretta, completa la passaggi mostrati nel seguente 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 frame per swapchain

Per inizializzare il pacing del frame Android per un determinato dispositivo fisico e 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. Sono presenti macro helper definita in swappy_common.h per le durate comuni dello scambio (ad esempio, SWAPPY_SWAP_60FPS).

Poi 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 A NativeWindow

Spotpy ha bisogno dell'handle ANativeWindow per funzionare per un'operazione specifica per ANativeWindow, ad esempio la chiamata ANativeWindow_setFrameRate() Chiama SwappyVk_setWindow() Quando la superficie del display Android è cambiata e hai un nuovo ANativeWindow (vedi esempio di cubo per un esempio).

Modalità automatiche

Il pacing del frame Android regola la durata dello scambio e la modalità pipeline in base al 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 una cornice

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

Distruggi la catena di swap

Per eliminare i dati SwappyVk associati a una determinata swapchain, completa la 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);