// This file is ***GENERATED***. Do Not Edit. // See layer_chassis_generator.py for modifications. /* Copyright (c) 2015-2019 The Khronos Group Inc. * Copyright (c) 2015-2019 Valve Corporation * Copyright (c) 2015-2019 LunarG, Inc. * Copyright (c) 2015-2019 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * * Author: Mark Lobodzinski */ #include #include #define VALIDATION_ERROR_MAP_IMPL #include "chassis.h" #include "layer_chassis_dispatch.h" std::unordered_map layer_data_map; // Global unique object identifier. std::atomic global_unique_id(1ULL); // Map uniqueID to actual object handle. Accesses to the map itself are // internally synchronized. vl_concurrent_unordered_map unique_id_mapping; // TODO: This variable controls handle wrapping -- in the future it should be hooked // up to the new VALIDATION_FEATURES extension. Temporarily, control with a compile-time flag. #if defined(LAYER_CHASSIS_CAN_WRAP_HANDLES) bool wrap_handles = true; #else bool wrap_handles = false; #endif // Set layer name -- Khronos layer name overrides any other defined names #if BUILD_KHRONOS_VALIDATION #define OBJECT_LAYER_NAME "VK_LAYER_KHRONOS_validation" #define OBJECT_LAYER_DESCRIPTION "khronos_validation" #elif BUILD_OBJECT_TRACKER #define OBJECT_LAYER_NAME "VK_LAYER_LUNARG_object_tracker" #define OBJECT_LAYER_DESCRIPTION "lunarg_object_tracker" #elif BUILD_THREAD_SAFETY #define OBJECT_LAYER_NAME "VK_LAYER_GOOGLE_threading" #define OBJECT_LAYER_DESCRIPTION "google_thread_checker" #elif BUILD_PARAMETER_VALIDATION #define OBJECT_LAYER_NAME "VK_LAYER_LUNARG_parameter_validation" #define OBJECT_LAYER_DESCRIPTION "lunarg_parameter_validation" #elif BUILD_CORE_VALIDATION #define OBJECT_LAYER_NAME "VK_LAYER_LUNARG_core_validation" #define OBJECT_LAYER_DESCRIPTION "lunarg_core_validation" #else #define OBJECT_LAYER_NAME "VK_LAYER_GOOGLE_unique_objects" #define OBJECT_LAYER_DESCRIPTION "lunarg_unique_objects" #endif // Include layer validation object definitions #if BUILD_OBJECT_TRACKER #include "object_lifetime_validation.h" #endif #if BUILD_THREAD_SAFETY #include "thread_safety.h" #endif #if BUILD_PARAMETER_VALIDATION #include "stateless_validation.h" #endif #if BUILD_CORE_VALIDATION #include "core_validation.h" #endif #if BUILD_BEST_PRACTICES #include "best_practices.h" #endif namespace vulkan_layer_chassis { using std::unordered_map; static const VkLayerProperties global_layer = { OBJECT_LAYER_NAME, VK_LAYER_API_VERSION, 1, "LunarG validation Layer", }; static const VkExtensionProperties instance_extensions[] = {{VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION}, {VK_EXT_DEBUG_UTILS_EXTENSION_NAME, VK_EXT_DEBUG_UTILS_SPEC_VERSION}}; static const VkExtensionProperties device_extensions[] = { {VK_EXT_VALIDATION_CACHE_EXTENSION_NAME, VK_EXT_VALIDATION_CACHE_SPEC_VERSION}, {VK_EXT_DEBUG_MARKER_EXTENSION_NAME, VK_EXT_DEBUG_MARKER_SPEC_VERSION}, }; typedef struct { bool is_instance_api; void* funcptr; } function_data; extern const std::unordered_map name_to_funcptr_map; // Manually written functions // Check enabled instance extensions against supported instance extension whitelist static void InstanceExtensionWhitelist(ValidationObject *layer_data, const VkInstanceCreateInfo *pCreateInfo, VkInstance instance) { for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { // Check for recognized instance extensions if (!white_list(pCreateInfo->ppEnabledExtensionNames[i], kInstanceExtensionNames)) { log_msg(layer_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUIDUndefined, "Instance Extension %s is not supported by this layer. Using this extension may adversely affect validation " "results and/or produce undefined behavior.", pCreateInfo->ppEnabledExtensionNames[i]); } } } // Check enabled device extensions against supported device extension whitelist static void DeviceExtensionWhitelist(ValidationObject *layer_data, const VkDeviceCreateInfo *pCreateInfo, VkDevice device) { for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { // Check for recognized device extensions if (!white_list(pCreateInfo->ppEnabledExtensionNames[i], kDeviceExtensionNames)) { log_msg(layer_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUIDUndefined, "Device Extension %s is not supported by this layer. Using this extension may adversely affect validation " "results and/or produce undefined behavior.", pCreateInfo->ppEnabledExtensionNames[i]); } } } // Process validation features, flags and settings specified through extensions, a layer settings file, or environment variables static const std::unordered_map VkValFeatureDisableLookup = { {"VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT", VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT}, {"VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT", VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT}, {"VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT", VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT}, {"VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT", VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT}, {"VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT", VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT}, {"VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT", VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT}, {"VK_VALIDATION_FEATURE_DISABLE_ALL_EXT", VK_VALIDATION_FEATURE_DISABLE_ALL_EXT}, }; static const std::unordered_map VkValFeatureEnableLookup = { {"VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT", VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT}, {"VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT", VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT}, }; static const std::unordered_map VkValFeatureEnableLookup2 = { {"VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES", VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES}, }; static const std::unordered_map ValidationDisableLookup = { {"VALIDATION_CHECK_DISABLE_COMMAND_BUFFER_STATE", VALIDATION_CHECK_DISABLE_COMMAND_BUFFER_STATE}, {"VALIDATION_CHECK_DISABLE_OBJECT_IN_USE", VALIDATION_CHECK_DISABLE_OBJECT_IN_USE}, {"VALIDATION_CHECK_DISABLE_IDLE_DESCRIPTOR_SET", VALIDATION_CHECK_DISABLE_IDLE_DESCRIPTOR_SET}, {"VALIDATION_CHECK_DISABLE_PUSH_CONSTANT_RANGE", VALIDATION_CHECK_DISABLE_PUSH_CONSTANT_RANGE}, {"VALIDATION_CHECK_DISABLE_QUERY_VALIDATION", VALIDATION_CHECK_DISABLE_QUERY_VALIDATION}, {"VALIDATION_CHECK_DISABLE_IMAGE_LAYOUT_VALIDATION", VALIDATION_CHECK_DISABLE_IMAGE_LAYOUT_VALIDATION}, }; // Set the local disable flag for the appropriate VALIDATION_CHECK_DISABLE enum void SetValidationDisable(CHECK_DISABLED* disable_data, const ValidationCheckDisables disable_id) { switch (disable_id) { case VALIDATION_CHECK_DISABLE_COMMAND_BUFFER_STATE: disable_data->command_buffer_state = true; break; case VALIDATION_CHECK_DISABLE_OBJECT_IN_USE: disable_data->object_in_use = true; break; case VALIDATION_CHECK_DISABLE_IDLE_DESCRIPTOR_SET: disable_data->idle_descriptor_set = true; break; case VALIDATION_CHECK_DISABLE_PUSH_CONSTANT_RANGE: disable_data->push_constant_range = true; break; case VALIDATION_CHECK_DISABLE_QUERY_VALIDATION: disable_data->query_validation = true; break; case VALIDATION_CHECK_DISABLE_IMAGE_LAYOUT_VALIDATION: disable_data->image_layout_validation = true; break; default: assert(true); } } // Set the local disable flag for a single VK_VALIDATION_FEATURE_DISABLE_* flag void SetValidationFeatureDisable(CHECK_DISABLED* disable_data, const VkValidationFeatureDisableEXT feature_disable) { switch (feature_disable) { case VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT: disable_data->shader_validation = true; break; case VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT: disable_data->thread_safety = true; break; case VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT: disable_data->stateless_checks = true; break; case VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT: disable_data->object_tracking = true; break; case VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT: disable_data->core_checks = true; break; case VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT: disable_data->handle_wrapping = true; break; case VK_VALIDATION_FEATURE_DISABLE_ALL_EXT: // Set all disabled flags to true disable_data->SetAll(true); break; default: break; } } // Set the local enable flag for a single VK_VALIDATION_FEATURE_ENABLE_* flag void SetValidationFeatureEnable(CHECK_ENABLED *enable_data, const VkValidationFeatureEnableEXT feature_enable) { switch (feature_enable) { case VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT: enable_data->gpu_validation = true; break; case VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT: enable_data->gpu_validation_reserve_binding_slot = true; break; default: break; } } void SetValidationFeatureEnable(CHECK_ENABLED *enable_data, const VkValidationFeatureEnable feature_enable) { switch(feature_enable) { case VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES: enable_data->best_practices = true; break; default: break; } } // Set the local disable flag for settings specified through the VK_EXT_validation_flags extension void SetValidationFlags(CHECK_DISABLED* disables, const VkValidationFlagsEXT* val_flags_struct) { for (uint32_t i = 0; i < val_flags_struct->disabledValidationCheckCount; ++i) { switch (val_flags_struct->pDisabledValidationChecks[i]) { case VK_VALIDATION_CHECK_SHADERS_EXT: disables->shader_validation = true; break; case VK_VALIDATION_CHECK_ALL_EXT: // Set all disabled flags to true disables->SetAll(true); break; default: break; } } } // Process Validation Features flags specified through the ValidationFeature extension void SetValidationFeatures(CHECK_DISABLED *disable_data, CHECK_ENABLED *enable_data, const VkValidationFeaturesEXT *val_features_struct) { for (uint32_t i = 0; i < val_features_struct->disabledValidationFeatureCount; ++i) { SetValidationFeatureDisable(disable_data, val_features_struct->pDisabledValidationFeatures[i]); } for (uint32_t i = 0; i < val_features_struct->enabledValidationFeatureCount; ++i) { SetValidationFeatureEnable(enable_data, val_features_struct->pEnabledValidationFeatures[i]); } } // Given a string representation of a list of enable enum values, call the appropriate setter function void SetLocalEnableSetting(std::string list_of_enables, std::string delimiter, CHECK_ENABLED* enables) { size_t pos = 0; std::string token; while (list_of_enables.length() != 0) { pos = list_of_enables.find(delimiter); if (pos != std::string::npos) { token = list_of_enables.substr(0, pos); } else { pos = list_of_enables.length() - delimiter.length(); token = list_of_enables; } if (token.find("VK_VALIDATION_FEATURE_ENABLE_") != std::string::npos) { auto result = VkValFeatureEnableLookup.find(token); if (result != VkValFeatureEnableLookup.end()) { SetValidationFeatureEnable(enables, result->second); } else { auto result2 = VkValFeatureEnableLookup2.find(token); if (result2 != VkValFeatureEnableLookup2.end()) { SetValidationFeatureEnable(enables, result2->second); } } } list_of_enables.erase(0, pos + delimiter.length()); } } // Given a string representation of a list of disable enum values, call the appropriate setter function void SetLocalDisableSetting(std::string list_of_disables, std::string delimiter, CHECK_DISABLED* disables) { size_t pos = 0; std::string token; while (list_of_disables.length() != 0) { pos = list_of_disables.find(delimiter); if (pos != std::string::npos) { token = list_of_disables.substr(0, pos); } else { pos = list_of_disables.length() - delimiter.length(); token = list_of_disables; } if (token.find("VK_VALIDATION_FEATURE_DISABLE_") != std::string::npos) { auto result = VkValFeatureDisableLookup.find(token); if (result != VkValFeatureDisableLookup.end()) { SetValidationFeatureDisable(disables, result->second); } } if (token.find("VALIDATION_CHECK_DISABLE_") != std::string::npos) { auto result = ValidationDisableLookup.find(token); if (result != ValidationDisableLookup.end()) { SetValidationDisable(disables, result->second); } } list_of_disables.erase(0, pos + delimiter.length()); } } // Process enables and disables set though the vk_layer_settings.txt config file or through an environment variable void ProcessConfigAndEnvSettings(const char* layer_description, CHECK_ENABLED* enables, CHECK_DISABLED* disables) { std::string enable_key = layer_description; std::string disable_key = layer_description; enable_key.append(".enables"); disable_key.append(".disables"); std::string list_of_config_enables = getLayerOption(enable_key.c_str()); std::string list_of_env_enables = GetLayerEnvVar("VK_LAYER_ENABLES"); std::string list_of_config_disables = getLayerOption(disable_key.c_str()); std::string list_of_env_disables = GetLayerEnvVar("VK_LAYER_DISABLES"); #if defined(_WIN32) std::string env_delimiter = ";"; #else std::string env_delimiter = ":"; #endif SetLocalEnableSetting(list_of_config_enables, ",", enables); SetLocalEnableSetting(list_of_env_enables, env_delimiter, enables); SetLocalDisableSetting(list_of_config_disables, ",", disables); SetLocalDisableSetting(list_of_env_disables, env_delimiter, disables); } // Non-code-generated chassis API functions VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *funcName) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); if (!ApiParentExtensionEnabled(funcName, &layer_data->device_extensions)) { return nullptr; } const auto &item = name_to_funcptr_map.find(funcName); if (item != name_to_funcptr_map.end()) { if (item->second.is_instance_api) { return nullptr; } else { return reinterpret_cast(item->second.funcptr); } } auto &table = layer_data->device_dispatch_table; if (!table.GetDeviceProcAddr) return nullptr; return table.GetDeviceProcAddr(device, funcName); } VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char *funcName) { const auto &item = name_to_funcptr_map.find(funcName); if (item != name_to_funcptr_map.end()) { return reinterpret_cast(item->second.funcptr); } auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); auto &table = layer_data->instance_dispatch_table; if (!table.GetInstanceProcAddr) return nullptr; return table.GetInstanceProcAddr(instance, funcName); } VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) { return util_GetLayerProperties(1, &global_layer, pCount, pProperties); } VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties *pProperties) { return util_GetLayerProperties(1, &global_layer, pCount, pProperties); } VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) { if (pLayerName && !strcmp(pLayerName, global_layer.layerName)) return util_GetExtensionProperties(ARRAY_SIZE(instance_extensions), instance_extensions, pCount, pProperties); return VK_ERROR_LAYER_NOT_PRESENT; } VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) { if (pLayerName && !strcmp(pLayerName, global_layer.layerName)) return util_GetExtensionProperties(ARRAY_SIZE(device_extensions), device_extensions, pCount, pProperties); assert(physicalDevice); auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); return layer_data->instance_dispatch_table.EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pCount, pProperties); } VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) { VkLayerInstanceCreateInfo* chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); assert(chain_info->u.pLayerInfo); PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance"); if (fpCreateInstance == NULL) return VK_ERROR_INITIALIZATION_FAILED; chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; uint32_t specified_version = (pCreateInfo->pApplicationInfo ? pCreateInfo->pApplicationInfo->apiVersion : VK_API_VERSION_1_0); uint32_t api_version = (specified_version < VK_API_VERSION_1_1) ? VK_API_VERSION_1_0 : VK_API_VERSION_1_1; CHECK_ENABLED local_enables {}; CHECK_DISABLED local_disables {}; const auto *validation_features_ext = lvl_find_in_chain(pCreateInfo->pNext); if (validation_features_ext) { SetValidationFeatures(&local_disables, &local_enables, validation_features_ext); } const auto *validation_flags_ext = lvl_find_in_chain(pCreateInfo->pNext); if (validation_flags_ext) { SetValidationFlags(&local_disables, validation_flags_ext); } ProcessConfigAndEnvSettings(OBJECT_LAYER_DESCRIPTION, &local_enables, &local_disables); // Create temporary dispatch vector for pre-calls until instance is created std::vector local_object_dispatch; // Add VOs to dispatch vector. Order here will be the validation dispatch order! #if BUILD_THREAD_SAFETY auto thread_checker = new ThreadSafety; if (!local_disables.thread_safety) { local_object_dispatch.emplace_back(thread_checker); } thread_checker->container_type = LayerObjectTypeThreading; thread_checker->api_version = api_version; #endif #if BUILD_PARAMETER_VALIDATION auto parameter_validation = new StatelessValidation; if (!local_disables.stateless_checks) { local_object_dispatch.emplace_back(parameter_validation); } parameter_validation->container_type = LayerObjectTypeParameterValidation; parameter_validation->api_version = api_version; #endif #if BUILD_OBJECT_TRACKER auto object_tracker = new ObjectLifetimes; if (!local_disables.object_tracking) { local_object_dispatch.emplace_back(object_tracker); } object_tracker->container_type = LayerObjectTypeObjectTracker; object_tracker->api_version = api_version; #endif #if BUILD_CORE_VALIDATION auto core_checks = new CoreChecks; if (!local_disables.core_checks) { local_object_dispatch.emplace_back(core_checks); } core_checks->container_type = LayerObjectTypeCoreValidation; core_checks->api_version = api_version; #endif #if BUILD_BEST_PRACTICES auto best_practices = new BestPractices; if (local_enables.best_practices) { local_object_dispatch.emplace_back(best_practices); } best_practices->container_type = LayerObjectTypeBestPractices; best_practices->api_version = api_version; #endif // If handle wrapping is disabled via the ValidationFeatures extension, override build flag if (local_disables.handle_wrapping) { wrap_handles = false; } // Init dispatch array and call registration functions for (auto intercept : local_object_dispatch) { intercept->PreCallValidateCreateInstance(pCreateInfo, pAllocator, pInstance); } for (auto intercept : local_object_dispatch) { intercept->PreCallRecordCreateInstance(pCreateInfo, pAllocator, pInstance); } VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance); if (result != VK_SUCCESS) return result; auto framework = GetLayerDataPtr(get_dispatch_key(*pInstance), layer_data_map); framework->object_dispatch = local_object_dispatch; framework->container_type = LayerObjectTypeInstance; framework->disabled = local_disables; framework->enabled = local_enables; framework->instance = *pInstance; layer_init_instance_dispatch_table(*pInstance, &framework->instance_dispatch_table, fpGetInstanceProcAddr); framework->report_data = debug_utils_create_instance(&framework->instance_dispatch_table, *pInstance, pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames); framework->api_version = api_version; framework->instance_extensions.InitFromInstanceCreateInfo(specified_version, pCreateInfo); layer_debug_messenger_actions(framework->report_data, framework->logging_messenger, pAllocator, OBJECT_LAYER_DESCRIPTION); #if BUILD_OBJECT_TRACKER object_tracker->report_data = framework->report_data; object_tracker->instance_dispatch_table = framework->instance_dispatch_table; object_tracker->enabled = framework->enabled; object_tracker->disabled = framework->disabled; #endif #if BUILD_THREAD_SAFETY thread_checker->report_data = framework->report_data; thread_checker->instance_dispatch_table = framework->instance_dispatch_table; thread_checker->enabled = framework->enabled; thread_checker->disabled = framework->disabled; #endif #if BUILD_PARAMETER_VALIDATION parameter_validation->report_data = framework->report_data; parameter_validation->instance_dispatch_table = framework->instance_dispatch_table; parameter_validation->enabled = framework->enabled; parameter_validation->disabled = framework->disabled; #endif #if BUILD_CORE_VALIDATION core_checks->report_data = framework->report_data; core_checks->instance_dispatch_table = framework->instance_dispatch_table; core_checks->instance = *pInstance; core_checks->enabled = framework->enabled; core_checks->disabled = framework->disabled; core_checks->instance_state = core_checks; #endif #if BUILD_BEST_PRACTICES best_practices->report_data = framework->report_data; best_practices->instance_dispatch_table = framework->instance_dispatch_table; best_practices->enabled = framework->enabled; best_practices->disabled = framework->disabled; #endif for (auto intercept : framework->object_dispatch) { intercept->PostCallRecordCreateInstance(pCreateInfo, pAllocator, pInstance, result); } InstanceExtensionWhitelist(framework, pCreateInfo, *pInstance); return result; } VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) { dispatch_key key = get_dispatch_key(instance); auto layer_data = GetLayerDataPtr(key, layer_data_map); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallValidateDestroyInstance(instance, pAllocator); } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyInstance(instance, pAllocator); } layer_data->instance_dispatch_table.DestroyInstance(instance, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyInstance(instance, pAllocator); } // Clean up logging callback, if any while (layer_data->logging_messenger.size() > 0) { VkDebugUtilsMessengerEXT messenger = layer_data->logging_messenger.back(); layer_destroy_messenger_callback(layer_data->report_data, messenger, pAllocator); layer_data->logging_messenger.pop_back(); } while (layer_data->logging_callback.size() > 0) { VkDebugReportCallbackEXT callback = layer_data->logging_callback.back(); layer_destroy_report_callback(layer_data->report_data, callback, pAllocator); layer_data->logging_callback.pop_back(); } layer_debug_utils_destroy_instance(layer_data->report_data); for (auto item = layer_data->object_dispatch.begin(); item != layer_data->object_dispatch.end(); item++) { delete *item; } FreeLayerDataPtr(key, layer_data_map); } VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) { VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); auto instance_interceptor = GetLayerDataPtr(get_dispatch_key(gpu), layer_data_map); PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr; PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(instance_interceptor->instance, "vkCreateDevice"); if (fpCreateDevice == NULL) { return VK_ERROR_INITIALIZATION_FAILED; } chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; // Get physical device limits for device VkPhysicalDeviceProperties device_properties = {}; instance_interceptor->instance_dispatch_table.GetPhysicalDeviceProperties(gpu, &device_properties); // Setup the validation tables based on the application API version from the instance and the capabilities of the device driver uint32_t effective_api_version = std::min(device_properties.apiVersion, instance_interceptor->api_version); DeviceExtensions device_extensions = {}; device_extensions.InitFromDeviceCreateInfo(&instance_interceptor->instance_extensions, effective_api_version, pCreateInfo); for (auto item : instance_interceptor->object_dispatch) { item->device_extensions = device_extensions; } safe_VkDeviceCreateInfo modified_create_info(pCreateInfo); bool skip = false; for (auto intercept : instance_interceptor->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateDevice(gpu, pCreateInfo, pAllocator, pDevice); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : instance_interceptor->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateDevice(gpu, pCreateInfo, pAllocator, pDevice, &modified_create_info); } VkResult result = fpCreateDevice(gpu, reinterpret_cast(&modified_create_info), pAllocator, pDevice); if (result != VK_SUCCESS) { return result; } auto device_interceptor = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map); device_interceptor->container_type = LayerObjectTypeDevice; // Save local info in device object device_interceptor->phys_dev_properties.properties = device_properties; device_interceptor->api_version = device_interceptor->device_extensions.InitFromDeviceCreateInfo( &instance_interceptor->instance_extensions, effective_api_version, pCreateInfo); device_interceptor->device_extensions = device_extensions; layer_init_device_dispatch_table(*pDevice, &device_interceptor->device_dispatch_table, fpGetDeviceProcAddr); device_interceptor->device = *pDevice; device_interceptor->physical_device = gpu; device_interceptor->instance = instance_interceptor->instance; device_interceptor->report_data = layer_debug_utils_create_device(instance_interceptor->report_data, *pDevice); // Note that this defines the order in which the layer validation objects are called #if BUILD_THREAD_SAFETY auto thread_safety = new ThreadSafety; thread_safety->container_type = LayerObjectTypeThreading; if (!instance_interceptor->disabled.thread_safety) { device_interceptor->object_dispatch.emplace_back(thread_safety); } #endif #if BUILD_PARAMETER_VALIDATION auto stateless_validation = new StatelessValidation; stateless_validation->container_type = LayerObjectTypeParameterValidation; if (!instance_interceptor->disabled.stateless_checks) { device_interceptor->object_dispatch.emplace_back(stateless_validation); } #endif #if BUILD_OBJECT_TRACKER auto object_tracker = new ObjectLifetimes; object_tracker->container_type = LayerObjectTypeObjectTracker; if (!instance_interceptor->disabled.object_tracking) { device_interceptor->object_dispatch.emplace_back(object_tracker); } #endif #if BUILD_CORE_VALIDATION auto core_checks = new CoreChecks; core_checks->container_type = LayerObjectTypeCoreValidation; core_checks->instance_state = reinterpret_cast( core_checks->GetValidationObject(instance_interceptor->object_dispatch, LayerObjectTypeCoreValidation)); if (!instance_interceptor->disabled.core_checks) { device_interceptor->object_dispatch.emplace_back(core_checks); } #endif #if BUILD_BEST_PRACTICES auto best_practices = new BestPractices; best_practices->container_type = LayerObjectTypeBestPractices; if (instance_interceptor->enabled.best_practices) { device_interceptor->object_dispatch.emplace_back(best_practices); } #endif // Set per-intercept common data items for (auto dev_intercept : device_interceptor->object_dispatch) { dev_intercept->device = *pDevice; dev_intercept->physical_device = gpu; dev_intercept->instance = instance_interceptor->instance; dev_intercept->report_data = device_interceptor->report_data; dev_intercept->device_dispatch_table = device_interceptor->device_dispatch_table; dev_intercept->api_version = device_interceptor->api_version; dev_intercept->disabled = instance_interceptor->disabled; dev_intercept->enabled = instance_interceptor->enabled; dev_intercept->instance_dispatch_table = instance_interceptor->instance_dispatch_table; dev_intercept->instance_extensions = instance_interceptor->instance_extensions; dev_intercept->device_extensions = device_interceptor->device_extensions; } for (auto intercept : instance_interceptor->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateDevice(gpu, pCreateInfo, pAllocator, pDevice, result); } DeviceExtensionWhitelist(device_interceptor, pCreateInfo, *pDevice); return result; } VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) { dispatch_key key = get_dispatch_key(device); auto layer_data = GetLayerDataPtr(key, layer_data_map); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallValidateDestroyDevice(device, pAllocator); } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyDevice(device, pAllocator); } layer_debug_utils_destroy_device(device); layer_data->device_dispatch_table.DestroyDevice(device, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyDevice(device, pAllocator); } for (auto item = layer_data->object_dispatch.begin(); item != layer_data->object_dispatch.end(); item++) { delete *item; } FreeLayerDataPtr(key, layer_data_map); } // Special-case APIs for which core_validation needs custom parameter lists and/or modifies parameters VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; #ifdef BUILD_CORE_VALIDATION create_graphics_pipeline_api_state cgpl_state{}; #else struct create_graphics_pipeline_api_state { const VkGraphicsPipelineCreateInfo* pCreateInfos; } cgpl_state; #endif cgpl_state.pCreateInfos = pCreateInfos; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &cgpl_state); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &cgpl_state); } VkResult result = DispatchCreateGraphicsPipelines(device, pipelineCache, createInfoCount, cgpl_state.pCreateInfos, pAllocator, pPipelines); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result, &cgpl_state); } return result; } // This API saves some core_validation pipeline state state on the stack for performance purposes VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; #ifdef BUILD_CORE_VALIDATION create_compute_pipeline_api_state ccpl_state{}; #else struct create_compute_pipeline_api_state { const VkComputePipelineCreateInfo* pCreateInfos; } ccpl_state; #endif ccpl_state.pCreateInfos = pCreateInfos; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &ccpl_state); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &ccpl_state); } VkResult result = DispatchCreateComputePipelines(device, pipelineCache, createInfoCount, ccpl_state.pCreateInfos, pAllocator, pPipelines); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result, &ccpl_state); } return result; } VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; #ifdef BUILD_CORE_VALIDATION create_ray_tracing_pipeline_api_state crtpl_state{}; #else struct create_ray_tracing_pipeline_api_state { const VkRayTracingPipelineCreateInfoNV* pCreateInfos; } crtpl_state; #endif crtpl_state.pCreateInfos = pCreateInfos; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &crtpl_state); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &crtpl_state); } VkResult result = DispatchCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result, &crtpl_state); } return result; } // This API needs the ability to modify a down-chain parameter VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout( VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; #ifndef BUILD_CORE_VALIDATION struct create_pipeline_layout_api_state { VkPipelineLayoutCreateInfo modified_create_info; }; #endif create_pipeline_layout_api_state cpl_state{}; cpl_state.modified_create_info = *pCreateInfo; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout, &cpl_state); } VkResult result = DispatchCreatePipelineLayout(device, &cpl_state.modified_create_info, pAllocator, pPipelineLayout); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout, result); } return result; } // This API needs some local stack data for performance reasons and also may modify a parameter VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule( VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; #ifndef BUILD_CORE_VALIDATION struct create_shader_module_api_state { VkShaderModuleCreateInfo instrumented_create_info; }; #endif create_shader_module_api_state csm_state{}; csm_state.instrumented_create_info = *pCreateInfo; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule, &csm_state); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule, &csm_state); } VkResult result = DispatchCreateShaderModule(device, &csm_state.instrumented_create_info, pAllocator, pShaderModule); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule, result, &csm_state); } return result; } VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets( VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; #ifdef BUILD_CORE_VALIDATION cvdescriptorset::AllocateDescriptorSetsData ads_state(pAllocateInfo->descriptorSetCount); #else struct ads_state {} ads_state; #endif for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets, &ads_state); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); } VkResult result = DispatchAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets, result, &ads_state); } return result; } // ValidationCache APIs do not dispatch VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT( VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = VK_SUCCESS; ValidationObject *validation_data = layer_data->GetValidationObject(layer_data->object_dispatch, LayerObjectTypeCoreValidation); if (validation_data) { auto lock = validation_data->write_lock(); result = validation_data->CoreLayerCreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); ValidationObject *validation_data = layer_data->GetValidationObject(layer_data->object_dispatch, LayerObjectTypeCoreValidation); if (validation_data) { auto lock = validation_data->write_lock(); validation_data->CoreLayerDestroyValidationCacheEXT(device, validationCache, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT( VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = VK_SUCCESS; ValidationObject *validation_data = layer_data->GetValidationObject(layer_data->object_dispatch, LayerObjectTypeCoreValidation); if (validation_data) { auto lock = validation_data->write_lock(); result = validation_data->CoreLayerMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = VK_SUCCESS; ValidationObject *validation_data = layer_data->GetValidationObject(layer_data->object_dispatch, LayerObjectTypeCoreValidation); if (validation_data) { auto lock = validation_data->write_lock(); result = validation_data->CoreLayerGetValidationCacheDataEXT(device, validationCache, pDataSize, pData); } return result; } VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices( VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); } VkResult result = DispatchEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices, result); } return result; } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceFeatures(physicalDevice, pFeatures); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceFeatures(physicalDevice, pFeatures); } DispatchGetPhysicalDeviceFeatures(physicalDevice, pFeatures); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceFeatures(physicalDevice, pFeatures); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); } DispatchGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); } } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); } VkResult result = DispatchGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, result); } return result; } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceProperties(physicalDevice, pProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceProperties(physicalDevice, pProperties); } DispatchGetPhysicalDeviceProperties(physicalDevice, pProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceProperties(physicalDevice, pProperties); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); } DispatchGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); } DispatchGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); } } VKAPI_ATTR void VKAPI_CALL GetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); } DispatchGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); } } VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) { auto layer_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateQueueSubmit(queue, submitCount, pSubmits, fence); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordQueueSubmit(queue, submitCount, pSubmits, fence); } VkResult result = DispatchQueueSubmit(queue, submitCount, pSubmits, fence); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordQueueSubmit(queue, submitCount, pSubmits, fence, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle( VkQueue queue) { auto layer_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateQueueWaitIdle(queue); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordQueueWaitIdle(queue); } VkResult result = DispatchQueueWaitIdle(queue); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordQueueWaitIdle(queue, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle( VkDevice device) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDeviceWaitIdle(device); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDeviceWaitIdle(device); } VkResult result = DispatchDeviceWaitIdle(device); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDeviceWaitIdle(device, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory( VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateAllocateMemory(device, pAllocateInfo, pAllocator, pMemory); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordAllocateMemory(device, pAllocateInfo, pAllocator, pMemory); } VkResult result = DispatchAllocateMemory(device, pAllocateInfo, pAllocator, pMemory); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordAllocateMemory(device, pAllocateInfo, pAllocator, pMemory, result); } return result; } VKAPI_ATTR void VKAPI_CALL FreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateFreeMemory(device, memory, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordFreeMemory(device, memory, pAllocator); } DispatchFreeMemory(device, memory, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordFreeMemory(device, memory, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL MapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateMapMemory(device, memory, offset, size, flags, ppData); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordMapMemory(device, memory, offset, size, flags, ppData); } VkResult result = DispatchMapMemory(device, memory, offset, size, flags, ppData); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordMapMemory(device, memory, offset, size, flags, ppData, result); } return result; } VKAPI_ATTR void VKAPI_CALL UnmapMemory( VkDevice device, VkDeviceMemory memory) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateUnmapMemory(device, memory); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordUnmapMemory(device, memory); } DispatchUnmapMemory(device, memory); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordUnmapMemory(device, memory); } } VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); } VkResult result = DispatchFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); } VkResult result = DispatchInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges, result); } return result; } VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); } DispatchGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); } } VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateBindBufferMemory(device, buffer, memory, memoryOffset); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordBindBufferMemory(device, buffer, memory, memoryOffset); } VkResult result = DispatchBindBufferMemory(device, buffer, memory, memoryOffset); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordBindBufferMemory(device, buffer, memory, memoryOffset, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateBindImageMemory(device, image, memory, memoryOffset); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordBindImageMemory(device, image, memory, memoryOffset); } VkResult result = DispatchBindImageMemory(device, image, memory, memoryOffset); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordBindImageMemory(device, image, memory, memoryOffset, result); } return result; } VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetBufferMemoryRequirements(device, buffer, pMemoryRequirements); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetBufferMemoryRequirements(device, buffer, pMemoryRequirements); } DispatchGetBufferMemoryRequirements(device, buffer, pMemoryRequirements); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetBufferMemoryRequirements(device, buffer, pMemoryRequirements); } } VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetImageMemoryRequirements(device, image, pMemoryRequirements); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetImageMemoryRequirements(device, image, pMemoryRequirements); } DispatchGetImageMemoryRequirements(device, image, pMemoryRequirements); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetImageMemoryRequirements(device, image, pMemoryRequirements); } } VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements( VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } DispatchGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); } DispatchGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); } } VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) { auto layer_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateQueueBindSparse(queue, bindInfoCount, pBindInfo, fence); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordQueueBindSparse(queue, bindInfoCount, pBindInfo, fence); } VkResult result = DispatchQueueBindSparse(queue, bindInfoCount, pBindInfo, fence); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordQueueBindSparse(queue, bindInfoCount, pBindInfo, fence, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL CreateFence( VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateFence(device, pCreateInfo, pAllocator, pFence); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateFence(device, pCreateInfo, pAllocator, pFence); } VkResult result = DispatchCreateFence(device, pCreateInfo, pAllocator, pFence); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateFence(device, pCreateInfo, pAllocator, pFence, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyFence(device, fence, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyFence(device, fence, pAllocator); } DispatchDestroyFence(device, fence, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyFence(device, fence, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL ResetFences( VkDevice device, uint32_t fenceCount, const VkFence* pFences) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateResetFences(device, fenceCount, pFences); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordResetFences(device, fenceCount, pFences); } VkResult result = DispatchResetFences(device, fenceCount, pFences); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordResetFences(device, fenceCount, pFences, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus( VkDevice device, VkFence fence) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetFenceStatus(device, fence); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetFenceStatus(device, fence); } VkResult result = DispatchGetFenceStatus(device, fence); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetFenceStatus(device, fence, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL WaitForFences( VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateWaitForFences(device, fenceCount, pFences, waitAll, timeout); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordWaitForFences(device, fenceCount, pFences, waitAll, timeout); } VkResult result = DispatchWaitForFences(device, fenceCount, pFences, waitAll, timeout); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordWaitForFences(device, fenceCount, pFences, waitAll, timeout, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore( VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); } VkResult result = DispatchCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroySemaphore(device, semaphore, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroySemaphore(device, semaphore, pAllocator); } DispatchDestroySemaphore(device, semaphore, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroySemaphore(device, semaphore, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL CreateEvent( VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateEvent(device, pCreateInfo, pAllocator, pEvent); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateEvent(device, pCreateInfo, pAllocator, pEvent); } VkResult result = DispatchCreateEvent(device, pCreateInfo, pAllocator, pEvent); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateEvent(device, pCreateInfo, pAllocator, pEvent, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyEvent(device, event, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyEvent(device, event, pAllocator); } DispatchDestroyEvent(device, event, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyEvent(device, event, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus( VkDevice device, VkEvent event) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetEventStatus(device, event); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetEventStatus(device, event); } VkResult result = DispatchGetEventStatus(device, event); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetEventStatus(device, event, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL SetEvent( VkDevice device, VkEvent event) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateSetEvent(device, event); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordSetEvent(device, event); } VkResult result = DispatchSetEvent(device, event); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordSetEvent(device, event, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL ResetEvent( VkDevice device, VkEvent event) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateResetEvent(device, event); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordResetEvent(device, event); } VkResult result = DispatchResetEvent(device, event); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordResetEvent(device, event, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool( VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); } VkResult result = DispatchCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyQueryPool(device, queryPool, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyQueryPool(device, queryPool, pAllocator); } DispatchDestroyQueryPool(device, queryPool, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyQueryPool(device, queryPool, pAllocator); } } 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) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); } VkResult result = DispatchGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer( VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateBuffer(device, pCreateInfo, pAllocator, pBuffer); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateBuffer(device, pCreateInfo, pAllocator, pBuffer); } VkResult result = DispatchCreateBuffer(device, pCreateInfo, pAllocator, pBuffer); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateBuffer(device, pCreateInfo, pAllocator, pBuffer, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyBuffer(device, buffer, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyBuffer(device, buffer, pAllocator); } DispatchDestroyBuffer(device, buffer, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyBuffer(device, buffer, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView( VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateBufferView(device, pCreateInfo, pAllocator, pView); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateBufferView(device, pCreateInfo, pAllocator, pView); } VkResult result = DispatchCreateBufferView(device, pCreateInfo, pAllocator, pView); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateBufferView(device, pCreateInfo, pAllocator, pView, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyBufferView(device, bufferView, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyBufferView(device, bufferView, pAllocator); } DispatchDestroyBufferView(device, bufferView, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyBufferView(device, bufferView, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL CreateImage( VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateImage(device, pCreateInfo, pAllocator, pImage); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateImage(device, pCreateInfo, pAllocator, pImage); } VkResult result = DispatchCreateImage(device, pCreateInfo, pAllocator, pImage); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateImage(device, pCreateInfo, pAllocator, pImage, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyImage(device, image, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyImage(device, image, pAllocator); } DispatchDestroyImage(device, image, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyImage(device, image, pAllocator); } } VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout( VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetImageSubresourceLayout(device, image, pSubresource, pLayout); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetImageSubresourceLayout(device, image, pSubresource, pLayout); } DispatchGetImageSubresourceLayout(device, image, pSubresource, pLayout); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetImageSubresourceLayout(device, image, pSubresource, pLayout); } } VKAPI_ATTR VkResult VKAPI_CALL CreateImageView( VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateImageView(device, pCreateInfo, pAllocator, pView); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateImageView(device, pCreateInfo, pAllocator, pView); } VkResult result = DispatchCreateImageView(device, pCreateInfo, pAllocator, pView); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateImageView(device, pCreateInfo, pAllocator, pView, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyImageView(device, imageView, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyImageView(device, imageView, pAllocator); } DispatchDestroyImageView(device, imageView, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyImageView(device, imageView, pAllocator); } } VKAPI_ATTR void VKAPI_CALL DestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyShaderModule(device, shaderModule, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyShaderModule(device, shaderModule, pAllocator); } DispatchDestroyShaderModule(device, shaderModule, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyShaderModule(device, shaderModule, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache( VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); } VkResult result = DispatchCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyPipelineCache(device, pipelineCache, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyPipelineCache(device, pipelineCache, pAllocator); } DispatchDestroyPipelineCache(device, pipelineCache, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyPipelineCache(device, pipelineCache, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPipelineCacheData(device, pipelineCache, pDataSize, pData); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPipelineCacheData(device, pipelineCache, pDataSize, pData); } VkResult result = DispatchGetPipelineCacheData(device, pipelineCache, pDataSize, pData); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPipelineCacheData(device, pipelineCache, pDataSize, pData, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); } VkResult result = DispatchMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyPipeline(device, pipeline, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyPipeline(device, pipeline, pAllocator); } DispatchDestroyPipeline(device, pipeline, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyPipeline(device, pipeline, pAllocator); } } VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyPipelineLayout(device, pipelineLayout, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyPipelineLayout(device, pipelineLayout, pAllocator); } DispatchDestroyPipelineLayout(device, pipelineLayout, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyPipelineLayout(device, pipelineLayout, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL CreateSampler( VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateSampler(device, pCreateInfo, pAllocator, pSampler); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateSampler(device, pCreateInfo, pAllocator, pSampler); } VkResult result = DispatchCreateSampler(device, pCreateInfo, pAllocator, pSampler); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateSampler(device, pCreateInfo, pAllocator, pSampler, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroySampler(device, sampler, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroySampler(device, sampler, pAllocator); } DispatchDestroySampler(device, sampler, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroySampler(device, sampler, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); } VkResult result = DispatchCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout( VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); } DispatchDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool( VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); } VkResult result = DispatchCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyDescriptorPool(device, descriptorPool, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyDescriptorPool(device, descriptorPool, pAllocator); } DispatchDestroyDescriptorPool(device, descriptorPool, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyDescriptorPool(device, descriptorPool, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateResetDescriptorPool(device, descriptorPool, flags); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordResetDescriptorPool(device, descriptorPool, flags); } VkResult result = DispatchResetDescriptorPool(device, descriptorPool, flags); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordResetDescriptorPool(device, descriptorPool, flags, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets( VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); } VkResult result = DispatchFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets, result); } return result; } VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets( VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); } DispatchUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); } } VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer( VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); } VkResult result = DispatchCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyFramebuffer(device, framebuffer, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyFramebuffer(device, framebuffer, pAllocator); } DispatchDestroyFramebuffer(device, framebuffer, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyFramebuffer(device, framebuffer, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass( VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); } VkResult result = DispatchCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyRenderPass(device, renderPass, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyRenderPass(device, renderPass, pAllocator); } DispatchDestroyRenderPass(device, renderPass, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyRenderPass(device, renderPass, pAllocator); } } VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetRenderAreaGranularity(device, renderPass, pGranularity); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetRenderAreaGranularity(device, renderPass, pGranularity); } DispatchGetRenderAreaGranularity(device, renderPass, pGranularity); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetRenderAreaGranularity(device, renderPass, pGranularity); } } VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool( VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); } VkResult result = DispatchCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyCommandPool(device, commandPool, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyCommandPool(device, commandPool, pAllocator); } DispatchDestroyCommandPool(device, commandPool, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyCommandPool(device, commandPool, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateResetCommandPool(device, commandPool, flags); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordResetCommandPool(device, commandPool, flags); } VkResult result = DispatchResetCommandPool(device, commandPool, flags); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordResetCommandPool(device, commandPool, flags, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers( VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); } VkResult result = DispatchAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers, result); } return result; } VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers( VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); } DispatchFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); } } VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateBeginCommandBuffer(commandBuffer, pBeginInfo); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordBeginCommandBuffer(commandBuffer, pBeginInfo); } VkResult result = DispatchBeginCommandBuffer(commandBuffer, pBeginInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordBeginCommandBuffer(commandBuffer, pBeginInfo, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer( VkCommandBuffer commandBuffer) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateEndCommandBuffer(commandBuffer); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordEndCommandBuffer(commandBuffer); } VkResult result = DispatchEndCommandBuffer(commandBuffer); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordEndCommandBuffer(commandBuffer, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateResetCommandBuffer(commandBuffer, flags); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordResetCommandBuffer(commandBuffer, flags); } VkResult result = DispatchResetCommandBuffer(commandBuffer, flags); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordResetCommandBuffer(commandBuffer, flags, result); } return result; } VKAPI_ATTR void VKAPI_CALL CmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); } DispatchCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); } } VKAPI_ATTR void VKAPI_CALL CmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); } DispatchCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); } } VKAPI_ATTR void VKAPI_CALL CmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); } DispatchCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); } } VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetLineWidth(commandBuffer, lineWidth); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetLineWidth(commandBuffer, lineWidth); } DispatchCmdSetLineWidth(commandBuffer, lineWidth); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetLineWidth(commandBuffer, lineWidth); } } VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias( VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); } DispatchCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); } } VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4]) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetBlendConstants(commandBuffer, blendConstants); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetBlendConstants(commandBuffer, blendConstants); } DispatchCmdSetBlendConstants(commandBuffer, blendConstants); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetBlendConstants(commandBuffer, blendConstants); } } VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); } DispatchCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); } } VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); } DispatchCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); } } VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); } DispatchCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); } } VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetStencilReference(commandBuffer, faceMask, reference); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetStencilReference(commandBuffer, faceMask, reference); } DispatchCmdSetStencilReference(commandBuffer, faceMask, reference); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetStencilReference(commandBuffer, faceMask, reference); } } VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); } DispatchCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); } } VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); } DispatchCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); } } VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); } DispatchCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); } } VKAPI_ATTR void VKAPI_CALL CmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); } DispatchCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); } } VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed( VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); } DispatchCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); } } VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); } DispatchCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); } } VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); } DispatchCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); } } VKAPI_ATTR void VKAPI_CALL CmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); } DispatchCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); } } VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDispatchIndirect(commandBuffer, buffer, offset); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDispatchIndirect(commandBuffer, buffer, offset); } DispatchCmdDispatchIndirect(commandBuffer, buffer, offset); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDispatchIndirect(commandBuffer, buffer, offset); } } VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); } DispatchCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); } } VKAPI_ATTR void VKAPI_CALL CmdCopyImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } DispatchCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } } VKAPI_ATTR void VKAPI_CALL CmdBlitImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); } DispatchCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); } } VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); } DispatchCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); } } VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); } DispatchCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); } } VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); } DispatchCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); } } VKAPI_ATTR void VKAPI_CALL CmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); } DispatchCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); } } VKAPI_ATTR void VKAPI_CALL CmdClearColorImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); } DispatchCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); } } VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); } DispatchCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); } } VKAPI_ATTR void VKAPI_CALL CmdClearAttachments( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); } DispatchCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); } } VKAPI_ATTR void VKAPI_CALL CmdResolveImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } DispatchCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } } VKAPI_ATTR void VKAPI_CALL CmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetEvent(commandBuffer, event, stageMask); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetEvent(commandBuffer, event, stageMask); } DispatchCmdSetEvent(commandBuffer, event, stageMask); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetEvent(commandBuffer, event, stageMask); } } VKAPI_ATTR void VKAPI_CALL CmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdResetEvent(commandBuffer, event, stageMask); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdResetEvent(commandBuffer, event, stageMask); } DispatchCmdResetEvent(commandBuffer, event, stageMask); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdResetEvent(commandBuffer, event, stageMask); } } VKAPI_ATTR void VKAPI_CALL CmdWaitEvents( VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); } DispatchCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); } } VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier( VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); } DispatchCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); } } VKAPI_ATTR void VKAPI_CALL CmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdBeginQuery(commandBuffer, queryPool, query, flags); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdBeginQuery(commandBuffer, queryPool, query, flags); } DispatchCmdBeginQuery(commandBuffer, queryPool, query, flags); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdBeginQuery(commandBuffer, queryPool, query, flags); } } VKAPI_ATTR void VKAPI_CALL CmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdEndQuery(commandBuffer, queryPool, query); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdEndQuery(commandBuffer, queryPool, query); } DispatchCmdEndQuery(commandBuffer, queryPool, query); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdEndQuery(commandBuffer, queryPool, query); } } VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); } DispatchCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); } } VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); } DispatchCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); } } VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); } DispatchCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); } } VKAPI_ATTR void VKAPI_CALL CmdPushConstants( VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); } DispatchCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); } } VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); } DispatchCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); } } VKAPI_ATTR void VKAPI_CALL CmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdNextSubpass(commandBuffer, contents); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdNextSubpass(commandBuffer, contents); } DispatchCmdNextSubpass(commandBuffer, contents); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdNextSubpass(commandBuffer, contents); } } VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass( VkCommandBuffer commandBuffer) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdEndRenderPass(commandBuffer); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdEndRenderPass(commandBuffer); } DispatchCmdEndRenderPass(commandBuffer); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdEndRenderPass(commandBuffer); } } VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); } DispatchCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); } } VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateBindBufferMemory2(device, bindInfoCount, pBindInfos); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordBindBufferMemory2(device, bindInfoCount, pBindInfos); } VkResult result = DispatchBindBufferMemory2(device, bindInfoCount, pBindInfos); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordBindBufferMemory2(device, bindInfoCount, pBindInfos, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateBindImageMemory2(device, bindInfoCount, pBindInfos); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordBindImageMemory2(device, bindInfoCount, pBindInfos); } VkResult result = DispatchBindImageMemory2(device, bindInfoCount, pBindInfos); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordBindImageMemory2(device, bindInfoCount, pBindInfos, result); } return result; } VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); } DispatchGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); } } VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetDeviceMask(commandBuffer, deviceMask); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetDeviceMask(commandBuffer, deviceMask); } DispatchCmdSetDeviceMask(commandBuffer, deviceMask); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetDeviceMask(commandBuffer, deviceMask); } } VKAPI_ATTR void VKAPI_CALL CmdDispatchBase( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); } DispatchCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); } } VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); } VkResult result = DispatchEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, result); } return result; } VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); } DispatchGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); } } VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2( VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); } DispatchGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); } } VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } DispatchGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceFeatures2(physicalDevice, pFeatures); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceFeatures2(physicalDevice, pFeatures); } DispatchGetPhysicalDeviceFeatures2(physicalDevice, pFeatures); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceFeatures2(physicalDevice, pFeatures); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceProperties2(physicalDevice, pProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceProperties2(physicalDevice, pProperties); } DispatchGetPhysicalDeviceProperties2(physicalDevice, pProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceProperties2(physicalDevice, pProperties); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties); } DispatchGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties); } } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); } VkResult result = DispatchGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties, result); } return result; } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); } DispatchGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties); } DispatchGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties); } DispatchGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties); } } VKAPI_ATTR void VKAPI_CALL TrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateTrimCommandPool(device, commandPool, flags); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordTrimCommandPool(device, commandPool, flags); } DispatchTrimCommandPool(device, commandPool, flags); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordTrimCommandPool(device, commandPool, flags); } } VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetDeviceQueue2(device, pQueueInfo, pQueue); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetDeviceQueue2(device, pQueueInfo, pQueue); } DispatchGetDeviceQueue2(device, pQueueInfo, pQueue); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetDeviceQueue2(device, pQueueInfo, pQueue); } } VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); } VkResult result = DispatchCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); } DispatchDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); } VkResult result = DispatchCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); } DispatchDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); } } VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); } DispatchUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); } DispatchGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); } DispatchGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); } DispatchGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); } } VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); } DispatchGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); } } VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroySurfaceKHR(instance, surface, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroySurfaceKHR(instance, surface, pAllocator); } DispatchDestroySurfaceKHR(instance, surface, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroySurfaceKHR(instance, surface, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); } VkResult result = DispatchGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); } VkResult result = DispatchGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); } VkResult result = DispatchGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); } VkResult result = DispatchGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR( VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); } VkResult result = DispatchCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroySwapchainKHR(device, swapchain, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroySwapchainKHR(device, swapchain, pAllocator); } DispatchDestroySwapchainKHR(device, swapchain, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroySwapchainKHR(device, swapchain, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); } VkResult result = DispatchGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); } VkResult result = DispatchAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR( VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateQueuePresentKHR(queue, pPresentInfo); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordQueuePresentKHR(queue, pPresentInfo); } VkResult result = DispatchQueuePresentKHR(queue, pPresentInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordQueuePresentKHR(queue, pPresentInfo, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR( VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); } VkResult result = DispatchGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); } VkResult result = DispatchGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); } VkResult result = DispatchGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); } VkResult result = DispatchAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties); } VkResult result = DispatchGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties); } VkResult result = DispatchGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays); } VkResult result = DispatchGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties); } VkResult result = DispatchGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode); } VkResult result = DispatchCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities); } VkResult result = DispatchGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR( VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); } VkResult result = DispatchCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR( VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); } VkResult result = DispatchCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains, result); } return result; } #ifdef VK_USE_PLATFORM_XLIB_KHR VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR( VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); } VkResult result = DispatchCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface, result); } return result; } VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID); if (skip) return VK_FALSE; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID); } VkBool32 result = DispatchGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID); } return result; } #endif // VK_USE_PLATFORM_XLIB_KHR #ifdef VK_USE_PLATFORM_XCB_KHR VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR( VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); } VkResult result = DispatchCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface, result); } return result; } VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id); if (skip) return VK_FALSE; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id); } VkBool32 result = DispatchGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id); } return result; } #endif // VK_USE_PLATFORM_XCB_KHR #ifdef VK_USE_PLATFORM_WAYLAND_KHR VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR( VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); } VkResult result = DispatchCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface, result); } return result; } VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display); if (skip) return VK_FALSE; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display); } VkBool32 result = DispatchGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display); } return result; } #endif // VK_USE_PLATFORM_WAYLAND_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR( VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); } VkResult result = DispatchCreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface, result); } return result; } #endif // VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR( VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); } VkResult result = DispatchCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface, result); } return result; } VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex); if (skip) return VK_FALSE; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex); } VkBool32 result = DispatchGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex); } return result; } #endif // VK_USE_PLATFORM_WIN32_KHR VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); } DispatchGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); } DispatchGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); } DispatchGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); } } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); } VkResult result = DispatchGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties, result); } return result; } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); } DispatchGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); } DispatchGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); } DispatchGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); } } VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); } DispatchGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); } } VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetDeviceMaskKHR(commandBuffer, deviceMask); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetDeviceMaskKHR(commandBuffer, deviceMask); } DispatchCmdSetDeviceMaskKHR(commandBuffer, deviceMask); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetDeviceMaskKHR(commandBuffer, deviceMask); } } VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); } DispatchCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); } } VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateTrimCommandPoolKHR(device, commandPool, flags); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordTrimCommandPoolKHR(device, commandPool, flags); } DispatchTrimCommandPoolKHR(device, commandPool, flags); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordTrimCommandPoolKHR(device, commandPool, flags); } } VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); } VkResult result = DispatchEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, result); } return result; } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); } DispatchGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); } } #ifdef VK_USE_PLATFORM_WIN32_KHR VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); } VkResult result = DispatchGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties); } VkResult result = DispatchGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties, result); } return result; } #endif // VK_USE_PLATFORM_WIN32_KHR VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetMemoryFdKHR(device, pGetFdInfo, pFd); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetMemoryFdKHR(device, pGetFdInfo, pFd); } VkResult result = DispatchGetMemoryFdKHR(device, pGetFdInfo, pFd); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetMemoryFdKHR(device, pGetFdInfo, pFd, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); } VkResult result = DispatchGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties, result); } return result; } #ifdef VK_USE_PLATFORM_WIN32_KHR #endif // VK_USE_PLATFORM_WIN32_KHR VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); } DispatchGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); } } #ifdef VK_USE_PLATFORM_WIN32_KHR VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR( VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); } VkResult result = DispatchImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR( VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); } VkResult result = DispatchGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle, result); } return result; } #endif // VK_USE_PLATFORM_WIN32_KHR VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); } VkResult result = DispatchImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetSemaphoreFdKHR(device, pGetFdInfo, pFd); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetSemaphoreFdKHR(device, pGetFdInfo, pFd); } VkResult result = DispatchGetSemaphoreFdKHR(device, pGetFdInfo, pFd); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetSemaphoreFdKHR(device, pGetFdInfo, pFd, result); } return result; } VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); } DispatchCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); } } VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); } DispatchCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); } } VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); } VkResult result = DispatchCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); } DispatchDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); } } VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); } DispatchUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); } } VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR( VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass); } VkResult result = DispatchCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass, result); } return result; } VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); } DispatchCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); } } VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR( VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); } DispatchCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); } } VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo); } DispatchCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo); } } VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetSwapchainStatusKHR(device, swapchain); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetSwapchainStatusKHR(device, swapchain); } VkResult result = DispatchGetSwapchainStatusKHR(device, swapchain); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetSwapchainStatusKHR(device, swapchain, result); } return result; } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); } DispatchGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); } } #ifdef VK_USE_PLATFORM_WIN32_KHR VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); } VkResult result = DispatchImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); } VkResult result = DispatchGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle, result); } return result; } #endif // VK_USE_PLATFORM_WIN32_KHR VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateImportFenceFdKHR(device, pImportFenceFdInfo); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordImportFenceFdKHR(device, pImportFenceFdInfo); } VkResult result = DispatchImportFenceFdKHR(device, pImportFenceFdInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordImportFenceFdKHR(device, pImportFenceFdInfo, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetFenceFdKHR(device, pGetFdInfo, pFd); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetFenceFdKHR(device, pGetFdInfo, pFd); } VkResult result = DispatchGetFenceFdKHR(device, pGetFdInfo, pFd); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetFenceFdKHR(device, pGetFdInfo, pFd, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities); } VkResult result = DispatchGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); } VkResult result = DispatchGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties); } VkResult result = DispatchGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties); } VkResult result = DispatchGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties); } VkResult result = DispatchGetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities); } VkResult result = DispatchGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities, result); } return result; } VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } DispatchGetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } } VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR( VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } DispatchGetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } } VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } DispatchGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } } VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion); } VkResult result = DispatchCreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator); } DispatchDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateBindBufferMemory2KHR(device, bindInfoCount, pBindInfos); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordBindBufferMemory2KHR(device, bindInfoCount, pBindInfos); } VkResult result = DispatchBindBufferMemory2KHR(device, bindInfoCount, pBindInfos); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordBindBufferMemory2KHR(device, bindInfoCount, pBindInfos, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateBindImageMemory2KHR(device, bindInfoCount, pBindInfos); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordBindImageMemory2KHR(device, bindInfoCount, pBindInfos); } VkResult result = DispatchBindImageMemory2KHR(device, bindInfoCount, pBindInfos); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordBindImageMemory2KHR(device, bindInfoCount, pBindInfos, result); } return result; } VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport); } DispatchGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport); } } VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } DispatchCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } } VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } DispatchCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } } VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR( VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties); } VkResult result = DispatchGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR( VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics); } VkResult result = DispatchGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR( VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); } VkResult result = DispatchGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT( VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); } VkResult result = DispatchCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); layer_create_report_callback(layer_data->report_data, false, pCreateInfo, pAllocator, pCallback); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT( VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyDebugReportCallbackEXT(instance, callback, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyDebugReportCallbackEXT(instance, callback, pAllocator); } DispatchDestroyDebugReportCallbackEXT(instance, callback, pAllocator); layer_destroy_report_callback(layer_data->report_data, callback, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyDebugReportCallbackEXT(instance, callback, pAllocator); } } VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT( VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); } DispatchDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); } } VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDebugMarkerSetObjectTagEXT(device, pTagInfo); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDebugMarkerSetObjectTagEXT(device, pTagInfo); } VkResult result = DispatchDebugMarkerSetObjectTagEXT(device, pTagInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDebugMarkerSetObjectTagEXT(device, pTagInfo, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDebugMarkerSetObjectNameEXT(device, pNameInfo); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDebugMarkerSetObjectNameEXT(device, pNameInfo); } layer_data->report_data->DebugReportSetMarkerObjectName(pNameInfo); VkResult result = DispatchDebugMarkerSetObjectNameEXT(device, pNameInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDebugMarkerSetObjectNameEXT(device, pNameInfo, result); } return result; } VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); } DispatchCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); } } VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDebugMarkerEndEXT(commandBuffer); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDebugMarkerEndEXT(commandBuffer); } DispatchCmdDebugMarkerEndEXT(commandBuffer); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDebugMarkerEndEXT(commandBuffer); } } VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); } DispatchCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); } } VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); } DispatchCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); } } VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); } DispatchCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); } } VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); } DispatchCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); } } VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); } DispatchCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); } } VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); } DispatchCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); } } VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); } DispatchCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); } } VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX( VkDevice device, const VkImageViewHandleInfoNVX* pInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetImageViewHandleNVX(device, pInfo); if (skip) return 0; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetImageViewHandleNVX(device, pInfo); } uint32_t result = DispatchGetImageViewHandleNVX(device, pInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetImageViewHandleNVX(device, pInfo); } return result; } VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } DispatchCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } } VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } DispatchCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } } VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD( VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo); } VkResult result = DispatchGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo, result); } return result; } #ifdef VK_USE_PLATFORM_GGP VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP( VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface); } VkResult result = DispatchCreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface, result); } return result; } #endif // VK_USE_PLATFORM_GGP VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); } VkResult result = DispatchGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties, result); } return result; } #ifdef VK_USE_PLATFORM_WIN32_KHR VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV( VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetMemoryWin32HandleNV(device, memory, handleType, pHandle); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetMemoryWin32HandleNV(device, memory, handleType, pHandle); } VkResult result = DispatchGetMemoryWin32HandleNV(device, memory, handleType, pHandle); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetMemoryWin32HandleNV(device, memory, handleType, pHandle, result); } return result; } #endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR #endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_VI_NN VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN( VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface); } VkResult result = DispatchCreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface, result); } return result; } #endif // VK_USE_PLATFORM_VI_NN VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT( VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); } DispatchCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); } } VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdEndConditionalRenderingEXT(commandBuffer); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdEndConditionalRenderingEXT(commandBuffer); } DispatchCmdEndConditionalRenderingEXT(commandBuffer); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdEndConditionalRenderingEXT(commandBuffer); } } VKAPI_ATTR void VKAPI_CALL CmdProcessCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo); } DispatchCmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo); } } VKAPI_ATTR void VKAPI_CALL CmdReserveSpaceForCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo); } DispatchCmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo); } } VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNVX( VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); } VkResult result = DispatchCreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNVX( VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator); } DispatchDestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL CreateObjectTableNVX( VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable); } VkResult result = DispatchCreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyObjectTableNVX( VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyObjectTableNVX(device, objectTable, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyObjectTableNVX(device, objectTable, pAllocator); } DispatchDestroyObjectTableNVX(device, objectTable, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyObjectTableNVX(device, objectTable, pAllocator); } } VKAPI_ATTR VkResult VKAPI_CALL RegisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateRegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordRegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices); } VkResult result = DispatchRegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordRegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL UnregisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateUnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordUnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices); } VkResult result = DispatchUnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordUnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices, result); } return result; } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceGeneratedCommandsPropertiesNVX( VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceGeneratedCommandsPropertiesNVX(physicalDevice, pFeatures, pLimits); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceGeneratedCommandsPropertiesNVX(physicalDevice, pFeatures, pLimits); } DispatchGetPhysicalDeviceGeneratedCommandsPropertiesNVX(physicalDevice, pFeatures, pLimits); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceGeneratedCommandsPropertiesNVX(physicalDevice, pFeatures, pLimits); } } VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); } DispatchCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); } } VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateReleaseDisplayEXT(physicalDevice, display); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordReleaseDisplayEXT(physicalDevice, display); } VkResult result = DispatchReleaseDisplayEXT(physicalDevice, display); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordReleaseDisplayEXT(physicalDevice, display, result); } return result; } #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateAcquireXlibDisplayEXT(physicalDevice, dpy, display); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordAcquireXlibDisplayEXT(physicalDevice, dpy, display); } VkResult result = DispatchAcquireXlibDisplayEXT(physicalDevice, dpy, display); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordAcquireXlibDisplayEXT(physicalDevice, dpy, display, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay); } VkResult result = DispatchGetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay, result); } return result; } #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); } VkResult result = DispatchGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDisplayPowerControlEXT(device, display, pDisplayPowerInfo); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDisplayPowerControlEXT(device, display, pDisplayPowerInfo); } VkResult result = DispatchDisplayPowerControlEXT(device, display, pDisplayPowerInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDisplayPowerControlEXT(device, display, pDisplayPowerInfo, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT( VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence); } VkResult result = DispatchRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT( VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence); } VkResult result = DispatchRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT( VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue); } VkResult result = DispatchGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE( VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties); } VkResult result = DispatchGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings); } VkResult result = DispatchGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings, result); } return result; } VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); } DispatchCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); } } VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT( VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); } DispatchSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); } } #ifdef VK_USE_PLATFORM_IOS_MVK VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK( VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); } VkResult result = DispatchCreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface, result); } return result; } #endif // VK_USE_PLATFORM_IOS_MVK #ifdef VK_USE_PLATFORM_MACOS_MVK VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK( VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); } VkResult result = DispatchCreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface, result); } return result; } #endif // VK_USE_PLATFORM_MACOS_MVK VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateSetDebugUtilsObjectNameEXT(device, pNameInfo); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordSetDebugUtilsObjectNameEXT(device, pNameInfo); } layer_data->report_data->DebugReportSetUtilsObjectName(pNameInfo); VkResult result = DispatchSetDebugUtilsObjectNameEXT(device, pNameInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordSetDebugUtilsObjectNameEXT(device, pNameInfo, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateSetDebugUtilsObjectTagEXT(device, pTagInfo); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordSetDebugUtilsObjectTagEXT(device, pTagInfo); } VkResult result = DispatchSetDebugUtilsObjectTagEXT(device, pTagInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordSetDebugUtilsObjectTagEXT(device, pTagInfo, result); } return result; } VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); } BeginQueueDebugUtilsLabel(layer_data->report_data, queue, pLabelInfo); DispatchQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); } } VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT( VkQueue queue) { auto layer_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateQueueEndDebugUtilsLabelEXT(queue); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordQueueEndDebugUtilsLabelEXT(queue); } DispatchQueueEndDebugUtilsLabelEXT(queue); EndQueueDebugUtilsLabel(layer_data->report_data, queue); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordQueueEndDebugUtilsLabelEXT(queue); } } VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); } InsertQueueDebugUtilsLabel(layer_data->report_data, queue, pLabelInfo); DispatchQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); } } VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); } DispatchCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); } } VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdEndDebugUtilsLabelEXT(commandBuffer); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdEndDebugUtilsLabelEXT(commandBuffer); } DispatchCmdEndDebugUtilsLabelEXT(commandBuffer); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdEndDebugUtilsLabelEXT(commandBuffer); } } VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); } DispatchCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); } } VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT( VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); } VkResult result = DispatchCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); layer_create_messenger_callback(layer_data->report_data, false, pCreateInfo, pAllocator, pMessenger); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT( VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); } DispatchDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); layer_destroy_messenger_callback(layer_data->report_data, messenger, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); } } VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT( VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); } DispatchSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); } } #ifdef VK_USE_PLATFORM_ANDROID_KHR VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID( VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties); } VkResult result = DispatchGetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID( VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer); } VkResult result = DispatchGetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer, result); } return result; } #endif // VK_USE_PLATFORM_ANDROID_KHR VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); } DispatchCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); } } VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties); } DispatchGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties); } } VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT( VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties); } VkResult result = DispatchGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties, result); } return result; } VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout); } DispatchCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout); } } VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); } DispatchCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); } } VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); } DispatchCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); } } VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV( VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure); } VkResult result = DispatchCreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure, result); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateDestroyAccelerationStructureNV(device, accelerationStructure, pAllocator); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordDestroyAccelerationStructureNV(device, accelerationStructure, pAllocator); } DispatchDestroyAccelerationStructureNV(device, accelerationStructure, pAllocator); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordDestroyAccelerationStructureNV(device, accelerationStructure, pAllocator); } } VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV( VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements); } DispatchGetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements); } } VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV( VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateBindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordBindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos); } VkResult result = DispatchBindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordBindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos, result); } return result; } VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); } DispatchCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); } } VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode); } DispatchCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode); } } VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV( VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); } DispatchCmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); } } VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV( VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData); } VkResult result = DispatchGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData); } VkResult result = DispatchGetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData, result); } return result; } VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); } DispatchCmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); } } VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCompileDeferredNV(device, pipeline, shader); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCompileDeferredNV(device, pipeline, shader); } VkResult result = DispatchCompileDeferredNV(device, pipeline, shader); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCompileDeferredNV(device, pipeline, shader, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties); } VkResult result = DispatchGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties, result); } return result; } VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); } DispatchCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); } } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains); } VkResult result = DispatchGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT( VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); } VkResult result = DispatchGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation, result); } return result; } #ifdef VK_USE_PLATFORM_GGP #endif // VK_USE_PLATFORM_GGP VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask); } DispatchCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask); } } VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride); } DispatchCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride); } } VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } DispatchCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } } VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); } DispatchCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); } } VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void* pCheckpointMarker) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetCheckpointNV(commandBuffer, pCheckpointMarker); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetCheckpointNV(commandBuffer, pCheckpointMarker); } DispatchCmdSetCheckpointNV(commandBuffer, pCheckpointMarker); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetCheckpointNV(commandBuffer, pCheckpointMarker); } } VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV( VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) { auto layer_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData); } DispatchGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData); } } VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL( VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateInitializePerformanceApiINTEL(device, pInitializeInfo); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordInitializePerformanceApiINTEL(device, pInitializeInfo); } VkResult result = DispatchInitializePerformanceApiINTEL(device, pInitializeInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordInitializePerformanceApiINTEL(device, pInitializeInfo, result); } return result; } VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL( VkDevice device) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateUninitializePerformanceApiINTEL(device); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordUninitializePerformanceApiINTEL(device); } DispatchUninitializePerformanceApiINTEL(device); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordUninitializePerformanceApiINTEL(device); } } VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo); } VkResult result = DispatchCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo); } VkResult result = DispatchCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL( VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo); } VkResult result = DispatchCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL AcquirePerformanceConfigurationINTEL( VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateAcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordAcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration); } VkResult result = DispatchAcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordAcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL( VkDevice device, VkPerformanceConfigurationINTEL configuration) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateReleasePerformanceConfigurationINTEL(device, configuration); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordReleasePerformanceConfigurationINTEL(device, configuration); } VkResult result = DispatchReleasePerformanceConfigurationINTEL(device, configuration); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordReleasePerformanceConfigurationINTEL(device, configuration, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL( VkQueue queue, VkPerformanceConfigurationINTEL configuration) { auto layer_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateQueueSetPerformanceConfigurationINTEL(queue, configuration); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordQueueSetPerformanceConfigurationINTEL(queue, configuration); } VkResult result = DispatchQueueSetPerformanceConfigurationINTEL(queue, configuration); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordQueueSetPerformanceConfigurationINTEL(queue, configuration, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL( VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPerformanceParameterINTEL(device, parameter, pValue); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPerformanceParameterINTEL(device, parameter, pValue); } VkResult result = DispatchGetPerformanceParameterINTEL(device, parameter, pValue); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPerformanceParameterINTEL(device, parameter, pValue, result); } return result; } VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD( VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateSetLocalDimmingAMD(device, swapChain, localDimmingEnable); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordSetLocalDimmingAMD(device, swapChain, localDimmingEnable); } DispatchSetLocalDimmingAMD(device, swapChain, localDimmingEnable); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordSetLocalDimmingAMD(device, swapChain, localDimmingEnable); } } #ifdef VK_USE_PLATFORM_FUCHSIA VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA( VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface); } VkResult result = DispatchCreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface, result); } return result; } #endif // VK_USE_PLATFORM_FUCHSIA #ifdef VK_USE_PLATFORM_METAL_EXT VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT( VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); } VkResult result = DispatchCreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface, result); } return result; } #endif // VK_USE_PLATFORM_METAL_EXT VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT( VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetBufferDeviceAddressEXT(device, pInfo); if (skip) return 0; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetBufferDeviceAddressEXT(device, pInfo); } VkDeviceAddress result = DispatchGetBufferDeviceAddressEXT(device, pInfo); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetBufferDeviceAddressEXT(device, pInfo); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties); } VkResult result = DispatchGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations); } VkResult result = DispatchGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations, result); } return result; } #ifdef VK_USE_PLATFORM_WIN32_KHR VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes); } VkResult result = DispatchGetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateAcquireFullScreenExclusiveModeEXT(device, swapchain); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordAcquireFullScreenExclusiveModeEXT(device, swapchain); } VkResult result = DispatchAcquireFullScreenExclusiveModeEXT(device, swapchain); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordAcquireFullScreenExclusiveModeEXT(device, swapchain, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateReleaseFullScreenExclusiveModeEXT(device, swapchain); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordReleaseFullScreenExclusiveModeEXT(device, swapchain); } VkResult result = DispatchReleaseFullScreenExclusiveModeEXT(device, swapchain); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordReleaseFullScreenExclusiveModeEXT(device, swapchain, result); } return result; } VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT( VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateGetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordGetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes); } VkResult result = DispatchGetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordGetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes, result); } return result; } #endif // VK_USE_PLATFORM_WIN32_KHR VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT( VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); } VkResult result = DispatchCreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface, result); } return result; } VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) { auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); } DispatchCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); } } VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); skip |= intercept->PreCallValidateResetQueryPoolEXT(device, queryPool, firstQuery, queryCount); if (skip) return; } for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PreCallRecordResetQueryPoolEXT(device, queryPool, firstQuery, queryCount); } DispatchResetQueryPoolEXT(device, queryPool, firstQuery, queryCount); for (auto intercept : layer_data->object_dispatch) { auto lock = intercept->write_lock(); intercept->PostCallRecordResetQueryPoolEXT(device, queryPool, firstQuery, queryCount); } } // Map of intercepted ApiName to its associated function data const std::unordered_map name_to_funcptr_map = { {"vkCreateInstance", {true, (void*)CreateInstance}}, {"vkDestroyInstance", {true, (void*)DestroyInstance}}, {"vkEnumeratePhysicalDevices", {true, (void*)EnumeratePhysicalDevices}}, {"vkGetPhysicalDeviceFeatures", {true, (void*)GetPhysicalDeviceFeatures}}, {"vkGetPhysicalDeviceFormatProperties", {true, (void*)GetPhysicalDeviceFormatProperties}}, {"vkGetPhysicalDeviceImageFormatProperties", {true, (void*)GetPhysicalDeviceImageFormatProperties}}, {"vkGetPhysicalDeviceProperties", {true, (void*)GetPhysicalDeviceProperties}}, {"vkGetPhysicalDeviceQueueFamilyProperties", {true, (void*)GetPhysicalDeviceQueueFamilyProperties}}, {"vkGetPhysicalDeviceMemoryProperties", {true, (void*)GetPhysicalDeviceMemoryProperties}}, {"vkGetInstanceProcAddr", {true, (void*)GetInstanceProcAddr}}, {"vkGetDeviceProcAddr", {false, (void*)GetDeviceProcAddr}}, {"vkCreateDevice", {true, (void*)CreateDevice}}, {"vkDestroyDevice", {false, (void*)DestroyDevice}}, {"vkEnumerateInstanceExtensionProperties", {false, (void*)EnumerateInstanceExtensionProperties}}, {"vkEnumerateDeviceExtensionProperties", {true, (void*)EnumerateDeviceExtensionProperties}}, {"vkEnumerateInstanceLayerProperties", {false, (void*)EnumerateInstanceLayerProperties}}, {"vkEnumerateDeviceLayerProperties", {true, (void*)EnumerateDeviceLayerProperties}}, {"vkGetDeviceQueue", {false, (void*)GetDeviceQueue}}, {"vkQueueSubmit", {false, (void*)QueueSubmit}}, {"vkQueueWaitIdle", {false, (void*)QueueWaitIdle}}, {"vkDeviceWaitIdle", {false, (void*)DeviceWaitIdle}}, {"vkAllocateMemory", {false, (void*)AllocateMemory}}, {"vkFreeMemory", {false, (void*)FreeMemory}}, {"vkMapMemory", {false, (void*)MapMemory}}, {"vkUnmapMemory", {false, (void*)UnmapMemory}}, {"vkFlushMappedMemoryRanges", {false, (void*)FlushMappedMemoryRanges}}, {"vkInvalidateMappedMemoryRanges", {false, (void*)InvalidateMappedMemoryRanges}}, {"vkGetDeviceMemoryCommitment", {false, (void*)GetDeviceMemoryCommitment}}, {"vkBindBufferMemory", {false, (void*)BindBufferMemory}}, {"vkBindImageMemory", {false, (void*)BindImageMemory}}, {"vkGetBufferMemoryRequirements", {false, (void*)GetBufferMemoryRequirements}}, {"vkGetImageMemoryRequirements", {false, (void*)GetImageMemoryRequirements}}, {"vkGetImageSparseMemoryRequirements", {false, (void*)GetImageSparseMemoryRequirements}}, {"vkGetPhysicalDeviceSparseImageFormatProperties", {true, (void*)GetPhysicalDeviceSparseImageFormatProperties}}, {"vkQueueBindSparse", {false, (void*)QueueBindSparse}}, {"vkCreateFence", {false, (void*)CreateFence}}, {"vkDestroyFence", {false, (void*)DestroyFence}}, {"vkResetFences", {false, (void*)ResetFences}}, {"vkGetFenceStatus", {false, (void*)GetFenceStatus}}, {"vkWaitForFences", {false, (void*)WaitForFences}}, {"vkCreateSemaphore", {false, (void*)CreateSemaphore}}, {"vkDestroySemaphore", {false, (void*)DestroySemaphore}}, {"vkCreateEvent", {false, (void*)CreateEvent}}, {"vkDestroyEvent", {false, (void*)DestroyEvent}}, {"vkGetEventStatus", {false, (void*)GetEventStatus}}, {"vkSetEvent", {false, (void*)SetEvent}}, {"vkResetEvent", {false, (void*)ResetEvent}}, {"vkCreateQueryPool", {false, (void*)CreateQueryPool}}, {"vkDestroyQueryPool", {false, (void*)DestroyQueryPool}}, {"vkGetQueryPoolResults", {false, (void*)GetQueryPoolResults}}, {"vkCreateBuffer", {false, (void*)CreateBuffer}}, {"vkDestroyBuffer", {false, (void*)DestroyBuffer}}, {"vkCreateBufferView", {false, (void*)CreateBufferView}}, {"vkDestroyBufferView", {false, (void*)DestroyBufferView}}, {"vkCreateImage", {false, (void*)CreateImage}}, {"vkDestroyImage", {false, (void*)DestroyImage}}, {"vkGetImageSubresourceLayout", {false, (void*)GetImageSubresourceLayout}}, {"vkCreateImageView", {false, (void*)CreateImageView}}, {"vkDestroyImageView", {false, (void*)DestroyImageView}}, {"vkCreateShaderModule", {false, (void*)CreateShaderModule}}, {"vkDestroyShaderModule", {false, (void*)DestroyShaderModule}}, {"vkCreatePipelineCache", {false, (void*)CreatePipelineCache}}, {"vkDestroyPipelineCache", {false, (void*)DestroyPipelineCache}}, {"vkGetPipelineCacheData", {false, (void*)GetPipelineCacheData}}, {"vkMergePipelineCaches", {false, (void*)MergePipelineCaches}}, {"vkCreateGraphicsPipelines", {false, (void*)CreateGraphicsPipelines}}, {"vkCreateComputePipelines", {false, (void*)CreateComputePipelines}}, {"vkDestroyPipeline", {false, (void*)DestroyPipeline}}, {"vkCreatePipelineLayout", {false, (void*)CreatePipelineLayout}}, {"vkDestroyPipelineLayout", {false, (void*)DestroyPipelineLayout}}, {"vkCreateSampler", {false, (void*)CreateSampler}}, {"vkDestroySampler", {false, (void*)DestroySampler}}, {"vkCreateDescriptorSetLayout", {false, (void*)CreateDescriptorSetLayout}}, {"vkDestroyDescriptorSetLayout", {false, (void*)DestroyDescriptorSetLayout}}, {"vkCreateDescriptorPool", {false, (void*)CreateDescriptorPool}}, {"vkDestroyDescriptorPool", {false, (void*)DestroyDescriptorPool}}, {"vkResetDescriptorPool", {false, (void*)ResetDescriptorPool}}, {"vkAllocateDescriptorSets", {false, (void*)AllocateDescriptorSets}}, {"vkFreeDescriptorSets", {false, (void*)FreeDescriptorSets}}, {"vkUpdateDescriptorSets", {false, (void*)UpdateDescriptorSets}}, {"vkCreateFramebuffer", {false, (void*)CreateFramebuffer}}, {"vkDestroyFramebuffer", {false, (void*)DestroyFramebuffer}}, {"vkCreateRenderPass", {false, (void*)CreateRenderPass}}, {"vkDestroyRenderPass", {false, (void*)DestroyRenderPass}}, {"vkGetRenderAreaGranularity", {false, (void*)GetRenderAreaGranularity}}, {"vkCreateCommandPool", {false, (void*)CreateCommandPool}}, {"vkDestroyCommandPool", {false, (void*)DestroyCommandPool}}, {"vkResetCommandPool", {false, (void*)ResetCommandPool}}, {"vkAllocateCommandBuffers", {false, (void*)AllocateCommandBuffers}}, {"vkFreeCommandBuffers", {false, (void*)FreeCommandBuffers}}, {"vkBeginCommandBuffer", {false, (void*)BeginCommandBuffer}}, {"vkEndCommandBuffer", {false, (void*)EndCommandBuffer}}, {"vkResetCommandBuffer", {false, (void*)ResetCommandBuffer}}, {"vkCmdBindPipeline", {false, (void*)CmdBindPipeline}}, {"vkCmdSetViewport", {false, (void*)CmdSetViewport}}, {"vkCmdSetScissor", {false, (void*)CmdSetScissor}}, {"vkCmdSetLineWidth", {false, (void*)CmdSetLineWidth}}, {"vkCmdSetDepthBias", {false, (void*)CmdSetDepthBias}}, {"vkCmdSetBlendConstants", {false, (void*)CmdSetBlendConstants}}, {"vkCmdSetDepthBounds", {false, (void*)CmdSetDepthBounds}}, {"vkCmdSetStencilCompareMask", {false, (void*)CmdSetStencilCompareMask}}, {"vkCmdSetStencilWriteMask", {false, (void*)CmdSetStencilWriteMask}}, {"vkCmdSetStencilReference", {false, (void*)CmdSetStencilReference}}, {"vkCmdBindDescriptorSets", {false, (void*)CmdBindDescriptorSets}}, {"vkCmdBindIndexBuffer", {false, (void*)CmdBindIndexBuffer}}, {"vkCmdBindVertexBuffers", {false, (void*)CmdBindVertexBuffers}}, {"vkCmdDraw", {false, (void*)CmdDraw}}, {"vkCmdDrawIndexed", {false, (void*)CmdDrawIndexed}}, {"vkCmdDrawIndirect", {false, (void*)CmdDrawIndirect}}, {"vkCmdDrawIndexedIndirect", {false, (void*)CmdDrawIndexedIndirect}}, {"vkCmdDispatch", {false, (void*)CmdDispatch}}, {"vkCmdDispatchIndirect", {false, (void*)CmdDispatchIndirect}}, {"vkCmdCopyBuffer", {false, (void*)CmdCopyBuffer}}, {"vkCmdCopyImage", {false, (void*)CmdCopyImage}}, {"vkCmdBlitImage", {false, (void*)CmdBlitImage}}, {"vkCmdCopyBufferToImage", {false, (void*)CmdCopyBufferToImage}}, {"vkCmdCopyImageToBuffer", {false, (void*)CmdCopyImageToBuffer}}, {"vkCmdUpdateBuffer", {false, (void*)CmdUpdateBuffer}}, {"vkCmdFillBuffer", {false, (void*)CmdFillBuffer}}, {"vkCmdClearColorImage", {false, (void*)CmdClearColorImage}}, {"vkCmdClearDepthStencilImage", {false, (void*)CmdClearDepthStencilImage}}, {"vkCmdClearAttachments", {false, (void*)CmdClearAttachments}}, {"vkCmdResolveImage", {false, (void*)CmdResolveImage}}, {"vkCmdSetEvent", {false, (void*)CmdSetEvent}}, {"vkCmdResetEvent", {false, (void*)CmdResetEvent}}, {"vkCmdWaitEvents", {false, (void*)CmdWaitEvents}}, {"vkCmdPipelineBarrier", {false, (void*)CmdPipelineBarrier}}, {"vkCmdBeginQuery", {false, (void*)CmdBeginQuery}}, {"vkCmdEndQuery", {false, (void*)CmdEndQuery}}, {"vkCmdResetQueryPool", {false, (void*)CmdResetQueryPool}}, {"vkCmdWriteTimestamp", {false, (void*)CmdWriteTimestamp}}, {"vkCmdCopyQueryPoolResults", {false, (void*)CmdCopyQueryPoolResults}}, {"vkCmdPushConstants", {false, (void*)CmdPushConstants}}, {"vkCmdBeginRenderPass", {false, (void*)CmdBeginRenderPass}}, {"vkCmdNextSubpass", {false, (void*)CmdNextSubpass}}, {"vkCmdEndRenderPass", {false, (void*)CmdEndRenderPass}}, {"vkCmdExecuteCommands", {false, (void*)CmdExecuteCommands}}, {"vkBindBufferMemory2", {false, (void*)BindBufferMemory2}}, {"vkBindImageMemory2", {false, (void*)BindImageMemory2}}, {"vkGetDeviceGroupPeerMemoryFeatures", {false, (void*)GetDeviceGroupPeerMemoryFeatures}}, {"vkCmdSetDeviceMask", {false, (void*)CmdSetDeviceMask}}, {"vkCmdDispatchBase", {false, (void*)CmdDispatchBase}}, {"vkEnumeratePhysicalDeviceGroups", {true, (void*)EnumeratePhysicalDeviceGroups}}, {"vkGetImageMemoryRequirements2", {false, (void*)GetImageMemoryRequirements2}}, {"vkGetBufferMemoryRequirements2", {false, (void*)GetBufferMemoryRequirements2}}, {"vkGetImageSparseMemoryRequirements2", {false, (void*)GetImageSparseMemoryRequirements2}}, {"vkGetPhysicalDeviceFeatures2", {true, (void*)GetPhysicalDeviceFeatures2}}, {"vkGetPhysicalDeviceProperties2", {true, (void*)GetPhysicalDeviceProperties2}}, {"vkGetPhysicalDeviceFormatProperties2", {true, (void*)GetPhysicalDeviceFormatProperties2}}, {"vkGetPhysicalDeviceImageFormatProperties2", {true, (void*)GetPhysicalDeviceImageFormatProperties2}}, {"vkGetPhysicalDeviceQueueFamilyProperties2", {true, (void*)GetPhysicalDeviceQueueFamilyProperties2}}, {"vkGetPhysicalDeviceMemoryProperties2", {true, (void*)GetPhysicalDeviceMemoryProperties2}}, {"vkGetPhysicalDeviceSparseImageFormatProperties2", {true, (void*)GetPhysicalDeviceSparseImageFormatProperties2}}, {"vkTrimCommandPool", {false, (void*)TrimCommandPool}}, {"vkGetDeviceQueue2", {false, (void*)GetDeviceQueue2}}, {"vkCreateSamplerYcbcrConversion", {false, (void*)CreateSamplerYcbcrConversion}}, {"vkDestroySamplerYcbcrConversion", {false, (void*)DestroySamplerYcbcrConversion}}, {"vkCreateDescriptorUpdateTemplate", {false, (void*)CreateDescriptorUpdateTemplate}}, {"vkDestroyDescriptorUpdateTemplate", {false, (void*)DestroyDescriptorUpdateTemplate}}, {"vkUpdateDescriptorSetWithTemplate", {false, (void*)UpdateDescriptorSetWithTemplate}}, {"vkGetPhysicalDeviceExternalBufferProperties", {true, (void*)GetPhysicalDeviceExternalBufferProperties}}, {"vkGetPhysicalDeviceExternalFenceProperties", {true, (void*)GetPhysicalDeviceExternalFenceProperties}}, {"vkGetPhysicalDeviceExternalSemaphoreProperties", {true, (void*)GetPhysicalDeviceExternalSemaphoreProperties}}, {"vkGetDescriptorSetLayoutSupport", {false, (void*)GetDescriptorSetLayoutSupport}}, {"vkDestroySurfaceKHR", {true, (void*)DestroySurfaceKHR}}, {"vkGetPhysicalDeviceSurfaceSupportKHR", {true, (void*)GetPhysicalDeviceSurfaceSupportKHR}}, {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", {true, (void*)GetPhysicalDeviceSurfaceCapabilitiesKHR}}, {"vkGetPhysicalDeviceSurfaceFormatsKHR", {true, (void*)GetPhysicalDeviceSurfaceFormatsKHR}}, {"vkGetPhysicalDeviceSurfacePresentModesKHR", {true, (void*)GetPhysicalDeviceSurfacePresentModesKHR}}, {"vkCreateSwapchainKHR", {false, (void*)CreateSwapchainKHR}}, {"vkDestroySwapchainKHR", {false, (void*)DestroySwapchainKHR}}, {"vkGetSwapchainImagesKHR", {false, (void*)GetSwapchainImagesKHR}}, {"vkAcquireNextImageKHR", {false, (void*)AcquireNextImageKHR}}, {"vkQueuePresentKHR", {false, (void*)QueuePresentKHR}}, {"vkGetDeviceGroupPresentCapabilitiesKHR", {false, (void*)GetDeviceGroupPresentCapabilitiesKHR}}, {"vkGetDeviceGroupSurfacePresentModesKHR", {false, (void*)GetDeviceGroupSurfacePresentModesKHR}}, {"vkGetPhysicalDevicePresentRectanglesKHR", {true, (void*)GetPhysicalDevicePresentRectanglesKHR}}, {"vkAcquireNextImage2KHR", {false, (void*)AcquireNextImage2KHR}}, {"vkGetPhysicalDeviceDisplayPropertiesKHR", {true, (void*)GetPhysicalDeviceDisplayPropertiesKHR}}, {"vkGetPhysicalDeviceDisplayPlanePropertiesKHR", {true, (void*)GetPhysicalDeviceDisplayPlanePropertiesKHR}}, {"vkGetDisplayPlaneSupportedDisplaysKHR", {true, (void*)GetDisplayPlaneSupportedDisplaysKHR}}, {"vkGetDisplayModePropertiesKHR", {true, (void*)GetDisplayModePropertiesKHR}}, {"vkCreateDisplayModeKHR", {true, (void*)CreateDisplayModeKHR}}, {"vkGetDisplayPlaneCapabilitiesKHR", {true, (void*)GetDisplayPlaneCapabilitiesKHR}}, {"vkCreateDisplayPlaneSurfaceKHR", {true, (void*)CreateDisplayPlaneSurfaceKHR}}, {"vkCreateSharedSwapchainsKHR", {false, (void*)CreateSharedSwapchainsKHR}}, #ifdef VK_USE_PLATFORM_XLIB_KHR {"vkCreateXlibSurfaceKHR", {true, (void*)CreateXlibSurfaceKHR}}, #endif #ifdef VK_USE_PLATFORM_XLIB_KHR {"vkGetPhysicalDeviceXlibPresentationSupportKHR", {true, (void*)GetPhysicalDeviceXlibPresentationSupportKHR}}, #endif #ifdef VK_USE_PLATFORM_XCB_KHR {"vkCreateXcbSurfaceKHR", {true, (void*)CreateXcbSurfaceKHR}}, #endif #ifdef VK_USE_PLATFORM_XCB_KHR {"vkGetPhysicalDeviceXcbPresentationSupportKHR", {true, (void*)GetPhysicalDeviceXcbPresentationSupportKHR}}, #endif #ifdef VK_USE_PLATFORM_WAYLAND_KHR {"vkCreateWaylandSurfaceKHR", {true, (void*)CreateWaylandSurfaceKHR}}, #endif #ifdef VK_USE_PLATFORM_WAYLAND_KHR {"vkGetPhysicalDeviceWaylandPresentationSupportKHR", {true, (void*)GetPhysicalDeviceWaylandPresentationSupportKHR}}, #endif #ifdef VK_USE_PLATFORM_ANDROID_KHR {"vkCreateAndroidSurfaceKHR", {true, (void*)CreateAndroidSurfaceKHR}}, #endif #ifdef VK_USE_PLATFORM_WIN32_KHR {"vkCreateWin32SurfaceKHR", {true, (void*)CreateWin32SurfaceKHR}}, #endif #ifdef VK_USE_PLATFORM_WIN32_KHR {"vkGetPhysicalDeviceWin32PresentationSupportKHR", {true, (void*)GetPhysicalDeviceWin32PresentationSupportKHR}}, #endif {"vkGetPhysicalDeviceFeatures2KHR", {true, (void*)GetPhysicalDeviceFeatures2KHR}}, {"vkGetPhysicalDeviceProperties2KHR", {true, (void*)GetPhysicalDeviceProperties2KHR}}, {"vkGetPhysicalDeviceFormatProperties2KHR", {true, (void*)GetPhysicalDeviceFormatProperties2KHR}}, {"vkGetPhysicalDeviceImageFormatProperties2KHR", {true, (void*)GetPhysicalDeviceImageFormatProperties2KHR}}, {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", {true, (void*)GetPhysicalDeviceQueueFamilyProperties2KHR}}, {"vkGetPhysicalDeviceMemoryProperties2KHR", {true, (void*)GetPhysicalDeviceMemoryProperties2KHR}}, {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", {true, (void*)GetPhysicalDeviceSparseImageFormatProperties2KHR}}, {"vkGetDeviceGroupPeerMemoryFeaturesKHR", {false, (void*)GetDeviceGroupPeerMemoryFeaturesKHR}}, {"vkCmdSetDeviceMaskKHR", {false, (void*)CmdSetDeviceMaskKHR}}, {"vkCmdDispatchBaseKHR", {false, (void*)CmdDispatchBaseKHR}}, {"vkTrimCommandPoolKHR", {false, (void*)TrimCommandPoolKHR}}, {"vkEnumeratePhysicalDeviceGroupsKHR", {true, (void*)EnumeratePhysicalDeviceGroupsKHR}}, {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", {true, (void*)GetPhysicalDeviceExternalBufferPropertiesKHR}}, #ifdef VK_USE_PLATFORM_WIN32_KHR {"vkGetMemoryWin32HandleKHR", {false, (void*)GetMemoryWin32HandleKHR}}, #endif #ifdef VK_USE_PLATFORM_WIN32_KHR {"vkGetMemoryWin32HandlePropertiesKHR", {false, (void*)GetMemoryWin32HandlePropertiesKHR}}, #endif {"vkGetMemoryFdKHR", {false, (void*)GetMemoryFdKHR}}, {"vkGetMemoryFdPropertiesKHR", {false, (void*)GetMemoryFdPropertiesKHR}}, {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", {true, (void*)GetPhysicalDeviceExternalSemaphorePropertiesKHR}}, #ifdef VK_USE_PLATFORM_WIN32_KHR {"vkImportSemaphoreWin32HandleKHR", {false, (void*)ImportSemaphoreWin32HandleKHR}}, #endif #ifdef VK_USE_PLATFORM_WIN32_KHR {"vkGetSemaphoreWin32HandleKHR", {false, (void*)GetSemaphoreWin32HandleKHR}}, #endif {"vkImportSemaphoreFdKHR", {false, (void*)ImportSemaphoreFdKHR}}, {"vkGetSemaphoreFdKHR", {false, (void*)GetSemaphoreFdKHR}}, {"vkCmdPushDescriptorSetKHR", {false, (void*)CmdPushDescriptorSetKHR}}, {"vkCmdPushDescriptorSetWithTemplateKHR", {false, (void*)CmdPushDescriptorSetWithTemplateKHR}}, {"vkCreateDescriptorUpdateTemplateKHR", {false, (void*)CreateDescriptorUpdateTemplateKHR}}, {"vkDestroyDescriptorUpdateTemplateKHR", {false, (void*)DestroyDescriptorUpdateTemplateKHR}}, {"vkUpdateDescriptorSetWithTemplateKHR", {false, (void*)UpdateDescriptorSetWithTemplateKHR}}, {"vkCreateRenderPass2KHR", {false, (void*)CreateRenderPass2KHR}}, {"vkCmdBeginRenderPass2KHR", {false, (void*)CmdBeginRenderPass2KHR}}, {"vkCmdNextSubpass2KHR", {false, (void*)CmdNextSubpass2KHR}}, {"vkCmdEndRenderPass2KHR", {false, (void*)CmdEndRenderPass2KHR}}, {"vkGetSwapchainStatusKHR", {false, (void*)GetSwapchainStatusKHR}}, {"vkGetPhysicalDeviceExternalFencePropertiesKHR", {true, (void*)GetPhysicalDeviceExternalFencePropertiesKHR}}, #ifdef VK_USE_PLATFORM_WIN32_KHR {"vkImportFenceWin32HandleKHR", {false, (void*)ImportFenceWin32HandleKHR}}, #endif #ifdef VK_USE_PLATFORM_WIN32_KHR {"vkGetFenceWin32HandleKHR", {false, (void*)GetFenceWin32HandleKHR}}, #endif {"vkImportFenceFdKHR", {false, (void*)ImportFenceFdKHR}}, {"vkGetFenceFdKHR", {false, (void*)GetFenceFdKHR}}, {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", {true, (void*)GetPhysicalDeviceSurfaceCapabilities2KHR}}, {"vkGetPhysicalDeviceSurfaceFormats2KHR", {true, (void*)GetPhysicalDeviceSurfaceFormats2KHR}}, {"vkGetPhysicalDeviceDisplayProperties2KHR", {true, (void*)GetPhysicalDeviceDisplayProperties2KHR}}, {"vkGetPhysicalDeviceDisplayPlaneProperties2KHR", {true, (void*)GetPhysicalDeviceDisplayPlaneProperties2KHR}}, {"vkGetDisplayModeProperties2KHR", {true, (void*)GetDisplayModeProperties2KHR}}, {"vkGetDisplayPlaneCapabilities2KHR", {true, (void*)GetDisplayPlaneCapabilities2KHR}}, {"vkGetImageMemoryRequirements2KHR", {false, (void*)GetImageMemoryRequirements2KHR}}, {"vkGetBufferMemoryRequirements2KHR", {false, (void*)GetBufferMemoryRequirements2KHR}}, {"vkGetImageSparseMemoryRequirements2KHR", {false, (void*)GetImageSparseMemoryRequirements2KHR}}, {"vkCreateSamplerYcbcrConversionKHR", {false, (void*)CreateSamplerYcbcrConversionKHR}}, {"vkDestroySamplerYcbcrConversionKHR", {false, (void*)DestroySamplerYcbcrConversionKHR}}, {"vkBindBufferMemory2KHR", {false, (void*)BindBufferMemory2KHR}}, {"vkBindImageMemory2KHR", {false, (void*)BindImageMemory2KHR}}, {"vkGetDescriptorSetLayoutSupportKHR", {false, (void*)GetDescriptorSetLayoutSupportKHR}}, {"vkCmdDrawIndirectCountKHR", {false, (void*)CmdDrawIndirectCountKHR}}, {"vkCmdDrawIndexedIndirectCountKHR", {false, (void*)CmdDrawIndexedIndirectCountKHR}}, {"vkGetPipelineExecutablePropertiesKHR", {false, (void*)GetPipelineExecutablePropertiesKHR}}, {"vkGetPipelineExecutableStatisticsKHR", {false, (void*)GetPipelineExecutableStatisticsKHR}}, {"vkGetPipelineExecutableInternalRepresentationsKHR", {false, (void*)GetPipelineExecutableInternalRepresentationsKHR}}, {"vkCreateDebugReportCallbackEXT", {true, (void*)CreateDebugReportCallbackEXT}}, {"vkDestroyDebugReportCallbackEXT", {true, (void*)DestroyDebugReportCallbackEXT}}, {"vkDebugReportMessageEXT", {true, (void*)DebugReportMessageEXT}}, {"vkDebugMarkerSetObjectTagEXT", {false, (void*)DebugMarkerSetObjectTagEXT}}, {"vkDebugMarkerSetObjectNameEXT", {false, (void*)DebugMarkerSetObjectNameEXT}}, {"vkCmdDebugMarkerBeginEXT", {false, (void*)CmdDebugMarkerBeginEXT}}, {"vkCmdDebugMarkerEndEXT", {false, (void*)CmdDebugMarkerEndEXT}}, {"vkCmdDebugMarkerInsertEXT", {false, (void*)CmdDebugMarkerInsertEXT}}, {"vkCmdBindTransformFeedbackBuffersEXT", {false, (void*)CmdBindTransformFeedbackBuffersEXT}}, {"vkCmdBeginTransformFeedbackEXT", {false, (void*)CmdBeginTransformFeedbackEXT}}, {"vkCmdEndTransformFeedbackEXT", {false, (void*)CmdEndTransformFeedbackEXT}}, {"vkCmdBeginQueryIndexedEXT", {false, (void*)CmdBeginQueryIndexedEXT}}, {"vkCmdEndQueryIndexedEXT", {false, (void*)CmdEndQueryIndexedEXT}}, {"vkCmdDrawIndirectByteCountEXT", {false, (void*)CmdDrawIndirectByteCountEXT}}, {"vkGetImageViewHandleNVX", {false, (void*)GetImageViewHandleNVX}}, {"vkCmdDrawIndirectCountAMD", {false, (void*)CmdDrawIndirectCountAMD}}, {"vkCmdDrawIndexedIndirectCountAMD", {false, (void*)CmdDrawIndexedIndirectCountAMD}}, {"vkGetShaderInfoAMD", {false, (void*)GetShaderInfoAMD}}, #ifdef VK_USE_PLATFORM_GGP {"vkCreateStreamDescriptorSurfaceGGP", {true, (void*)CreateStreamDescriptorSurfaceGGP}}, #endif {"vkGetPhysicalDeviceExternalImageFormatPropertiesNV", {true, (void*)GetPhysicalDeviceExternalImageFormatPropertiesNV}}, #ifdef VK_USE_PLATFORM_WIN32_KHR {"vkGetMemoryWin32HandleNV", {false, (void*)GetMemoryWin32HandleNV}}, #endif #ifdef VK_USE_PLATFORM_VI_NN {"vkCreateViSurfaceNN", {true, (void*)CreateViSurfaceNN}}, #endif {"vkCmdBeginConditionalRenderingEXT", {false, (void*)CmdBeginConditionalRenderingEXT}}, {"vkCmdEndConditionalRenderingEXT", {false, (void*)CmdEndConditionalRenderingEXT}}, {"vkCmdProcessCommandsNVX", {false, (void*)CmdProcessCommandsNVX}}, {"vkCmdReserveSpaceForCommandsNVX", {false, (void*)CmdReserveSpaceForCommandsNVX}}, {"vkCreateIndirectCommandsLayoutNVX", {false, (void*)CreateIndirectCommandsLayoutNVX}}, {"vkDestroyIndirectCommandsLayoutNVX", {false, (void*)DestroyIndirectCommandsLayoutNVX}}, {"vkCreateObjectTableNVX", {false, (void*)CreateObjectTableNVX}}, {"vkDestroyObjectTableNVX", {false, (void*)DestroyObjectTableNVX}}, {"vkRegisterObjectsNVX", {false, (void*)RegisterObjectsNVX}}, {"vkUnregisterObjectsNVX", {false, (void*)UnregisterObjectsNVX}}, {"vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", {true, (void*)GetPhysicalDeviceGeneratedCommandsPropertiesNVX}}, {"vkCmdSetViewportWScalingNV", {false, (void*)CmdSetViewportWScalingNV}}, {"vkReleaseDisplayEXT", {true, (void*)ReleaseDisplayEXT}}, #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT {"vkAcquireXlibDisplayEXT", {true, (void*)AcquireXlibDisplayEXT}}, #endif #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT {"vkGetRandROutputDisplayEXT", {true, (void*)GetRandROutputDisplayEXT}}, #endif {"vkGetPhysicalDeviceSurfaceCapabilities2EXT", {true, (void*)GetPhysicalDeviceSurfaceCapabilities2EXT}}, {"vkDisplayPowerControlEXT", {false, (void*)DisplayPowerControlEXT}}, {"vkRegisterDeviceEventEXT", {false, (void*)RegisterDeviceEventEXT}}, {"vkRegisterDisplayEventEXT", {false, (void*)RegisterDisplayEventEXT}}, {"vkGetSwapchainCounterEXT", {false, (void*)GetSwapchainCounterEXT}}, {"vkGetRefreshCycleDurationGOOGLE", {false, (void*)GetRefreshCycleDurationGOOGLE}}, {"vkGetPastPresentationTimingGOOGLE", {false, (void*)GetPastPresentationTimingGOOGLE}}, {"vkCmdSetDiscardRectangleEXT", {false, (void*)CmdSetDiscardRectangleEXT}}, {"vkSetHdrMetadataEXT", {false, (void*)SetHdrMetadataEXT}}, #ifdef VK_USE_PLATFORM_IOS_MVK {"vkCreateIOSSurfaceMVK", {true, (void*)CreateIOSSurfaceMVK}}, #endif #ifdef VK_USE_PLATFORM_MACOS_MVK {"vkCreateMacOSSurfaceMVK", {true, (void*)CreateMacOSSurfaceMVK}}, #endif {"vkSetDebugUtilsObjectNameEXT", {false, (void*)SetDebugUtilsObjectNameEXT}}, {"vkSetDebugUtilsObjectTagEXT", {false, (void*)SetDebugUtilsObjectTagEXT}}, {"vkQueueBeginDebugUtilsLabelEXT", {false, (void*)QueueBeginDebugUtilsLabelEXT}}, {"vkQueueEndDebugUtilsLabelEXT", {false, (void*)QueueEndDebugUtilsLabelEXT}}, {"vkQueueInsertDebugUtilsLabelEXT", {false, (void*)QueueInsertDebugUtilsLabelEXT}}, {"vkCmdBeginDebugUtilsLabelEXT", {false, (void*)CmdBeginDebugUtilsLabelEXT}}, {"vkCmdEndDebugUtilsLabelEXT", {false, (void*)CmdEndDebugUtilsLabelEXT}}, {"vkCmdInsertDebugUtilsLabelEXT", {false, (void*)CmdInsertDebugUtilsLabelEXT}}, {"vkCreateDebugUtilsMessengerEXT", {true, (void*)CreateDebugUtilsMessengerEXT}}, {"vkDestroyDebugUtilsMessengerEXT", {true, (void*)DestroyDebugUtilsMessengerEXT}}, {"vkSubmitDebugUtilsMessageEXT", {true, (void*)SubmitDebugUtilsMessageEXT}}, #ifdef VK_USE_PLATFORM_ANDROID_KHR {"vkGetAndroidHardwareBufferPropertiesANDROID", {false, (void*)GetAndroidHardwareBufferPropertiesANDROID}}, #endif #ifdef VK_USE_PLATFORM_ANDROID_KHR {"vkGetMemoryAndroidHardwareBufferANDROID", {false, (void*)GetMemoryAndroidHardwareBufferANDROID}}, #endif {"vkCmdSetSampleLocationsEXT", {false, (void*)CmdSetSampleLocationsEXT}}, {"vkGetPhysicalDeviceMultisamplePropertiesEXT", {true, (void*)GetPhysicalDeviceMultisamplePropertiesEXT}}, {"vkGetImageDrmFormatModifierPropertiesEXT", {false, (void*)GetImageDrmFormatModifierPropertiesEXT}}, #ifdef BUILD_CORE_VALIDATION {"vkCreateValidationCacheEXT", {false, (void*)CreateValidationCacheEXT}}, #endif #ifdef BUILD_CORE_VALIDATION {"vkDestroyValidationCacheEXT", {false, (void*)DestroyValidationCacheEXT}}, #endif #ifdef BUILD_CORE_VALIDATION {"vkMergeValidationCachesEXT", {false, (void*)MergeValidationCachesEXT}}, #endif #ifdef BUILD_CORE_VALIDATION {"vkGetValidationCacheDataEXT", {false, (void*)GetValidationCacheDataEXT}}, #endif {"vkCmdBindShadingRateImageNV", {false, (void*)CmdBindShadingRateImageNV}}, {"vkCmdSetViewportShadingRatePaletteNV", {false, (void*)CmdSetViewportShadingRatePaletteNV}}, {"vkCmdSetCoarseSampleOrderNV", {false, (void*)CmdSetCoarseSampleOrderNV}}, {"vkCreateAccelerationStructureNV", {false, (void*)CreateAccelerationStructureNV}}, {"vkDestroyAccelerationStructureNV", {false, (void*)DestroyAccelerationStructureNV}}, {"vkGetAccelerationStructureMemoryRequirementsNV", {false, (void*)GetAccelerationStructureMemoryRequirementsNV}}, {"vkBindAccelerationStructureMemoryNV", {false, (void*)BindAccelerationStructureMemoryNV}}, {"vkCmdBuildAccelerationStructureNV", {false, (void*)CmdBuildAccelerationStructureNV}}, {"vkCmdCopyAccelerationStructureNV", {false, (void*)CmdCopyAccelerationStructureNV}}, {"vkCmdTraceRaysNV", {false, (void*)CmdTraceRaysNV}}, {"vkCreateRayTracingPipelinesNV", {false, (void*)CreateRayTracingPipelinesNV}}, {"vkGetRayTracingShaderGroupHandlesNV", {false, (void*)GetRayTracingShaderGroupHandlesNV}}, {"vkGetAccelerationStructureHandleNV", {false, (void*)GetAccelerationStructureHandleNV}}, {"vkCmdWriteAccelerationStructuresPropertiesNV", {false, (void*)CmdWriteAccelerationStructuresPropertiesNV}}, {"vkCompileDeferredNV", {false, (void*)CompileDeferredNV}}, {"vkGetMemoryHostPointerPropertiesEXT", {false, (void*)GetMemoryHostPointerPropertiesEXT}}, {"vkCmdWriteBufferMarkerAMD", {false, (void*)CmdWriteBufferMarkerAMD}}, {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", {true, (void*)GetPhysicalDeviceCalibrateableTimeDomainsEXT}}, {"vkGetCalibratedTimestampsEXT", {false, (void*)GetCalibratedTimestampsEXT}}, {"vkCmdDrawMeshTasksNV", {false, (void*)CmdDrawMeshTasksNV}}, {"vkCmdDrawMeshTasksIndirectNV", {false, (void*)CmdDrawMeshTasksIndirectNV}}, {"vkCmdDrawMeshTasksIndirectCountNV", {false, (void*)CmdDrawMeshTasksIndirectCountNV}}, {"vkCmdSetExclusiveScissorNV", {false, (void*)CmdSetExclusiveScissorNV}}, {"vkCmdSetCheckpointNV", {false, (void*)CmdSetCheckpointNV}}, {"vkGetQueueCheckpointDataNV", {false, (void*)GetQueueCheckpointDataNV}}, {"vkInitializePerformanceApiINTEL", {false, (void*)InitializePerformanceApiINTEL}}, {"vkUninitializePerformanceApiINTEL", {false, (void*)UninitializePerformanceApiINTEL}}, {"vkCmdSetPerformanceMarkerINTEL", {false, (void*)CmdSetPerformanceMarkerINTEL}}, {"vkCmdSetPerformanceStreamMarkerINTEL", {false, (void*)CmdSetPerformanceStreamMarkerINTEL}}, {"vkCmdSetPerformanceOverrideINTEL", {false, (void*)CmdSetPerformanceOverrideINTEL}}, {"vkAcquirePerformanceConfigurationINTEL", {false, (void*)AcquirePerformanceConfigurationINTEL}}, {"vkReleasePerformanceConfigurationINTEL", {false, (void*)ReleasePerformanceConfigurationINTEL}}, {"vkQueueSetPerformanceConfigurationINTEL", {false, (void*)QueueSetPerformanceConfigurationINTEL}}, {"vkGetPerformanceParameterINTEL", {false, (void*)GetPerformanceParameterINTEL}}, {"vkSetLocalDimmingAMD", {false, (void*)SetLocalDimmingAMD}}, #ifdef VK_USE_PLATFORM_FUCHSIA {"vkCreateImagePipeSurfaceFUCHSIA", {true, (void*)CreateImagePipeSurfaceFUCHSIA}}, #endif #ifdef VK_USE_PLATFORM_METAL_EXT {"vkCreateMetalSurfaceEXT", {true, (void*)CreateMetalSurfaceEXT}}, #endif {"vkGetBufferDeviceAddressEXT", {false, (void*)GetBufferDeviceAddressEXT}}, {"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", {true, (void*)GetPhysicalDeviceCooperativeMatrixPropertiesNV}}, {"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", {true, (void*)GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV}}, #ifdef VK_USE_PLATFORM_WIN32_KHR {"vkGetPhysicalDeviceSurfacePresentModes2EXT", {true, (void*)GetPhysicalDeviceSurfacePresentModes2EXT}}, #endif #ifdef VK_USE_PLATFORM_WIN32_KHR {"vkAcquireFullScreenExclusiveModeEXT", {false, (void*)AcquireFullScreenExclusiveModeEXT}}, #endif #ifdef VK_USE_PLATFORM_WIN32_KHR {"vkReleaseFullScreenExclusiveModeEXT", {false, (void*)ReleaseFullScreenExclusiveModeEXT}}, #endif #ifdef VK_USE_PLATFORM_WIN32_KHR {"vkGetDeviceGroupSurfacePresentModes2EXT", {false, (void*)GetDeviceGroupSurfacePresentModes2EXT}}, #endif {"vkCreateHeadlessSurfaceEXT", {true, (void*)CreateHeadlessSurfaceEXT}}, {"vkCmdSetLineStippleEXT", {false, (void*)CmdSetLineStippleEXT}}, {"vkResetQueryPoolEXT", {false, (void*)ResetQueryPoolEXT}}, }; } // namespace vulkan_layer_chassis // loader-layer interface v0, just wrappers since there is only a layer VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) { return vulkan_layer_chassis::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) { return vulkan_layer_chassis::EnumerateInstanceLayerProperties(pCount, pProperties); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties *pProperties) { // the layer command handles VK_NULL_HANDLE just fine internally assert(physicalDevice == VK_NULL_HANDLE); return vulkan_layer_chassis::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) { // the layer command handles VK_NULL_HANDLE just fine internally assert(physicalDevice == VK_NULL_HANDLE); return vulkan_layer_chassis::EnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties); } VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char *funcName) { return vulkan_layer_chassis::GetDeviceProcAddr(dev, funcName); } VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName) { return vulkan_layer_chassis::GetInstanceProcAddr(instance, funcName); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct) { assert(pVersionStruct != NULL); assert(pVersionStruct->sType == LAYER_NEGOTIATE_INTERFACE_STRUCT); // Fill in the function pointers if our version is at least capable of having the structure contain them. if (pVersionStruct->loaderLayerInterfaceVersion >= 2) { pVersionStruct->pfnGetInstanceProcAddr = vkGetInstanceProcAddr; pVersionStruct->pfnGetDeviceProcAddr = vkGetDeviceProcAddr; pVersionStruct->pfnGetPhysicalDeviceProcAddr = nullptr; } return VK_SUCCESS; }