| |
| // 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 <mark@lunarg.com> |
| */ |
| |
| |
| #include <string.h> |
| #include <mutex> |
| |
| #define VALIDATION_ERROR_MAP_IMPL |
| |
| #include "chassis.h" |
| #include "layer_chassis_dispatch.h" |
| |
| std::unordered_map<void*, ValidationObject*> layer_data_map; |
| |
| // Global unique object identifier. |
| std::atomic<uint64_t> global_unique_id(1ULL); |
| // Map uniqueID to actual object handle. Accesses to the map itself are |
| // internally synchronized. |
| vl_concurrent_unordered_map<uint64_t, uint64_t, 4> 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<std::string, function_data> 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<std::string, VkValidationFeatureDisableEXT> 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<std::string, VkValidationFeatureEnableEXT> 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<std::string, VkValidationFeatureEnable> VkValFeatureEnableLookup2 = { |
| {"VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES", VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES}, |
| }; |
| |
| static const std::unordered_map<std::string, ValidationCheckDisables> 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<PFN_vkVoidFunction>(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<PFN_vkVoidFunction>(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<VkValidationFeaturesEXT>(pCreateInfo->pNext); |
| if (validation_features_ext) { |
| SetValidationFeatures(&local_disables, &local_enables, validation_features_ext); |
| } |
| const auto *validation_flags_ext = lvl_find_in_chain<VkValidationFlagsEXT>(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<ValidationObject*> 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<VkDeviceCreateInfo *>(&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<CoreChecks *>( |
| 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<std::string, function_data> 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; |
| } |