diff options
Diffstat (limited to 'layers/core_validation.cpp')
| -rw-r--r-- | layers/core_validation.cpp | 336 |
1 files changed, 168 insertions, 168 deletions
diff --git a/layers/core_validation.cpp b/layers/core_validation.cpp index 396df59e..3951a8fb 100644 --- a/layers/core_validation.cpp +++ b/layers/core_validation.cpp @@ -3846,7 +3846,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreat VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance); if (result != VK_SUCCESS) return result; - instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(*pInstance), instance_layer_data_map); + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(*pInstance), instance_layer_data_map); instance_data->instance = *pInstance; layer_init_instance_dispatch_table(*pInstance, &instance_data->dispatch_table, fpGetInstanceProcAddr); instance_data->report_data = debug_report_create_instance( @@ -3865,7 +3865,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocati dispatch_key key = get_dispatch_key(instance); // TBD: Need any locking this early, in case this function is called at the // same time by more than one thread? - instance_layer_data *instance_data = get_my_data_ptr(key, instance_layer_data_map); + instance_layer_data *instance_data = GetLayerDataPtr(key, instance_layer_data_map); instance_data->dispatch_table.DestroyInstance(instance, pAllocator); std::lock_guard<std::mutex> lock(global_lock); @@ -3883,7 +3883,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocati static void checkDeviceRegisterExtensions(const VkDeviceCreateInfo *pCreateInfo, VkDevice device) { uint32_t i; // TBD: Need any locking, in case this function is called at the same time by more than one thread? - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); dev_data->device_extensions.wsi_enabled = false; dev_data->device_extensions.wsi_display_swapchain_enabled = false; dev_data->device_extensions.nv_glsl_shader_enabled = false; @@ -3978,14 +3978,14 @@ static bool ValidateRequestedFeatures(instance_layer_data *dev_data, VkPhysicalD VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) { - instance_layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), instance_layer_data_map); + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(gpu), instance_layer_data_map); bool skip_call = false; // Check that any requested features are available if (pCreateInfo->pEnabledFeatures) { - skip_call |= ValidateRequestedFeatures(my_instance_data, gpu, pCreateInfo->pEnabledFeatures); + skip_call |= ValidateRequestedFeatures(instance_data, gpu, pCreateInfo->pEnabledFeatures); } - skip_call |= ValidateRequestedQueueFamilyProperties(my_instance_data, gpu, pCreateInfo); + skip_call |= ValidateRequestedQueueFamilyProperties(instance_data, gpu, pCreateInfo); if (skip_call) { return VK_ERROR_VALIDATION_FAILED_EXT; @@ -3996,7 +3996,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDevice assert(chain_info->u.pLayerInfo); PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr; - PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(my_instance_data->instance, "vkCreateDevice"); + PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(instance_data->instance, "vkCreateDevice"); if (fpCreateDevice == NULL) { return VK_ERROR_INITIALIZATION_FAILED; } @@ -4010,33 +4010,33 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDevice } std::unique_lock<std::mutex> lock(global_lock); - layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map); + layer_data *device_data = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map); - my_device_data->instance_data = my_instance_data; + device_data->instance_data = instance_data; // Setup device dispatch table - layer_init_device_dispatch_table(*pDevice, &my_device_data->dispatch_table, fpGetDeviceProcAddr); - my_device_data->device = *pDevice; + layer_init_device_dispatch_table(*pDevice, &device_data->dispatch_table, fpGetDeviceProcAddr); + device_data->device = *pDevice; // Save PhysicalDevice handle - my_device_data->physical_device = gpu; + device_data->physical_device = gpu; - my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice); + device_data->report_data = layer_debug_report_create_device(instance_data->report_data, *pDevice); checkDeviceRegisterExtensions(pCreateInfo, *pDevice); // Get physical device limits for this device - my_instance_data->dispatch_table.GetPhysicalDeviceProperties(gpu, &(my_device_data->phys_dev_properties.properties)); + instance_data->dispatch_table.GetPhysicalDeviceProperties(gpu, &(device_data->phys_dev_properties.properties)); uint32_t count; - my_instance_data->dispatch_table.GetPhysicalDeviceQueueFamilyProperties(gpu, &count, nullptr); - my_device_data->phys_dev_properties.queue_family_properties.resize(count); - my_instance_data->dispatch_table.GetPhysicalDeviceQueueFamilyProperties( - gpu, &count, &my_device_data->phys_dev_properties.queue_family_properties[0]); + instance_data->dispatch_table.GetPhysicalDeviceQueueFamilyProperties(gpu, &count, nullptr); + device_data->phys_dev_properties.queue_family_properties.resize(count); + instance_data->dispatch_table.GetPhysicalDeviceQueueFamilyProperties( + gpu, &count, &device_data->phys_dev_properties.queue_family_properties[0]); // TODO: device limits should make sure these are compatible if (pCreateInfo->pEnabledFeatures) { - my_device_data->enabled_features = *pCreateInfo->pEnabledFeatures; + device_data->enabled_features = *pCreateInfo->pEnabledFeatures; } else { - memset(&my_device_data->enabled_features, 0, sizeof(VkPhysicalDeviceFeatures)); + memset(&device_data->enabled_features, 0, sizeof(VkPhysicalDeviceFeatures)); } // Store physical device properties and physical device mem limits into device layer_data structs - my_instance_data->dispatch_table.GetPhysicalDeviceMemoryProperties(gpu, &my_device_data->phys_dev_mem_props); - my_instance_data->dispatch_table.GetPhysicalDeviceProperties(gpu, &my_device_data->phys_dev_props); + instance_data->dispatch_table.GetPhysicalDeviceMemoryProperties(gpu, &device_data->phys_dev_mem_props); + instance_data->dispatch_table.GetPhysicalDeviceProperties(gpu, &device_data->phys_dev_props); lock.unlock(); ValidateLayerOrdering(*pCreateInfo); @@ -4049,7 +4049,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCall // TODOSC : Shouldn't need any customization here bool skip = false; dispatch_key key = get_dispatch_key(device); - layer_data *dev_data = get_my_data_ptr(key, layer_data_map); + layer_data *dev_data = GetLayerDataPtr(key, layer_data_map); // Free all the memory std::unique_lock<std::mutex> lock(global_lock); deletePipelines(dev_data); @@ -4507,7 +4507,7 @@ static bool ValidateFenceForSubmit(layer_data *dev_data, FENCE_NODE *pFence) { VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; std::unique_lock<std::mutex> lock(global_lock); @@ -4640,7 +4640,7 @@ static void PostCallRecordAllocateMemory(layer_data *dev_data, const VkMemoryAll VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); bool skip = PreCallValidateAllocateMemory(dev_data); if (!skip) { @@ -4708,7 +4708,7 @@ static void PostCallRecordFreeMemory(layer_data *dev_data, VkDeviceMemory mem, D } VKAPI_ATTR void VKAPI_CALL FreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); DEVICE_MEM_INFO *mem_info = nullptr; VK_OBJECT obj_struct; std::unique_lock<std::mutex> lock(global_lock); @@ -4894,7 +4894,7 @@ static void PostCallRecordWaitForFences(layer_data *dev_data, uint32_t fence_cou VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); // Verify fence status of submitted fences std::unique_lock<std::mutex> lock(global_lock); bool skip = PreCallValidateWaitForFences(dev_data, fenceCount, pFences); @@ -4919,7 +4919,7 @@ static bool PreCallValidateGetFenceStatus(layer_data *dev_data, VkFence fence) { static void PostCallRecordGetFenceStatus(layer_data *dev_data, VkFence fence) { RetireFence(dev_data, fence); } VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(VkDevice device, VkFence fence) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); bool skip = PreCallValidateGetFenceStatus(dev_data, fence); lock.unlock(); @@ -4946,7 +4946,7 @@ static void PostCallRecordGetDeviceQueue(layer_data *dev_data, uint32_t q_family } VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); dev_data->dispatch_table.GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); std::lock_guard<std::mutex> lock(global_lock); @@ -4964,7 +4964,7 @@ static void PostCallRecordQueueWaitIdle(layer_data *dev_data, QUEUE_STATE *queue } VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(VkQueue queue) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); QUEUE_STATE *queue_state = nullptr; std::unique_lock<std::mutex> lock(global_lock); bool skip = PreCallValidateQueueWaitIdle(dev_data, queue, &queue_state); @@ -4995,7 +4995,7 @@ static void PostCallRecordDeviceWaitIdle(layer_data *dev_data) { } VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(VkDevice device) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); bool skip = PreCallValidateDeviceWaitIdle(dev_data); lock.unlock(); @@ -5027,7 +5027,7 @@ static bool PreCallValidateDestroyFence(layer_data *dev_data, VkFence fence, FEN static void PostCallRecordDestroyFence(layer_data *dev_data, VkFence fence) { dev_data->fenceMap.erase(fence); } VKAPI_ATTR void VKAPI_CALL DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); // Common data objects used pre & post call FENCE_NODE *fence_node = nullptr; VK_OBJECT obj_struct; @@ -5057,7 +5057,7 @@ static bool PreCallValidateDestroySemaphore(layer_data *dev_data, VkSemaphore se static void PostCallRecordDestroySemaphore(layer_data *dev_data, VkSemaphore sema) { dev_data->semaphoreMap.erase(sema); } VKAPI_ATTR void VKAPI_CALL DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); SEMAPHORE_NODE *sema_node; VK_OBJECT obj_struct; std::unique_lock<std::mutex> lock(global_lock); @@ -5087,7 +5087,7 @@ static void PostCallRecordDestroyEvent(layer_data *dev_data, VkEvent event, EVEN } VKAPI_ATTR void VKAPI_CALL DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); EVENT_STATE *event_state = nullptr; VK_OBJECT obj_struct; std::unique_lock<std::mutex> lock(global_lock); @@ -5121,7 +5121,7 @@ static void PostCallRecordDestroyQueryPool(layer_data *dev_data, VkQueryPool que } VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); QUERY_POOL_NODE *qp_state = nullptr; VK_OBJECT obj_struct; std::unique_lock<std::mutex> lock(global_lock); @@ -5225,7 +5225,7 @@ static void PostCallRecordGetQueryPoolResults(layer_data *dev_data, VkQueryPool VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); unordered_map<QueryObject, vector<VkCommandBuffer>> queries_in_flight; std::unique_lock<std::mutex> lock(global_lock); bool skip = PreCallValidateGetQueryPoolResults(dev_data, queryPool, firstQuery, queryCount, flags, &queries_in_flight); @@ -5423,7 +5423,7 @@ static void PostCallRecordDestroyBuffer(layer_data *dev_data, VkBuffer buffer, B } VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); BUFFER_STATE *buffer_state = nullptr; VK_OBJECT obj_struct; std::unique_lock<std::mutex> lock(global_lock); @@ -5458,7 +5458,7 @@ static void PostCallRecordDestroyBufferView(layer_data *dev_data, VkBufferView b } VKAPI_ATTR void VKAPI_CALL DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); // Common data objects used pre & post call BUFFER_VIEW_STATE *buffer_view_state = nullptr; VK_OBJECT obj_struct; @@ -5476,7 +5476,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyBufferView(VkDevice device, VkBufferView buffe } VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); IMAGE_STATE *image_state = nullptr; VK_OBJECT obj_struct; std::unique_lock<std::mutex> lock(global_lock); @@ -5507,7 +5507,7 @@ static bool ValidateMemoryTypes(const layer_data *dev_data, const DEVICE_MEM_INF } VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; std::unique_lock<std::mutex> lock(global_lock); // Track objects tied to memory @@ -5595,7 +5595,7 @@ VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(VkDevice device, VkBuffer buffer VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); dev_data->dispatch_table.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); auto buffer_state = getBufferState(dev_data, buffer); if (buffer_state) { @@ -5605,7 +5605,7 @@ VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(VkDevice device, VkBuffer } VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); dev_data->dispatch_table.GetImageMemoryRequirements(device, image, pMemoryRequirements); auto image_state = getImageState(dev_data, image); if (image_state) { @@ -5634,7 +5634,7 @@ static void PostCallRecordDestroyImageView(layer_data *dev_data, VkImageView ima } VKAPI_ATTR void VKAPI_CALL DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); // Common data objects used pre & post call IMAGE_VIEW_STATE *image_view_state = nullptr; VK_OBJECT obj_struct; @@ -5652,7 +5652,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyImageView(VkDevice device, VkImageView imageVi VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); dev_data->shaderModuleMap.erase(shaderModule); @@ -5681,7 +5681,7 @@ static void PostCallRecordDestroyPipeline(layer_data *dev_data, VkPipeline pipel } VKAPI_ATTR void VKAPI_CALL DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); PIPELINE_STATE *pipeline_state = nullptr; VK_OBJECT obj_struct; std::unique_lock<std::mutex> lock(global_lock); @@ -5698,7 +5698,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyPipeline(VkDevice device, VkPipeline pipeline, VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); dev_data->pipelineLayoutMap.erase(pipelineLayout); lock.unlock(); @@ -5726,7 +5726,7 @@ static void PostCallRecordDestroySampler(layer_data *dev_data, VkSampler sampler } VKAPI_ATTR void VKAPI_CALL DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); SAMPLER_STATE *sampler_state = nullptr; VK_OBJECT obj_struct; std::unique_lock<std::mutex> lock(global_lock); @@ -5747,7 +5747,7 @@ static void PostCallRecordDestroyDescriptorSetLayout(layer_data *dev_data, VkDes VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); dev_data->dispatch_table.DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); std::unique_lock<std::mutex> lock(global_lock); PostCallRecordDestroyDescriptorSetLayout(dev_data, descriptorSetLayout); @@ -5778,7 +5778,7 @@ static void PostCallRecordDestroyDescriptorPool(layer_data *dev_data, VkDescript VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); DESCRIPTOR_POOL_STATE *desc_pool_state = nullptr; VK_OBJECT obj_struct; std::unique_lock<std::mutex> lock(global_lock); @@ -5833,7 +5833,7 @@ static void clearCommandBuffersInFlight(layer_data *dev_data, COMMAND_POOL_NODE VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); @@ -5869,7 +5869,7 @@ VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool com VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); @@ -5883,7 +5883,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(VkDevice device, const VkComman VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; if (pCreateInfo && pCreateInfo->queryType == VK_QUERY_TYPE_PIPELINE_STATISTICS) { if (!dev_data->enabled_features.pipelineStatisticsQuery) { @@ -5941,7 +5941,7 @@ static void PostCallRecordDestroyCommandPool(layer_data *dev_data, VkCommandPool // Destroy commandPool along with all of the commandBuffers allocated from that pool VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); COMMAND_POOL_NODE *cp_state = nullptr; std::unique_lock<std::mutex> lock(global_lock); bool skip = PreCallValidateDestroyCommandPool(dev_data, commandPool, &cp_state); @@ -5956,7 +5956,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool com } VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); @@ -5981,7 +5981,7 @@ VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool c } VKAPI_ATTR VkResult VKAPI_CALL ResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); for (uint32_t i = 0; i < fenceCount; ++i) { @@ -6045,7 +6045,7 @@ static void PostCallRecordDestroyFramebuffer(layer_data *dev_data, VkFramebuffer } VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); FRAMEBUFFER_STATE *framebuffer_state = nullptr; VK_OBJECT obj_struct; std::unique_lock<std::mutex> lock(global_lock); @@ -6079,7 +6079,7 @@ static void PostCallRecordDestroyRenderPass(layer_data *dev_data, VkRenderPass r } VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); RENDER_PASS_STATE *rp_state = nullptr; VK_OBJECT obj_struct; std::unique_lock<std::mutex> lock(global_lock); @@ -6096,7 +6096,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass rende VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); // TODO: Add check for VALIDATION_ERROR_00658 // TODO: Add check for VALIDATION_ERROR_00666 // TODO: Add check for VALIDATION_ERROR_00667 @@ -6129,7 +6129,7 @@ static bool PreCallValidateCreateBufferView(layer_data *dev_data, const VkBuffer VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); bool skip_call = PreCallValidateCreateBufferView(dev_data, pCreateInfo); lock.unlock(); @@ -6177,7 +6177,7 @@ std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_NODE> *GetImageLayoutMap(l VKAPI_ATTR VkResult VKAPI_CALL CreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = PreCallValidateCreateImage(dev_data, pCreateInfo, pAllocator, pImage); if (!skip) { result = dev_data->dispatch_table.CreateImage(device, pCreateInfo, pAllocator, pImage); @@ -6340,7 +6340,7 @@ static inline void PostCallRecordCreateImageView(layer_data *dev_data, const VkI VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); bool skip = PreCallValidateCreateImageView(dev_data, pCreateInfo); lock.unlock(); @@ -6357,7 +6357,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(VkDevice device, const VkImageVie VKAPI_ATTR VkResult VKAPI_CALL CreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.CreateFence(device, pCreateInfo, pAllocator, pFence); if (VK_SUCCESS == result) { std::lock_guard<std::mutex> lock(global_lock); @@ -6372,27 +6372,27 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateFence(VkDevice device, const VkFenceCreateI // TODO handle pipeline caches VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); return result; } VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); dev_data->dispatch_table.DestroyPipelineCache(device, pipelineCache, pAllocator); } VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.GetPipelineCacheData(device, pipelineCache, pDataSize, pData); return result; } VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); return result; } @@ -6422,7 +6422,7 @@ static bool PreCallCreateGraphicsPipelines(layer_data *device_data, uint32_t cou const VkGraphicsPipelineCreateInfo *create_infos, vector<PIPELINE_STATE *> &pipe_state) { bool skip = false; instance_layer_data *instance_data = - get_my_data_ptr(get_dispatch_key(device_data->instance_data->instance), instance_layer_data_map); + GetLayerDataPtr(get_dispatch_key(device_data->instance_data->instance), instance_layer_data_map); for (uint32_t i = 0; i < count; i++) { skip |= verifyPipelineCreateState(device_data, pipe_state, i); @@ -6457,7 +6457,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(VkDevice device, VkPipeli bool skip = false; // TODO : Improve this data struct w/ unique_ptrs so cleanup below is automatic vector<PIPELINE_STATE *> pipe_state(count); - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); uint32_t i = 0; std::unique_lock<std::mutex> lock(global_lock); @@ -6501,7 +6501,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(VkDevice device, VkPipelin // TODO : Improve this data struct w/ unique_ptrs so cleanup below is automatic vector<PIPELINE_STATE *> pPipeState(count); - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); uint32_t i = 0; std::unique_lock<std::mutex> lock(global_lock); @@ -6546,7 +6546,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(VkDevice device, VkPipelin VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.CreateSampler(device, pCreateInfo, pAllocator, pSampler); if (VK_SUCCESS == result) { std::lock_guard<std::mutex> lock(global_lock); @@ -6569,7 +6569,7 @@ static void PostCallRecordCreateDescriptorSetLayout(layer_data *dev_data, const VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; std::unique_lock<std::mutex> lock(global_lock); bool skip = PreCallValidateCreateDescriptorSetLayout(dev_data, pCreateInfo); @@ -6696,7 +6696,7 @@ static bool validatePushConstantRange(const layer_data *dev_data, const uint32_t VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); // TODO : Add checks for VALIDATION_ERRORS 865-871 // Push Constant Range checks uint32_t i, j; @@ -6748,7 +6748,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(VkDevice device, const VkPip VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); if (VK_SUCCESS == result) { if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, @@ -6774,7 +6774,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(VkDevice device, const VkDes VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) { // TODO : Add checks for VALIDATION_ERROR_00928 - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.ResetDescriptorPool(device, descriptorPool, flags); if (VK_SUCCESS == result) { std::lock_guard<std::mutex> lock(global_lock); @@ -6802,7 +6802,7 @@ static void PostCallRecordAllocateDescriptorSets(layer_data *dev_data, const VkD VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); cvdescriptorset::AllocateDescriptorSetsData common_data(pAllocateInfo->descriptorSetCount); bool skip_call = PreCallValidateAllocateDescriptorSets(dev_data, pAllocateInfo, &common_data); @@ -6867,7 +6867,7 @@ static void PostCallRecordFreeDescriptorSets(layer_data *dev_data, VkDescriptorP VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet *pDescriptorSets) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); // Make sure that no sets being destroyed are in-flight std::unique_lock<std::mutex> lock(global_lock); bool skip_call = PreCallValidateFreeDescriptorSets(dev_data, descriptorPool, count, pDescriptorSets); @@ -6912,7 +6912,7 @@ VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(VkDevice device, uint32_t descri const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies) { // Only map look-up at top level is for device-level layer_data - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); bool skip_call = PreCallValidateUpdateDescriptorSets(dev_data, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); @@ -6929,7 +6929,7 @@ VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(VkDevice device, uint32_t descri VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pCreateInfo, VkCommandBuffer *pCommandBuffer) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer); if (VK_SUCCESS == result) { std::unique_lock<std::mutex> lock(global_lock); @@ -6973,7 +6973,7 @@ static void AddFramebufferBinding(layer_data *dev_data, GLOBAL_CB_NODE *cb_state VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); // Validate command buffer level GLOBAL_CB_NODE *cb_node = getCBNode(dev_data, commandBuffer); @@ -7101,7 +7101,7 @@ VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer, VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(VkCommandBuffer commandBuffer) { bool skip_call = false; VkResult result = VK_SUCCESS; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -7138,7 +7138,7 @@ VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(VkCommandBuffer commandBuffer) { VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); VkCommandPool cmdPool = pCB->createInfo.commandPool; @@ -7166,7 +7166,7 @@ VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(VkCommandBuffer commandBuffer, VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { bool skip = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *cb_state = getCBNode(dev_data, commandBuffer); if (cb_state) { @@ -7211,7 +7211,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipe VKAPI_ATTR void VKAPI_CALL CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -7226,7 +7226,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetViewport(VkCommandBuffer commandBuffer, uint32_ VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -7240,7 +7240,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -7266,7 +7266,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(VkCommandBuffer commandBuffer, float VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -7281,7 +7281,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(VkCommandBuffer commandBuffer, float VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -7295,7 +7295,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(VkCommandBuffer commandBuffer, c VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -7310,7 +7310,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(VkCommandBuffer commandBuffer, floa VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -7324,7 +7324,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(VkCommandBuffer commandBuffe VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -7338,7 +7338,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -7355,7 +7355,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(VkCommandBuffer commandBuffer, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -7526,7 +7526,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); // TODO : Somewhere need to verify that IBs have correct usage state flagged std::unique_lock<std::mutex> lock(global_lock); @@ -7581,7 +7581,7 @@ static inline void updateResourceTrackingOnDraw(GLOBAL_CB_NODE *pCB) { pCB->draw VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); // TODO : Somewhere need to verify that VBs have correct usage state flagged std::unique_lock<std::mutex> lock(global_lock); @@ -7674,7 +7674,7 @@ static void PostCallRecordCmdDraw(layer_data *dev_data, GLOBAL_CB_NODE *cb_state VKAPI_ATTR void VKAPI_CALL CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); GLOBAL_CB_NODE *cb_state = nullptr; std::unique_lock<std::mutex> lock(global_lock); bool skip = PreCallValidateCmdDraw(dev_data, commandBuffer, false, VK_PIPELINE_BIND_POINT_GRAPHICS, &cb_state, "vkCmdDraw()"); @@ -7699,7 +7699,7 @@ static void PostCallRecordCmdDrawIndexed(layer_data *dev_data, GLOBAL_CB_NODE *c VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); GLOBAL_CB_NODE *cb_state = nullptr; std::unique_lock<std::mutex> lock(global_lock); bool skip = PreCallValidateCmdDrawIndexed(dev_data, commandBuffer, true, VK_PIPELINE_BIND_POINT_GRAPHICS, &cb_state, @@ -7731,7 +7731,7 @@ static void PostCallRecordCmdDrawIndirect(layer_data *dev_data, GLOBAL_CB_NODE * VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); GLOBAL_CB_NODE *cb_state = nullptr; BUFFER_STATE *buffer_state = nullptr; std::unique_lock<std::mutex> lock(global_lock); @@ -7764,7 +7764,7 @@ static void PostCallRecordCmdDrawIndexedIndirect(layer_data *dev_data, GLOBAL_CB VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); GLOBAL_CB_NODE *cb_state = nullptr; BUFFER_STATE *buffer_state = nullptr; std::unique_lock<std::mutex> lock(global_lock); @@ -7790,7 +7790,7 @@ static void PostCallRecordCmdDispatch(layer_data *dev_data, GLOBAL_CB_NODE *cb_s } VKAPI_ATTR void VKAPI_CALL CmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); GLOBAL_CB_NODE *cb_state = nullptr; std::unique_lock<std::mutex> lock(global_lock); bool skip = @@ -7821,7 +7821,7 @@ static void PostCallRecordCmdDispatchIndirect(layer_data *dev_data, GLOBAL_CB_NO } VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); GLOBAL_CB_NODE *cb_state = nullptr; BUFFER_STATE *buffer_state = nullptr; std::unique_lock<std::mutex> lock(global_lock); @@ -7839,7 +7839,7 @@ VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(VkCommandBuffer commandBuffer, Vk VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); auto cb_node = getCBNode(dev_data, commandBuffer); @@ -8078,7 +8078,7 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyImage(VkCommandBuffer commandBuffer, VkImage s VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); auto cb_node = getCBNode(dev_data, commandBuffer); @@ -8146,7 +8146,7 @@ bool ValidateImageSampleCount(layer_data *dev_data, IMAGE_STATE *image_state, Vk VKAPI_ATTR void VKAPI_CALL CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); auto cb_node = getCBNode(dev_data, commandBuffer); @@ -8167,7 +8167,7 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, V VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); auto cb_node = getCBNode(dev_data, commandBuffer); @@ -8213,7 +8213,7 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, V VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); auto cb_node = getCBNode(dev_data, commandBuffer); @@ -8263,7 +8263,7 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, V VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t *pData) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); auto cb_node = getCBNode(dev_data, commandBuffer); @@ -8294,7 +8294,7 @@ VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuff VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); auto cb_node = getCBNode(dev_data, commandBuffer); @@ -8326,7 +8326,7 @@ VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(VkCommandBuffer commandBuffer, ui const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects) { bool skip = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); { std::lock_guard<std::mutex> lock(global_lock); skip = PreCallValidateCmdClearAttachments(dev_data, commandBuffer, attachmentCount, pAttachments, rectCount, pRects); @@ -8337,7 +8337,7 @@ VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(VkCommandBuffer commandBuffer, ui VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); bool skip = PreCallValidateCmdClearColorImage(dev_data, commandBuffer, image, imageLayout, rangeCount, pRanges); @@ -8351,7 +8351,7 @@ VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(VkCommandBuffer commandBuffer, VkI VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); bool skip = PreCallValidateCmdClearDepthStencilImage(dev_data, commandBuffer, image, imageLayout, rangeCount, pRanges); @@ -8365,7 +8365,7 @@ VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(VkCommandBuffer commandBuff VKAPI_ATTR void VKAPI_CALL CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); auto cb_node = getCBNode(dev_data, commandBuffer); @@ -8385,7 +8385,7 @@ VKAPI_ATTR void VKAPI_CALL CmdResolveImage(VkCommandBuffer commandBuffer, VkImag VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout) { bool skipCall = false; - layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkFormat format; auto imageEntry = getImageState(device_data, image); @@ -8421,7 +8421,7 @@ VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(VkDevice device, VkImage im } bool setEventStageMask(VkQueue queue, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { pCB->eventToStageMap[event] = stageMask; @@ -8435,7 +8435,7 @@ bool setEventStageMask(VkQueue queue, VkCommandBuffer commandBuffer, VkEvent eve VKAPI_ATTR void VKAPI_CALL CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -8464,7 +8464,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent ev VKAPI_ATTR void VKAPI_CALL CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -8497,7 +8497,7 @@ static bool ValidateBarriers(const char *funcName, VkCommandBuffer cmdBuffer, ui const VkBufferMemoryBarrier *pBufferMemBarriers, uint32_t imageMemBarrierCount, const VkImageMemoryBarrier *pImageMemBarriers) { bool skip = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(cmdBuffer), layer_data_map); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, cmdBuffer); if (pCB->activeRenderPass && memBarrierCount) { if (!pCB->activeRenderPass->hasSelfDependency[pCB->activeSubpass]) { @@ -8671,7 +8671,7 @@ bool validateEventStageMask(VkQueue queue, GLOBAL_CB_NODE *pCB, uint32_t eventCo VkPipelineStageFlags sourceStageMask) { bool skip_call = false; VkPipelineStageFlags stageMask = 0; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); for (uint32_t i = 0; i < eventCount; ++i) { auto event = pCB->events[firstEventIndex + i]; auto queue_data = dev_data->queueMap.find(queue); @@ -8764,7 +8764,7 @@ bool ValidateStageMasksAgainstQueueCapabilities(layer_data *dev_data, GLOBAL_CB_ const char *function, UNIQUE_VALIDATION_ERROR_CODE error_code) { bool skip = false; uint32_t queue_family_index = dev_data->commandPoolMap[cb_state->createInfo.commandPool].queueFamilyIndex; - instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(dev_data->physical_device), instance_layer_data_map); + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(dev_data->physical_device), instance_layer_data_map); auto physical_device_state = getPhysicalDeviceState(instance_data, dev_data->physical_device); // Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family @@ -8792,7 +8792,7 @@ VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) { bool skip = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *cb_state = getCBNode(dev_data, commandBuffer); if (cb_state) { @@ -8840,7 +8840,7 @@ VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkP uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) { bool skip = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *cb_state = getCBNode(dev_data, commandBuffer); if (cb_state) { @@ -8864,7 +8864,7 @@ VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkP } bool setQueryState(VkQueue queue, VkCommandBuffer commandBuffer, QueryObject object, bool value) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { pCB->queryToStateMap[object] = value; @@ -8878,7 +8878,7 @@ bool setQueryState(VkQueue queue, VkCommandBuffer commandBuffer, QueryObject obj VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -8898,7 +8898,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryP VKAPI_ATTR void VKAPI_CALL CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -8929,7 +8929,7 @@ VKAPI_ATTR void VKAPI_CALL CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPoo VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -8955,7 +8955,7 @@ VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQu bool validateQuery(VkQueue queue, GLOBAL_CB_NODE *pCB, VkQueryPool queryPool, uint32_t queryCount, uint32_t firstQuery) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(pCB->commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(pCB->commandBuffer), layer_data_map); auto queue_data = dev_data->queueMap.find(queue); if (queue_data == dev_data->queueMap.end()) return false; for (uint32_t i = 0; i < queryCount; i++) { @@ -8990,7 +8990,7 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); auto cb_node = getCBNode(dev_data, commandBuffer); @@ -9032,7 +9032,7 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -9126,7 +9126,7 @@ VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPip VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -9352,7 +9352,7 @@ static void PostCallRecordCreateFramebuffer(layer_data *dev_data, const VkFrameb VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); bool skip_call = PreCallValidateCreateFramebuffer(dev_data, pCreateInfo); lock.unlock(); @@ -9622,7 +9622,7 @@ static bool CreatePassDAG(const layer_data *dev_data, VkDevice device, const VkR VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip_call = false; spv_result_t spv_valid = SPV_SUCCESS; @@ -9760,7 +9760,7 @@ static bool ValidateRenderpassAttachmentUsage(layer_data *dev_data, const VkRend VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); // TODO: As part of wrapping up the mem_tracker/core_validation merge the following routine should be consolidated with @@ -9877,7 +9877,7 @@ static bool FormatSpecificLoadAndStoreOpSettings(VkFormat format, T color_depth_ VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *cb_node = getCBNode(dev_data, commandBuffer); auto render_pass_state = pRenderPassBegin ? getRenderPassState(dev_data, pRenderPassBegin->renderPass) : nullptr; @@ -9972,7 +9972,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(VkCommandBuffer commandBuffer, con VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -10006,7 +10006,7 @@ VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpa VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(VkCommandBuffer commandBuffer) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); auto pCB = getCBNode(dev_data, commandBuffer); FRAMEBUFFER_STATE *framebuffer = NULL; @@ -10277,7 +10277,7 @@ static bool validateSecondaryCommandBufferState(layer_data *dev_data, GLOBAL_CB_ VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer *pCommandBuffers) { bool skip_call = false; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { @@ -10383,7 +10383,7 @@ VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(VkCommandBuffer commandBuffer, uin VKAPI_ATTR VkResult VKAPI_CALL MapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void **ppData) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip_call = false; VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; @@ -10421,7 +10421,7 @@ VKAPI_ATTR VkResult VKAPI_CALL MapMemory(VkDevice device, VkDeviceMemory mem, Vk } VKAPI_ATTR void VKAPI_CALL UnmapMemory(VkDevice device, VkDeviceMemory mem) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); @@ -10552,7 +10552,7 @@ static bool PreCallValidateFlushMappedMemoryRanges(layer_data *dev_data, uint32_ VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange *pMemRanges) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); if (!PreCallValidateFlushMappedMemoryRanges(dev_data, memRangeCount, pMemRanges)) { result = dev_data->dispatch_table.FlushMappedMemoryRanges(device, memRangeCount, pMemRanges); @@ -10578,7 +10578,7 @@ static void PostCallRecordInvalidateMappedMemoryRanges(layer_data *dev_data, uin VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange *pMemRanges) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); if (!PreCallValidateInvalidateMappedMemoryRanges(dev_data, memRangeCount, pMemRanges)) { result = dev_data->dispatch_table.InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges); @@ -10590,7 +10590,7 @@ VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(VkDevice device, uin } VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memoryOffset) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); @@ -10644,7 +10644,7 @@ VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(VkDevice device, VkImage image, V VKAPI_ATTR VkResult VKAPI_CALL SetEvent(VkDevice device, VkEvent event) { bool skip_call = false; VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); auto event_state = getEventNode(dev_data, event); if (event_state) { @@ -10673,7 +10673,7 @@ VKAPI_ATTR VkResult VKAPI_CALL SetEvent(VkDevice device, VkEvent event) { VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); @@ -10782,7 +10782,7 @@ VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(VkQueue queue, uint32_t bindInfoC VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); if (result == VK_SUCCESS) { std::lock_guard<std::mutex> lock(global_lock); @@ -10796,7 +10796,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(VkDevice device, const VkSemaphor VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.CreateEvent(device, pCreateInfo, pAllocator, pEvent); if (result == VK_SUCCESS) { std::lock_guard<std::mutex> lock(global_lock); @@ -11045,7 +11045,7 @@ static void PostCallRecordCreateSwapchainKHR(layer_data *dev_data, VkResult resu VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); auto surface_state = getSurfaceState(dev_data->instance_data, pCreateInfo->surface); auto old_swapchain_state = getSwapchainNode(dev_data, pCreateInfo->oldSwapchain); @@ -11061,7 +11061,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapc } VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); @@ -11099,7 +11099,7 @@ VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR s VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pCount, VkImage *pSwapchainImages) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.GetSwapchainImagesKHR(device, swapchain, pCount, pSwapchainImages); if (result == VK_SUCCESS && pSwapchainImages != NULL) { @@ -11150,7 +11150,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchai } VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); bool skip_call = false; std::lock_guard<std::mutex> lock(global_lock); @@ -11317,7 +11317,7 @@ static void PostCallRecordCreateSharedSwapchainsKHR(layer_data *dev_data, VkResu VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); std::vector<SURFACE_STATE *> surface_state; std::vector<SWAPCHAIN_NODE *> old_swapchain_state; @@ -11337,7 +11337,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(VkDevice device, uint32 VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) { - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); @@ -11423,7 +11423,7 @@ VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(VkDevice device, VkSwapchainK VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices) { bool skip_call = false; - instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map); + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); assert(instance_data); // For this instance, flag when vkEnumeratePhysicalDevices goes to QUERY_COUNT and then QUERY_DETAILS @@ -11551,7 +11551,7 @@ static void PostCallRecordGetPhysicalDeviceQueueFamilyProperties2KHR(PHYSICAL_DE VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkQueueFamilyProperties *pQueueFamilyProperties) { - instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); auto physical_device_state = getPhysicalDeviceState(instance_data, physicalDevice); assert(physical_device_state); bool skip = @@ -11566,7 +11566,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevi VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR *pQueueFamilyProperties) { - instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); auto physical_device_state = getPhysicalDeviceState(instance_data, physicalDevice); assert(physical_device_state); bool skip = PreCallValidateGetPhysicalDeviceQueueFamilyProperties2KHR(instance_data, physical_device_state, @@ -11583,7 +11583,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysical template <typename TCreateInfo, typename FPtr> static VkResult CreateSurface(VkInstance instance, TCreateInfo const *pCreateInfo, VkAllocationCallbacks const *pAllocator, VkSurfaceKHR *pSurface, FPtr fptr) { - instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map); + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); // Call down the call chain: VkResult result = (instance_data->dispatch_table.*fptr)(instance, pCreateInfo, pAllocator, pSurface); @@ -11599,7 +11599,7 @@ static VkResult CreateSurface(VkInstance instance, TCreateInfo const *pCreateInf VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) { bool skip_call = false; - instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map); + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); std::unique_lock<std::mutex> lock(global_lock); auto surface_state = getSurfaceState(instance_data, surface); @@ -11664,7 +11664,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(VkInstance instance, const V VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) { - auto instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); std::unique_lock<std::mutex> lock(global_lock); auto physical_device_state = getPhysicalDeviceState(instance_data, physicalDevice); @@ -11683,7 +11683,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysica VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported) { - auto instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); std::unique_lock<std::mutex> lock(global_lock); auto surface_state = getSurfaceState(instance_data, surface); lock.unlock(); @@ -11702,7 +11702,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(VkPhysica uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes) { bool skip_call = false; - auto instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); std::unique_lock<std::mutex> lock(global_lock); // TODO: this isn't quite right. available modes may differ by surface AND physical device. auto physical_device_state = getPhysicalDeviceState(instance_data, physicalDevice); @@ -11763,7 +11763,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevi uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats) { bool skip_call = false; - auto instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); std::unique_lock<std::mutex> lock(global_lock); auto physical_device_state = getPhysicalDeviceState(instance_data, physicalDevice); auto &call_state = physical_device_state->vkGetPhysicalDeviceSurfaceFormatsKHRState; @@ -11827,7 +11827,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pMsgCallback) { - instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map); + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); VkResult res = instance_data->dispatch_table.CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback); if (VK_SUCCESS == res) { std::lock_guard<std::mutex> lock(global_lock); @@ -11838,7 +11838,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance, VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback, const VkAllocationCallbacks *pAllocator) { - instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map); + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); instance_data->dispatch_table.DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator); std::lock_guard<std::mutex> lock(global_lock); layer_destroy_msg_callback(instance_data->report_data, msgCallback, pAllocator); @@ -11847,7 +11847,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, Vk VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg) { - instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map); + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); instance_data->dispatch_table.DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg); } @@ -11874,7 +11874,7 @@ VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevi assert(physicalDevice); - instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map); + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); return instance_data->dispatch_table.EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties); } @@ -11897,7 +11897,7 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice dev, const c proc = intercept_khr_swapchain_command(funcName, dev); if (proc) return proc; - layer_data *dev_data = get_my_data_ptr(get_dispatch_key(dev), layer_data_map); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(dev), layer_data_map); auto &table = dev_data->dispatch_table; if (!table.GetDeviceProcAddr) return nullptr; @@ -11913,7 +11913,7 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance assert(instance); - instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map); + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); proc = debug_report_get_instance_proc_addr(instance_data->report_data, funcName); if (proc) return proc; @@ -11928,7 +11928,7 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) { assert(instance); - instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map); + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); auto &table = instance_data->dispatch_table; if (!table.GetPhysicalDeviceProcAddr) return nullptr; @@ -12106,7 +12106,7 @@ static PFN_vkVoidFunction intercept_khr_swapchain_command(const char *name, VkDe layer_data *dev_data = nullptr; if (dev) { - dev_data = get_my_data_ptr(get_dispatch_key(dev), layer_data_map); + dev_data = GetLayerDataPtr(get_dispatch_key(dev), layer_data_map); if (!dev_data->device_extensions.wsi_enabled) return nullptr; } @@ -12169,7 +12169,7 @@ static PFN_vkVoidFunction intercept_khr_surface_command(const char *name, VkInst instance_layer_data *instance_data = nullptr; if (instance) { - instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map); + instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); } for (size_t i = 0; i < ARRAY_SIZE(khr_surface_commands); i++) { |