blob: 91cfb6d6670bde3e776f2ac4143acbf7ba5c5e94 [file] [log] [blame]
// Copyright (C) 2018 The Android Open Source Project
// Copyright (C) 2018 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Autogenerated module func_table
//
// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
// -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
//
// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
// $CEREAL_OUTPUT_DIR
//
#include "func_table.h"
#include <log/log.h>
#include <cstring>
#include "../OpenglSystemCommon/HostConnection.h"
#include "ResourceTracker.h"
#include "VkEncoder.h"
#include "goldfish_vk_private_defs.h"
// Stuff we are not going to use but if included,
// will cause compile errors. These are Android Vulkan
// required extensions, but the approach will be to
// implement them completely on the guest side.
#undef VK_KHR_android_surface
namespace gfxstream {
namespace vk {
static void sOnInvalidDynamicallyCheckedCall(const char* apiname, const char* neededFeature) {
ALOGE("invalid call to %s: %s not supported", apiname, neededFeature);
abort();
}
#ifdef VK_VERSION_1_0
static VkResult entry_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkInstance* pInstance) {
AEMU_SCOPED_TRACE("vkCreateInstance");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateInstance_VkResult_return = (VkResult)0;
vkCreateInstance_VkResult_return =
vkEnc->vkCreateInstance(pCreateInfo, pAllocator, pInstance, true /* do lock */);
return vkCreateInstance_VkResult_return;
}
static void entry_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyInstance");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyInstance(instance, pAllocator, true /* do lock */);
}
static VkResult entry_vkEnumeratePhysicalDevices(VkInstance instance,
uint32_t* pPhysicalDeviceCount,
VkPhysicalDevice* pPhysicalDevices) {
AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkEnumeratePhysicalDevices_VkResult_return = resources->on_vkEnumeratePhysicalDevices(
vkEnc, VK_SUCCESS, instance, pPhysicalDeviceCount, pPhysicalDevices);
return vkEnumeratePhysicalDevices_VkResult_return;
}
static void entry_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures* pFeatures) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties* pFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties,
true /* do lock */);
}
static VkResult entry_vkGetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling,
VkImageUsageFlags usage, VkImageCreateFlags flags,
VkImageFormatProperties* pImageFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
vkGetPhysicalDeviceImageFormatProperties_VkResult_return =
vkEnc->vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage,
flags, pImageFormatProperties,
true /* do lock */);
return vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
}
static void entry_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceProperties(physicalDevice, pProperties, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties* pQueueFamilyProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount,
pQueueFamilyProperties, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties,
true /* do lock */);
}
static PFN_vkVoidFunction entry_vkGetInstanceProcAddr(VkInstance instance, const char* pName) {
AEMU_SCOPED_TRACE("vkGetInstanceProcAddr");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
vkGetInstanceProcAddr_PFN_vkVoidFunction_return =
vkEnc->vkGetInstanceProcAddr(instance, pName, true /* do lock */);
return vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
}
static PFN_vkVoidFunction entry_vkGetDeviceProcAddr(VkDevice device, const char* pName) {
AEMU_SCOPED_TRACE("vkGetDeviceProcAddr");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
vkGetDeviceProcAddr_PFN_vkVoidFunction_return =
vkEnc->vkGetDeviceProcAddr(device, pName, true /* do lock */);
return vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
}
static VkResult entry_vkCreateDevice(VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
AEMU_SCOPED_TRACE("vkCreateDevice");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDevice_VkResult_return = (VkResult)0;
vkCreateDevice_VkResult_return =
vkEnc->vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice, true /* do lock */);
return vkCreateDevice_VkResult_return;
}
static void entry_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDevice");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyDevice(device, pAllocator, true /* do lock */);
}
static VkResult entry_vkEnumerateInstanceExtensionProperties(const char* pLayerName,
uint32_t* pPropertyCount,
VkExtensionProperties* pProperties) {
AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkEnumerateInstanceExtensionProperties_VkResult_return =
resources->on_vkEnumerateInstanceExtensionProperties(vkEnc, VK_SUCCESS, pLayerName,
pPropertyCount, pProperties);
return vkEnumerateInstanceExtensionProperties_VkResult_return;
}
static VkResult entry_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
const char* pLayerName,
uint32_t* pPropertyCount,
VkExtensionProperties* pProperties) {
AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkEnumerateDeviceExtensionProperties_VkResult_return =
resources->on_vkEnumerateDeviceExtensionProperties(vkEnc, VK_SUCCESS, physicalDevice,
pLayerName, pPropertyCount, pProperties);
return vkEnumerateDeviceExtensionProperties_VkResult_return;
}
static VkResult entry_vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
VkLayerProperties* pProperties) {
AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
vkEnumerateInstanceLayerProperties_VkResult_return =
vkEnc->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties, true /* do lock */);
return vkEnumerateInstanceLayerProperties_VkResult_return;
}
static VkResult entry_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
uint32_t* pPropertyCount,
VkLayerProperties* pProperties) {
AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(
physicalDevice, pPropertyCount, pProperties, true /* do lock */);
return vkEnumerateDeviceLayerProperties_VkResult_return;
}
static void entry_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex,
VkQueue* pQueue) {
AEMU_SCOPED_TRACE("vkGetDeviceQueue");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue, true /* do lock */);
}
static VkResult entry_vkQueueSubmit(VkQueue queue, uint32_t submitCount,
const VkSubmitInfo* pSubmits, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueSubmit");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkQueueSubmit_VkResult_return =
resources->on_vkQueueSubmit(vkEnc, VK_SUCCESS, queue, submitCount, pSubmits, fence);
return vkQueueSubmit_VkResult_return;
}
static VkResult entry_vkQueueWaitIdle(VkQueue queue) {
AEMU_SCOPED_TRACE("vkQueueWaitIdle");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkQueueWaitIdle_VkResult_return = resources->on_vkQueueWaitIdle(vkEnc, VK_SUCCESS, queue);
return vkQueueWaitIdle_VkResult_return;
}
static VkResult entry_vkDeviceWaitIdle(VkDevice device) {
AEMU_SCOPED_TRACE("vkDeviceWaitIdle");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
vkDeviceWaitIdle_VkResult_return = vkEnc->vkDeviceWaitIdle(device, true /* do lock */);
return vkDeviceWaitIdle_VkResult_return;
}
static VkResult entry_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
const VkAllocationCallbacks* pAllocator,
VkDeviceMemory* pMemory) {
AEMU_SCOPED_TRACE("vkAllocateMemory");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkAllocateMemory_VkResult_return = resources->on_vkAllocateMemory(
vkEnc, VK_SUCCESS, device, pAllocateInfo, pAllocator, pMemory);
return vkAllocateMemory_VkResult_return;
}
static void entry_vkFreeMemory(VkDevice device, VkDeviceMemory memory,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkFreeMemory");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkFreeMemory(vkEnc, device, memory, pAllocator);
}
static VkResult entry_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset,
VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
AEMU_SCOPED_TRACE("vkMapMemory");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkMapMemory_VkResult_return = (VkResult)0;
vkMapMemory_VkResult_return =
vkEnc->vkMapMemory(device, memory, offset, size, flags, ppData, true /* do lock */);
return vkMapMemory_VkResult_return;
}
static void entry_vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
AEMU_SCOPED_TRACE("vkUnmapMemory");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkUnmapMemory(device, memory, true /* do lock */);
}
static VkResult entry_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges) {
AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
vkFlushMappedMemoryRanges_VkResult_return = vkEnc->vkFlushMappedMemoryRanges(
device, memoryRangeCount, pMemoryRanges, true /* do lock */);
return vkFlushMappedMemoryRanges_VkResult_return;
}
static VkResult entry_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges) {
AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(
device, memoryRangeCount, pMemoryRanges, true /* do lock */);
return vkInvalidateMappedMemoryRanges_VkResult_return;
}
static void entry_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes) {
AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes, true /* do lock */);
}
static VkResult entry_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
VkDeviceSize memoryOffset) {
AEMU_SCOPED_TRACE("vkBindBufferMemory");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkBindBufferMemory_VkResult_return =
resources->on_vkBindBufferMemory(vkEnc, VK_SUCCESS, device, buffer, memory, memoryOffset);
return vkBindBufferMemory_VkResult_return;
}
static VkResult entry_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
VkDeviceSize memoryOffset) {
AEMU_SCOPED_TRACE("vkBindImageMemory");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkBindImageMemory_VkResult_return =
resources->on_vkBindImageMemory(vkEnc, VK_SUCCESS, device, image, memory, memoryOffset);
return vkBindImageMemory_VkResult_return;
}
static void entry_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
VkMemoryRequirements* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkGetBufferMemoryRequirements(vkEnc, device, buffer, pMemoryRequirements);
}
static void entry_vkGetImageMemoryRequirements(VkDevice device, VkImage image,
VkMemoryRequirements* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkGetImageMemoryRequirements(vkEnc, device, image, pMemoryRequirements);
}
static void entry_vkGetImageSparseMemoryRequirements(
VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount,
pSparseMemoryRequirements, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceSparseImageFormatProperties(
VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling,
uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples,
usage, tiling, pPropertyCount,
pProperties, true /* do lock */);
}
static VkResult entry_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
const VkBindSparseInfo* pBindInfo, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueBindSparse");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
vkQueueBindSparse_VkResult_return =
vkEnc->vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence, true /* do lock */);
return vkQueueBindSparse_VkResult_return;
}
static VkResult entry_vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
AEMU_SCOPED_TRACE("vkCreateFence");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateFence_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkCreateFence_VkResult_return =
resources->on_vkCreateFence(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pFence);
return vkCreateFence_VkResult_return;
}
static void entry_vkDestroyFence(VkDevice device, VkFence fence,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyFence");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyFence(device, fence, pAllocator, true /* do lock */);
}
static VkResult entry_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
AEMU_SCOPED_TRACE("vkResetFences");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkResetFences_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkResetFences_VkResult_return =
resources->on_vkResetFences(vkEnc, VK_SUCCESS, device, fenceCount, pFences);
return vkResetFences_VkResult_return;
}
static VkResult entry_vkGetFenceStatus(VkDevice device, VkFence fence) {
AEMU_SCOPED_TRACE("vkGetFenceStatus");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
vkGetFenceStatus_VkResult_return = vkEnc->vkGetFenceStatus(device, fence, true /* do lock */);
return vkGetFenceStatus_VkResult_return;
}
static VkResult entry_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
VkBool32 waitAll, uint64_t timeout) {
AEMU_SCOPED_TRACE("vkWaitForFences");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkWaitForFences_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkWaitForFences_VkResult_return = resources->on_vkWaitForFences(
vkEnc, VK_SUCCESS, device, fenceCount, pFences, waitAll, timeout);
return vkWaitForFences_VkResult_return;
}
static VkResult entry_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSemaphore* pSemaphore) {
AEMU_SCOPED_TRACE("vkCreateSemaphore");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkCreateSemaphore_VkResult_return = resources->on_vkCreateSemaphore(
vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSemaphore);
return vkCreateSemaphore_VkResult_return;
}
static void entry_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySemaphore");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkDestroySemaphore(vkEnc, device, semaphore, pAllocator);
}
static VkResult entry_vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
AEMU_SCOPED_TRACE("vkCreateEvent");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateEvent_VkResult_return = (VkResult)0;
vkCreateEvent_VkResult_return =
vkEnc->vkCreateEvent(device, pCreateInfo, pAllocator, pEvent, true /* do lock */);
return vkCreateEvent_VkResult_return;
}
static void entry_vkDestroyEvent(VkDevice device, VkEvent event,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyEvent");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyEvent(device, event, pAllocator, true /* do lock */);
}
static VkResult entry_vkGetEventStatus(VkDevice device, VkEvent event) {
AEMU_SCOPED_TRACE("vkGetEventStatus");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
vkGetEventStatus_VkResult_return = vkEnc->vkGetEventStatus(device, event, true /* do lock */);
return vkGetEventStatus_VkResult_return;
}
static VkResult entry_vkSetEvent(VkDevice device, VkEvent event) {
AEMU_SCOPED_TRACE("vkSetEvent");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetEvent_VkResult_return = (VkResult)0;
vkSetEvent_VkResult_return = vkEnc->vkSetEvent(device, event, true /* do lock */);
return vkSetEvent_VkResult_return;
}
static VkResult entry_vkResetEvent(VkDevice device, VkEvent event) {
AEMU_SCOPED_TRACE("vkResetEvent");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkResetEvent_VkResult_return = (VkResult)0;
vkResetEvent_VkResult_return = vkEnc->vkResetEvent(device, event, true /* do lock */);
return vkResetEvent_VkResult_return;
}
static VkResult entry_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkQueryPool* pQueryPool) {
AEMU_SCOPED_TRACE("vkCreateQueryPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
vkCreateQueryPool_VkResult_return =
vkEnc->vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool, true /* do lock */);
return vkCreateQueryPool_VkResult_return;
}
static void entry_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyQueryPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyQueryPool(device, queryPool, pAllocator, true /* do lock */);
}
static VkResult entry_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
uint32_t firstQuery, uint32_t queryCount,
size_t dataSize, void* pData, VkDeviceSize stride,
VkQueryResultFlags flags) {
AEMU_SCOPED_TRACE("vkGetQueryPoolResults");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
vkGetQueryPoolResults_VkResult_return =
vkEnc->vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData,
stride, flags, true /* do lock */);
return vkGetQueryPoolResults_VkResult_return;
}
static VkResult entry_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
AEMU_SCOPED_TRACE("vkCreateBuffer");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkCreateBuffer_VkResult_return =
resources->on_vkCreateBuffer(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pBuffer);
return vkCreateBuffer_VkResult_return;
}
static void entry_vkDestroyBuffer(VkDevice device, VkBuffer buffer,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyBuffer");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkDestroyBuffer(vkEnc, device, buffer, pAllocator);
}
static VkResult entry_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkBufferView* pView) {
AEMU_SCOPED_TRACE("vkCreateBufferView");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
vkCreateBufferView_VkResult_return =
vkEnc->vkCreateBufferView(device, pCreateInfo, pAllocator, pView, true /* do lock */);
return vkCreateBufferView_VkResult_return;
}
static void entry_vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyBufferView");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyBufferView(device, bufferView, pAllocator, true /* do lock */);
}
static VkResult entry_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
AEMU_SCOPED_TRACE("vkCreateImage");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateImage_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkCreateImage_VkResult_return =
resources->on_vkCreateImage(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pImage);
return vkCreateImage_VkResult_return;
}
static void entry_vkDestroyImage(VkDevice device, VkImage image,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyImage");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkDestroyImage(vkEnc, device, image, pAllocator);
}
static void entry_vkGetImageSubresourceLayout(VkDevice device, VkImage image,
const VkImageSubresource* pSubresource,
VkSubresourceLayout* pLayout) {
AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetImageSubresourceLayout(device, image, pSubresource, pLayout, true /* do lock */);
}
static VkResult entry_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkImageView* pView) {
AEMU_SCOPED_TRACE("vkCreateImageView");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateImageView_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkCreateImageView_VkResult_return =
resources->on_vkCreateImageView(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pView);
return vkCreateImageView_VkResult_return;
}
static void entry_vkDestroyImageView(VkDevice device, VkImageView imageView,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyImageView");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyImageView(device, imageView, pAllocator, true /* do lock */);
}
static VkResult entry_vkCreateShaderModule(VkDevice device,
const VkShaderModuleCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkShaderModule* pShaderModule) {
AEMU_SCOPED_TRACE("vkCreateShaderModule");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(
device, pCreateInfo, pAllocator, pShaderModule, true /* do lock */);
return vkCreateShaderModule_VkResult_return;
}
static void entry_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyShaderModule");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyShaderModule(device, shaderModule, pAllocator, true /* do lock */);
}
static VkResult entry_vkCreatePipelineCache(VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkPipelineCache* pPipelineCache) {
AEMU_SCOPED_TRACE("vkCreatePipelineCache");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(
device, pCreateInfo, pAllocator, pPipelineCache, true /* do lock */);
return vkCreatePipelineCache_VkResult_return;
}
static void entry_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPipelineCache");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyPipelineCache(device, pipelineCache, pAllocator, true /* do lock */);
}
static VkResult entry_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
size_t* pDataSize, void* pData) {
AEMU_SCOPED_TRACE("vkGetPipelineCacheData");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
vkGetPipelineCacheData_VkResult_return =
vkEnc->vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData, true /* do lock */);
return vkGetPipelineCacheData_VkResult_return;
}
static VkResult entry_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
uint32_t srcCacheCount,
const VkPipelineCache* pSrcCaches) {
AEMU_SCOPED_TRACE("vkMergePipelineCaches");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(
device, dstCache, srcCacheCount, pSrcCaches, true /* do lock */);
return vkMergePipelineCaches_VkResult_return;
}
static VkResult entry_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines) {
AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkCreateGraphicsPipelines_VkResult_return = resources->on_vkCreateGraphicsPipelines(
vkEnc, VK_SUCCESS, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
pPipelines);
return vkCreateGraphicsPipelines_VkResult_return;
}
static VkResult entry_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkComputePipelineCreateInfo* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines) {
AEMU_SCOPED_TRACE("vkCreateComputePipelines");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
vkCreateComputePipelines_VkResult_return =
vkEnc->vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos,
pAllocator, pPipelines, true /* do lock */);
return vkCreateComputePipelines_VkResult_return;
}
static void entry_vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPipeline");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyPipeline(device, pipeline, pAllocator, true /* do lock */);
}
static VkResult entry_vkCreatePipelineLayout(VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout) {
AEMU_SCOPED_TRACE("vkCreatePipelineLayout");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(
device, pCreateInfo, pAllocator, pPipelineLayout, true /* do lock */);
return vkCreatePipelineLayout_VkResult_return;
}
static void entry_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPipelineLayout");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyPipelineLayout(device, pipelineLayout, pAllocator, true /* do lock */);
}
static VkResult entry_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSampler* pSampler) {
AEMU_SCOPED_TRACE("vkCreateSampler");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSampler_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkCreateSampler_VkResult_return =
resources->on_vkCreateSampler(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSampler);
return vkCreateSampler_VkResult_return;
}
static void entry_vkDestroySampler(VkDevice device, VkSampler sampler,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySampler");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroySampler(device, sampler, pAllocator, true /* do lock */);
}
static VkResult entry_vkCreateDescriptorSetLayout(
VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkCreateDescriptorSetLayout_VkResult_return = resources->on_vkCreateDescriptorSetLayout(
vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSetLayout);
return vkCreateDescriptorSetLayout_VkResult_return;
}
static void entry_vkDestroyDescriptorSetLayout(VkDevice device,
VkDescriptorSetLayout descriptorSetLayout,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkDestroyDescriptorSetLayout(vkEnc, device, descriptorSetLayout, pAllocator);
}
static VkResult entry_vkCreateDescriptorPool(VkDevice device,
const VkDescriptorPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool) {
AEMU_SCOPED_TRACE("vkCreateDescriptorPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkCreateDescriptorPool_VkResult_return = resources->on_vkCreateDescriptorPool(
vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pDescriptorPool);
return vkCreateDescriptorPool_VkResult_return;
}
static void entry_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDescriptorPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkDestroyDescriptorPool(vkEnc, device, descriptorPool, pAllocator);
}
static VkResult entry_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
VkDescriptorPoolResetFlags flags) {
AEMU_SCOPED_TRACE("vkResetDescriptorPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkResetDescriptorPool_VkResult_return =
resources->on_vkResetDescriptorPool(vkEnc, VK_SUCCESS, device, descriptorPool, flags);
return vkResetDescriptorPool_VkResult_return;
}
static VkResult entry_vkAllocateDescriptorSets(VkDevice device,
const VkDescriptorSetAllocateInfo* pAllocateInfo,
VkDescriptorSet* pDescriptorSets) {
AEMU_SCOPED_TRACE("vkAllocateDescriptorSets");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkAllocateDescriptorSets_VkResult_return = resources->on_vkAllocateDescriptorSets(
vkEnc, VK_SUCCESS, device, pAllocateInfo, pDescriptorSets);
return vkAllocateDescriptorSets_VkResult_return;
}
static VkResult entry_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
uint32_t descriptorSetCount,
const VkDescriptorSet* pDescriptorSets) {
AEMU_SCOPED_TRACE("vkFreeDescriptorSets");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkFreeDescriptorSets_VkResult_return = resources->on_vkFreeDescriptorSets(
vkEnc, VK_SUCCESS, device, descriptorPool, descriptorSetCount, pDescriptorSets);
return vkFreeDescriptorSets_VkResult_return;
}
static void entry_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
const VkWriteDescriptorSet* pDescriptorWrites,
uint32_t descriptorCopyCount,
const VkCopyDescriptorSet* pDescriptorCopies) {
AEMU_SCOPED_TRACE("vkUpdateDescriptorSets");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkUpdateDescriptorSets(vkEnc, device, descriptorWriteCount, pDescriptorWrites,
descriptorCopyCount, pDescriptorCopies);
}
static VkResult entry_vkCreateFramebuffer(VkDevice device,
const VkFramebufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkFramebuffer* pFramebuffer) {
AEMU_SCOPED_TRACE("vkCreateFramebuffer");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(
device, pCreateInfo, pAllocator, pFramebuffer, true /* do lock */);
return vkCreateFramebuffer_VkResult_return;
}
static void entry_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyFramebuffer");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyFramebuffer(device, framebuffer, pAllocator, true /* do lock */);
}
static VkResult entry_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass) {
AEMU_SCOPED_TRACE("vkCreateRenderPass");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
vkCreateRenderPass_VkResult_return =
vkEnc->vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
return vkCreateRenderPass_VkResult_return;
}
static void entry_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyRenderPass");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyRenderPass(device, renderPass, pAllocator, true /* do lock */);
}
static void entry_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
VkExtent2D* pGranularity) {
AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetRenderAreaGranularity(device, renderPass, pGranularity, true /* do lock */);
}
static VkResult entry_vkCreateCommandPool(VkDevice device,
const VkCommandPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkCommandPool* pCommandPool) {
AEMU_SCOPED_TRACE("vkCreateCommandPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
vkCreateCommandPool_VkResult_return = vkEnc->vkCreateCommandPool(
device, pCreateInfo, pAllocator, pCommandPool, true /* do lock */);
return vkCreateCommandPool_VkResult_return;
}
static void entry_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyCommandPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyCommandPool(device, commandPool, pAllocator, true /* do lock */);
}
static VkResult entry_vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
VkCommandPoolResetFlags flags) {
AEMU_SCOPED_TRACE("vkResetCommandPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
vkResetCommandPool_VkResult_return =
vkEnc->vkResetCommandPool(device, commandPool, flags, true /* do lock */);
if (vkResetCommandPool_VkResult_return == VK_SUCCESS) {
ResourceTracker::get()->resetCommandPoolStagingInfo(commandPool);
}
return vkResetCommandPool_VkResult_return;
}
static VkResult entry_vkAllocateCommandBuffers(VkDevice device,
const VkCommandBufferAllocateInfo* pAllocateInfo,
VkCommandBuffer* pCommandBuffers) {
AEMU_SCOPED_TRACE("vkAllocateCommandBuffers");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkAllocateCommandBuffers_VkResult_return = resources->on_vkAllocateCommandBuffers(
vkEnc, VK_SUCCESS, device, pAllocateInfo, pCommandBuffers);
if (vkAllocateCommandBuffers_VkResult_return == VK_SUCCESS) {
ResourceTracker::get()->addToCommandPool(
pAllocateInfo->commandPool, pAllocateInfo->commandBufferCount, pCommandBuffers);
}
return vkAllocateCommandBuffers_VkResult_return;
}
static void entry_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers) {
AEMU_SCOPED_TRACE("vkFreeCommandBuffers");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers,
true /* do lock */);
}
static VkResult entry_vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
const VkCommandBufferBeginInfo* pBeginInfo) {
AEMU_SCOPED_TRACE("vkBeginCommandBuffer");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkBeginCommandBuffer_VkResult_return =
resources->on_vkBeginCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, pBeginInfo);
return vkBeginCommandBuffer_VkResult_return;
}
static VkResult entry_vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkEndCommandBuffer");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkEndCommandBuffer_VkResult_return =
resources->on_vkEndCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer);
return vkEndCommandBuffer_VkResult_return;
}
static VkResult entry_vkResetCommandBuffer(VkCommandBuffer commandBuffer,
VkCommandBufferResetFlags flags) {
AEMU_SCOPED_TRACE("vkResetCommandBuffer");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkResetCommandBuffer_VkResult_return =
resources->on_vkResetCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, flags);
return vkResetCommandBuffer_VkResult_return;
}
static void entry_vkCmdBindPipeline(VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
AEMU_SCOPED_TRACE("vkCmdBindPipeline");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline, true /* do lock */);
}
static void entry_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
uint32_t viewportCount, const VkViewport* pViewports) {
AEMU_SCOPED_TRACE("vkCmdSetViewport");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports,
true /* do lock */);
}
static void entry_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
uint32_t scissorCount, const VkRect2D* pScissors) {
AEMU_SCOPED_TRACE("vkCmdSetScissor");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors,
true /* do lock */);
}
static void entry_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
AEMU_SCOPED_TRACE("vkCmdSetLineWidth");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetLineWidth(commandBuffer, lineWidth, true /* do lock */);
}
static void entry_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
float depthBiasClamp, float depthBiasSlopeFactor) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBias");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp,
depthBiasSlopeFactor, true /* do lock */);
}
static void entry_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer,
const float blendConstants[4]) {
AEMU_SCOPED_TRACE("vkCmdSetBlendConstants");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetBlendConstants(commandBuffer, blendConstants, true /* do lock */);
}
static void entry_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
float maxDepthBounds) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBounds");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds, true /* do lock */);
}
static void entry_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask, uint32_t compareMask) {
AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask, true /* do lock */);
}
static void entry_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask, uint32_t writeMask) {
AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask, true /* do lock */);
}
static void entry_vkCmdSetStencilReference(VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask, uint32_t reference) {
AEMU_SCOPED_TRACE("vkCmdSetStencilReference");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetStencilReference(commandBuffer, faceMask, reference, true /* do lock */);
}
static void entry_vkCmdBindDescriptorSets(
VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets,
uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
auto resources = ResourceTracker::get();
resources->on_vkCmdBindDescriptorSets(vkEnc, commandBuffer, pipelineBindPoint, layout, firstSet,
descriptorSetCount, pDescriptorSets, dynamicOffsetCount,
pDynamicOffsets);
}
static void entry_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
VkDeviceSize offset, VkIndexType indexType) {
AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType, true /* do lock */);
}
static void entry_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
uint32_t bindingCount, const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets) {
AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
true /* do lock */);
}
static void entry_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
AEMU_SCOPED_TRACE("vkCmdDraw");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance,
true /* do lock */);
}
static void entry_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
uint32_t instanceCount, uint32_t firstIndex,
int32_t vertexOffset, uint32_t firstInstance) {
AEMU_SCOPED_TRACE("vkCmdDrawIndexed");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset,
firstInstance, true /* do lock */);
}
static void entry_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndirect");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride, true /* do lock */);
}
static void entry_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
VkDeviceSize offset, uint32_t drawCount,
uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride,
true /* do lock */);
}
static void entry_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX,
uint32_t groupCountY, uint32_t groupCountZ) {
AEMU_SCOPED_TRACE("vkCmdDispatch");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ, true /* do lock */);
}
static void entry_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
VkDeviceSize offset) {
AEMU_SCOPED_TRACE("vkCmdDispatchIndirect");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDispatchIndirect(commandBuffer, buffer, offset, true /* do lock */);
}
static void entry_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
VkBuffer dstBuffer, uint32_t regionCount,
const VkBufferCopy* pRegions) {
AEMU_SCOPED_TRACE("vkCmdCopyBuffer");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions,
true /* do lock */);
}
static void entry_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
VkImageLayout srcImageLayout, VkImage dstImage,
VkImageLayout dstImageLayout, uint32_t regionCount,
const VkImageCopy* pRegions) {
AEMU_SCOPED_TRACE("vkCmdCopyImage");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
regionCount, pRegions, true /* do lock */);
}
static void entry_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
VkImageLayout srcImageLayout, VkImage dstImage,
VkImageLayout dstImageLayout, uint32_t regionCount,
const VkImageBlit* pRegions, VkFilter filter) {
AEMU_SCOPED_TRACE("vkCmdBlitImage");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
regionCount, pRegions, filter, true /* do lock */);
}
static void entry_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
VkImage dstImage, VkImageLayout dstImageLayout,
uint32_t regionCount, const VkBufferImageCopy* pRegions) {
AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount,
pRegions, true /* do lock */);
}
static void entry_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
VkImageLayout srcImageLayout, VkBuffer dstBuffer,
uint32_t regionCount, const VkBufferImageCopy* pRegions) {
AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount,
pRegions, true /* do lock */);
}
static void entry_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
VkDeviceSize dstOffset, VkDeviceSize dataSize,
const void* pData) {
AEMU_SCOPED_TRACE("vkCmdUpdateBuffer");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData,
true /* do lock */);
}
static void entry_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
AEMU_SCOPED_TRACE("vkCmdFillBuffer");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data, true /* do lock */);
}
static void entry_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
VkImageLayout imageLayout, const VkClearColorValue* pColor,
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges) {
AEMU_SCOPED_TRACE("vkCmdClearColorImage");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges,
true /* do lock */);
}
static void entry_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue* pDepthStencil,
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges) {
AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount,
pRanges, true /* do lock */);
}
static void entry_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
const VkClearAttachment* pAttachments, uint32_t rectCount,
const VkClearRect* pRects) {
AEMU_SCOPED_TRACE("vkCmdClearAttachments");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects,
true /* do lock */);
}
static void entry_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
VkImageLayout srcImageLayout, VkImage dstImage,
VkImageLayout dstImageLayout, uint32_t regionCount,
const VkImageResolve* pRegions) {
AEMU_SCOPED_TRACE("vkCmdResolveImage");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
regionCount, pRegions, true /* do lock */);
}
static void entry_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
VkPipelineStageFlags stageMask) {
AEMU_SCOPED_TRACE("vkCmdSetEvent");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetEvent(commandBuffer, event, stageMask, true /* do lock */);
}
static void entry_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
VkPipelineStageFlags stageMask) {
AEMU_SCOPED_TRACE("vkCmdResetEvent");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdResetEvent(commandBuffer, event, stageMask, true /* do lock */);
}
static void entry_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount,
const VkEvent* pEvents, VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount,
const VkMemoryBarrier* pMemoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier* pImageMemoryBarriers) {
AEMU_SCOPED_TRACE("vkCmdWaitEvents");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask,
memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers,
true /* do lock */);
}
static void entry_vkCmdPipelineBarrier(
VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
AEMU_SCOPED_TRACE("vkCmdPipelineBarrier");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
auto resources = ResourceTracker::get();
resources->on_vkCmdPipelineBarrier(vkEnc, commandBuffer, srcStageMask, dstStageMask,
dependencyFlags, memoryBarrierCount, pMemoryBarriers,
bufferMemoryBarrierCount, pBufferMemoryBarriers,
imageMemoryBarrierCount, pImageMemoryBarriers);
}
static void entry_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
uint32_t query, VkQueryControlFlags flags) {
AEMU_SCOPED_TRACE("vkCmdBeginQuery");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBeginQuery(commandBuffer, queryPool, query, flags, true /* do lock */);
}
static void entry_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
uint32_t query) {
AEMU_SCOPED_TRACE("vkCmdEndQuery");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdEndQuery(commandBuffer, queryPool, query, true /* do lock */);
}
static void entry_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
uint32_t firstQuery, uint32_t queryCount) {
AEMU_SCOPED_TRACE("vkCmdResetQueryPool");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount,
true /* do lock */);
}
static void entry_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool,
uint32_t query) {
AEMU_SCOPED_TRACE("vkCmdWriteTimestamp");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query, true /* do lock */);
}
static void entry_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
uint32_t firstQuery, uint32_t queryCount,
VkBuffer dstBuffer, VkDeviceSize dstOffset,
VkDeviceSize stride, VkQueryResultFlags flags) {
AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer,
dstOffset, stride, flags, true /* do lock */);
}
static void entry_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
const void* pValues) {
AEMU_SCOPED_TRACE("vkCmdPushConstants");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues,
true /* do lock */);
}
static void entry_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
VkSubpassContents contents) {
AEMU_SCOPED_TRACE("vkCmdBeginRenderPass");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents, true /* do lock */);
}
static void entry_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
AEMU_SCOPED_TRACE("vkCmdNextSubpass");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdNextSubpass(commandBuffer, contents, true /* do lock */);
}
static void entry_vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkCmdEndRenderPass");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdEndRenderPass(commandBuffer, true /* do lock */);
}
static void entry_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers) {
AEMU_SCOPED_TRACE("vkCmdExecuteCommands");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
auto resources = ResourceTracker::get();
resources->on_vkCmdExecuteCommands(vkEnc, commandBuffer, commandBufferCount, pCommandBuffers);
}
#endif
#ifdef VK_VERSION_1_1
static VkResult entry_vkEnumerateInstanceVersion(uint32_t* pApiVersion) {
AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
vkEnumerateInstanceVersion_VkResult_return =
vkEnc->vkEnumerateInstanceVersion(pApiVersion, true /* do lock */);
return vkEnumerateInstanceVersion_VkResult_return;
}
static VkResult entry_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
const VkBindBufferMemoryInfo* pBindInfos) {
AEMU_SCOPED_TRACE("vkBindBufferMemory2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkBindBufferMemory2_VkResult_return =
resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
return vkBindBufferMemory2_VkResult_return;
}
static VkResult dynCheck_entry_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
const VkBindBufferMemoryInfo* pBindInfos) {
auto resources = ResourceTracker::get();
if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkBindBufferMemory2", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkBindBufferMemory2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
vkBindBufferMemory2_VkResult_return =
resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
return vkBindBufferMemory2_VkResult_return;
}
static VkResult entry_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
const VkBindImageMemoryInfo* pBindInfos) {
AEMU_SCOPED_TRACE("vkBindImageMemory2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkBindImageMemory2_VkResult_return =
resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
return vkBindImageMemory2_VkResult_return;
}
static VkResult dynCheck_entry_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
const VkBindImageMemoryInfo* pBindInfos) {
auto resources = ResourceTracker::get();
if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkBindImageMemory2", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkBindImageMemory2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
vkBindImageMemory2_VkResult_return =
resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
return vkBindImageMemory2_VkResult_return;
}
static void entry_vkGetDeviceGroupPeerMemoryFeatures(
VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex,
remoteDeviceIndex, pPeerMemoryFeatures,
true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceGroupPeerMemoryFeatures(
VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
auto resources = ResourceTracker::get();
if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupPeerMemoryFeatures", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex,
remoteDeviceIndex, pPeerMemoryFeatures,
true /* do lock */);
}
static void entry_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) {
AEMU_SCOPED_TRACE("vkCmdSetDeviceMask");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetDeviceMask(commandBuffer, deviceMask, true /* do lock */);
}
static void entry_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX,
uint32_t groupCountY, uint32_t groupCountZ) {
AEMU_SCOPED_TRACE("vkCmdDispatchBase");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX,
groupCountY, groupCountZ, true /* do lock */);
}
static VkResult entry_vkEnumeratePhysicalDeviceGroups(
VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
vkEnumeratePhysicalDeviceGroups_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroups(
instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, true /* do lock */);
return vkEnumeratePhysicalDeviceGroups_VkResult_return;
}
static void entry_vkGetImageMemoryRequirements2(VkDevice device,
const VkImageMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkGetImageMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
}
static void dynCheck_entry_vkGetImageMemoryRequirements2(
VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
auto resources = ResourceTracker::get();
if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkGetImageMemoryRequirements2", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
resources->on_vkGetImageMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
}
static void entry_vkGetBufferMemoryRequirements2(VkDevice device,
const VkBufferMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkGetBufferMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
}
static void dynCheck_entry_vkGetBufferMemoryRequirements2(
VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
auto resources = ResourceTracker::get();
if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkGetBufferMemoryRequirements2", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
resources->on_vkGetBufferMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
}
static void entry_vkGetImageSparseMemoryRequirements2(
VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount,
pSparseMemoryRequirements, true /* do lock */);
}
static void dynCheck_entry_vkGetImageSparseMemoryRequirements2(
VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
auto resources = ResourceTracker::get();
if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkGetImageSparseMemoryRequirements2", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount,
pSparseMemoryRequirements, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures2* pFeatures) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties2* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceProperties2(physicalDevice, pProperties, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties2* pFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties,
true /* do lock */);
}
static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
VkImageFormatProperties2* pImageFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkGetPhysicalDeviceImageFormatProperties2_VkResult_return =
resources->on_vkGetPhysicalDeviceImageFormatProperties2(
vkEnc, VK_SUCCESS, physicalDevice, pImageFormatInfo, pImageFormatProperties);
return vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
}
static void entry_vkGetPhysicalDeviceQueueFamilyProperties2(
VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties2* pQueueFamilyProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount,
pQueueFamilyProperties, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceMemoryProperties2(
VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties,
true /* do lock */);
}
static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(
physicalDevice, pFormatInfo, pPropertyCount, pProperties, true /* do lock */);
}
static void entry_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
VkCommandPoolTrimFlags flags) {
AEMU_SCOPED_TRACE("vkTrimCommandPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkTrimCommandPool(device, commandPool, flags, true /* do lock */);
}
static void dynCheck_entry_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
VkCommandPoolTrimFlags flags) {
auto resources = ResourceTracker::get();
if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkTrimCommandPool", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkTrimCommandPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkTrimCommandPool(device, commandPool, flags, true /* do lock */);
}
static void entry_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo,
VkQueue* pQueue) {
AEMU_SCOPED_TRACE("vkGetDeviceQueue2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue, true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo,
VkQueue* pQueue) {
auto resources = ResourceTracker::get();
if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkGetDeviceQueue2", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkGetDeviceQueue2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue, true /* do lock */);
}
static VkResult entry_vkCreateSamplerYcbcrConversion(
VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkCreateSamplerYcbcrConversion_VkResult_return = resources->on_vkCreateSamplerYcbcrConversion(
vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
return vkCreateSamplerYcbcrConversion_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateSamplerYcbcrConversion(
VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
auto resources = ResourceTracker::get();
if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkCreateSamplerYcbcrConversion", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
vkCreateSamplerYcbcrConversion_VkResult_return = resources->on_vkCreateSamplerYcbcrConversion(
vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
return vkCreateSamplerYcbcrConversion_VkResult_return;
}
static void entry_vkDestroySamplerYcbcrConversion(VkDevice device,
VkSamplerYcbcrConversion ycbcrConversion,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkDestroySamplerYcbcrConversion(vkEnc, device, ycbcrConversion, pAllocator);
}
static void dynCheck_entry_vkDestroySamplerYcbcrConversion(
VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkDestroySamplerYcbcrConversion", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
resources->on_vkDestroySamplerYcbcrConversion(vkEnc, device, ycbcrConversion, pAllocator);
}
static VkResult entry_vkCreateDescriptorUpdateTemplate(
VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(
device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, true /* do lock */);
return vkCreateDescriptorUpdateTemplate_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateDescriptorUpdateTemplate(
VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
auto resources = ResourceTracker::get();
if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkCreateDescriptorUpdateTemplate", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(
device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, true /* do lock */);
return vkCreateDescriptorUpdateTemplate_VkResult_return;
}
static void entry_vkDestroyDescriptorUpdateTemplate(
VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator,
true /* do lock */);
}
static void dynCheck_entry_vkDestroyDescriptorUpdateTemplate(
VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkDestroyDescriptorUpdateTemplate", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator,
true /* do lock */);
}
static void entry_vkUpdateDescriptorSetWithTemplate(
VkDevice device, VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkUpdateDescriptorSetWithTemplate(vkEnc, device, descriptorSet,
descriptorUpdateTemplate, pData);
}
static void dynCheck_entry_vkUpdateDescriptorSetWithTemplate(
VkDevice device, VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
auto resources = ResourceTracker::get();
if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplate", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
resources->on_vkUpdateDescriptorSetWithTemplate(vkEnc, device, descriptorSet,
descriptorUpdateTemplate, pData);
}
static void entry_vkGetPhysicalDeviceExternalBufferProperties(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
VkExternalBufferProperties* pExternalBufferProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceExternalBufferProperties(
physicalDevice, pExternalBufferInfo, pExternalBufferProperties, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceExternalFenceProperties(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
VkExternalFenceProperties* pExternalFenceProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkGetPhysicalDeviceExternalFenceProperties(
vkEnc, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
}
static void entry_vkGetPhysicalDeviceExternalSemaphoreProperties(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(
physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, true /* do lock */);
}
static void entry_vkGetDescriptorSetLayoutSupport(
VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupport* pSupport) {
AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport, true /* do lock */);
}
static void dynCheck_entry_vkGetDescriptorSetLayoutSupport(
VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupport* pSupport) {
auto resources = ResourceTracker::get();
if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkGetDescriptorSetLayoutSupport", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport, true /* do lock */);
}
#endif
#ifdef VK_VERSION_1_2
static void entry_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
VkDeviceSize offset, VkBuffer countBuffer,
VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndirectCount");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset,
maxDrawCount, stride, true /* do lock */);
}
static void entry_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
VkDeviceSize offset, VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount, uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCount");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer,
countBufferOffset, maxDrawCount, stride,
true /* do lock */);
}
static VkResult entry_vkCreateRenderPass2(VkDevice device,
const VkRenderPassCreateInfo2* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass) {
AEMU_SCOPED_TRACE("vkCreateRenderPass2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRenderPass2_VkResult_return = (VkResult)0;
vkCreateRenderPass2_VkResult_return = vkEnc->vkCreateRenderPass2(
device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
return vkCreateRenderPass2_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateRenderPass2(VkDevice device,
const VkRenderPassCreateInfo2* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2")) {
sOnInvalidDynamicallyCheckedCall("vkCreateRenderPass2", "VK_VERSION_1_2");
}
AEMU_SCOPED_TRACE("vkCreateRenderPass2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRenderPass2_VkResult_return = (VkResult)0;
vkCreateRenderPass2_VkResult_return = vkEnc->vkCreateRenderPass2(
device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
return vkCreateRenderPass2_VkResult_return;
}
static void entry_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
const VkSubpassBeginInfo* pSubpassBeginInfo) {
AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo,
true /* do lock */);
}
static void entry_vkCmdNextSubpass2(VkCommandBuffer commandBuffer,
const VkSubpassBeginInfo* pSubpassBeginInfo,
const VkSubpassEndInfo* pSubpassEndInfo) {
AEMU_SCOPED_TRACE("vkCmdNextSubpass2");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, true /* do lock */);
}
static void entry_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer,
const VkSubpassEndInfo* pSubpassEndInfo) {
AEMU_SCOPED_TRACE("vkCmdEndRenderPass2");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo, true /* do lock */);
}
static void entry_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
uint32_t queryCount) {
AEMU_SCOPED_TRACE("vkResetQueryPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkResetQueryPool(device, queryPool, firstQuery, queryCount, true /* do lock */);
}
static void dynCheck_entry_vkResetQueryPool(VkDevice device, VkQueryPool queryPool,
uint32_t firstQuery, uint32_t queryCount) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2")) {
sOnInvalidDynamicallyCheckedCall("vkResetQueryPool", "VK_VERSION_1_2");
}
AEMU_SCOPED_TRACE("vkResetQueryPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkResetQueryPool(device, queryPool, firstQuery, queryCount, true /* do lock */);
}
static VkResult entry_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
uint64_t* pValue) {
AEMU_SCOPED_TRACE("vkGetSemaphoreCounterValue");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSemaphoreCounterValue_VkResult_return = (VkResult)0;
vkGetSemaphoreCounterValue_VkResult_return =
vkEnc->vkGetSemaphoreCounterValue(device, semaphore, pValue, true /* do lock */);
return vkGetSemaphoreCounterValue_VkResult_return;
}
static VkResult dynCheck_entry_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
uint64_t* pValue) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2")) {
sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreCounterValue", "VK_VERSION_1_2");
}
AEMU_SCOPED_TRACE("vkGetSemaphoreCounterValue");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSemaphoreCounterValue_VkResult_return = (VkResult)0;
vkGetSemaphoreCounterValue_VkResult_return =
vkEnc->vkGetSemaphoreCounterValue(device, semaphore, pValue, true /* do lock */);
return vkGetSemaphoreCounterValue_VkResult_return;
}
static VkResult entry_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo,
uint64_t timeout) {
AEMU_SCOPED_TRACE("vkWaitSemaphores");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkWaitSemaphores_VkResult_return = (VkResult)0;
vkWaitSemaphores_VkResult_return =
vkEnc->vkWaitSemaphores(device, pWaitInfo, timeout, true /* do lock */);
return vkWaitSemaphores_VkResult_return;
}
static VkResult dynCheck_entry_vkWaitSemaphores(VkDevice device,
const VkSemaphoreWaitInfo* pWaitInfo,
uint64_t timeout) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2")) {
sOnInvalidDynamicallyCheckedCall("vkWaitSemaphores", "VK_VERSION_1_2");
}
AEMU_SCOPED_TRACE("vkWaitSemaphores");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkWaitSemaphores_VkResult_return = (VkResult)0;
vkWaitSemaphores_VkResult_return =
vkEnc->vkWaitSemaphores(device, pWaitInfo, timeout, true /* do lock */);
return vkWaitSemaphores_VkResult_return;
}
static VkResult entry_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
AEMU_SCOPED_TRACE("vkSignalSemaphore");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSignalSemaphore_VkResult_return = (VkResult)0;
vkSignalSemaphore_VkResult_return =
vkEnc->vkSignalSemaphore(device, pSignalInfo, true /* do lock */);
return vkSignalSemaphore_VkResult_return;
}
static VkResult dynCheck_entry_vkSignalSemaphore(VkDevice device,
const VkSemaphoreSignalInfo* pSignalInfo) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2")) {
sOnInvalidDynamicallyCheckedCall("vkSignalSemaphore", "VK_VERSION_1_2");
}
AEMU_SCOPED_TRACE("vkSignalSemaphore");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSignalSemaphore_VkResult_return = (VkResult)0;
vkSignalSemaphore_VkResult_return =
vkEnc->vkSignalSemaphore(device, pSignalInfo, true /* do lock */);
return vkSignalSemaphore_VkResult_return;
}
static VkDeviceAddress entry_vkGetBufferDeviceAddress(VkDevice device,
const VkBufferDeviceAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetBufferDeviceAddress");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkDeviceAddress vkGetBufferDeviceAddress_VkDeviceAddress_return = (VkDeviceAddress)0;
vkGetBufferDeviceAddress_VkDeviceAddress_return =
vkEnc->vkGetBufferDeviceAddress(device, pInfo, true /* do lock */);
return vkGetBufferDeviceAddress_VkDeviceAddress_return;
}
static VkDeviceAddress dynCheck_entry_vkGetBufferDeviceAddress(
VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2")) {
sOnInvalidDynamicallyCheckedCall("vkGetBufferDeviceAddress", "VK_VERSION_1_2");
}
AEMU_SCOPED_TRACE("vkGetBufferDeviceAddress");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkDeviceAddress vkGetBufferDeviceAddress_VkDeviceAddress_return = (VkDeviceAddress)0;
vkGetBufferDeviceAddress_VkDeviceAddress_return =
vkEnc->vkGetBufferDeviceAddress(device, pInfo, true /* do lock */);
return vkGetBufferDeviceAddress_VkDeviceAddress_return;
}
static uint64_t entry_vkGetBufferOpaqueCaptureAddress(VkDevice device,
const VkBufferDeviceAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddress");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetBufferOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
vkGetBufferOpaqueCaptureAddress_uint64_t_return =
vkEnc->vkGetBufferOpaqueCaptureAddress(device, pInfo, true /* do lock */);
return vkGetBufferOpaqueCaptureAddress_uint64_t_return;
}
static uint64_t dynCheck_entry_vkGetBufferOpaqueCaptureAddress(
VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2")) {
sOnInvalidDynamicallyCheckedCall("vkGetBufferOpaqueCaptureAddress", "VK_VERSION_1_2");
}
AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddress");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetBufferOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
vkGetBufferOpaqueCaptureAddress_uint64_t_return =
vkEnc->vkGetBufferOpaqueCaptureAddress(device, pInfo, true /* do lock */);
return vkGetBufferOpaqueCaptureAddress_uint64_t_return;
}
static uint64_t entry_vkGetDeviceMemoryOpaqueCaptureAddress(
VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddress");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo, true /* do lock */);
return vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return;
}
static uint64_t dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddress(
VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2")) {
sOnInvalidDynamicallyCheckedCall("vkGetDeviceMemoryOpaqueCaptureAddress", "VK_VERSION_1_2");
}
AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddress");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo, true /* do lock */);
return vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return;
}
#endif
#ifdef VK_KHR_surface
static void entry_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySurfaceKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroySurfaceKHR(instance, surface, pAllocator, true /* do lock */);
}
static VkResult entry_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
VkSurfaceKHR surface,
VkBool32* pSupported) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceSupportKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0;
vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return =
vkEnc->vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface,
pSupported, true /* do lock */);
return vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0;
vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return =
vkEnc->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface,
pSurfaceCapabilities, true /* do lock */);
return vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pSurfaceFormatCount,
VkSurfaceFormatKHR* pSurfaceFormats) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormatsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0;
vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return =
vkEnc->vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount,
pSurfaceFormats, true /* do lock */);
return vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pPresentModeCount,
VkPresentModeKHR* pPresentModes) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfacePresentModesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0;
vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return =
vkEnc->vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount,
pPresentModes, true /* do lock */);
return vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_swapchain
static VkResult entry_vkCreateSwapchainKHR(VkDevice device,
const VkSwapchainCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSwapchainKHR* pSwapchain) {
AEMU_SCOPED_TRACE("vkCreateSwapchainKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
vkCreateSwapchainKHR_VkResult_return = vkEnc->vkCreateSwapchainKHR(
device, pCreateInfo, pAllocator, pSwapchain, true /* do lock */);
return vkCreateSwapchainKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateSwapchainKHR(VkDevice device,
const VkSwapchainCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSwapchainKHR* pSwapchain) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
sOnInvalidDynamicallyCheckedCall("vkCreateSwapchainKHR", "VK_KHR_swapchain");
}
AEMU_SCOPED_TRACE("vkCreateSwapchainKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
vkCreateSwapchainKHR_VkResult_return = vkEnc->vkCreateSwapchainKHR(
device, pCreateInfo, pAllocator, pSwapchain, true /* do lock */);
return vkCreateSwapchainKHR_VkResult_return;
}
static void entry_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySwapchainKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroySwapchainKHR(device, swapchain, pAllocator, true /* do lock */);
}
static void dynCheck_entry_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
sOnInvalidDynamicallyCheckedCall("vkDestroySwapchainKHR", "VK_KHR_swapchain");
}
AEMU_SCOPED_TRACE("vkDestroySwapchainKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroySwapchainKHR(device, swapchain, pAllocator, true /* do lock */);
}
static VkResult entry_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain,
uint32_t* pSwapchainImageCount,
VkImage* pSwapchainImages) {
AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
vkGetSwapchainImagesKHR_VkResult_return = vkEnc->vkGetSwapchainImagesKHR(
device, swapchain, pSwapchainImageCount, pSwapchainImages, true /* do lock */);
return vkGetSwapchainImagesKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain,
uint32_t* pSwapchainImageCount,
VkImage* pSwapchainImages) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
sOnInvalidDynamicallyCheckedCall("vkGetSwapchainImagesKHR", "VK_KHR_swapchain");
}
AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
vkGetSwapchainImagesKHR_VkResult_return = vkEnc->vkGetSwapchainImagesKHR(
device, swapchain, pSwapchainImageCount, pSwapchainImages, true /* do lock */);
return vkGetSwapchainImagesKHR_VkResult_return;
}
static VkResult entry_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain,
uint64_t timeout, VkSemaphore semaphore, VkFence fence,
uint32_t* pImageIndex) {
AEMU_SCOPED_TRACE("vkAcquireNextImageKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
vkAcquireNextImageKHR_VkResult_return = vkEnc->vkAcquireNextImageKHR(
device, swapchain, timeout, semaphore, fence, pImageIndex, true /* do lock */);
return vkAcquireNextImageKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain,
uint64_t timeout, VkSemaphore semaphore,
VkFence fence, uint32_t* pImageIndex) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
sOnInvalidDynamicallyCheckedCall("vkAcquireNextImageKHR", "VK_KHR_swapchain");
}
AEMU_SCOPED_TRACE("vkAcquireNextImageKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
vkAcquireNextImageKHR_VkResult_return = vkEnc->vkAcquireNextImageKHR(
device, swapchain, timeout, semaphore, fence, pImageIndex, true /* do lock */);
return vkAcquireNextImageKHR_VkResult_return;
}
static VkResult entry_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
AEMU_SCOPED_TRACE("vkQueuePresentKHR");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0;
vkQueuePresentKHR_VkResult_return =
vkEnc->vkQueuePresentKHR(queue, pPresentInfo, true /* do lock */);
return vkQueuePresentKHR_VkResult_return;
}
static VkResult entry_vkGetDeviceGroupPresentCapabilitiesKHR(
VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return =
vkEnc->vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities,
true /* do lock */);
return vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetDeviceGroupPresentCapabilitiesKHR(
VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupPresentCapabilitiesKHR",
"VK_KHR_swapchain");
}
AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return =
vkEnc->vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities,
true /* do lock */);
return vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
}
static VkResult entry_vkGetDeviceGroupSurfacePresentModesKHR(
VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) {
AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return =
vkEnc->vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes, true /* do lock */);
return vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetDeviceGroupSurfacePresentModesKHR(
VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupSurfacePresentModesKHR",
"VK_KHR_swapchain");
}
AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return =
vkEnc->vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes, true /* do lock */);
return vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pRectCount,
VkRect2D* pRects) {
AEMU_SCOPED_TRACE("vkGetPhysicalDevicePresentRectanglesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return =
vkEnc->vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects,
true /* do lock */);
return vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return;
}
static VkResult entry_vkAcquireNextImage2KHR(VkDevice device,
const VkAcquireNextImageInfoKHR* pAcquireInfo,
uint32_t* pImageIndex) {
AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
vkAcquireNextImage2KHR_VkResult_return =
vkEnc->vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex, true /* do lock */);
return vkAcquireNextImage2KHR_VkResult_return;
}
static VkResult dynCheck_entry_vkAcquireNextImage2KHR(VkDevice device,
const VkAcquireNextImageInfoKHR* pAcquireInfo,
uint32_t* pImageIndex) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
sOnInvalidDynamicallyCheckedCall("vkAcquireNextImage2KHR", "VK_KHR_swapchain");
}
AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
vkAcquireNextImage2KHR_VkResult_return =
vkEnc->vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex, true /* do lock */);
return vkAcquireNextImage2KHR_VkResult_return;
}
#endif
#ifdef VK_KHR_display
static VkResult entry_vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
uint32_t* pPropertyCount,
VkDisplayPropertiesKHR* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0;
vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return =
vkEnc->vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties,
true /* do lock */);
return vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
VkDisplayPlanePropertiesKHR* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlanePropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0;
vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return =
vkEnc->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount,
pProperties, true /* do lock */);
return vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return;
}
static VkResult entry_vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice,
uint32_t planeIndex,
uint32_t* pDisplayCount,
VkDisplayKHR* pDisplays) {
AEMU_SCOPED_TRACE("vkGetDisplayPlaneSupportedDisplaysKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0;
vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return =
vkEnc->vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount,
pDisplays, true /* do lock */);
return vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return;
}
static VkResult entry_vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice,
VkDisplayKHR display, uint32_t* pPropertyCount,
VkDisplayModePropertiesKHR* pProperties) {
AEMU_SCOPED_TRACE("vkGetDisplayModePropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0;
vkGetDisplayModePropertiesKHR_VkResult_return = vkEnc->vkGetDisplayModePropertiesKHR(
physicalDevice, display, pPropertyCount, pProperties, true /* do lock */);
return vkGetDisplayModePropertiesKHR_VkResult_return;
}
static VkResult entry_vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
const VkDisplayModeCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDisplayModeKHR* pMode) {
AEMU_SCOPED_TRACE("vkCreateDisplayModeKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
vkCreateDisplayModeKHR_VkResult_return = vkEnc->vkCreateDisplayModeKHR(
physicalDevice, display, pCreateInfo, pAllocator, pMode, true /* do lock */);
return vkCreateDisplayModeKHR_VkResult_return;
}
static VkResult entry_vkGetDisplayPlaneCapabilitiesKHR(
VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex,
VkDisplayPlaneCapabilitiesKHR* pCapabilities) {
AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilitiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0;
vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = vkEnc->vkGetDisplayPlaneCapabilitiesKHR(
physicalDevice, mode, planeIndex, pCapabilities, true /* do lock */);
return vkGetDisplayPlaneCapabilitiesKHR_VkResult_return;
}
static VkResult entry_vkCreateDisplayPlaneSurfaceKHR(
VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateDisplayPlaneSurfaceKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
vkCreateDisplayPlaneSurfaceKHR_VkResult_return = vkEnc->vkCreateDisplayPlaneSurfaceKHR(
instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateDisplayPlaneSurfaceKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_display_swapchain
static VkResult entry_vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
const VkSwapchainCreateInfoKHR* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkSwapchainKHR* pSwapchains) {
AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
vkCreateSharedSwapchainsKHR_VkResult_return = vkEnc->vkCreateSharedSwapchainsKHR(
device, swapchainCount, pCreateInfos, pAllocator, pSwapchains, true /* do lock */);
return vkCreateSharedSwapchainsKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateSharedSwapchainsKHR(
VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos,
const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_KHR_display_swapchain")) {
sOnInvalidDynamicallyCheckedCall("vkCreateSharedSwapchainsKHR", "VK_KHR_display_swapchain");
}
AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
vkCreateSharedSwapchainsKHR_VkResult_return = vkEnc->vkCreateSharedSwapchainsKHR(
device, swapchainCount, pCreateInfos, pAllocator, pSwapchains, true /* do lock */);
return vkCreateSharedSwapchainsKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_xlib_surface
static VkResult entry_vkCreateXlibSurfaceKHR(VkInstance instance,
const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateXlibSurfaceKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
vkCreateXlibSurfaceKHR_VkResult_return = vkEnc->vkCreateXlibSurfaceKHR(
instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateXlibSurfaceKHR_VkResult_return;
}
static VkBool32 entry_vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
Display* dpy,
VisualID visualID) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXlibPresentationSupportKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0;
vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return =
vkEnc->vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy,
visualID, true /* do lock */);
return vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return;
}
#endif
#ifdef VK_KHR_xcb_surface
static VkResult entry_vkCreateXcbSurfaceKHR(VkInstance instance,
const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateXcbSurfaceKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
vkCreateXcbSurfaceKHR_VkResult_return = vkEnc->vkCreateXcbSurfaceKHR(
instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateXcbSurfaceKHR_VkResult_return;
}
static VkBool32 entry_vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
xcb_connection_t* connection,
xcb_visualid_t visual_id) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXcbPresentationSupportKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0;
vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return =
vkEnc->vkGetPhysicalDeviceXcbPresentationSupportKHR(
physicalDevice, queueFamilyIndex, connection, visual_id, true /* do lock */);
return vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return;
}
#endif
#ifdef VK_KHR_wayland_surface
static VkResult entry_vkCreateWaylandSurfaceKHR(VkInstance instance,
const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateWaylandSurfaceKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
vkCreateWaylandSurfaceKHR_VkResult_return = vkEnc->vkCreateWaylandSurfaceKHR(
instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateWaylandSurfaceKHR_VkResult_return;
}
static VkBool32 entry_vkGetPhysicalDeviceWaylandPresentationSupportKHR(
VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, wl_display* display) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWaylandPresentationSupportKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = (VkBool32)0;
vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return =
vkEnc->vkGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex,
display, true /* do lock */);
return vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return;
}
#endif
#ifdef VK_KHR_android_surface
static VkResult entry_vkCreateAndroidSurfaceKHR(VkInstance instance,
const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
vkCreateAndroidSurfaceKHR_VkResult_return = vkEnc->vkCreateAndroidSurfaceKHR(
instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateAndroidSurfaceKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_win32_surface
static VkResult entry_vkCreateWin32SurfaceKHR(VkInstance instance,
const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateWin32SurfaceKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0;
vkCreateWin32SurfaceKHR_VkResult_return = vkEnc->vkCreateWin32SurfaceKHR(
instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateWin32SurfaceKHR_VkResult_return;
}
static VkBool32 entry_vkGetPhysicalDeviceWin32PresentationSupportKHR(
VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWin32PresentationSupportKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = (VkBool32)0;
vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return =
vkEnc->vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex,
true /* do lock */);
return vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return;
}
#endif
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_video_queue
static VkResult entry_vkGetPhysicalDeviceVideoCapabilitiesKHR(
VkPhysicalDevice physicalDevice, const VkVideoProfileKHR* pVideoProfile,
VkVideoCapabilitiesKHR* pCapabilities) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceVideoCapabilitiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR_VkResult_return = (VkResult)0;
vkGetPhysicalDeviceVideoCapabilitiesKHR_VkResult_return =
vkEnc->vkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, pCapabilities,
true /* do lock */);
return vkGetPhysicalDeviceVideoCapabilitiesKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceVideoFormatPropertiesKHR(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo,
uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceVideoFormatPropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR_VkResult_return = (VkResult)0;
vkGetPhysicalDeviceVideoFormatPropertiesKHR_VkResult_return =
vkEnc->vkGetPhysicalDeviceVideoFormatPropertiesKHR(
physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties,
true /* do lock */);
return vkGetPhysicalDeviceVideoFormatPropertiesKHR_VkResult_return;
}
static VkResult entry_vkCreateVideoSessionKHR(VkDevice device,
const VkVideoSessionCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkVideoSessionKHR* pVideoSession) {
AEMU_SCOPED_TRACE("vkCreateVideoSessionKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateVideoSessionKHR_VkResult_return = (VkResult)0;
vkCreateVideoSessionKHR_VkResult_return = vkEnc->vkCreateVideoSessionKHR(
device, pCreateInfo, pAllocator, pVideoSession, true /* do lock */);
return vkCreateVideoSessionKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateVideoSessionKHR(
VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue")) {
sOnInvalidDynamicallyCheckedCall("vkCreateVideoSessionKHR", "VK_KHR_video_queue");
}
AEMU_SCOPED_TRACE("vkCreateVideoSessionKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateVideoSessionKHR_VkResult_return = (VkResult)0;
vkCreateVideoSessionKHR_VkResult_return = vkEnc->vkCreateVideoSessionKHR(
device, pCreateInfo, pAllocator, pVideoSession, true /* do lock */);
return vkCreateVideoSessionKHR_VkResult_return;
}
static void entry_vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyVideoSessionKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyVideoSessionKHR(device, videoSession, pAllocator, true /* do lock */);
}
static void dynCheck_entry_vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession,
const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue")) {
sOnInvalidDynamicallyCheckedCall("vkDestroyVideoSessionKHR", "VK_KHR_video_queue");
}
AEMU_SCOPED_TRACE("vkDestroyVideoSessionKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyVideoSessionKHR(device, videoSession, pAllocator, true /* do lock */);
}
static VkResult entry_vkGetVideoSessionMemoryRequirementsKHR(
VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pVideoSessionMemoryRequirementsCount,
VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetVideoSessionMemoryRequirementsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetVideoSessionMemoryRequirementsKHR_VkResult_return = (VkResult)0;
vkGetVideoSessionMemoryRequirementsKHR_VkResult_return =
vkEnc->vkGetVideoSessionMemoryRequirementsKHR(
device, videoSession, pVideoSessionMemoryRequirementsCount,
pVideoSessionMemoryRequirements, true /* do lock */);
return vkGetVideoSessionMemoryRequirementsKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetVideoSessionMemoryRequirementsKHR(
VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pVideoSessionMemoryRequirementsCount,
VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue")) {
sOnInvalidDynamicallyCheckedCall("vkGetVideoSessionMemoryRequirementsKHR",
"VK_KHR_video_queue");
}
AEMU_SCOPED_TRACE("vkGetVideoSessionMemoryRequirementsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetVideoSessionMemoryRequirementsKHR_VkResult_return = (VkResult)0;
vkGetVideoSessionMemoryRequirementsKHR_VkResult_return =
vkEnc->vkGetVideoSessionMemoryRequirementsKHR(
device, videoSession, pVideoSessionMemoryRequirementsCount,
pVideoSessionMemoryRequirements, true /* do lock */);
return vkGetVideoSessionMemoryRequirementsKHR_VkResult_return;
}
static VkResult entry_vkBindVideoSessionMemoryKHR(
VkDevice device, VkVideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount,
const VkVideoBindMemoryKHR* pVideoSessionBindMemories) {
AEMU_SCOPED_TRACE("vkBindVideoSessionMemoryKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindVideoSessionMemoryKHR_VkResult_return = (VkResult)0;
vkBindVideoSessionMemoryKHR_VkResult_return =
vkEnc->vkBindVideoSessionMemoryKHR(device, videoSession, videoSessionBindMemoryCount,
pVideoSessionBindMemories, true /* do lock */);
return vkBindVideoSessionMemoryKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkBindVideoSessionMemoryKHR(
VkDevice device, VkVideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount,
const VkVideoBindMemoryKHR* pVideoSessionBindMemories) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue")) {
sOnInvalidDynamicallyCheckedCall("vkBindVideoSessionMemoryKHR", "VK_KHR_video_queue");
}
AEMU_SCOPED_TRACE("vkBindVideoSessionMemoryKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindVideoSessionMemoryKHR_VkResult_return = (VkResult)0;
vkBindVideoSessionMemoryKHR_VkResult_return =
vkEnc->vkBindVideoSessionMemoryKHR(device, videoSession, videoSessionBindMemoryCount,
pVideoSessionBindMemories, true /* do lock */);
return vkBindVideoSessionMemoryKHR_VkResult_return;
}
static VkResult entry_vkCreateVideoSessionParametersKHR(
VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) {
AEMU_SCOPED_TRACE("vkCreateVideoSessionParametersKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateVideoSessionParametersKHR_VkResult_return = (VkResult)0;
vkCreateVideoSessionParametersKHR_VkResult_return = vkEnc->vkCreateVideoSessionParametersKHR(
device, pCreateInfo, pAllocator, pVideoSessionParameters, true /* do lock */);
return vkCreateVideoSessionParametersKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateVideoSessionParametersKHR(
VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue")) {
sOnInvalidDynamicallyCheckedCall("vkCreateVideoSessionParametersKHR", "VK_KHR_video_queue");
}
AEMU_SCOPED_TRACE("vkCreateVideoSessionParametersKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateVideoSessionParametersKHR_VkResult_return = (VkResult)0;
vkCreateVideoSessionParametersKHR_VkResult_return = vkEnc->vkCreateVideoSessionParametersKHR(
device, pCreateInfo, pAllocator, pVideoSessionParameters, true /* do lock */);
return vkCreateVideoSessionParametersKHR_VkResult_return;
}
static VkResult entry_vkUpdateVideoSessionParametersKHR(
VkDevice device, VkVideoSessionParametersKHR videoSessionParameters,
const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) {
AEMU_SCOPED_TRACE("vkUpdateVideoSessionParametersKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkUpdateVideoSessionParametersKHR_VkResult_return = (VkResult)0;
vkUpdateVideoSessionParametersKHR_VkResult_return = vkEnc->vkUpdateVideoSessionParametersKHR(
device, videoSessionParameters, pUpdateInfo, true /* do lock */);
return vkUpdateVideoSessionParametersKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkUpdateVideoSessionParametersKHR(
VkDevice device, VkVideoSessionParametersKHR videoSessionParameters,
const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) {
auto resources = ResourceTracker::get();
if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue")) {
sOnInvalidDynamicallyCheckedCall(