diff options
Diffstat (limited to 'layers')
| -rw-r--r-- | layers/CMakeLists.txt | 3 | ||||
| -rw-r--r-- | layers/linux/VkLayer_unique_objects.json | 11 | ||||
| -rw-r--r-- | layers/unique_objects.h | 671 | ||||
| -rw-r--r-- | layers/windows/VkLayer_unique_objects.json | 11 |
4 files changed, 696 insertions, 0 deletions
diff --git a/layers/CMakeLists.txt b/layers/CMakeLists.txt index 1c47165b..22994214 100644 --- a/layers/CMakeLists.txt +++ b/layers/CMakeLists.txt @@ -23,6 +23,7 @@ set(LAYER_JSON_FILES VkLayer_mem_tracker VkLayer_multi VkLayer_object_tracker + VkLayer_unique_objects VkLayer_param_checker VkLayer_screenshot VkLayer_swapchain @@ -129,6 +130,7 @@ run_vk_layer_generate(generic generic_layer.cpp) run_vk_layer_generate(api_dump api_dump.cpp) run_vk_layer_generate(object_tracker object_tracker.cpp) run_vk_layer_generate(threading threading.cpp) +run_vk_layer_generate(unique_objects unique_objects.cpp) add_library(layer_utils SHARED vk_layer_config.cpp vk_layer_extension_utils.cpp vk_layer_utils.cpp) if (WIN32) @@ -153,3 +155,4 @@ add_vk_layer(generic generic_layer.cpp vk_layer_table.cpp) add_vk_layer(api_dump api_dump.cpp vk_layer_table.cpp) add_vk_layer(object_tracker object_tracker.cpp vk_layer_table.cpp) add_vk_layer(threading threading.cpp vk_layer_table.cpp) +add_vk_layer(unique_objects unique_objects.cpp vk_layer_table.cpp) diff --git a/layers/linux/VkLayer_unique_objects.json b/layers/linux/VkLayer_unique_objects.json new file mode 100644 index 00000000..056ad7bd --- /dev/null +++ b/layers/linux/VkLayer_unique_objects.json @@ -0,0 +1,11 @@ +{ + "file_format_version" : "1.0.0", + "layer" : { + "name": "VK_LAYER_GOOGLE_unique_objects", + "type": "GLOBAL", + "library_path": "./libVkLayer_unique_objects.so", + "api_version": "0.210.0", + "implementation_version": "1", + "description": "Google Validation Layer" + } +} diff --git a/layers/unique_objects.h b/layers/unique_objects.h new file mode 100644 index 00000000..f12cf8c3 --- /dev/null +++ b/layers/unique_objects.h @@ -0,0 +1,671 @@ +/* + * + * Copyright (C) 2015 Google, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Author: Tobin Ehlis <tobine@google.com> + */ + +// CODEGEN : file vk-layer-generate.py line #1757 +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <inttypes.h> + +#include "vulkan/vulkan.h" +#include "vk_loader_platform.h" + +#include <vector> +#include <unordered_map> + +#include "vulkan/vk_layer.h" +#include "vk_layer_config.h" +//#include "vulkan/vk_lunarg_debug_report.h" +#include "vk_layer_table.h" +#include "vk_layer_data.h" +#include "vk_layer_logging.h" +#include "vk_layer_extension_utils.h" + +struct layer_data { + debug_report_data *report_data; + VkDebugReportCallbackEXT logging_callback; + bool wsi_enabled; + + layer_data() : + report_data(nullptr), + logging_callback(VK_NULL_HANDLE), + wsi_enabled(false) + {}; +}; + +struct instExts { + bool wsi_enabled; +}; + +static std::unordered_map<void*, struct instExts> instanceExtMap; +static std::unordered_map<void*, layer_data *> layer_data_map; +static device_table_map unique_objects_device_table_map; +static instance_table_map unique_objects_instance_table_map; +// Structure to wrap returned non-dispatchable objects to guarantee they have unique handles +// address of struct will be used as the unique handle +struct VkUniqueObject +{ + uint64_t actualObject; +}; + +static void +initUniqueObjects( + layer_data *my_data, + const VkAllocationCallbacks *pAllocator) +{ + uint32_t report_flags = 0; + uint32_t debug_action = 0; + FILE *log_output = NULL; + const char *option_str; + // initialize UniqueObjects options + report_flags = getLayerOptionFlags("UniqueObjectsReportFlags", 0); + getLayerOptionEnum("UniqueObjectsDebugAction", (uint32_t *) &debug_action); + + if (debug_action & VK_DBG_LAYER_ACTION_LOG_MSG) + { + option_str = getLayerOption("UniqueObjectsLogFilename"); + log_output = getLayerLogOutput(option_str, "UniqueObjects"); + VkDebugReportCallbackCreateInfoEXT dbgInfo; + memset(&dbgInfo, 0, sizeof(dbgInfo)); + dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT; + dbgInfo.pfnCallback = log_callback; + dbgInfo.pUserData = log_output; + dbgInfo.flags = report_flags; + layer_create_msg_callback(my_data->report_data, &dbgInfo, pAllocator, &my_data->logging_callback); + } +} + +// Handle CreateInstance +static void createInstanceRegisterExtensions(const VkInstanceCreateInfo* pCreateInfo, VkInstance instance) +{ + uint32_t i; + VkLayerInstanceDispatchTable *pDisp = get_dispatch_table(unique_objects_instance_table_map, instance); + PFN_vkGetInstanceProcAddr gpa = pDisp->GetInstanceProcAddr; + pDisp->GetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR) gpa(instance, "vkGetPhysicalDeviceSurfaceSupportKHR"); + pDisp->GetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR) gpa(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"); + pDisp->GetPhysicalDeviceSurfaceFormatsKHR = (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR) gpa(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR"); + pDisp->GetPhysicalDeviceSurfacePresentModesKHR = (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR) gpa(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR"); +#if VK_USE_PLATFORM_WIN32_KHR + pDisp->CreateWin32SurfaceKHR = (PFN_vkCreateWin32SurfaceKHR) gpa(instance, "vkCreateWin32SurfaceKHR"); + pDisp->GetPhysicalDeviceWin32PresentationSupportKHR = (PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR) gpa(instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR"); +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_XCB_KHR + pDisp->CreateXcbSurfaceKHR = (PFN_vkCreateXcbSurfaceKHR) gpa(instance, "vkCreateXcbSurfaceKHR"); + pDisp->GetPhysicalDeviceXcbPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR) gpa(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR"); +#endif // VK_USE_PLATFORM_XCB_KHR +#ifdef VK_USE_PLATFORM_XLIB_KHR + pDisp->CreateXlibSurfaceKHR = (PFN_vkCreateXlibSurfaceKHR) gpa(instance, "vkCreateXlibSurfaceKHR"); + pDisp->GetPhysicalDeviceXlibPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR) gpa(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR"); +#endif // VK_USE_PLATFORM_XLIB_KHR +#ifdef VK_USE_PLATFORM_MIR_KHR + pDisp->CreateMirSurfaceKHR = (PFN_vkCreateMirSurfaceKHR) gpa(instance, "vkCreateMirSurfaceKHR"); + pDisp->GetPhysicalDeviceMirPresentationSupportKHR = (PFN_vkGetPhysicalDeviceMirPresentationSupportKHR) gpa(instance, "vkGetPhysicalDeviceMirPresentationSupportKHR"); +#endif // VK_USE_PLATFORM_MIR_KHR +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + pDisp->CreateWaylandSurfaceKHR = (PFN_vkCreateWaylandSurfaceKHR) gpa(instance, "vkCreateWaylandSurfaceKHR"); + pDisp->GetPhysicalDeviceWaylandPresentationSupportKHR = (PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR) gpa(instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR"); +#endif // VK_USE_PLATFORM_WAYLAND_KHR +#ifdef VK_USE_PLATFORM_ANDROID_KHR + pDisp->CreateAndroidSurfaceKHR = (PFN_vkCreateAndroidSurfaceKHR) gpa(instance, "vkCreateAndroidSurfaceKHR"); +#endif // VK_USE_PLATFORM_ANDROID_KHR + + instanceExtMap[pDisp].wsi_enabled = false; + for (i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) { + if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SURFACE_EXTENSION_NAME) == 0) + instanceExtMap[pDisp].wsi_enabled = true; + } +} + +VkResult +explicit_CreateInstance( + const VkInstanceCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, + VkInstance *pInstance) +{ + + VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(unique_objects_instance_table_map, *pInstance); + VkResult result = pInstanceTable->CreateInstance(pCreateInfo, pAllocator, pInstance); + + if (result == VK_SUCCESS) { + layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map); + my_data->report_data = debug_report_create_instance( + pInstanceTable, + *pInstance, + pCreateInfo->enabledExtensionNameCount, + pCreateInfo->ppEnabledExtensionNames); + createInstanceRegisterExtensions(pCreateInfo, *pInstance); + + initUniqueObjects(my_data, pAllocator); + } + return result; +} + +// Handle CreateDevice +static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo, VkDevice device) +{ + layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + VkLayerDispatchTable *pDisp = get_dispatch_table(unique_objects_device_table_map, device); + PFN_vkGetDeviceProcAddr gpa = pDisp->GetDeviceProcAddr; + pDisp->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR) gpa(device, "vkCreateSwapchainKHR"); + pDisp->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR) gpa(device, "vkDestroySwapchainKHR"); + pDisp->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR) gpa(device, "vkGetSwapchainImagesKHR"); + pDisp->AcquireNextImageKHR = (PFN_vkAcquireNextImageKHR) gpa(device, "vkAcquireNextImageKHR"); + pDisp->QueuePresentKHR = (PFN_vkQueuePresentKHR) gpa(device, "vkQueuePresentKHR"); + my_device_data->wsi_enabled = false; + for (uint32_t i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) { + if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) + my_device_data->wsi_enabled = true; + } +} + +VkResult +explicit_CreateDevice( + VkPhysicalDevice gpu, + const VkDeviceCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, + VkDevice *pDevice) +{ + VkLayerDispatchTable *pDeviceTable = get_dispatch_table(unique_objects_device_table_map, *pDevice); + VkResult result = pDeviceTable->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice); + if (result == VK_SUCCESS) { + layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map); + layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map); + my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice); + createDeviceRegisterExtensions(pCreateInfo, *pDevice); + } + return result; +} + +VkResult explicit_QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) +{ +// UNWRAP USES: +// 0 : fence,VkFence + if (VK_NULL_HANDLE != fence) { + fence = (VkFence)((VkUniqueObject*)fence)->actualObject; + } +// waitSemaphoreCount : pSubmits[submitCount]->pWaitSemaphores,VkSemaphore + std::vector<VkSemaphore> original_pWaitSemaphores = {}; +// signalSemaphoreCount : pSubmits[submitCount]->pSignalSemaphores,VkSemaphore + std::vector<VkSemaphore> original_pSignalSemaphores = {}; + if (pSubmits) { + for (uint32_t index0=0; index0<submitCount; ++index0) { + if (pSubmits[index0].pWaitSemaphores) { + for (uint32_t index1=0; index1<pSubmits[index0].waitSemaphoreCount; ++index1) { + VkSemaphore** ppSemaphore = (VkSemaphore**)&(pSubmits[index0].pWaitSemaphores); + original_pWaitSemaphores.push_back(pSubmits[index0].pWaitSemaphores[index1]); + *(ppSemaphore[index1]) = (VkSemaphore)((VkUniqueObject*)pSubmits[index0].pWaitSemaphores[index1])->actualObject; + } + } + if (pSubmits[index0].pSignalSemaphores) { + for (uint32_t index1=0; index1<pSubmits[index0].signalSemaphoreCount; ++index1) { + VkSemaphore** ppSemaphore = (VkSemaphore**)&(pSubmits[index0].pSignalSemaphores); + original_pSignalSemaphores.push_back(pSubmits[index0].pSignalSemaphores[index1]); + *(ppSemaphore[index1]) = (VkSemaphore)((VkUniqueObject*)pSubmits[index0].pSignalSemaphores[index1])->actualObject; + } + } + } + } + VkResult result = get_dispatch_table(unique_objects_device_table_map, queue)->QueueSubmit(queue, submitCount, pSubmits, fence); + if (pSubmits) { + for (uint32_t index0=0; index0<submitCount; ++index0) { + if (pSubmits[index0].pWaitSemaphores) { + for (uint32_t index1=0; index1<pSubmits[index0].waitSemaphoreCount; ++index1) { + VkSemaphore** ppSemaphore = (VkSemaphore**)&(pSubmits[index0].pWaitSemaphores); + *(ppSemaphore[index1]) = original_pWaitSemaphores[index1]; + } + } + if (pSubmits[index0].pSignalSemaphores) { + for (uint32_t index1=0; index1<pSubmits[index0].signalSemaphoreCount; ++index1) { + VkSemaphore** ppSemaphore = (VkSemaphore**)&(pSubmits[index0].pSignalSemaphores); + *(ppSemaphore[index1]) = original_pSignalSemaphores[index1]; + } + } + } + } + return result; +} + +VkResult explicit_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) +{ +// UNWRAP USES: +// 0 : pBindInfo[bindInfoCount]->pBufferBinds[bufferBindCount]->buffer,VkBuffer, pBindInfo[bindInfoCount]->pBufferBinds[bufferBindCount]->pBinds[bindCount]->memory,VkDeviceMemory, pBindInfo[bindInfoCount]->pImageOpaqueBinds[imageOpaqueBindCount]->image,VkImage, pBindInfo[bindInfoCount]->pImageOpaqueBinds[imageOpaqueBindCount]->pBinds[bindCount]->memory,VkDeviceMemory, pBindInfo[bindInfoCount]->pImageBinds[imageBindCount]->image,VkImage, pBindInfo[bindInfoCount]->pImageBinds[imageBindCount]->pBinds[bindCount]->memory,VkDeviceMemory + std::vector<VkBuffer> original_buffer = {}; + std::vector<VkDeviceMemory> original_memory1 = {}; + std::vector<VkImage> original_image1 = {}; + std::vector<VkDeviceMemory> original_memory2 = {}; + std::vector<VkImage> original_image2 = {}; + std::vector<VkDeviceMemory> original_memory3 = {}; + std::vector<VkSemaphore> original_pWaitSemaphores = {}; + std::vector<VkSemaphore> original_pSignalSemaphores = {}; + if (pBindInfo) { + for (uint32_t index0=0; index0<bindInfoCount; ++index0) { + if (pBindInfo[index0].pBufferBinds) { + for (uint32_t index1=0; index1<pBindInfo[index0].bufferBindCount; ++index1) { + if (pBindInfo[index0].pBufferBinds[index1].buffer) { + VkBuffer* pBuffer = (VkBuffer*)&(pBindInfo[index0].pBufferBinds[index1].buffer); + original_buffer.push_back(pBindInfo[index0].pBufferBinds[index1].buffer); + *(pBuffer) = (VkBuffer)((VkUniqueObject*)pBindInfo[index0].pBufferBinds[index1].buffer)->actualObject; + } + if (pBindInfo[index0].pBufferBinds[index1].pBinds) { + for (uint32_t index2=0; index2<pBindInfo[index0].pBufferBinds[index1].bindCount; ++index2) { + if (pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory) { + VkDeviceMemory* pDeviceMemory = (VkDeviceMemory*)&(pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory); + original_memory1.push_back(pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory); + *(pDeviceMemory) = (VkDeviceMemory)((VkUniqueObject*)pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory)->actualObject; + } + } + } + } + } + if (pBindInfo[index0].pImageOpaqueBinds) { + for (uint32_t index1=0; index1<pBindInfo[index0].imageOpaqueBindCount; ++index1) { + if (pBindInfo[index0].pImageOpaqueBinds[index1].image) { + VkImage* pImage = (VkImage*)&(pBindInfo[index0].pImageOpaqueBinds[index1].image); + original_image1.push_back(pBindInfo[index0].pImageOpaqueBinds[index1].image); + *(pImage) = (VkImage)((VkUniqueObject*)pBindInfo[index0].pImageOpaqueBinds[index1].image)->actualObject; + } + if (pBindInfo[index0].pImageOpaqueBinds[index1].pBinds) { + for (uint32_t index2=0; index2<pBindInfo[index0].pImageOpaqueBinds[index1].bindCount; ++index2) { + if (pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory) { + VkDeviceMemory* pDeviceMemory = (VkDeviceMemory*)&(pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory); + original_memory2.push_back(pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory); + *(pDeviceMemory) = (VkDeviceMemory)((VkUniqueObject*)pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory)->actualObject; + } + } + } + } + } + if (pBindInfo[index0].pImageBinds) { + for (uint32_t index1=0; index1<pBindInfo[index0].imageBindCount; ++index1) { + if (pBindInfo[index0].pImageBinds[index1].image) { + VkImage* pImage = (VkImage*)&(pBindInfo[index0].pImageBinds[index1].image); + original_image2.push_back(pBindInfo[index0].pImageBinds[index1].image); + *(pImage) = (VkImage)((VkUniqueObject*)pBindInfo[index0].pImageBinds[index1].image)->actualObject; + } + if (pBindInfo[index0].pImageBinds[index1].pBinds) { + for (uint32_t index2=0; index2<pBindInfo[index0].pImageBinds[index1].bindCount; ++index2) { + if (pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory) { + VkDeviceMemory* pDeviceMemory = (VkDeviceMemory*)&(pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory); + original_memory3.push_back(pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory); + *(pDeviceMemory) = (VkDeviceMemory)((VkUniqueObject*)pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory)->actualObject; + } + } + } + } + } + if (pBindInfo[index0].pWaitSemaphores) { + for (uint32_t index1=0; index1<pBindInfo[index0].waitSemaphoreCount; ++index1) { + VkSemaphore** ppSemaphore = (VkSemaphore**)&(pBindInfo[index0].pWaitSemaphores); + original_pWaitSemaphores.push_back(pBindInfo[index0].pWaitSemaphores[index1]); + *(ppSemaphore[index1]) = (VkSemaphore)((VkUniqueObject*)pBindInfo[index0].pWaitSemaphores[index1])->actualObject; + } + } + if (pBindInfo[index0].pSignalSemaphores) { + for (uint32_t index1=0; index1<pBindInfo[index0].signalSemaphoreCount; ++index1) { + VkSemaphore** ppSemaphore = (VkSemaphore**)&(pBindInfo[index0].pSignalSemaphores); + original_pSignalSemaphores.push_back(pBindInfo[index0].pSignalSemaphores[index1]); + *(ppSemaphore[index1]) = (VkSemaphore)((VkUniqueObject*)pBindInfo[index0].pSignalSemaphores[index1])->actualObject; + } + } + } + } + if (VK_NULL_HANDLE != fence) { + fence = (VkFence)((VkUniqueObject*)fence)->actualObject; + } + VkResult result = get_dispatch_table(unique_objects_device_table_map, queue)->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); + if (pBindInfo) { + for (uint32_t index0=0; index0<bindInfoCount; ++index0) { + if (pBindInfo[index0].pBufferBinds) { + for (uint32_t index1=0; index1<pBindInfo[index0].bufferBindCount; ++index1) { + if (pBindInfo[index0].pBufferBinds[index1].buffer) { + VkBuffer* pBuffer = (VkBuffer*)&(pBindInfo[index0].pBufferBinds[index1].buffer); + *(pBuffer) = original_buffer[index1]; + } + if (pBindInfo[index0].pBufferBinds[index1].pBinds) { + for (uint32_t index2=0; index2<pBindInfo[index0].pBufferBinds[index1].bindCount; ++index2) { + if (pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory) { + VkDeviceMemory* pDeviceMemory = (VkDeviceMemory*)&(pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory); + *(pDeviceMemory) = original_memory1[index2]; + } + } + } + } + } + if (pBindInfo[index0].pImageOpaqueBinds) { + for (uint32_t index1=0; index1<pBindInfo[index0].imageOpaqueBindCount; ++index1) { + if (pBindInfo[index0].pImageOpaqueBinds[index1].image) { + VkImage* pImage = (VkImage*)&(pBindInfo[index0].pImageOpaqueBinds[index1].image); + *(pImage) = original_image1[index1]; + } + if (pBindInfo[index0].pImageOpaqueBinds[index1].pBinds) { + for (uint32_t index2=0; index2<pBindInfo[index0].pImageOpaqueBinds[index1].bindCount; ++index2) { + if (pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory) { + VkDeviceMemory* pDeviceMemory = (VkDeviceMemory*)&(pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory); + *(pDeviceMemory) = original_memory2[index2]; + } + } + } + } + } + if (pBindInfo[index0].pImageBinds) { + for (uint32_t index1=0; index1<pBindInfo[index0].imageBindCount; ++index1) { + if (pBindInfo[index0].pImageBinds[index1].image) { + VkImage* pImage = (VkImage*)&(pBindInfo[index0].pImageBinds[index1].image); + *(pImage) = original_image2[index1]; + } + if (pBindInfo[index0].pImageBinds[index1].pBinds) { + for (uint32_t index2=0; index2<pBindInfo[index0].pImageBinds[index1].bindCount; ++index2) { + if (pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory) { + VkDeviceMemory* pDeviceMemory = (VkDeviceMemory*)&(pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory); + *(pDeviceMemory) = original_memory3[index2]; + } + } + } + } + } + if (pBindInfo[index0].pWaitSemaphores) { + for (uint32_t index1=0; index1<pBindInfo[index0].waitSemaphoreCount; ++index1) { + VkSemaphore** ppSemaphore = (VkSemaphore**)&(pBindInfo[index0].pWaitSemaphores); + *(ppSemaphore[index1]) = original_pWaitSemaphores[index1]; + } + } + if (pBindInfo[index0].pSignalSemaphores) { + for (uint32_t index1=0; index1<pBindInfo[index0].signalSemaphoreCount; ++index1) { + VkSemaphore** ppSemaphore = (VkSemaphore**)&(pBindInfo[index0].pSignalSemaphores); + *(ppSemaphore[index1]) = original_pSignalSemaphores[index1]; + } + } + } + } + return result; +} + +VkResult explicit_CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ +// UNWRAP USES: +// 0 : pipelineCache,VkPipelineCache, pCreateInfos[createInfoCount]->stage[0]->module,VkShaderModule, pCreateInfos[createInfoCount]->layout,VkPipelineLayout, pCreateInfos[createInfoCount]->basePipelineHandle,VkPipeline + if (VK_NULL_HANDLE != pipelineCache) { + pipelineCache = (VkPipelineCache)((VkUniqueObject*)pipelineCache)->actualObject; + } + std::vector<VkShaderModule> original_module = {}; + std::vector<VkPipelineLayout> original_layout = {}; + std::vector<VkPipeline> original_basePipelineHandle = {}; + if (pCreateInfos) { + for (uint32_t index0=0; index0<createInfoCount; ++index0) { + if (pCreateInfos[index0].stage.module) { + VkShaderModule* pShaderModule = (VkShaderModule*)&(pCreateInfos[index0].stage.module); + original_module.push_back(pCreateInfos[index0].stage.module); + *(pShaderModule) = (VkShaderModule)((VkUniqueObject*)pCreateInfos[index0].stage.module)->actualObject; + } + if (pCreateInfos[index0].layout) { + VkPipelineLayout* pPipelineLayout = (VkPipelineLayout*)&(pCreateInfos[index0].layout); + original_layout.push_back(pCreateInfos[index0].layout); + *(pPipelineLayout) = (VkPipelineLayout)((VkUniqueObject*)pCreateInfos[index0].layout)->actualObject; + } + if (pCreateInfos[index0].basePipelineHandle) { + VkPipeline* pPipeline = (VkPipeline*)&(pCreateInfos[index0].basePipelineHandle); + original_basePipelineHandle.push_back(pCreateInfos[index0].basePipelineHandle); + *(pPipeline) = (VkPipeline)((VkUniqueObject*)pCreateInfos[index0].basePipelineHandle)->actualObject; + } + } + } + VkResult result = get_dispatch_table(unique_objects_device_table_map, device)->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + if (pCreateInfos) { + for (uint32_t index0=0; index0<createInfoCount; ++index0) { + if (pCreateInfos[index0].stage.module) { + VkShaderModule* pShaderModule = (VkShaderModule*)&(pCreateInfos[index0].stage.module); + *(pShaderModule) = original_module[index0]; + } + if (pCreateInfos[index0].layout) { + VkPipelineLayout* pPipelineLayout = (VkPipelineLayout*)&(pCreateInfos[index0].layout); + *(pPipelineLayout) = original_layout[index0]; + } + if (pCreateInfos[index0].basePipelineHandle) { + VkPipeline* pPipeline = (VkPipeline*)&(pCreateInfos[index0].basePipelineHandle); + *(pPipeline) = original_basePipelineHandle[index0]; + } + } + } + if (VK_SUCCESS == result) { + std::vector<VkUniqueObject*> uniquePipelines = {}; + for (uint32_t i=0; i<createInfoCount; ++i) { + uniquePipelines.push_back(new VkUniqueObject()); + uniquePipelines[i]->actualObject = (uint64_t)pPipelines[i]; + pPipelines[i] = (VkPipeline)uniquePipelines[i]; + } + } + return result; +} + +VkResult explicit_CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ +// UNWRAP USES: +// 0 : pipelineCache,VkPipelineCache, pCreateInfos[createInfoCount]->pStages[stageCount]->module,VkShaderModule, pCreateInfos[createInfoCount]->layout,VkPipelineLayout, pCreateInfos[createInfoCount]->renderPass,VkRenderPass, pCreateInfos[createInfoCount]->basePipelineHandle,VkPipeline + if (VK_NULL_HANDLE != pipelineCache) { + pipelineCache = (VkPipelineCache)((VkUniqueObject*)pipelineCache)->actualObject; + } + std::vector<VkShaderModule> original_module = {}; + std::vector<VkPipelineLayout> original_layout = {}; + std::vector<VkRenderPass> original_renderPass = {}; + std::vector<VkPipeline> original_basePipelineHandle = {}; + if (pCreateInfos) { + for (uint32_t index0=0; index0<createInfoCount; ++index0) { + if (pCreateInfos[index0].pStages) { + for (uint32_t index1=0; index1<pCreateInfos[index0].stageCount; ++index1) { + if (pCreateInfos[index0].pStages[index1].module) { + VkShaderModule* pShaderModule = (VkShaderModule*)&(pCreateInfos[index0].pStages[index1].module); + original_module.push_back(pCreateInfos[index0].pStages[index1].module); + *(pShaderModule) = (VkShaderModule)((VkUniqueObject*)pCreateInfos[index0].pStages[index1].module)->actualObject; + } + } + } + if (pCreateInfos[index0].layout) { + VkPipelineLayout* pPipelineLayout = (VkPipelineLayout*)&(pCreateInfos[index0].layout); + original_layout.push_back(pCreateInfos[index0].layout); + *(pPipelineLayout) = (VkPipelineLayout)((VkUniqueObject*)pCreateInfos[index0].layout)->actualObject; + } + if (pCreateInfos[index0].renderPass) { + VkRenderPass* pRenderPass = (VkRenderPass*)&(pCreateInfos[index0].renderPass); + original_renderPass.push_back(pCreateInfos[index0].renderPass); + *(pRenderPass) = (VkRenderPass)((VkUniqueObject*)pCreateInfos[index0].renderPass)->actualObject; + } + if (pCreateInfos[index0].basePipelineHandle) { + VkPipeline* pPipeline = (VkPipeline*)&(pCreateInfos[index0].basePipelineHandle); + original_basePipelineHandle.push_back(pCreateInfos[index0].basePipelineHandle); + *(pPipeline) = (VkPipeline)((VkUniqueObject*)pCreateInfos[index0].basePipelineHandle)->actualObject; + } + } + } + VkResult result = get_dispatch_table(unique_objects_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + if (pCreateInfos) { + for (uint32_t index0=0; index0<createInfoCount; ++index0) { + if (pCreateInfos[index0].pStages) { + for (uint32_t index1=0; index1<pCreateInfos[index0].stageCount; ++index1) { + if (pCreateInfos[index0].pStages[index1].module) { + VkShaderModule* pShaderModule = (VkShaderModule*)&(pCreateInfos[index0].pStages[index1].module); + *(pShaderModule) = original_module[index1]; + } + } + } + if (pCreateInfos[index0].layout) { + VkPipelineLayout* pPipelineLayout = (VkPipelineLayout*)&(pCreateInfos[index0].layout); + *(pPipelineLayout) = original_layout[index0]; + } + if (pCreateInfos[index0].renderPass) { + VkRenderPass* pRenderPass = (VkRenderPass*)&(pCreateInfos[index0].renderPass); + *(pRenderPass) = original_renderPass[index0]; + } + if (pCreateInfos[index0].basePipelineHandle) { + VkPipeline* pPipeline = (VkPipeline*)&(pCreateInfos[index0].basePipelineHandle); + *(pPipeline) = original_basePipelineHandle[index0]; + } + } + } + if (VK_SUCCESS == result) { + std::vector<VkUniqueObject*> uniquePipelines = {}; + for (uint32_t i=0; i<createInfoCount; ++i) { + uniquePipelines.push_back(new VkUniqueObject()); + uniquePipelines[i]->actualObject = (uint64_t)pPipelines[i]; + pPipelines[i] = (VkPipeline)uniquePipelines[i]; + } + } + return result; +} + +void explicit_UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) +{ +// UNWRAP USES: +// 0 : pDescriptorWrites[descriptorWriteCount]->dstSet,VkDescriptorSet, pDescriptorWrites[descriptorWriteCount]->pImageInfo[descriptorCount]->sampler,VkSampler, pDescriptorWrites[descriptorWriteCount]->pImageInfo[descriptorCount]->imageView,VkImageView, pDescriptorWrites[descriptorWriteCount]->pBufferInfo[descriptorCount]->buffer,VkBuffer, pDescriptorCopies[descriptorCopyCount]->srcSet,VkDescriptorSet, pDescriptorCopies[descriptorCopyCount]->dstSet,VkDescriptorSet + std::vector<VkDescriptorSet> original_dstSet1 = {}; + std::vector<VkSampler> original_sampler = {}; + std::vector<VkImageView> original_imageView = {}; + std::vector<VkBuffer> original_buffer = {}; + std::vector<VkDescriptorSet> original_srcSet = {}; + std::vector<VkDescriptorSet> original_dstSet2 = {}; +// descriptorCount : pDescriptorWrites[descriptorWriteCount]->pTexelBufferView,VkBufferView + std::vector<VkBufferView> original_pTexelBufferView = {}; + if (pDescriptorWrites) { + for (uint32_t index0=0; index0<descriptorWriteCount; ++index0) { + if (pDescriptorWrites[index0].dstSet) { + VkDescriptorSet* pDescriptorSet = (VkDescriptorSet*)&(pDescriptorWrites[index0].dstSet); + original_dstSet1.push_back(pDescriptorWrites[index0].dstSet); + *(pDescriptorSet) = (VkDescriptorSet)((VkUniqueObject*)pDescriptorWrites[index0].dstSet)->actualObject; + } + if (pDescriptorWrites[index0].pImageInfo) { + for (uint32_t index1=0; index1<pDescriptorWrites[index0].descriptorCount; ++index1) { + if (pDescriptorWrites[index0].pImageInfo[index1].sampler) { + VkSampler* pSampler = (VkSampler*)&(pDescriptorWrites[index0].pImageInfo[index1].sampler); + original_sampler.push_back(pDescriptorWrites[index0].pImageInfo[index1].sampler); + *(pSampler) = (VkSampler)((VkUniqueObject*)pDescriptorWrites[index0].pImageInfo[index1].sampler)->actualObject; + } + if (pDescriptorWrites[index0].pImageInfo[index1].imageView) { + VkImageView* pImageView = (VkImageView*)&(pDescriptorWrites[index0].pImageInfo[index1].imageView); + original_imageView.push_back(pDescriptorWrites[index0].pImageInfo[index1].imageView); + *(pImageView) = (VkImageView)((VkUniqueObject*)pDescriptorWrites[index0].pImageInfo[index1].imageView)->actualObject; + } + } + } + if (pDescriptorWrites[index0].pBufferInfo) { + for (uint32_t index1=0; index1<pDescriptorWrites[index0].descriptorCount; ++index1) { + if (pDescriptorWrites[index0].pBufferInfo[index1].buffer) { + VkBuffer* pBuffer = (VkBuffer*)&(pDescriptorWrites[index0].pBufferInfo[index1].buffer); + original_buffer.push_back(pDescriptorWrites[index0].pBufferInfo[index1].buffer); + *(pBuffer) = (VkBuffer)((VkUniqueObject*)pDescriptorWrites[index0].pBufferInfo[index1].buffer)->actualObject; + } + } + } + if (pDescriptorWrites[index0].pTexelBufferView) { + for (uint32_t index1=0; index1<pDescriptorWrites[index0].descriptorCount; ++index1) { + VkBufferView** ppBufferView = (VkBufferView**)&(pDescriptorWrites[index0].pTexelBufferView); + original_pTexelBufferView.push_back(pDescriptorWrites[index0].pTexelBufferView[index1]); + *(ppBufferView[index1]) = (VkBufferView)((VkUniqueObject*)pDescriptorWrites[index0].pTexelBufferView[index1])->actualObject; + } + } + } + } + if (pDescriptorCopies) { + for (uint32_t index0=0; index0<descriptorCopyCount; ++index0) { + if (pDescriptorCopies[index0].srcSet) { + VkDescriptorSet* pDescriptorSet = (VkDescriptorSet*)&(pDescriptorCopies[index0].srcSet); + original_srcSet.push_back(pDescriptorCopies[index0].srcSet); + *(pDescriptorSet) = (VkDescriptorSet)((VkUniqueObject*)pDescriptorCopies[index0].srcSet)->actualObject; + } + if (pDescriptorCopies[index0].dstSet) { + VkDescriptorSet* pDescriptorSet = (VkDescriptorSet*)&(pDescriptorCopies[index0].dstSet); + original_dstSet2.push_back(pDescriptorCopies[index0].dstSet); + *(pDescriptorSet) = (VkDescriptorSet)((VkUniqueObject*)pDescriptorCopies[index0].dstSet)->actualObject; + } + } + } + get_dispatch_table(unique_objects_device_table_map, device)->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); + if (pDescriptorWrites) { + for (uint32_t index0=0; index0<descriptorWriteCount; ++index0) { + if (pDescriptorWrites[index0].dstSet) { + VkDescriptorSet* pDescriptorSet = (VkDescriptorSet*)&(pDescriptorWrites[index0].dstSet); + *(pDescriptorSet) = original_dstSet1[index0]; + } + if (pDescriptorWrites[index0].pImageInfo) { + for (uint32_t index1=0; index1<pDescriptorWrites[index0].descriptorCount; ++index1) { + if (pDescriptorWrites[index0].pImageInfo[index1].sampler) { + VkSampler* pSampler = (VkSampler*)&(pDescriptorWrites[index0].pImageInfo[index1].sampler); + *(pSampler) = original_sampler[index1]; + } + if (pDescriptorWrites[index0].pImageInfo[index1].imageView) { + VkImageView* pImageView = (VkImageView*)&(pDescriptorWrites[index0].pImageInfo[index1].imageView); + *(pImageView) = original_imageView[index1]; + } + } + } + if (pDescriptorWrites[index0].pBufferInfo) { + for (uint32_t index1=0; index1<pDescriptorWrites[index0].descriptorCount; ++index1) { + if (pDescriptorWrites[index0].pBufferInfo[index1].buffer) { + VkBuffer* pBuffer = (VkBuffer*)&(pDescriptorWrites[index0].pBufferInfo[index1].buffer); + *(pBuffer) = original_buffer[index1]; + } + } + } + if (pDescriptorWrites[index0].pTexelBufferView) { + for (uint32_t index1=0; index1<pDescriptorWrites[index0].descriptorCount; ++index1) { + VkBufferView** ppBufferView = (VkBufferView**)&(pDescriptorWrites[index0].pTexelBufferView); + *(ppBufferView[index1]) = original_pTexelBufferView[index1]; + } + } + } + } + if (pDescriptorCopies) { + for (uint32_t index0=0; index0<descriptorCopyCount; ++index0) { + if (pDescriptorCopies[index0].srcSet) { + VkDescriptorSet* pDescriptorSet = (VkDescriptorSet*)&(pDescriptorCopies[index0].srcSet); + *(pDescriptorSet) = original_srcSet[index0]; + } + if (pDescriptorCopies[index0].dstSet) { + VkDescriptorSet* pDescriptorSet = (VkDescriptorSet*)&(pDescriptorCopies[index0].dstSet); + *(pDescriptorSet) = original_dstSet2[index0]; + } + } + } +} + +VkResult explicit_GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) +{ +// UNWRAP USES: +// 0 : swapchain,VkSwapchainKHR, pSwapchainImages,VkImage + if (VK_NULL_HANDLE != swapchain) { + swapchain = (VkSwapchainKHR)((VkUniqueObject*)swapchain)->actualObject; + } + VkResult result = get_dispatch_table(unique_objects_device_table_map, device)->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); + // TODO : Need to add corresponding code to delete these images + if (VK_SUCCESS == result) { + if ((*pSwapchainImageCount > 0) && pSwapchainImages) { + std::vector<VkUniqueObject*> uniqueImages = {}; + for (uint32_t i=0; i<*pSwapchainImageCount; ++i) { + uniqueImages.push_back(new VkUniqueObject()); + uniqueImages[i]->actualObject = (uint64_t)pSwapchainImages[i]; + pSwapchainImages[i] = (VkImage)uniqueImages[i]; + } + } + } + return result; +} diff --git a/layers/windows/VkLayer_unique_objects.json b/layers/windows/VkLayer_unique_objects.json new file mode 100644 index 00000000..8e046ef2 --- /dev/null +++ b/layers/windows/VkLayer_unique_objects.json @@ -0,0 +1,11 @@ +{ + "file_format_version" : "1.0.0", + "layer" : { + "name": "VK_LAYER_GOOGLE_unique_objects", + "type": "GLOBAL", + "library_path": ".\\VkLayer_unique_objects.dll", + "api_version": "0.210.0", + "implementation_version": "1", + "description": "Google Validation Layer" + } +} |