Frame-Taktungsfunktionen hinzufügen

Verwenden Sie die folgenden Funktionen, um Android Frame Pacing mit einem Rendering-Modul zu verwenden basierend auf der Vulkan API.

Erforderliche Erweiterungen für die Erstellung ermitteln

Um die Erweiterungen zu erfassen, die zum Erstellen einer Android Frame-Instanz erforderlich sind Führe bei Verwendung von Vulkan die im folgenden Code gezeigten Schritte aus. 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);

Anschließend können Sie Android Frame Pacing starten, indem Sie vkCreateDevice() aufrufen. Das 2. -Argument einer Struktur vom Typ VkDeviceCreateInfo*, sollte ihre Für enabledExtensionCount Mitglied wurde die Anzahl der erforderlichen Erweiterungen festgelegt.

Warteschlangenfamilie identifizieren

Um die richtige Warteschlange für die Anzeige zu präsentieren, muss Android Frame Pacing wissen, welche Wiedergabelistenfamilie, die Vulkan verwendet. Um die richtige Familie zu ermitteln, füllen Sie das die im folgenden Code-Snippet dargestellt sind:

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

Framerate für Swapchain definieren

Um Android Frame Pacing für ein bestimmtes physisches Gerät und eine Swapchain zu initialisieren, führen Sie die im folgenden Code-Snippet gezeigten Schritte aus:

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

Damit wird die Dauer der Auslagerung in Nanosekunden festgelegt. Es gibt Hilfsmakros definiert in swappy_common.h für gängige Dauer der Auslagerung (z. B. SWAPPY_SWAP_60FPS).

Als Nächstes müssen Sie die Auslagerungsdauer in Nanosekunden angeben.

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

ANativeWindow festlegen

Swappy benötigt den Handle ANativeWindow, um Folgendes auszuführen: ANativeWindow-spezifischer Vorgang, z. B. das Aufrufen von ANativeWindow_setFrameRate() Anruf SwappyVk_setWindow() wenn sich die Android-Displayoberfläche geändert hat und du eine neue ANativeWindow hast Handle (ein Beispiel finden Sie im Cube-Beispiel).

Automatische Modi

Android Frame Pacing passt die Auslagerungsdauer und den Pipeline-Modus basierend auf den durchschnittliche Dauer vorheriger Frames. Sie können dieses Verhalten über die folgenden Funktionen:

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

Einen Frame präsentieren

Um einen Frame Ihres Spiels für Android Frame Pacing zu präsentieren, rufen Sie SwappyVk_queuePresent() Diese Funktion ruft vkQueuePresentKHR() im Namen deines Spiels auf.

Hinweis: Damit die richtige Frame-Taktung erreicht wird, kann die Android Frame Pacing API Vulkan-Befehle in die Präsentationswarteschlange.

Swapchain löschen

Um die SwappyVk-Daten zu löschen, die mit einer bestimmten Swapchain verknüpft sind, schließen Sie die die im folgenden Code-Snippet dargestellt sind:

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

SwappyVk_destroySwapchain(device, swapchain);
vkDestroySwapchainKHR(device, swapchain, &allocator);