| // 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 goldfish_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("vkUpdateVideoSessionParametersKHR", "VK_KHR_video_queue"); |
|