From ee3ba1acdc5f2555cf0483e37d2a07c693484642 Mon Sep 17 00:00:00 2001 From: Dustin Graves Date: Tue, 28 Mar 2017 14:18:54 -0600 Subject: layers: Fix extension func/core struct codegen Fix code generation for extension functions receiving struct parameter types defined by core Vulkan. Extensions are processed as separate features by the code generator, and the type info required for structure generation was not being shared across features. The code generator has been modified to share type info across features so that the validation code generated for extension functions includes validation for core structures: - Prevent unique objects and parameter validation code generators from clearing struct type info data structures at the start of feature processing. - Remove unused data structures from unique objects code generator. - Adds handle unwrapping and parameter validation for elements in the vkCmdPushDescriptorSetKHR pDescriptorWrites parameter. - Adds handle unwrapping and parameter validation for elements in the vkCreateSharedSwapCHainsKHR pCreateInfos parameter. - Adds VkAllocationCallback parameter validation to the WSI and descriptor update template extensions functions. Change-Id: I016aa6550681dbf7d6bda834272374ce63ed1940 --- layers/unique_objects.cpp | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) (limited to 'layers/unique_objects.cpp') diff --git a/layers/unique_objects.cpp b/layers/unique_objects.cpp index f6d78fef..4d7722ba 100644 --- a/layers/unique_objects.cpp +++ b/layers/unique_objects.cpp @@ -581,6 +581,45 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapc return result; } +VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, + const VkSwapchainCreateInfoKHR *pCreateInfos, + const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains) { + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + safe_VkSwapchainCreateInfoKHR *local_pCreateInfos = NULL; + { + std::lock_guard lock(global_lock); + if (pCreateInfos) { + // Need to pull surface mapping from the instance-level map + layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(dev_data->gpu), layer_data_map); + local_pCreateInfos = new safe_VkSwapchainCreateInfoKHR[swapchainCount]; + for (uint32_t i = 0; i < swapchainCount; ++i) { + local_pCreateInfos[i].initialize(&pCreateInfos[i]); + if (pCreateInfos[i].surface) { + local_pCreateInfos[i].surface = + (VkSurfaceKHR)instance_data->unique_id_mapping[reinterpret_cast(pCreateInfos[i].surface)]; + } + if (pCreateInfos[i].oldSwapchain) { + local_pCreateInfos[i].oldSwapchain = + (VkSwapchainKHR) + dev_data->unique_id_mapping[reinterpret_cast(pCreateInfos[i].oldSwapchain)]; + } + } + } + } + VkResult result = dev_data->device_dispatch_table->CreateSharedSwapchainsKHR( + device, swapchainCount, (const VkSwapchainCreateInfoKHR *)local_pCreateInfos, pAllocator, pSwapchains); + if (local_pCreateInfos) delete[] local_pCreateInfos; + if (VK_SUCCESS == result) { + std::lock_guard lock(global_lock); + for (uint32_t i = 0; i < swapchainCount; i++) { + uint64_t unique_id = global_unique_id++; + dev_data->unique_id_mapping[unique_id] = reinterpret_cast(pSwapchains[i]); + pSwapchains[i] = reinterpret_cast(unique_id); + } + } + return result; +} + VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) { layer_data *my_device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); -- cgit v1.2.3