tests: add dispatchable object wrapping layer
Change-Id: I181fd9b4363d98d4da63017b8bdce68e86e8aefc
diff --git a/tests/layers/wrap_objects.cpp b/tests/layers/wrap_objects.cpp
new file mode 100644
index 0000000..2cdd7ea
--- /dev/null
+++ b/tests/layers/wrap_objects.cpp
@@ -0,0 +1,1609 @@
+/*
+ * Copyright (c) 2015-2016 Valve Corporation
+ * Copyright (c) 2015-2016 LunarG, 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.
+ *
+ * Author: Jon Ashburn <jon@lunarg.com>
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "vk_loader_platform.h"
+#include "vulkan/vk_layer.h"
+#include "vk_dispatch_table_helper.h"
+#include "vk_layer_extension_utils.h"
+#include "vk_layer_utils.h"
+#include "wrap_objects.h"
+
+namespace wrap_objects {
+
+static const VkLayerProperties global_layer = {
+ "VK_LAYER_LUNARG_wrap_objects", VK_LAYER_API_VERSION, 1, "LunarG Test Layer",
+};
+
+//TODO Add wrapping of Vkdevice, Vkqueue, VkcommandBuffer
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
+{
+ VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
+ PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
+ PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance) fpGetInstanceProcAddr(NULL, "vkCreateInstance");
+ if (fpCreateInstance == NULL) {
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+ // Advance the link info for the next element on the chain
+ chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
+ VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance);
+ if (result != VK_SUCCESS) {
+ return result;
+ }
+ auto inst = new wrapped_inst_obj;
+ if (!inst)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ memset(inst, 0, sizeof(*inst));
+ inst->obj = (*pInstance);
+ *pInstance = reinterpret_cast<VkInstance> (inst);
+ // store the loader callback for initializing created dispatchable objects
+ chain_info = get_chain_info(pCreateInfo, VK_LOADER_DATA_CALLBACK);
+ if (chain_info) {
+ inst->pfn_inst_init = chain_info->u.pfnSetInstanceLoaderData;
+ result = inst->pfn_inst_init(inst->obj, reinterpret_cast<void *> (inst));
+ if (VK_SUCCESS != result)
+ return result;
+ } else {
+ inst->pfn_inst_init = NULL;
+ inst->loader_disp = *(reinterpret_cast<VkLayerInstanceDispatchTable **> (*pInstance));
+ }
+ layer_init_instance_dispatch_table(*pInstance, &inst->layer_disp, fpGetInstanceProcAddr);
+
+ create_instance_register_extensions(pCreateInfo, *pInstance, inst);
+
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
+{
+ wrapped_inst_obj *inst;
+ auto vk_inst = unwrap_instance(instance, &inst);
+ VkLayerInstanceDispatchTable *pDisp = &inst->layer_disp;
+ pDisp->DestroyInstance(vk_inst, pAllocator);
+ if (inst->ptr_phys_devs)
+ delete[] inst->ptr_phys_devs;
+ delete inst;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
+{
+ wrapped_inst_obj *inst;
+ auto vk_inst = unwrap_instance(instance, &inst);
+ VkResult result = inst->layer_disp.EnumeratePhysicalDevices(vk_inst, pPhysicalDeviceCount, pPhysicalDevices);
+
+ if (VK_SUCCESS != result)
+ return result;
+
+ if (pPhysicalDevices != NULL) {
+ assert(pPhysicalDeviceCount);
+ auto phys_devs = new wrapped_phys_dev_obj[*pPhysicalDeviceCount];
+ if (!phys_devs)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (inst->ptr_phys_devs)
+ delete[] inst->ptr_phys_devs;
+ inst->ptr_phys_devs = phys_devs;
+ for (int i = 0; i < *pPhysicalDeviceCount; i++) {
+ if (inst->pfn_inst_init == NULL) {
+ phys_devs[i].loader_disp = *(reinterpret_cast<VkLayerInstanceDispatchTable **> (pPhysicalDevices[i]));
+ } else {
+ result = inst->pfn_inst_init(vk_inst, reinterpret_cast<void *> (&phys_devs[i]));
+ if (VK_SUCCESS != result)
+ return result;
+
+ }
+ phys_devs[i].obj = reinterpret_cast<void *> (pPhysicalDevices[i]);
+ phys_devs[i].inst = inst;
+ pPhysicalDevices[i] = reinterpret_cast<VkPhysicalDevice> (&phys_devs[i]);
+ }
+ }
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ phys_dev->inst->layer_disp.GetPhysicalDeviceFeatures(vk_phys_dev, pFeatures);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ phys_dev->inst->layer_disp.GetPhysicalDeviceFormatProperties(vk_phys_dev, format, pFormatProperties);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ VkResult result = phys_dev->inst->layer_disp.GetPhysicalDeviceImageFormatProperties(vk_phys_dev, format, type, tiling, usage, flags, pImageFormatProperties);
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ phys_dev->inst->layer_disp.GetPhysicalDeviceProperties(vk_phys_dev, pProperties);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ phys_dev->inst->layer_disp.GetPhysicalDeviceQueueFamilyProperties(vk_phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ phys_dev->inst->layer_disp.GetPhysicalDeviceMemoryProperties(vk_phys_dev, pMemoryProperties);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
+ PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
+ PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
+ PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice) fpGetInstanceProcAddr(NULL, "vkCreateDevice");
+ if (fpCreateDevice == NULL) {
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+ // Advance the link info for the next element on the chain
+ chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
+ VkResult result = fpCreateDevice(vk_phys_dev, pCreateInfo, pAllocator, pDevice);
+ if (result != VK_SUCCESS) {
+ return result;
+ }
+ initDeviceTable(*pDevice, fpGetDeviceProcAddr);
+
+ create_device_register_extensions(pCreateInfo, *pDevice);
+
+#if 0 // TODO add once device is wrapped
+ // store the loader callback for initializing created dispatchable objects
+ chain_info = get_chain_info(pCreateInfo, VK_LOADER_DATA_CALLBACK);
+ if (chain_info) {
+ dev->pfn_dev_init = chain_info->u.pfnSetDeviceLoaderData;
+ } else {
+ dev->pfn_dev_init = NULL;
+ }
+#endif
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
+{
+ dispatch_key key = get_dispatch_key(device);
+ VkLayerDispatchTable *pDisp = device_dispatch_table(device);
+ pDisp->DestroyDevice(device, pAllocator);
+ deviceExtMap.erase(pDisp);
+ destroy_device_dispatch_table(key);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+
+ if (pLayerName && !strcmp(pLayerName, global_layer.layerName))
+ return util_GetExtensionProperties(0, nullptr, pPropertyCount, pProperties);
+
+ return phys_dev->inst->layer_disp.EnumerateDeviceExtensionProperties(vk_phys_dev, pLayerName, pPropertyCount, pProperties);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
+{
+ device_dispatch_table(device)->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
+{
+ VkResult result = device_dispatch_table(queue)->QueueSubmit(queue, submitCount, pSubmits, fence);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue)
+{
+ VkResult result = device_dispatch_table(queue)->QueueWaitIdle(queue);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device)
+{
+ VkResult result = device_dispatch_table(device)->DeviceWaitIdle(device);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
+{
+ VkResult result = device_dispatch_table(device)->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->FreeMemory(device, memory, pAllocator);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData)
+{
+ VkResult result = device_dispatch_table(device)->MapMemory(device, memory, offset, size, flags, ppData);
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
+{
+ device_dispatch_table(device)->UnmapMemory(device, memory);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
+{
+ VkResult result = device_dispatch_table(device)->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+ return result;
+}
+
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
+{
+ VkResult result = device_dispatch_table(device)->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
+{
+ device_dispatch_table(device)->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+{
+ VkResult result = device_dispatch_table(device)->BindBufferMemory(device, buffer, memory, memoryOffset);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+{
+ VkResult result = device_dispatch_table(device)->BindImageMemory(device, image, memory, memoryOffset);
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
+{
+ device_dispatch_table(device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
+{
+ device_dispatch_table(device)->GetImageMemoryRequirements(device, image, pMemoryRequirements);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+ device_dispatch_table(device)->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ phys_dev->inst->layer_disp.GetPhysicalDeviceSparseImageFormatProperties(vk_phys_dev, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
+{
+ VkResult result = device_dispatch_table(queue)->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
+{
+ VkResult result = device_dispatch_table(device)->CreateFence(device, pCreateInfo, pAllocator, pFence);
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroyFence(device, fence, pAllocator);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences)
+{
+ VkResult result = device_dispatch_table(device)->ResetFences(device, fenceCount, pFences);
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence)
+{
+ VkResult result = device_dispatch_table(device)->GetFenceStatus(device, fence);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
+{
+ VkResult result = device_dispatch_table(device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
+{
+ VkResult result = device_dispatch_table(device)->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroySemaphore(device, semaphore, pAllocator);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
+{
+ VkResult result = device_dispatch_table(device)->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroyEvent(device, event, pAllocator);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event)
+{
+ VkResult result = device_dispatch_table(device)->GetEventStatus(device, event);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event)
+{
+ VkResult result = device_dispatch_table(device)->SetEvent(device, event);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event)
+{
+ VkResult result = device_dispatch_table(device)->ResetEvent(device, event);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
+{
+ VkResult result = device_dispatch_table(device)->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroyQueryPool(device, queryPool, pAllocator);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+ VkResult result = device_dispatch_table(device)->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
+{
+ VkResult result = device_dispatch_table(device)->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroyBuffer(device, buffer, pAllocator);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
+{
+ VkResult result = device_dispatch_table(device)->CreateBufferView(device, pCreateInfo, pAllocator, pView);
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroyBufferView(device, bufferView, pAllocator);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
+{
+ VkResult result = device_dispatch_table(device)->CreateImage(device, pCreateInfo, pAllocator, pImage);
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroyImage(device, image, pAllocator);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
+{
+ device_dispatch_table(device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
+{
+ VkResult result = device_dispatch_table(device)->CreateImageView(device, pCreateInfo, pAllocator, pView);
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroyImageView(device, imageView, pAllocator);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
+{
+ VkResult result = device_dispatch_table(device)->CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroyShaderModule(device, shaderModule, pAllocator);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
+{
+ VkResult result = device_dispatch_table(device)->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroyPipelineCache(device, pipelineCache, pAllocator);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
+{
+ VkResult result = device_dispatch_table(device)->GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
+{
+ VkResult result = device_dispatch_table(device)->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
+{
+ VkResult result = device_dispatch_table(device)->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
+{
+ VkResult result = device_dispatch_table(device)->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroyPipeline(device, pipeline, pAllocator);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+{
+ VkResult result = device_dispatch_table(device)->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
+{
+ VkResult result = device_dispatch_table(device)->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroySampler(device, sampler, pAllocator);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+{
+ VkResult result = device_dispatch_table(device)->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+{
+ VkResult result = device_dispatch_table(device)->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroyDescriptorPool(device, descriptorPool, pAllocator);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+{
+ VkResult result = device_dispatch_table(device)->ResetDescriptorPool(device, descriptorPool, flags);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
+{
+ VkResult result = device_dispatch_table(device)->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
+{
+ VkResult result = device_dispatch_table(device)->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+{
+ device_dispatch_table(device)->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+{
+ VkResult result = device_dispatch_table(device)->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroyFramebuffer(device, framebuffer, pAllocator);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
+{
+ VkResult result = device_dispatch_table(device)->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroyRenderPass(device, renderPass, pAllocator);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
+{
+ device_dispatch_table(device)->GetRenderAreaGranularity(device, renderPass, pGranularity);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
+{
+ VkResult result = device_dispatch_table(device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
+ return result;
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroyCommandPool(device, commandPool, pAllocator);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+{
+ VkResult result = device_dispatch_table(device)->ResetCommandPool(device, commandPool, flags);
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
+{
+ VkResult result = device_dispatch_table(device)->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
+{
+ device_dispatch_table(device)->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
+{
+ VkResult result = device_dispatch_table(commandBuffer)->BeginCommandBuffer(commandBuffer, pBeginInfo);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer)
+{
+ VkResult result = device_dispatch_table(commandBuffer)->EndCommandBuffer(commandBuffer);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
+{
+ VkResult result = device_dispatch_table(commandBuffer)->ResetCommandBuffer(commandBuffer, flags);
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
+{
+ device_dispatch_table(commandBuffer)->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
+{
+ device_dispatch_table(commandBuffer)->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
+{
+ device_dispatch_table(commandBuffer)->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
+{
+ device_dispatch_table(commandBuffer)->CmdSetLineWidth(commandBuffer, lineWidth);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
+{
+ device_dispatch_table(commandBuffer)->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
+{
+ device_dispatch_table(commandBuffer)->CmdSetBlendConstants(commandBuffer, blendConstants);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
+{
+ device_dispatch_table(commandBuffer)->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
+{
+ device_dispatch_table(commandBuffer)->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
+{
+ device_dispatch_table(commandBuffer)->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
+{
+ device_dispatch_table(commandBuffer)->CmdSetStencilReference(commandBuffer, faceMask, reference);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
+{
+ device_dispatch_table(commandBuffer)->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+{
+ device_dispatch_table(commandBuffer)->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
+{
+ device_dispatch_table(commandBuffer)->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
+{
+ device_dispatch_table(commandBuffer)->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
+{
+ device_dispatch_table(commandBuffer)->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+ device_dispatch_table(commandBuffer)->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+{
+ device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z)
+{
+ device_dispatch_table(commandBuffer)->CmdDispatch(commandBuffer, x, y, z);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
+{
+ device_dispatch_table(commandBuffer)->CmdDispatchIndirect(commandBuffer, buffer, offset);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
+{
+ device_dispatch_table(commandBuffer)->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
+{
+ device_dispatch_table(commandBuffer)->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
+{
+ device_dispatch_table(commandBuffer)->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+ device_dispatch_table(commandBuffer)->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+ device_dispatch_table(commandBuffer)->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData)
+{
+ device_dispatch_table(commandBuffer)->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
+{
+ device_dispatch_table(commandBuffer)->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+ device_dispatch_table(commandBuffer)->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+ device_dispatch_table(commandBuffer)->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
+{
+ device_dispatch_table(commandBuffer)->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
+{
+ device_dispatch_table(commandBuffer)->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+{
+ device_dispatch_table(commandBuffer)->CmdSetEvent(commandBuffer, event, stageMask);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+{
+ device_dispatch_table(commandBuffer)->CmdResetEvent(commandBuffer, event, stageMask);
+}
+
+
+VKAPI_ATTR void VKAPI_CALL 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)
+{
+ device_dispatch_table(commandBuffer)->CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+}
+
+VKAPI_ATTR void VKAPI_CALL 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)
+{
+ device_dispatch_table(commandBuffer)->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
+{
+ device_dispatch_table(commandBuffer)->CmdBeginQuery(commandBuffer, queryPool, query, flags);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
+{
+ device_dispatch_table(commandBuffer)->CmdEndQuery(commandBuffer, queryPool, query);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+ device_dispatch_table(commandBuffer)->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
+{
+ device_dispatch_table(commandBuffer)->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+ device_dispatch_table(commandBuffer)->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
+{
+ device_dispatch_table(commandBuffer)->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
+{
+ device_dispatch_table(commandBuffer)->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
+{
+ device_dispatch_table(commandBuffer)->CmdNextSubpass(commandBuffer, contents);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
+{
+ device_dispatch_table(commandBuffer)->CmdEndRenderPass(commandBuffer);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
+{
+ device_dispatch_table(commandBuffer)->CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator)
+{
+ wrapped_inst_obj *inst;
+ auto vk_inst = unwrap_instance(instance, &inst);
+ inst->layer_disp.DestroySurfaceKHR(vk_inst, surface, pAllocator);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ VkResult result = phys_dev->inst->layer_disp.GetPhysicalDeviceSurfaceSupportKHR(vk_phys_dev, queueFamilyIndex, surface, pSupported);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ VkResult result = phys_dev->inst->layer_disp.GetPhysicalDeviceSurfaceCapabilitiesKHR(vk_phys_dev, surface, pSurfaceCapabilities);
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ VkResult result = phys_dev->inst->layer_disp.GetPhysicalDeviceSurfaceFormatsKHR(vk_phys_dev, surface, pSurfaceFormatCount, pSurfaceFormats);
+ return result;
+}
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ VkResult result = phys_dev->inst->layer_disp.GetPhysicalDeviceSurfacePresentModesKHR(vk_phys_dev, surface, pPresentModeCount, pPresentModes);
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain)
+{
+ VkResult result = device_dispatch_table(device)->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
+ return result;
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator)
+{
+ device_dispatch_table(device)->DestroySwapchainKHR(device, swapchain, pAllocator);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages)
+{
+ VkResult result = device_dispatch_table(device)->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex)
+{
+ VkResult result = device_dispatch_table(device)->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
+ return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo)
+{
+ VkResult result = device_dispatch_table(queue)->QueuePresentKHR(queue, pPresentInfo);
+ return result;
+}
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL
+vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
+ const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+ VkResult result;
+ wrapped_inst_obj *inst;
+ auto vk_inst = unwrap_instance(instance, &inst);
+ result = inst->layer_disp.CreateWin32SurfaceKHR(vk_inst, pCreateInfo, pAllocator, pSurface);
+ return result;
+}
+
+VKAPI_ATTR VkBool32 VKAPI_CALL
+vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) {
+ VkBool32 result;
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ result = phys_dev->inst->layer_disp.GetPhysicalDeviceWin32PresentationSupportKHR(vk_phys_dev, queueFamilyIndex);
+ return result;
+}
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
+{
+ wrapped_inst_obj *inst;
+ auto vk_inst = unwrap_instance(instance, &inst);
+ VkResult result = inst->layer_disp.CreateXcbSurfaceKHR(vk_inst, pCreateInfo, pAllocator, pSurface);
+ return result;
+}
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ VkBool32 result = phys_dev->inst->layer_disp.GetPhysicalDeviceXcbPresentationSupportKHR(vk_phys_dev, queueFamilyIndex, connection, visual_id);
+ return result;
+}
+#endif // VK_USE_PLATFORM_XCB_KHR
+
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
+{
+ wrapped_inst_obj *inst;
+ auto vk_inst = unwrap_instance(instance, &inst);
+ VkResult result = inst->layer_disp.CreateXlibSurfaceKHR(vk_inst, pCreateInfo, pAllocator, pSurface);
+ return result;
+}
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ VkBool32 result = phys_dev->inst->layer_disp.GetPhysicalDeviceXlibPresentationSupportKHR(vk_phys_dev, queueFamilyIndex, dpy, visualID);
+ return result;
+}
+#endif // VK_USE_PLATFORM_XLIB_KHR
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
+{
+ wrapped_inst_obj *inst;
+ auto vk_inst = unwrap_instance(instance, &inst);
+ VkResult result = inst->layer_disp.CreateWaylandSurfaceKHR(vk_inst, pCreateInfo, pAllocator, pSurface);
+ return result;
+}
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ VkBool32 result = inst->layer_disp.GetPhysicalDeviceWaylandPresentationSupportKHR(vk_phys_dev, queueFamilyIndex, display);
+ return result;
+}
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+
+
+#ifdef VK_USE_PLATFORM_MIR_KHR
+
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
+{
+ wrapped_inst_obj *inst;
+ auto vk_inst = unwrap_instance(instance, &inst);
+ VkResult result = inst->layer_disp.CreateMirSurfaceKHR(vk_inst, pCreateInfo, pAllocator, pSurface);
+ return result;
+}
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection)
+{
+ wrapped_phys_dev_obj *phys_dev;
+ auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+ VkBool32 result = inst->layer_disp.GetPhysicalDeviceMirPresentationSupportKHR(vk_phys_dev, queueFamilyIndex, connection);
+ return result;
+}
+#endif // VK_USE_PLATFORM_MIR_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL
+vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
+ const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pMsgCallback) {
+ wrapped_inst_obj *inst;
+ auto vk_inst = unwrap_instance(instance, &inst);
+
+ VkResult res = inst->layer_disp.CreateDebugReportCallbackEXT(vk_inst, pCreateInfo, pAllocator, pMsgCallback);
+ return res;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+vkDestroyDebugReportCallbackEXT(VkInstance instance,
+ VkDebugReportCallbackEXT msgCallback,
+ const VkAllocationCallbacks *pAllocator) {
+ wrapped_inst_obj *inst;
+ auto vk_inst = unwrap_instance(instance, &inst);
+ inst->layer_disp.DestroyDebugReportCallbackEXT(vk_inst, msgCallback, pAllocator);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t object,
+ size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
+ wrapped_inst_obj *inst;
+ auto vk_inst = unwrap_instance(instance, &inst);
+ inst->layer_disp.DebugReportMessageEXT(vk_inst, flags, objType, object, location, msgCode, pLayerPrefix,
+ pMsg);
+}
+
+static inline PFN_vkVoidFunction layer_intercept_proc(const char *name)
+{
+ if (!name || name[0] != 'v' || name[1] != 'k')
+ return NULL;
+
+ name += 2;
+ if (!strcmp(name, "CreateInstance"))
+ return (PFN_vkVoidFunction) vkCreateInstance;
+ if (!strcmp(name, "DestroyInstance"))
+ return (PFN_vkVoidFunction) vkDestroyInstance;
+ if (!strcmp(name, "EnumeratePhysicalDevices"))
+ return (PFN_vkVoidFunction) vkEnumeratePhysicalDevices;
+ if (!strcmp(name, "GetPhysicalDeviceFeatures"))
+ return (PFN_vkVoidFunction) vkGetPhysicalDeviceFeatures;
+ if (!strcmp(name, "GetPhysicalDeviceFormatProperties"))
+ return (PFN_vkVoidFunction) vkGetPhysicalDeviceFormatProperties;
+ if (!strcmp(name, "GetPhysicalDeviceImageFormatProperties"))
+ return (PFN_vkVoidFunction) vkGetPhysicalDeviceImageFormatProperties;
+ if (!strcmp(name, "GetPhysicalDeviceProperties"))
+ return (PFN_vkVoidFunction) vkGetPhysicalDeviceProperties;
+ if (!strcmp(name, "GetPhysicalDeviceQueueFamilyProperties"))
+ return (PFN_vkVoidFunction) vkGetPhysicalDeviceQueueFamilyProperties;
+ if (!strcmp(name, "GetPhysicalDeviceMemoryProperties"))
+ return (PFN_vkVoidFunction) vkGetPhysicalDeviceMemoryProperties;
+ if (!strcmp(name, "CreateDevice"))
+ return (PFN_vkVoidFunction) vkCreateDevice;
+ if (!strcmp(name, "DestroyDevice"))
+ return (PFN_vkVoidFunction) vkDestroyDevice;
+ if (!strcmp(name, "GetDeviceQueue"))
+ return (PFN_vkVoidFunction) vkGetDeviceQueue;
+ if (!strcmp(name, "QueueSubmit"))
+ return (PFN_vkVoidFunction) vkQueueSubmit;
+ if (!strcmp(name, "QueueWaitIdle"))
+ return (PFN_vkVoidFunction) vkQueueWaitIdle;
+ if (!strcmp(name, "DeviceWaitIdle"))
+ return (PFN_vkVoidFunction) vkDeviceWaitIdle;
+ if (!strcmp(name, "AllocateMemory"))
+ return (PFN_vkVoidFunction) vkAllocateMemory;
+ if (!strcmp(name, "FreeMemory"))
+ return (PFN_vkVoidFunction) vkFreeMemory;
+ if (!strcmp(name, "MapMemory"))
+ return (PFN_vkVoidFunction) vkMapMemory;
+ if (!strcmp(name, "UnmapMemory"))
+ return (PFN_vkVoidFunction) vkUnmapMemory;
+ if (!strcmp(name, "FlushMappedMemoryRanges"))
+ return (PFN_vkVoidFunction) vkFlushMappedMemoryRanges;
+ if (!strcmp(name, "InvalidateMappedMemoryRanges"))
+ return (PFN_vkVoidFunction) vkInvalidateMappedMemoryRanges;
+ if (!strcmp(name, "GetDeviceMemoryCommitment"))
+ return (PFN_vkVoidFunction) vkGetDeviceMemoryCommitment;
+ if (!strcmp(name, "BindBufferMemory"))
+ return (PFN_vkVoidFunction) vkBindBufferMemory;
+ if (!strcmp(name, "BindImageMemory"))
+ return (PFN_vkVoidFunction) vkBindImageMemory;
+ if (!strcmp(name, "GetBufferMemoryRequirements"))
+ return (PFN_vkVoidFunction) vkGetBufferMemoryRequirements;
+ if (!strcmp(name, "GetImageMemoryRequirements"))
+ return (PFN_vkVoidFunction) vkGetImageMemoryRequirements;
+ if (!strcmp(name, "GetImageSparseMemoryRequirements"))
+ return (PFN_vkVoidFunction) vkGetImageSparseMemoryRequirements;
+ if (!strcmp(name, "GetPhysicalDeviceSparseImageFormatProperties"))
+ return (PFN_vkVoidFunction) vkGetPhysicalDeviceSparseImageFormatProperties;
+ if (!strcmp(name, "QueueBindSparse"))
+ return (PFN_vkVoidFunction) vkQueueBindSparse;
+ if (!strcmp(name, "CreateFence"))
+ return (PFN_vkVoidFunction) vkCreateFence;
+ if (!strcmp(name, "DestroyFence"))
+ return (PFN_vkVoidFunction) vkDestroyFence;
+ if (!strcmp(name, "ResetFences"))
+ return (PFN_vkVoidFunction) vkResetFences;
+ if (!strcmp(name, "GetFenceStatus"))
+ return (PFN_vkVoidFunction) vkGetFenceStatus;
+ if (!strcmp(name, "WaitForFences"))
+ return (PFN_vkVoidFunction) vkWaitForFences;
+ if (!strcmp(name, "CreateSemaphore"))
+ return (PFN_vkVoidFunction) vkCreateSemaphore;
+ if (!strcmp(name, "DestroySemaphore"))
+ return (PFN_vkVoidFunction) vkDestroySemaphore;
+ if (!strcmp(name, "CreateEvent"))
+ return (PFN_vkVoidFunction) vkCreateEvent;
+ if (!strcmp(name, "DestroyEvent"))
+ return (PFN_vkVoidFunction) vkDestroyEvent;
+ if (!strcmp(name, "GetEventStatus"))
+ return (PFN_vkVoidFunction) vkGetEventStatus;
+ if (!strcmp(name, "SetEvent"))
+ return (PFN_vkVoidFunction) vkSetEvent;
+ if (!strcmp(name, "ResetEvent"))
+ return (PFN_vkVoidFunction) vkResetEvent;
+ if (!strcmp(name, "CreateQueryPool"))
+ return (PFN_vkVoidFunction) vkCreateQueryPool;
+ if (!strcmp(name, "DestroyQueryPool"))
+ return (PFN_vkVoidFunction) vkDestroyQueryPool;
+ if (!strcmp(name, "GetQueryPoolResults"))
+ return (PFN_vkVoidFunction) vkGetQueryPoolResults;
+ if (!strcmp(name, "CreateBuffer"))
+ return (PFN_vkVoidFunction) vkCreateBuffer;
+ if (!strcmp(name, "DestroyBuffer"))
+ return (PFN_vkVoidFunction) vkDestroyBuffer;
+ if (!strcmp(name, "CreateBufferView"))
+ return (PFN_vkVoidFunction) vkCreateBufferView;
+ if (!strcmp(name, "DestroyBufferView"))
+ return (PFN_vkVoidFunction) vkDestroyBufferView;
+ if (!strcmp(name, "CreateImage"))
+ return (PFN_vkVoidFunction) vkCreateImage;
+ if (!strcmp(name, "DestroyImage"))
+ return (PFN_vkVoidFunction) vkDestroyImage;
+ if (!strcmp(name, "GetImageSubresourceLayout"))
+ return (PFN_vkVoidFunction) vkGetImageSubresourceLayout;
+ if (!strcmp(name, "CreateImageView"))
+ return (PFN_vkVoidFunction) vkCreateImageView;
+ if (!strcmp(name, "DestroyImageView"))
+ return (PFN_vkVoidFunction) vkDestroyImageView;
+ if (!strcmp(name, "CreateShaderModule"))
+ return (PFN_vkVoidFunction) vkCreateShaderModule;
+ if (!strcmp(name, "DestroyShaderModule"))
+ return (PFN_vkVoidFunction) vkDestroyShaderModule;
+ if (!strcmp(name, "CreatePipelineCache"))
+ return (PFN_vkVoidFunction) vkCreatePipelineCache;
+ if (!strcmp(name, "DestroyPipelineCache"))
+ return (PFN_vkVoidFunction) vkDestroyPipelineCache;
+ if (!strcmp(name, "GetPipelineCacheData"))
+ return (PFN_vkVoidFunction) vkGetPipelineCacheData;
+ if (!strcmp(name, "MergePipelineCaches"))
+ return (PFN_vkVoidFunction) vkMergePipelineCaches;
+ if (!strcmp(name, "CreateGraphicsPipelines"))
+ return (PFN_vkVoidFunction) vkCreateGraphicsPipelines;
+ if (!strcmp(name, "CreateComputePipelines"))
+ return (PFN_vkVoidFunction) vkCreateComputePipelines;
+ if (!strcmp(name, "DestroyPipeline"))
+ return (PFN_vkVoidFunction) vkDestroyPipeline;
+ if (!strcmp(name, "CreatePipelineLayout"))
+ return (PFN_vkVoidFunction) vkCreatePipelineLayout;
+ if (!strcmp(name, "DestroyPipelineLayout"))
+ return (PFN_vkVoidFunction) vkDestroyPipelineLayout;
+ if (!strcmp(name, "CreateSampler"))
+ return (PFN_vkVoidFunction) vkCreateSampler;
+ if (!strcmp(name, "DestroySampler"))
+ return (PFN_vkVoidFunction) vkDestroySampler;
+ if (!strcmp(name, "CreateDescriptorSetLayout"))
+ return (PFN_vkVoidFunction) vkCreateDescriptorSetLayout;
+ if (!strcmp(name, "DestroyDescriptorSetLayout"))
+ return (PFN_vkVoidFunction) vkDestroyDescriptorSetLayout;
+ if (!strcmp(name, "CreateDescriptorPool"))
+ return (PFN_vkVoidFunction) vkCreateDescriptorPool;
+ if (!strcmp(name, "DestroyDescriptorPool"))
+ return (PFN_vkVoidFunction) vkDestroyDescriptorPool;
+ if (!strcmp(name, "ResetDescriptorPool"))
+ return (PFN_vkVoidFunction) vkResetDescriptorPool;
+ if (!strcmp(name, "AllocateDescriptorSets"))
+ return (PFN_vkVoidFunction) vkAllocateDescriptorSets;
+ if (!strcmp(name, "FreeDescriptorSets"))
+ return (PFN_vkVoidFunction) vkFreeDescriptorSets;
+ if (!strcmp(name, "UpdateDescriptorSets"))
+ return (PFN_vkVoidFunction) vkUpdateDescriptorSets;
+ if (!strcmp(name, "CreateFramebuffer"))
+ return (PFN_vkVoidFunction) vkCreateFramebuffer;
+ if (!strcmp(name, "DestroyFramebuffer"))
+ return (PFN_vkVoidFunction) vkDestroyFramebuffer;
+ if (!strcmp(name, "CreateRenderPass"))
+ return (PFN_vkVoidFunction) vkCreateRenderPass;
+ if (!strcmp(name, "DestroyRenderPass"))
+ return (PFN_vkVoidFunction) vkDestroyRenderPass;
+ if (!strcmp(name, "GetRenderAreaGranularity"))
+ return (PFN_vkVoidFunction) vkGetRenderAreaGranularity;
+ if (!strcmp(name, "CreateCommandPool"))
+ return (PFN_vkVoidFunction) vkCreateCommandPool;
+ if (!strcmp(name, "DestroyCommandPool"))
+ return (PFN_vkVoidFunction) vkDestroyCommandPool;
+ if (!strcmp(name, "ResetCommandPool"))
+ return (PFN_vkVoidFunction) vkResetCommandPool;
+ if (!strcmp(name, "AllocateCommandBuffers"))
+ return (PFN_vkVoidFunction) vkAllocateCommandBuffers;
+ if (!strcmp(name, "FreeCommandBuffers"))
+ return (PFN_vkVoidFunction) vkFreeCommandBuffers;
+ if (!strcmp(name, "BeginCommandBuffer"))
+ return (PFN_vkVoidFunction) vkBeginCommandBuffer;
+ if (!strcmp(name, "EndCommandBuffer"))
+ return (PFN_vkVoidFunction) vkEndCommandBuffer;
+ if (!strcmp(name, "ResetCommandBuffer"))
+ return (PFN_vkVoidFunction) vkResetCommandBuffer;
+ if (!strcmp(name, "CmdBindPipeline"))
+ return (PFN_vkVoidFunction) vkCmdBindPipeline;
+ if (!strcmp(name, "CmdSetViewport"))
+ return (PFN_vkVoidFunction) vkCmdSetViewport;
+ if (!strcmp(name, "CmdSetScissor"))
+ return (PFN_vkVoidFunction) vkCmdSetScissor;
+ if (!strcmp(name, "CmdSetLineWidth"))
+ return (PFN_vkVoidFunction) vkCmdSetLineWidth;
+ if (!strcmp(name, "CmdSetDepthBias"))
+ return (PFN_vkVoidFunction) vkCmdSetDepthBias;
+ if (!strcmp(name, "CmdSetBlendConstants"))
+ return (PFN_vkVoidFunction) vkCmdSetBlendConstants;
+ if (!strcmp(name, "CmdSetDepthBounds"))
+ return (PFN_vkVoidFunction) vkCmdSetDepthBounds;
+ if (!strcmp(name, "CmdSetStencilCompareMask"))
+ return (PFN_vkVoidFunction) vkCmdSetStencilCompareMask;
+ if (!strcmp(name, "CmdSetStencilWriteMask"))
+ return (PFN_vkVoidFunction) vkCmdSetStencilWriteMask;
+ if (!strcmp(name, "CmdSetStencilReference"))
+ return (PFN_vkVoidFunction) vkCmdSetStencilReference;
+ if (!strcmp(name, "CmdBindDescriptorSets"))
+ return (PFN_vkVoidFunction) vkCmdBindDescriptorSets;
+ if (!strcmp(name, "CmdBindIndexBuffer"))
+ return (PFN_vkVoidFunction) vkCmdBindIndexBuffer;
+ if (!strcmp(name, "CmdBindVertexBuffers"))
+ return (PFN_vkVoidFunction) vkCmdBindVertexBuffers;
+ if (!strcmp(name, "CmdDraw"))
+ return (PFN_vkVoidFunction) vkCmdDraw;
+ if (!strcmp(name, "CmdDrawIndexed"))
+ return (PFN_vkVoidFunction) vkCmdDrawIndexed;
+ if (!strcmp(name, "CmdDrawIndirect"))
+ return (PFN_vkVoidFunction) vkCmdDrawIndirect;
+ if (!strcmp(name, "CmdDrawIndexedIndirect"))
+ return (PFN_vkVoidFunction) vkCmdDrawIndexedIndirect;
+ if (!strcmp(name, "CmdDispatch"))
+ return (PFN_vkVoidFunction) vkCmdDispatch;
+ if (!strcmp(name, "CmdDispatchIndirect"))
+ return (PFN_vkVoidFunction) vkCmdDispatchIndirect;
+ if (!strcmp(name, "CmdCopyBuffer"))
+ return (PFN_vkVoidFunction) vkCmdCopyBuffer;
+ if (!strcmp(name, "CmdCopyImage"))
+ return (PFN_vkVoidFunction) vkCmdCopyImage;
+ if (!strcmp(name, "CmdBlitImage"))
+ return (PFN_vkVoidFunction) vkCmdBlitImage;
+ if (!strcmp(name, "CmdCopyBufferToImage"))
+ return (PFN_vkVoidFunction) vkCmdCopyBufferToImage;
+ if (!strcmp(name, "CmdCopyImageToBuffer"))
+ return (PFN_vkVoidFunction) vkCmdCopyImageToBuffer;
+ if (!strcmp(name, "CmdUpdateBuffer"))
+ return (PFN_vkVoidFunction) vkCmdUpdateBuffer;
+ if (!strcmp(name, "CmdFillBuffer"))
+ return (PFN_vkVoidFunction) vkCmdFillBuffer;
+ if (!strcmp(name, "CmdClearColorImage"))
+ return (PFN_vkVoidFunction) vkCmdClearColorImage;
+ if (!strcmp(name, "CmdClearDepthStencilImage"))
+ return (PFN_vkVoidFunction) vkCmdClearDepthStencilImage;
+ if (!strcmp(name, "CmdClearAttachments"))
+ return (PFN_vkVoidFunction) vkCmdClearAttachments;
+ if (!strcmp(name, "CmdResolveImage"))
+ return (PFN_vkVoidFunction) vkCmdResolveImage;
+ if (!strcmp(name, "CmdSetEvent"))
+ return (PFN_vkVoidFunction) vkCmdSetEvent;
+ if (!strcmp(name, "CmdResetEvent"))
+ return (PFN_vkVoidFunction) vkCmdResetEvent;
+ if (!strcmp(name, "CmdWaitEvents"))
+ return (PFN_vkVoidFunction) vkCmdWaitEvents;
+ if (!strcmp(name, "CmdPipelineBarrier"))
+ return (PFN_vkVoidFunction) vkCmdPipelineBarrier;
+ if (!strcmp(name, "CmdBeginQuery"))
+ return (PFN_vkVoidFunction) vkCmdBeginQuery;
+ if (!strcmp(name, "CmdEndQuery"))
+ return (PFN_vkVoidFunction) vkCmdEndQuery;
+ if (!strcmp(name, "CmdResetQueryPool"))
+ return (PFN_vkVoidFunction) vkCmdResetQueryPool;
+ if (!strcmp(name, "CmdWriteTimestamp"))
+ return (PFN_vkVoidFunction) vkCmdWriteTimestamp;
+ if (!strcmp(name, "CmdCopyQueryPoolResults"))
+ return (PFN_vkVoidFunction) vkCmdCopyQueryPoolResults;
+ if (!strcmp(name, "CmdPushConstants"))
+ return (PFN_vkVoidFunction) vkCmdPushConstants;
+ if (!strcmp(name, "CmdBeginRenderPass"))
+ return (PFN_vkVoidFunction) vkCmdBeginRenderPass;
+ if (!strcmp(name, "CmdNextSubpass"))
+ return (PFN_vkVoidFunction) vkCmdNextSubpass;
+ if (!strcmp(name, "CmdEndRenderPass"))
+ return (PFN_vkVoidFunction) vkCmdEndRenderPass;
+ if (!strcmp(name, "CmdExecuteCommands"))
+ return (PFN_vkVoidFunction) vkCmdExecuteCommands;
+
+ return NULL;
+}
+
+static inline PFN_vkVoidFunction layer_intercept_instance_proc(const char *name)
+{
+ if (!name || name[0] != 'v' || name[1] != 'k')
+ return NULL;
+
+ name += 2;
+ if (!strcmp(name, "GetInstanceProcAddr"))
+ return (PFN_vkVoidFunction)vkGetInstanceProcAddr;
+ if (!strcmp(name, "DestroyInstance"))
+ return (PFN_vkVoidFunction) vkDestroyInstance;
+ if (!strcmp(name, "EnumeratePhysicalDevices"))
+ return (PFN_vkVoidFunction) vkEnumeratePhysicalDevices;
+ if (!strcmp(name, "GetPhysicalDeviceFeatures"))
+ return (PFN_vkVoidFunction) vkGetPhysicalDeviceFeatures;
+ if (!strcmp(name, "GetPhysicalDeviceFormatProperties"))
+ return (PFN_vkVoidFunction) vkGetPhysicalDeviceFormatProperties;
+ if (!strcmp(name, "GetPhysicalDeviceImageFormatProperties"))
+ return (PFN_vkVoidFunction) vkGetPhysicalDeviceImageFormatProperties;
+ if (!strcmp(name, "GetPhysicalDeviceProperties"))
+ return (PFN_vkVoidFunction) vkGetPhysicalDeviceProperties;
+ if (!strcmp(name, "GetPhysicalDeviceQueueFamilyProperties"))
+ return (PFN_vkVoidFunction) vkGetPhysicalDeviceQueueFamilyProperties;
+ if (!strcmp(name, "GetPhysicalDeviceMemoryProperties"))
+ return (PFN_vkVoidFunction) vkGetPhysicalDeviceMemoryProperties;
+ if (!strcmp(name, "GetPhysicalDeviceSparseImageFormatProperties"))
+ return (PFN_vkVoidFunction) vkGetPhysicalDeviceSparseImageFormatProperties;
+ if (!strcmp(name, "EnumerateDeviceExtensionProperties"))
+ return (PFN_vkVoidFunction)vkEnumerateDeviceExtensionProperties;
+ return NULL;
+}
+
+VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char* funcName)
+{
+ PFN_vkVoidFunction addr;
+
+
+ if (!strcmp("vkGetDeviceProcAddr", funcName)) {
+ return (PFN_vkVoidFunction) vkGetDeviceProcAddr;
+ }
+
+ addr = layer_intercept_proc(funcName);
+ if (addr)
+ return addr;
+ if (device == VK_NULL_HANDLE) {
+ return NULL;
+ }
+
+ if (!strcmp("vkCreateSwapchainKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSwapchainKHR);
+ if (!strcmp("vkDestroySwapchainKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkDestroySwapchainKHR);
+ if (!strcmp("vkGetSwapchainImagesKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainImagesKHR);
+ if (!strcmp("vkAcquireNextImageKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImageKHR);
+ if (!strcmp("vkQueuePresentKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkQueuePresentKHR);
+
+ VkLayerDispatchTable *pDisp = device_dispatch_table(device);
+ if (pDisp->GetDeviceProcAddr == NULL)
+ {
+ return NULL;
+ }
+
+ return pDisp->GetDeviceProcAddr(device, funcName);
+}
+
+VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
+{
+ PFN_vkVoidFunction addr;
+
+ if (!strcmp(funcName, "vkCreateInstance"))
+ return (PFN_vkVoidFunction) vkCreateInstance;
+ if (!strcmp(funcName, "vkCreateDevice"))
+ return (PFN_vkVoidFunction) vkCreateDevice;
+
+ if (instance == VK_NULL_HANDLE) {
+ return NULL;
+ }
+
+ addr = layer_intercept_instance_proc(funcName);
+ if (addr)
+ return addr;
+
+ wrapped_inst_obj *inst;
+ auto vk_inst = unwrap_instance(instance, &inst);
+ VkLayerInstanceDispatchTable* pTable = &inst->layer_disp;
+
+ // EXT_debug_report
+ if (!strcmp(funcName, "vkCreateDebugReportCallbackEXT"))
+ return (PFN_vkVoidFunction)vkCreateDebugReportCallbackEXT;
+ if (!strcmp(funcName, "vkDestroyDebugReportCallbackEXT"))
+ return (PFN_vkVoidFunction)vkDestroyDebugReportCallbackEXT;
+ if (!strcmp(funcName, "vkDebugReportMessageEXT"))
+ return (PFN_vkVoidFunction)vkDebugReportMessageEXT;
+
+ //KHR_surface
+ if (!strcmp("vkDestroySurfaceKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkDestroySurfaceKHR);
+ if (!strcmp("vkGetPhysicalDeviceSurfaceSupportKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceSupportKHR);
+ if (!strcmp("vkGetPhysicalDeviceSurfaceCapabilitiesKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
+ if (!strcmp("vkGetPhysicalDeviceSurfaceFormatsKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceFormatsKHR);
+ if (!strcmp("vkGetPhysicalDeviceSurfacePresentModesKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfacePresentModesKHR);
+
+ // KHR_XXX_surface
+#ifdef VK_USE_PLATFORM_XCB_KHR
+ if (!strcmp("vkCreateXcbSurfaceKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkCreateXcbSurfaceKHR);
+ if (!strcmp("vkGetPhysicalDeviceXcbPresentationSupportKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceXcbPresentationSupportKHR);
+#endif // VK_USE_PLATFORM_XCB_KHR
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+ if (!strcmp("vkCreateXlibSurfaceKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkCreateXlibSurfaceKHR);
+ if (!strcmp("vkGetPhysicalDeviceXlibPresentationSupportKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceXlibPresentationSupportKHR);
+#endif // VK_USE_PLATFORM_XLIB_KHR
+#ifdef VK_USE_PLATFORM_MIR_KHR
+ if (!strcmp("vkCreateMirSurfaceKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkCreateMirSurfaceKHR);
+ if (!strcmp("vkGetPhysicalDeviceMirPresentationSupportKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceMirPresentationSupportKHR);
+#endif // VK_USE_PLATFORM_MIR_KHR
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+ if (!strcmp("vkCreateWaylandSurfaceKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkCreateWaylandSurfaceKHR);
+ if (!strcmp("vkGetPhysicalDeviceWaylandPresentationSupportKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceWaylandPresentationSupportKHR);
+#endif // VK_USE_PLATFORM_WAYLAND_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ if (!strcmp("vkCreateWin32SurfaceKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkCreateWin32SurfaceKHR);
+ if (!strcmp("vkGetPhysicalDeviceWin32PresentationSupportKHR", funcName))
+ return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceWin32PresentationSupportKHR);
+#endif // VK_USE_PLATFORM_WIN32_KHR
+
+ if (pTable->GetInstanceProcAddr == NULL)
+ return NULL;
+ return pTable->GetInstanceProcAddr(instance, funcName);
+}
+
+} // namespace wrap_objects
+
+// loader-layer interface v0, just wrappers since there is only a layer
+VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char* funcName) {
+ return wrap_objects::vkGetInstanceProcAddr(instance, funcName);
+}
+
+VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char* funcName) {
+ return wrap_objects::vkGetDeviceProcAddr(device, funcName);
+}
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) {
+ assert(0); // TODO return wrap_objects::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties);
+ return VK_SUCCESS;
+}
+
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+vkEnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) {
+ assert(0); // TODO return wrap_objects::EnumerateInstanceLayerProperties(pCount, pProperties);
+ return VK_SUCCESS;
+}
+
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties *pProperties) {
+ // the layer command handles VK_NULL_HANDLE just fine internally
+ assert(physicalDevice == VK_NULL_HANDLE);
+ assert(0); // TODO return wrap_objects::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties);
+ return VK_SUCCESS;
+}
+
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
+ const char *pLayerName, uint32_t *pCount,
+ VkExtensionProperties *pProperties) {
+ // the layer command handles VK_NULL_HANDLE just fine internally
+ assert(physicalDevice == VK_NULL_HANDLE);
+ return wrap_objects::vkEnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties);
+}