blob: 50e8a62b10786ee4e327a1f3fca791ffd367d57b [file] [log] [blame]
// Copyright (C) 2018 The Android Open Source Project
// Copyright (C) 2018 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Autogenerated module func_table
// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
// Please do not modify directly;
// re-run android/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
#include "func_table.h"
#include "VkEncoder.h"
#include "HostConnection.h"
#include "ResourceTracker.h"
#include "goldfish_vk_private_defs.h"
#include <log/log.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 = HostConnection::get()->vkEncoder();
VkResult vkCreateInstance_VkResult_return = (VkResult)0;
vkCreateInstance_VkResult_return = vkEnc->vkCreateInstance(pCreateInfo, pAllocator, pInstance);
return vkCreateInstance_VkResult_return;
}
static void entry_vkDestroyInstance(
VkInstance instance,
const VkAllocationCallbacks* pAllocator)
{
AEMU_SCOPED_TRACE("vkDestroyInstance");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyInstance(instance, pAllocator);
}
static VkResult entry_vkEnumeratePhysicalDevices(
VkInstance instance,
uint32_t* pPhysicalDeviceCount,
VkPhysicalDevice* pPhysicalDevices)
{
AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
vkEnc->vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
}
static void entry_vkGetPhysicalDeviceFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties* pFormatProperties)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
}
static VkResult entry_vkGetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
VkImageTiling tiling,
VkImageUsageFlags usage,
VkImageCreateFlags flags,
VkImageFormatProperties* pImageFormatProperties)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
vkGetPhysicalDeviceImageFormatProperties_VkResult_return = vkEnc->vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
return vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
}
static void entry_vkGetPhysicalDeviceProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties* pProperties)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
}
static void entry_vkGetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice physicalDevice,
uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties* pQueueFamilyProperties)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}
static void entry_vkGetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties* pMemoryProperties)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
}
static PFN_vkVoidFunction entry_vkGetInstanceProcAddr(
VkInstance instance,
const char* pName)
{
AEMU_SCOPED_TRACE("vkGetInstanceProcAddr");
auto vkEnc = HostConnection::get()->vkEncoder();
PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
vkGetInstanceProcAddr_PFN_vkVoidFunction_return = vkEnc->vkGetInstanceProcAddr(instance, pName);
return vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
}
static PFN_vkVoidFunction entry_vkGetDeviceProcAddr(
VkDevice device,
const char* pName)
{
AEMU_SCOPED_TRACE("vkGetDeviceProcAddr");
auto vkEnc = HostConnection::get()->vkEncoder();
PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
vkGetDeviceProcAddr_PFN_vkVoidFunction_return = vkEnc->vkGetDeviceProcAddr(device, pName);
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 = HostConnection::get()->vkEncoder();
VkResult vkCreateDevice_VkResult_return = (VkResult)0;
vkCreateDevice_VkResult_return = vkEnc->vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
return vkCreateDevice_VkResult_return;
}
static void entry_vkDestroyDevice(
VkDevice device,
const VkAllocationCallbacks* pAllocator)
{
AEMU_SCOPED_TRACE("vkDestroyDevice");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyDevice(device, pAllocator);
}
static VkResult entry_vkEnumerateInstanceExtensionProperties(
const char* pLayerName,
uint32_t* pPropertyCount,
VkExtensionProperties* pProperties)
{
AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
vkEnumerateInstanceLayerProperties_VkResult_return = vkEnc->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties);
return vkEnumerateInstanceLayerProperties_VkResult_return;
}
static VkResult entry_vkEnumerateDeviceLayerProperties(
VkPhysicalDevice physicalDevice,
uint32_t* pPropertyCount,
VkLayerProperties* pProperties)
{
AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
return vkEnumerateDeviceLayerProperties_VkResult_return;
}
static void entry_vkGetDeviceQueue(
VkDevice device,
uint32_t queueFamilyIndex,
uint32_t queueIndex,
VkQueue* pQueue)
{
AEMU_SCOPED_TRACE("vkGetDeviceQueue");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
}
static VkResult entry_vkQueueSubmit(
VkQueue queue,
uint32_t submitCount,
const VkSubmitInfo* pSubmits,
VkFence fence)
{
AEMU_SCOPED_TRACE("vkQueueSubmit");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
vkDeviceWaitIdle_VkResult_return = vkEnc->vkDeviceWaitIdle(device);
return vkDeviceWaitIdle_VkResult_return;
}
static VkResult entry_vkAllocateMemory(
VkDevice device,
const VkMemoryAllocateInfo* pAllocateInfo,
const VkAllocationCallbacks* pAllocator,
VkDeviceMemory* pMemory)
{
AEMU_SCOPED_TRACE("vkAllocateMemory");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
VkResult vkMapMemory_VkResult_return = (VkResult)0;
vkMapMemory_VkResult_return = vkEnc->vkMapMemory(device, memory, offset, size, flags, ppData);
return vkMapMemory_VkResult_return;
}
static void entry_vkUnmapMemory(
VkDevice device,
VkDeviceMemory memory)
{
AEMU_SCOPED_TRACE("vkUnmapMemory");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkUnmapMemory(device, memory);
}
static VkResult entry_vkFlushMappedMemoryRanges(
VkDevice device,
uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges)
{
AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
vkFlushMappedMemoryRanges_VkResult_return = vkEnc->vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
return vkFlushMappedMemoryRanges_VkResult_return;
}
static VkResult entry_vkInvalidateMappedMemoryRanges(
VkDevice device,
uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges)
{
AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
return vkInvalidateMappedMemoryRanges_VkResult_return;
}
static void entry_vkGetDeviceMemoryCommitment(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes)
{
AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
}
static VkResult entry_vkBindBufferMemory(
VkDevice device,
VkBuffer buffer,
VkDeviceMemory memory,
VkDeviceSize memoryOffset)
{
AEMU_SCOPED_TRACE("vkBindBufferMemory");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
vkEnc->vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}
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 = HostConnection::get()->vkEncoder();
vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
}
static VkResult entry_vkQueueBindSparse(
VkQueue queue,
uint32_t bindInfoCount,
const VkBindSparseInfo* pBindInfo,
VkFence fence)
{
AEMU_SCOPED_TRACE("vkQueueBindSparse");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
vkQueueBindSparse_VkResult_return = vkEnc->vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
return vkQueueBindSparse_VkResult_return;
}
static VkResult entry_vkCreateFence(
VkDevice device,
const VkFenceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkFence* pFence)
{
AEMU_SCOPED_TRACE("vkCreateFence");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyFence(device, fence, pAllocator);
}
static VkResult entry_vkResetFences(
VkDevice device,
uint32_t fenceCount,
const VkFence* pFences)
{
AEMU_SCOPED_TRACE("vkResetFences");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
vkGetFenceStatus_VkResult_return = vkEnc->vkGetFenceStatus(device, fence);
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
VkResult vkCreateEvent_VkResult_return = (VkResult)0;
vkCreateEvent_VkResult_return = vkEnc->vkCreateEvent(device, pCreateInfo, pAllocator, pEvent);
return vkCreateEvent_VkResult_return;
}
static void entry_vkDestroyEvent(
VkDevice device,
VkEvent event,
const VkAllocationCallbacks* pAllocator)
{
AEMU_SCOPED_TRACE("vkDestroyEvent");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyEvent(device, event, pAllocator);
}
static VkResult entry_vkGetEventStatus(
VkDevice device,
VkEvent event)
{
AEMU_SCOPED_TRACE("vkGetEventStatus");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
vkGetEventStatus_VkResult_return = vkEnc->vkGetEventStatus(device, event);
return vkGetEventStatus_VkResult_return;
}
static VkResult entry_vkSetEvent(
VkDevice device,
VkEvent event)
{
AEMU_SCOPED_TRACE("vkSetEvent");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkSetEvent_VkResult_return = (VkResult)0;
vkSetEvent_VkResult_return = vkEnc->vkSetEvent(device, event);
return vkSetEvent_VkResult_return;
}
static VkResult entry_vkResetEvent(
VkDevice device,
VkEvent event)
{
AEMU_SCOPED_TRACE("vkResetEvent");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkResetEvent_VkResult_return = (VkResult)0;
vkResetEvent_VkResult_return = vkEnc->vkResetEvent(device, event);
return vkResetEvent_VkResult_return;
}
static VkResult entry_vkCreateQueryPool(
VkDevice device,
const VkQueryPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkQueryPool* pQueryPool)
{
AEMU_SCOPED_TRACE("vkCreateQueryPool");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
vkCreateQueryPool_VkResult_return = vkEnc->vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
return vkCreateQueryPool_VkResult_return;
}
static void entry_vkDestroyQueryPool(
VkDevice device,
VkQueryPool queryPool,
const VkAllocationCallbacks* pAllocator)
{
AEMU_SCOPED_TRACE("vkDestroyQueryPool");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyQueryPool(device, queryPool, pAllocator);
}
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 = HostConnection::get()->vkEncoder();
VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
vkGetQueryPoolResults_VkResult_return = vkEnc->vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
return vkGetQueryPoolResults_VkResult_return;
}
static VkResult entry_vkCreateBuffer(
VkDevice device,
const VkBufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkBuffer* pBuffer)
{
AEMU_SCOPED_TRACE("vkCreateBuffer");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
vkCreateBufferView_VkResult_return = vkEnc->vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
return vkCreateBufferView_VkResult_return;
}
static void entry_vkDestroyBufferView(
VkDevice device,
VkBufferView bufferView,
const VkAllocationCallbacks* pAllocator)
{
AEMU_SCOPED_TRACE("vkDestroyBufferView");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyBufferView(device, bufferView, pAllocator);
}
static VkResult entry_vkCreateImage(
VkDevice device,
const VkImageCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkImage* pImage)
{
AEMU_SCOPED_TRACE("vkCreateImage");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
vkEnc->vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
}
static VkResult entry_vkCreateImageView(
VkDevice device,
const VkImageViewCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkImageView* pView)
{
AEMU_SCOPED_TRACE("vkCreateImageView");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyImageView(device, imageView, pAllocator);
}
static VkResult entry_vkCreateShaderModule(
VkDevice device,
const VkShaderModuleCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkShaderModule* pShaderModule)
{
AEMU_SCOPED_TRACE("vkCreateShaderModule");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
return vkCreateShaderModule_VkResult_return;
}
static void entry_vkDestroyShaderModule(
VkDevice device,
VkShaderModule shaderModule,
const VkAllocationCallbacks* pAllocator)
{
AEMU_SCOPED_TRACE("vkDestroyShaderModule");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyShaderModule(device, shaderModule, pAllocator);
}
static VkResult entry_vkCreatePipelineCache(
VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkPipelineCache* pPipelineCache)
{
AEMU_SCOPED_TRACE("vkCreatePipelineCache");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
return vkCreatePipelineCache_VkResult_return;
}
static void entry_vkDestroyPipelineCache(
VkDevice device,
VkPipelineCache pipelineCache,
const VkAllocationCallbacks* pAllocator)
{
AEMU_SCOPED_TRACE("vkDestroyPipelineCache");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyPipelineCache(device, pipelineCache, pAllocator);
}
static VkResult entry_vkGetPipelineCacheData(
VkDevice device,
VkPipelineCache pipelineCache,
size_t* pDataSize,
void* pData)
{
AEMU_SCOPED_TRACE("vkGetPipelineCacheData");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
vkGetPipelineCacheData_VkResult_return = vkEnc->vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData);
return vkGetPipelineCacheData_VkResult_return;
}
static VkResult entry_vkMergePipelineCaches(
VkDevice device,
VkPipelineCache dstCache,
uint32_t srcCacheCount,
const VkPipelineCache* pSrcCaches)
{
AEMU_SCOPED_TRACE("vkMergePipelineCaches");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
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 = HostConnection::get()->vkEncoder();
VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
vkCreateGraphicsPipelines_VkResult_return = vkEnc->vkCreateGraphicsPipelines(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 = HostConnection::get()->vkEncoder();
VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
vkCreateComputePipelines_VkResult_return = vkEnc->vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
return vkCreateComputePipelines_VkResult_return;
}
static void entry_vkDestroyPipeline(
VkDevice device,
VkPipeline pipeline,
const VkAllocationCallbacks* pAllocator)
{
AEMU_SCOPED_TRACE("vkDestroyPipeline");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyPipeline(device, pipeline, pAllocator);
}
static VkResult entry_vkCreatePipelineLayout(
VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout)
{
AEMU_SCOPED_TRACE("vkCreatePipelineLayout");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
return vkCreatePipelineLayout_VkResult_return;
}
static void entry_vkDestroyPipelineLayout(
VkDevice device,
VkPipelineLayout pipelineLayout,
const VkAllocationCallbacks* pAllocator)
{
AEMU_SCOPED_TRACE("vkDestroyPipelineLayout");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyPipelineLayout(device, pipelineLayout, pAllocator);
}
static VkResult entry_vkCreateSampler(
VkDevice device,
const VkSamplerCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSampler* pSampler)
{
AEMU_SCOPED_TRACE("vkCreateSampler");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
vkEnc->vkDestroySampler(device, sampler, pAllocator);
}
static VkResult entry_vkCreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout)
{
AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
}
static VkResult entry_vkCreateDescriptorPool(
VkDevice device,
const VkDescriptorPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool)
{
AEMU_SCOPED_TRACE("vkCreateDescriptorPool");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
return vkCreateFramebuffer_VkResult_return;
}
static void entry_vkDestroyFramebuffer(
VkDevice device,
VkFramebuffer framebuffer,
const VkAllocationCallbacks* pAllocator)
{
AEMU_SCOPED_TRACE("vkDestroyFramebuffer");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyFramebuffer(device, framebuffer, pAllocator);
}
static VkResult entry_vkCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass)
{
AEMU_SCOPED_TRACE("vkCreateRenderPass");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
vkCreateRenderPass_VkResult_return = vkEnc->vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
return vkCreateRenderPass_VkResult_return;
}
static void entry_vkDestroyRenderPass(
VkDevice device,
VkRenderPass renderPass,
const VkAllocationCallbacks* pAllocator)
{
AEMU_SCOPED_TRACE("vkDestroyRenderPass");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyRenderPass(device, renderPass, pAllocator);
}
static void entry_vkGetRenderAreaGranularity(
VkDevice device,
VkRenderPass renderPass,
VkExtent2D* pGranularity)
{
AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkGetRenderAreaGranularity(device, renderPass, pGranularity);
}
static VkResult entry_vkCreateCommandPool(
VkDevice device,
const VkCommandPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkCommandPool* pCommandPool)
{
AEMU_SCOPED_TRACE("vkCreateCommandPool");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
vkCreateCommandPool_VkResult_return = vkEnc->vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
return vkCreateCommandPool_VkResult_return;
}
static void entry_vkDestroyCommandPool(
VkDevice device,
VkCommandPool commandPool,
const VkAllocationCallbacks* pAllocator)
{
AEMU_SCOPED_TRACE("vkDestroyCommandPool");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyCommandPool(device, commandPool, pAllocator);
}
static VkResult entry_vkResetCommandPool(
VkDevice device,
VkCommandPool commandPool,
VkCommandPoolResetFlags flags)
{
AEMU_SCOPED_TRACE("vkResetCommandPool");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
vkResetCommandPool_VkResult_return = vkEnc->vkResetCommandPool(device, commandPool, flags);
return vkResetCommandPool_VkResult_return;
}
static VkResult entry_vkAllocateCommandBuffers(
VkDevice device,
const VkCommandBufferAllocateInfo* pAllocateInfo,
VkCommandBuffer* pCommandBuffers)
{
AEMU_SCOPED_TRACE("vkAllocateCommandBuffers");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
vkAllocateCommandBuffers_VkResult_return = vkEnc->vkAllocateCommandBuffers(device, pAllocateInfo, 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 = HostConnection::get()->vkEncoder();
vkEnc->vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
}
static VkResult entry_vkBeginCommandBuffer(
VkCommandBuffer commandBuffer,
const VkCommandBufferBeginInfo* pBeginInfo)
{
AEMU_SCOPED_TRACE("vkBeginCommandBuffer");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
}
static void entry_vkCmdSetViewport(
VkCommandBuffer commandBuffer,
uint32_t firstViewport,
uint32_t viewportCount,
const VkViewport* pViewports)
{
AEMU_SCOPED_TRACE("vkCmdSetViewport");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
}
static void entry_vkCmdSetScissor(
VkCommandBuffer commandBuffer,
uint32_t firstScissor,
uint32_t scissorCount,
const VkRect2D* pScissors)
{
AEMU_SCOPED_TRACE("vkCmdSetScissor");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
}
static void entry_vkCmdSetLineWidth(
VkCommandBuffer commandBuffer,
float lineWidth)
{
AEMU_SCOPED_TRACE("vkCmdSetLineWidth");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetLineWidth(commandBuffer, lineWidth);
}
static void entry_vkCmdSetDepthBias(
VkCommandBuffer commandBuffer,
float depthBiasConstantFactor,
float depthBiasClamp,
float depthBiasSlopeFactor)
{
AEMU_SCOPED_TRACE("vkCmdSetDepthBias");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
}
static void entry_vkCmdSetBlendConstants(
VkCommandBuffer commandBuffer,
const float blendConstants[4])
{
AEMU_SCOPED_TRACE("vkCmdSetBlendConstants");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetBlendConstants(commandBuffer, blendConstants);
}
static void entry_vkCmdSetDepthBounds(
VkCommandBuffer commandBuffer,
float minDepthBounds,
float maxDepthBounds)
{
AEMU_SCOPED_TRACE("vkCmdSetDepthBounds");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
}
static void entry_vkCmdSetStencilCompareMask(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t compareMask)
{
AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
}
static void entry_vkCmdSetStencilWriteMask(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t writeMask)
{
AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
}
static void entry_vkCmdSetStencilReference(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t reference)
{
AEMU_SCOPED_TRACE("vkCmdSetStencilReference");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetStencilReference(commandBuffer, faceMask, reference);
}
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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBindDescriptorSets(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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
}
static void entry_vkCmdBindVertexBuffers(
VkCommandBuffer commandBuffer,
uint32_t firstBinding,
uint32_t bindingCount,
const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets)
{
AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
}
static void entry_vkCmdDraw(
VkCommandBuffer commandBuffer,
uint32_t vertexCount,
uint32_t instanceCount,
uint32_t firstVertex,
uint32_t firstInstance)
{
AEMU_SCOPED_TRACE("vkCmdDraw");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
}
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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
}
static void entry_vkCmdDrawIndirect(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t drawCount,
uint32_t stride)
{
AEMU_SCOPED_TRACE("vkCmdDrawIndirect");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
}
static void entry_vkCmdDrawIndexedIndirect(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t drawCount,
uint32_t stride)
{
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
}
static void entry_vkCmdDispatch(
VkCommandBuffer commandBuffer,
uint32_t groupCountX,
uint32_t groupCountY,
uint32_t groupCountZ)
{
AEMU_SCOPED_TRACE("vkCmdDispatch");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
}
static void entry_vkCmdDispatchIndirect(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset)
{
AEMU_SCOPED_TRACE("vkCmdDispatchIndirect");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDispatchIndirect(commandBuffer, buffer, offset);
}
static void entry_vkCmdCopyBuffer(
VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferCopy* pRegions)
{
AEMU_SCOPED_TRACE("vkCmdCopyBuffer");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
}
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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
}
static void entry_vkCmdCopyBufferToImage(
VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkBufferImageCopy* pRegions)
{
AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
}
static void entry_vkCmdCopyImageToBuffer(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferImageCopy* pRegions)
{
AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
}
static void entry_vkCmdUpdateBuffer(
VkCommandBuffer commandBuffer,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize dataSize,
const void* pData)
{
AEMU_SCOPED_TRACE("vkCmdUpdateBuffer");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
}
static void entry_vkCmdFillBuffer(
VkCommandBuffer commandBuffer,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize size,
uint32_t data)
{
AEMU_SCOPED_TRACE("vkCmdFillBuffer");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
}
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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
}
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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
}
static void entry_vkCmdClearAttachments(
VkCommandBuffer commandBuffer,
uint32_t attachmentCount,
const VkClearAttachment* pAttachments,
uint32_t rectCount,
const VkClearRect* pRects)
{
AEMU_SCOPED_TRACE("vkCmdClearAttachments");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
}
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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
static void entry_vkCmdSetEvent(
VkCommandBuffer commandBuffer,
VkEvent event,
VkPipelineStageFlags stageMask)
{
AEMU_SCOPED_TRACE("vkCmdSetEvent");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetEvent(commandBuffer, event, stageMask);
}
static void entry_vkCmdResetEvent(
VkCommandBuffer commandBuffer,
VkEvent event,
VkPipelineStageFlags stageMask)
{
AEMU_SCOPED_TRACE("vkCmdResetEvent");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdResetEvent(commandBuffer, event, stageMask);
}
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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdPipelineBarrier(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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBeginQuery(commandBuffer, queryPool, query, flags);
}
static void entry_vkCmdEndQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t query)
{
AEMU_SCOPED_TRACE("vkCmdEndQuery");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdEndQuery(commandBuffer, queryPool, query);
}
static void entry_vkCmdResetQueryPool(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount)
{
AEMU_SCOPED_TRACE("vkCmdResetQueryPool");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
}
static void entry_vkCmdWriteTimestamp(
VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
uint32_t query)
{
AEMU_SCOPED_TRACE("vkCmdWriteTimestamp");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
}
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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
}
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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
}
static void entry_vkCmdBeginRenderPass(
VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
VkSubpassContents contents)
{
AEMU_SCOPED_TRACE("vkCmdBeginRenderPass");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
}
static void entry_vkCmdNextSubpass(
VkCommandBuffer commandBuffer,
VkSubpassContents contents)
{
AEMU_SCOPED_TRACE("vkCmdNextSubpass");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdNextSubpass(commandBuffer, contents);
}
static void entry_vkCmdEndRenderPass(
VkCommandBuffer commandBuffer)
{
AEMU_SCOPED_TRACE("vkCmdEndRenderPass");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdEndRenderPass(commandBuffer);
}
static void entry_vkCmdExecuteCommands(
VkCommandBuffer commandBuffer,
uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers)
{
AEMU_SCOPED_TRACE("vkCmdExecuteCommands");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
}
#endif
#ifdef VK_VERSION_1_1
static VkResult entry_vkEnumerateInstanceVersion(
uint32_t* pApiVersion)
{
AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
vkEnumerateInstanceVersion_VkResult_return = vkEnc->vkEnumerateInstanceVersion(pApiVersion);
return vkEnumerateInstanceVersion_VkResult_return;
}
static VkResult entry_vkBindBufferMemory2(
VkDevice device,
uint32_t bindInfoCount,
const VkBindBufferMemoryInfo* pBindInfos)
{
AEMU_SCOPED_TRACE("vkBindBufferMemory2");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
}
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 = HostConnection::get()->vkEncoder();
vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
}
static void entry_vkCmdSetDeviceMask(
VkCommandBuffer commandBuffer,
uint32_t deviceMask)
{
AEMU_SCOPED_TRACE("vkCmdSetDeviceMask");
auto vkEnc = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetDeviceMask(commandBuffer, deviceMask);
}
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 = HostConnection::get()->vkEncoder();
ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
}
static VkResult entry_vkEnumeratePhysicalDeviceGroups(
VkInstance instance,
uint32_t* pPhysicalDeviceGroupCount,
VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
{
AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
vkEnumeratePhysicalDeviceGroups_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
return vkEnumeratePhysicalDeviceGroups_VkResult_return;
}
static void entry_vkGetImageMemoryRequirements2(
VkDevice device,
const VkImageMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements)
{
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
resources->on_vkGetImageMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
}
static void entry_vkGetBufferMemoryRequirements2(
VkDevice device,
const VkBufferMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements)
{
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}
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 = HostConnection::get()->vkEncoder();
vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}
static void entry_vkGetPhysicalDeviceFeatures2(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures2* pFeatures)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
}
static void entry_vkGetPhysicalDeviceProperties2(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties2* pProperties)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
}
static void entry_vkGetPhysicalDeviceFormatProperties2(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties2* pFormatProperties)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
}
static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
VkImageFormatProperties2* pImageFormatProperties)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}
static void entry_vkGetPhysicalDeviceMemoryProperties2(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
}
static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
uint32_t* pPropertyCount,
VkSparseImageFormatProperties2* pProperties)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
}
static void entry_vkTrimCommandPool(
VkDevice device,
VkCommandPool commandPool,
VkCommandPoolTrimFlags flags)
{
AEMU_SCOPED_TRACE("vkTrimCommandPool");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkTrimCommandPool(device, commandPool, flags);
}
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 = HostConnection::get()->vkEncoder();
vkEnc->vkTrimCommandPool(device, commandPool, flags);
}
static void entry_vkGetDeviceQueue2(
VkDevice device,
const VkDeviceQueueInfo2* pQueueInfo,
VkQueue* pQueue)
{
AEMU_SCOPED_TRACE("vkGetDeviceQueue2");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue);
}
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 = HostConnection::get()->vkEncoder();
vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue);
}
static VkResult entry_vkCreateSamplerYcbcrConversion(
VkDevice device,
const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSamplerYcbcrConversion* pYcbcrConversion)
{
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
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 = HostConnection::get()->vkEncoder();
VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
return vkCreateDescriptorUpdateTemplate_VkResult_return;
}
static void entry_vkDestroyDescriptorUpdateTemplate(
VkDevice device,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator)
{
AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
}
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 = HostConnection::get()->vkEncoder();
vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
}
static void entry_vkUpdateDescriptorSetWithTemplate(
VkDevice device,
VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const void* pData)
{
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
vkEnc->vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
}
static void entry_vkGetPhysicalDeviceExternalFenceProperties(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
VkExternalFenceProperties* pExternalFenceProperties)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties");
auto vkEnc = HostConnection::get()->vkEncoder();
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 = HostConnection::get()->vkEncoder();
vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
}
static void entry_vkGetDescriptorSetLayoutSupport(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupport* pSupport)
{
AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
}
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 = HostConnection::get()->vkEncoder();
vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
}
#endif
#ifdef VK_KHR_surface
static void entry_vkDestroySurfaceKHR(
VkInstance instance,
VkSurfaceKHR surface,
const VkAllocationCallbacks* pAllocator)
{
AEMU_SCOPED_TRACE("vkDestroySurfaceKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkDestroySurfaceKHR(instance, surface, pAllocator);
}
static VkResult entry_vkGetPhysicalDeviceSurfaceSupportKHR(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
VkSurfaceKHR surface,
VkBool32* pSupported)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceSupportKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0;
vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
return vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0;
vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
return vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceSurfaceFormatsKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pSurfaceFormatCount,
VkSurfaceFormatKHR* pSurfaceFormats)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormatsKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0;
vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
return vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceSurfacePresentModesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pPresentModeCount,
VkPresentModeKHR* pPresentModes)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfacePresentModesKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0;
vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
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 = HostConnection::get()->vkEncoder();
VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
vkCreateSwapchainKHR_VkResult_return = vkEnc->vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
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 = HostConnection::get()->vkEncoder();
VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
vkCreateSwapchainKHR_VkResult_return = vkEnc->vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
return vkCreateSwapchainKHR_VkResult_return;
}
static void entry_vkDestroySwapchainKHR(
VkDevice device,
VkSwapchainKHR swapchain,
const VkAllocationCallbacks* pAllocator)
{
AEMU_SCOPED_TRACE("vkDestroySwapchainKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
vkEnc->vkDestroySwapchainKHR(device, swapchain, pAllocator);
}
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 = HostConnection::get()->vkEncoder();
vkEnc->vkDestroySwapchainKHR(device, swapchain, pAllocator);
}
static VkResult entry_vkGetSwapchainImagesKHR(
VkDevice device,
VkSwapchainKHR swapchain,
uint32_t* pSwapchainImageCount,
VkImage* pSwapchainImages)
{
AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
vkGetSwapchainImagesKHR_VkResult_return = vkEnc->vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
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 = HostConnection::get()->vkEncoder();
VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
vkGetSwapchainImagesKHR_VkResult_return = vkEnc->vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
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 = HostConnection::get()->vkEncoder();
VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
vkAcquireNextImageKHR_VkResult_return = vkEnc->vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
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 = HostConnection::get()->vkEncoder();
VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
vkAcquireNextImageKHR_VkResult_return = vkEnc->vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
return vkAcquireNextImageKHR_VkResult_return;
}
static VkResult entry_vkQueuePresentKHR(
VkQueue queue,
const VkPresentInfoKHR* pPresentInfo)
{
AEMU_SCOPED_TRACE("vkQueuePresentKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0;
vkQueuePresentKHR_VkResult_return = vkEnc->vkQueuePresentKHR(queue, pPresentInfo);
return vkQueuePresentKHR_VkResult_return;
}
static VkResult entry_vkGetDeviceGroupPresentCapabilitiesKHR(
VkDevice device,
VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
{
AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = vkEnc->vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
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 = HostConnection::get()->vkEncoder();
VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = vkEnc->vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
return vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
}
static VkResult entry_vkGetDeviceGroupSurfacePresentModesKHR(
VkDevice device,
VkSurfaceKHR surface,
VkDeviceGroupPresentModeFlagsKHR* pModes)
{
AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
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 = HostConnection::get()->vkEncoder();
VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
return vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDevicePresentRectanglesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pRectCount,
VkRect2D* pRects)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDevicePresentRectanglesKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = vkEnc->vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
return vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return;
}
static VkResult entry_vkAcquireNextImage2KHR(
VkDevice device,
const VkAcquireNextImageInfoKHR* pAcquireInfo,
uint32_t* pImageIndex)
{
AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
vkAcquireNextImage2KHR_VkResult_return = vkEnc->vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
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 = HostConnection::get()->vkEncoder();
VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
vkAcquireNextImage2KHR_VkResult_return = vkEnc->vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
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 = HostConnection::get()->vkEncoder();
VkResult vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0;
vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
return vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
VkPhysicalDevice physicalDevice,
uint32_t* pPropertyCount,
VkDisplayPlanePropertiesKHR* pProperties)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlanePropertiesKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0;
vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties);
return vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return;
}
static VkResult entry_vkGetDisplayPlaneSupportedDisplaysKHR(
VkPhysicalDevice physicalDevice,
uint32_t planeIndex,
uint32_t* pDisplayCount,
VkDisplayKHR* pDisplays)
{
AEMU_SCOPED_TRACE("vkGetDisplayPlaneSupportedDisplaysKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0;
vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = vkEnc->vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays);
return vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return;
}
static VkResult entry_vkGetDisplayModePropertiesKHR(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
uint32_t* pPropertyCount,
VkDisplayModePropertiesKHR* pProperties)
{
AEMU_SCOPED_TRACE("vkGetDisplayModePropertiesKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0;
vkGetDisplayModePropertiesKHR_VkResult_return = vkEnc->vkGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties);
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 = HostConnection::get()->vkEncoder();
VkResult vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
vkCreateDisplayModeKHR_VkResult_return = vkEnc->vkCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode);
return vkCreateDisplayModeKHR_VkResult_return;
}
static VkResult entry_vkGetDisplayPlaneCapabilitiesKHR(
VkPhysicalDevice physicalDevice,
VkDisplayModeKHR mode,
uint32_t planeIndex,
VkDisplayPlaneCapabilitiesKHR* pCapabilities)
{
AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilitiesKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0;
vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = vkEnc->vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
return vkGetDisplayPlaneCapabilitiesKHR_VkResult_return;
}
static VkResult entry_vkCreateDisplayPlaneSurfaceKHR(
VkInstance instance,
const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
AEMU_SCOPED_TRACE("vkCreateDisplayPlaneSurfaceKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
vkCreateDisplayPlaneSurfaceKHR_VkResult_return = vkEnc->vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
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 = HostConnection::get()->vkEncoder();
VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
vkCreateSharedSwapchainsKHR_VkResult_return = vkEnc->vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
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 = HostConnection::get()->vkEncoder();
VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
vkCreateSharedSwapchainsKHR_VkResult_return = vkEnc->vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
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 = HostConnection::get()->vkEncoder();
VkResult vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
vkCreateXlibSurfaceKHR_VkResult_return = vkEnc->vkCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
return vkCreateXlibSurfaceKHR_VkResult_return;
}
static VkBool32 entry_vkGetPhysicalDeviceXlibPresentationSupportKHR(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
Display* dpy,
VisualID visualID)
{
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXlibPresentationSupportKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0;
vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID);
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 = HostConnection::get()->vkEncoder();
VkResult vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
vkCreateXcbSurfaceKHR_VkResult_return = vkEnc->vkCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
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 = HostConnection::get()->vkEncoder();
VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0;
vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id);
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 = HostConnection::get()->vkEncoder();
VkResult vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
vkCreateWaylandSurfaceKHR_VkResult_return = vkEnc->vkCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
return vkCreateWaylandSurfaceKHR_VkResult_return;
}